-
+
{heading.title}
diff --git a/packages/dashboard/src/components/landing/LandingNav.tsx b/packages/dashboard/src/components/landing/LandingNav.tsx
index c884b5d..e82fc54 100644
--- a/packages/dashboard/src/components/landing/LandingNav.tsx
+++ b/packages/dashboard/src/components/landing/LandingNav.tsx
@@ -1,7 +1,7 @@
import { useState } from "react";
import { Menu, X } from "lucide-react";
import { motion, AnimatePresence } from "motion/react";
-import logoFull from "@/assets/logo-full.png";
+import logoMark from "@/assets/logo-mark.svg";
/* ------------------------------------------------------------------ */
/* Landing page sticky navigation bar */
@@ -25,8 +25,9 @@ export function LandingNav() {
{/* Brand */}
-
-
+
+
+ DevScope
{/* Desktop nav links */}
diff --git a/packages/dashboard/src/components/landing/MockupActivityFeed.tsx b/packages/dashboard/src/components/landing/MockupActivityFeed.tsx
deleted file mode 100644
index 6c1c4e4..0000000
--- a/packages/dashboard/src/components/landing/MockupActivityFeed.tsx
+++ /dev/null
@@ -1,314 +0,0 @@
-import { useEffect, useRef, useState } from "react";
-import { motion, AnimatePresence } from "motion/react";
-import {
- Play,
- MessageSquare,
- Wrench,
- Bot,
- CheckCircle2,
- Square,
- AlertTriangle,
- Bell,
- GitBranch,
-} from "lucide-react";
-
-/* ------------------------------------------------------------------ */
-/* Infinite-streaming activity feed mockup for the landing page hero */
-/* Generates random developer events forever — no loops, no resets. */
-/* ------------------------------------------------------------------ */
-
-const DEVELOPERS = ["Lucas S", "Sarah K", "Alex M", "Jordan P"] as const;
-const PROJECTS = ["devscope", "api-gateway", "auth-service", "web-app", "cli-tools"] as const;
-const TOOLS = ["Read", "Grep", "Edit", "Write", "Bash", "Glob", "WebFetch"] as const;
-const AGENTS = ["code-reviewer", "test-runner", "debugger", "explorer"] as const;
-const PROMPTS = [
- "Refactor the auth middleware to use JWT validation",
- "Add pagination to the users endpoint",
- "Fix the race condition in the WebSocket handler",
- "Update the CI pipeline to run tests in parallel",
- "Implement rate limiting on the API routes",
- "Migrate the database schema to support multi-tenancy",
- "Add error boundaries to the dashboard components",
- "Optimize the query for fetching session history",
-] as const;
-const TASKS = [
- "Update auth tests",
- "Fix flaky CI build",
- "Add input validation",
- "Refactor DB queries",
- "Write migration script",
-] as const;
-
-type EventKind =
- | "session-start"
- | "prompt"
- | "tools"
- | "agent"
- | "task"
- | "session-end"
- | "alert"
- | "notification"
- | "worktree";
-
-interface FeedEvent {
- id: number;
- kind: EventKind;
- developer: string;
- project: string;
- detail: string;
- /** Timestamp when this event was created (epoch ms). */
- createdAt: number;
-}
-
-function pick
(arr: readonly T[]): T {
- return arr[Math.floor(Math.random() * arr.length)];
-}
-
-/** Format seconds into a human-friendly relative time string. */
-function formatTime(seconds: number): string {
- if (seconds < 5) return "just now";
- if (seconds < 60) return `${seconds}s ago`;
- const mins = Math.floor(seconds / 60);
- if (mins < 60) return `${mins}m ago`;
- return `${Math.floor(mins / 60)}h ago`;
-}
-
-function randomToolList(): string {
- const count = 2 + Math.floor(Math.random() * 4);
- const shuffled = [...TOOLS].sort(() => Math.random() - 0.5);
- return shuffled.slice(0, count).join(", ");
-}
-
-let nextId = 0;
-
-function generateEvent(): FeedEvent {
- const dev = pick(DEVELOPERS);
- const proj = pick(PROJECTS);
- const kinds: EventKind[] = [
- "prompt", "prompt", "prompt", // weighted heavier
- "tools", "tools", "tools",
- "agent", "agent",
- "task",
- "session-start",
- "session-end",
- "notification",
- "worktree",
- ];
- const kind = pick(kinds);
-
- let detail = "";
- switch (kind) {
- case "session-start":
- detail = proj;
- break;
- case "session-end":
- detail = proj;
- break;
- case "prompt":
- detail = pick(PROMPTS);
- break;
- case "tools":
- detail = randomToolList();
- break;
- case "agent":
- detail = pick(AGENTS);
- break;
- case "task":
- detail = pick(TASKS);
- break;
- case "notification":
- detail = "Build succeeded";
- break;
- case "worktree":
- detail = `feature/${proj}-${Math.floor(Math.random() * 100)}`;
- break;
- }
-
- return { id: nextId++, kind, developer: dev, project: proj, detail, createdAt: Date.now() };
-}
-
-/** Max visible items before oldest are trimmed. */
-const MAX_VISIBLE = 5;
-/** Ms between new events. */
-const INTERVAL = 1600;
-
-/* ----- Rendering helpers per event kind ----- */
-
-function dotProps(kind: EventKind) {
- switch (kind) {
- case "session-start":
- return { color: "bg-emerald-600", Icon: Play, iconClass: "text-white" };
- case "session-end":
- return { color: "bg-muted", Icon: Square, iconClass: "text-muted-foreground" };
- case "prompt":
- return { color: "bg-blue-600", Icon: MessageSquare, iconClass: "text-white" };
- case "tools":
- return { color: "bg-muted", Icon: Wrench, iconClass: "text-muted-foreground" };
- case "agent":
- return { color: "bg-purple-600", Icon: Bot, iconClass: "text-white" };
- case "task":
- return { color: "bg-teal-600", Icon: CheckCircle2, iconClass: "text-white" };
- case "alert":
- return { color: "bg-destructive", Icon: AlertTriangle, iconClass: "text-white" };
- case "notification":
- return { color: "bg-yellow-600", Icon: Bell, iconClass: "text-white" };
- case "worktree":
- return { color: "bg-indigo-600", Icon: GitBranch, iconClass: "text-white" };
- }
-}
-
-function EventContent({ event }: { event: FeedEvent }) {
- switch (event.kind) {
- case "session-start":
- return (
-
- {event.developer}
- {" started working on "}
- {event.detail}
-
- );
- case "session-end":
- return (
-
- {event.developer}
- {" ended session in "}
- {event.detail}
-
- );
- case "tools":
- return (
-
- Used tools: {event.detail}
-
- );
- case "agent":
- return (
-
- {event.developer}
- {" spawned "}
-
- {event.detail}
-
-
- );
- case "task":
- return (
-
- {event.developer}
- {" completed "}
- {event.detail}
-
- );
- case "notification":
- return (
-
- {event.detail}
- {" — "}
- {event.project}
-
- );
- case "worktree":
- return (
-
- {event.developer}
- {" created worktree "}
- {event.detail}
-
- );
- default:
- return null;
- }
-}
-
-export function MockupActivityFeed() {
- const [events, setEvents] = useState(() => [generateEvent()]);
- const [now, setNow] = useState(() => Date.now());
- const intervalRef = useRef>(undefined);
-
- useEffect(() => {
-
- // Add new events on interval
- intervalRef.current = setInterval(() => {
- setEvents((prev) => {
- const next = [generateEvent(), ...prev];
- return next.slice(0, MAX_VISIBLE);
- });
- }, INTERVAL);
-
- // Tick `now` every second so relative times stay accurate
- const tickId = setInterval(() => setNow(Date.now()), 1000);
-
- return () => {
- clearInterval(intervalRef.current);
- clearInterval(tickId);
- };
- }, []);
-
- return (
-
-
- {events.map((event, i) => {
- const { color, Icon, iconClass } = dotProps(event.kind);
- const isLast = i === events.length - 1;
- const isPrompt = event.kind === "prompt";
- const elapsed = Math.max(0, Math.round((now - event.createdAt) / 1000));
- const timeLabel = formatTime(elapsed);
-
- return (
-
- {/* Vertical connector line */}
- {!isLast && (
-
- )}
-
- {/* Dot */}
-
-
-
-
- {/* Content */}
-
- {isPrompt ? (
-
-
- {event.developer}
-
- {event.project}
-
- {timeLabel}
-
-
- {event.detail}
-
-
- ) : (
-
-
- {timeLabel}
-
- )}
-
-
- );
- })}
-
-
- );
-}
diff --git a/packages/dashboard/src/components/landing/MockupTeamDashboard.tsx b/packages/dashboard/src/components/landing/MockupTeamDashboard.tsx
index c4efaef..cf4200a 100644
--- a/packages/dashboard/src/components/landing/MockupTeamDashboard.tsx
+++ b/packages/dashboard/src/components/landing/MockupTeamDashboard.tsx
@@ -1,130 +1,146 @@
+import { motion } from "motion/react";
import {
- TrendingUp,
- Lightbulb,
AlertTriangle,
- FileText,
+ BookOpen,
CheckCircle,
- Sparkles,
+ FileText,
+ MessageSquareText,
+ TrendingDown,
+ Wand2,
} from "lucide-react";
/* ------------------------------------------------------------------ */
-/* AI insights & reports mockup for the landing page (non-technical) */
+/* Team view mockup for the landing page (team-lead persona). */
+/* Everything here is aggregate and about tools, projects and shared */
+/* know-how, never about individual developers (see CLAUDE.md ethics). */
/* ------------------------------------------------------------------ */
-const INSIGHTS = [
- {
- icon: TrendingUp,
- iconColor: "text-blue-400",
- title: "Velocity up 18% this week",
- severity: "Info",
- severityClass: "bg-muted text-muted-foreground",
- narrative:
- "Team output increased across all metrics. Prompt volume and tool usage both trending higher than the 4-week average.",
- },
+const STATS = [
+ { label: "Sessions this week", value: "142", note: null },
+ { label: "Tool failure rate", value: "4.1%", note: "↓ 0.8 pts" },
+ { label: "Team skill runs", value: "38", note: "↑ 12" },
+] as const;
+
+const FRICTION = [
{
icon: AlertTriangle,
iconColor: "text-amber-400",
- title: "High session volume across the team",
- severity: "Warning",
- severityClass: "border border-amber-500/30 text-amber-400",
- narrative:
- "Team-wide session count is 40% above the rolling average. Consider reviewing workload distribution in the next standup.",
+ title: "pnpm test times out in web-app",
+ detail: "12 Bash failures across 5 sessions. The team playbook suggests --runInBand.",
+ tag: "Tooling",
+ tagClass: "border border-amber-500/30 text-amber-400",
},
{
- icon: Lightbulb,
+ icon: TrendingDown,
iconColor: "text-emerald-400",
- title: "auth-service has recurring blockers",
- severity: "Info",
- severityClass: "bg-muted text-muted-foreground",
- narrative:
- "4 stuck sessions on auth-service this week. Past resolutions suggest a pairing session or shared runbook could help.",
+ title: "Fewer failures in api-service",
+ detail: "Down 30% since its CLAUDE.md gained a section on the test database.",
+ tag: "CLAUDE.md",
+ tagClass: "bg-muted text-muted-foreground",
},
] as const;
+const SPREADING = [
+ { icon: Wand2, label: "release-notes", kind: "Team skill", count: "9 sessions" },
+ { icon: MessageSquareText, label: "run the e2e suite first", kind: "Prompt", count: "6 sessions" },
+ { icon: BookOpen, label: "Fixing flaky Playwright tests", kind: "Playbook", count: "4 sessions" },
+] as const;
+
const REPORTS = [
- {
- title: "Weekly Team Digest",
- type: "digest",
- time: "2h ago",
- readTime: "3 min read",
- },
- {
- title: "Sprint Velocity Analysis",
- type: "analysis",
- time: "1d ago",
- readTime: "5 min read",
- },
+ { title: "Weekly Team Digest", time: "2h ago" },
+ { title: "Tooling Health Report", time: "1d ago" },
] as const;
export function MockupTeamDashboard() {
return (
-
- {/* Section header */}
-
-
-
- AI Insights
+
+ {/* Scope line: says out loud that this is aggregate */}
+
+ This week across the team
+
+ Aggregate · 8 developers, 5 sharing details
- — last 7 days
- {/* Insight cards */}
-
- {INSIGHTS.map((insight) => {
- const Icon = insight.icon;
- return (
-
-
-
-
-
- {insight.title}
-
-
- {insight.severity}
-
-
-
- {insight.narrative}
-
-
+ {/* Stat strip */}
+
+ {STATS.map((s) => (
+
+
{s.label}
+
+ {s.value}
+ {s.note ? {s.note} : null}
- );
- })}
+
+ ))}
+
+
Waiting on someone
+
+
+ 2
+ sessions now
+
+
- {/* Reports row */}
-
-
-
- Recent Reports
-
-
-
- {REPORTS.map((report) => (
-
-
-
-
- {report.title}
-
-
-
{report.type}
-
·
-
{report.time}
-
·
-
{report.readTime}
+
+ {/* Tooling friction */}
+
+
Where the team gets stuck
+ {FRICTION.map((f) => {
+ const Icon = f.icon;
+ return (
+
+
+
+
+ {f.title}
+ {f.tag}
+
+
{f.detail}
+
-
+ );
+ })}
+
+
+ {/* Shared know-how */}
+
+
What's spreading
+
+ {SPREADING.map((s) => {
+ const Icon = s.icon;
+ return (
+
+ );
+ })}
+
+
+
+ {/* Reports */}
+
+
+ {REPORTS.map((r) => (
+
+
+ {r.title}
+ · {r.time}
+
))}
diff --git a/packages/dashboard/src/components/landing/MockupTerminal.tsx b/packages/dashboard/src/components/landing/MockupTerminal.tsx
new file mode 100644
index 0000000..c1a5b60
--- /dev/null
+++ b/packages/dashboard/src/components/landing/MockupTerminal.tsx
@@ -0,0 +1,173 @@
+import { useEffect, useState, type ReactNode } from "react";
+import { motion, useReducedMotion } from "motion/react";
+import { Users, Volume2 } from "lucide-react";
+
+/* ------------------------------------------------------------------ */
+/* A Claude Code session with DevScope, played line by line. */
+/* The DevScope lines use the plugin's real wording */
+/* (scripts/error-recall.sh, the devscope-live mod). */
+/* ------------------------------------------------------------------ */
+
+interface Line {
+ key: string;
+ /** Pause before this line appears, in ms. */
+ delay: number;
+ node: ReactNode;
+}
+
+const dim = "text-gray-500";
+
+const LINES: Line[] = [
+ {
+ key: "prompt",
+ delay: 400,
+ node: (
+
+ > fix the failing auth test
+
+ ),
+ },
+ {
+ key: "bash1",
+ delay: 900,
+ node: (
+
+ ● Bash
+ (bun test src/auth)
+
+ ),
+ },
+ {
+ key: "fail",
+ delay: 900,
+ node: (
+
+ ⎿ TypeError: Cannot read properties of undefined (reading 'token')
+
+ ),
+ },
+ {
+ key: "recall",
+ delay: 700,
+ node: (
+
+ DevScope: you've hit this error before (3x, 2 resolved). Claude has the notes.
+
+ ),
+ },
+ {
+ key: "claude",
+ delay: 1100,
+ node: (
+
+ ● Last time this was fixed by awaiting{" "}
+ refreshToken() before reading the token. Applying that.
+
+ ),
+ },
+ {
+ key: "edit",
+ delay: 1000,
+ node: (
+
+ ● Edit
+ (src/auth/session.ts)
+ +1 −1
+
+ ),
+ },
+ {
+ key: "bash2",
+ delay: 900,
+ node: (
+
+
● Bash
+
(bun test src/auth)
+
+ ⎿ 14 passed
+
+
+ ),
+ },
+ {
+ key: "voice",
+ delay: 1000,
+ node: (
+
+
+
+ "Auth tests pass. The session now waits for the token refresh."
+
+ ),
+ },
+ {
+ key: "next",
+ delay: 1400,
+ node: (
+
+ >
+ open a PR
+
+ worked for your team
+
+
+ ),
+ },
+];
+
+/** How long the finished session stays on screen before it plays again. */
+const HOLD_MS = 5000;
+
+function VoiceBars() {
+ return (
+
+ {[0, 1, 2, 3].map((i) => (
+
+ ))}
+
+ );
+}
+
+export function MockupTerminal() {
+ const reduceMotion = useReducedMotion();
+ const [shown, setShown] = useState(reduceMotion ? LINES.length : 0);
+
+ useEffect(() => {
+ if (reduceMotion) return;
+ const delay = shown < LINES.length ? LINES[shown].delay : HOLD_MS;
+ const timer = setTimeout(() => setShown((n) => (n < LINES.length ? n + 1 : 0)), delay);
+ return () => clearTimeout(timer);
+ }, [shown, reduceMotion]);
+
+ return (
+
+ {LINES.slice(0, shown).map((line) => (
+
+ {line.node}
+
+ ))}
+ {shown < LINES.length ? (
+
+ ) : null}
+
+ );
+}
diff --git a/packages/dashboard/src/components/landing/SecuritySection.tsx b/packages/dashboard/src/components/landing/SecuritySection.tsx
index 28acac0..9359e72 100644
--- a/packages/dashboard/src/components/landing/SecuritySection.tsx
+++ b/packages/dashboard/src/components/landing/SecuritySection.tsx
@@ -1,56 +1,47 @@
-import { Shield, Lock, UserCheck, EyeOff, ServerCrash, Key } from "lucide-react";
+import { Lock, Shield, Trash2, Users } from "lucide-react";
import type { LucideIcon } from "lucide-react";
import { motion } from "motion/react";
+import { Backdrop } from "./Backdrop";
/* ------------------------------------------------------------------ */
-/* SecuritySection — highlights DevScope's security commitments */
+/* SecuritySection — what developers control, in plain words. */
+/* The exact switches live in the FAQ ("How do I opt out?"). */
/* ------------------------------------------------------------------ */
-interface Commitment {
+interface PrivacyPromise {
icon: LucideIcon;
title: string;
description: string;
}
-const COMMITMENTS: Commitment[] = [
- {
- icon: EyeOff,
- title: "No individual surveillance",
- description:
- "Activity data surfaces team-wide patterns and tooling health — never individual rankings, comparisons, or productivity scores.",
- },
- {
- icon: UserCheck,
- title: "Consent-first collection",
- description:
- "Developers opt in by installing the plugin. Privacy mode is the default. Data collection is minimal and fully transparent.",
- },
- {
- icon: Key,
- title: "API key scoped access",
- description:
- "Each team uses scoped API keys. Keys are hashed at rest and can be revoked instantly from the dashboard.",
- },
+const PROMISES: PrivacyPromise[] = [
{
icon: Lock,
- title: "Encrypted in transit",
+ title: "Private mode",
description:
- "All data travels over TLS. WebSocket connections are wss:// end-to-end. No plaintext event data ever leaves your machine unencrypted.",
+ "Keep prompts and replies on your machine. Only tool names and timings are sent.",
},
{
- icon: ServerCrash,
- title: "Self-hostable",
+ icon: Users,
+ title: "Sharing is off by default",
description:
- "Run DevScope on your own infrastructure. The full stack is open-source and ships as a single Docker Compose file.",
+ "Teammates see that you're active, nothing more, until you choose to share.",
},
{
- icon: Shield,
- title: "Open source & auditable",
+ icon: Trash2,
+ title: "Export or delete anytime",
description:
- "Every line of backend and dashboard code is public on GitHub. No black-box data pipelines — audit anything, anytime.",
+ "Ask for your data or have it removed. Old events expire on their own.",
},
];
+const TRUST = [
+ "No rankings or productivity scores",
+ "Open source",
+ "Self-hostable",
+ "Encrypted in transit",
+];
+
/* ------------------------------------------------------------------ */
/* Animation config */
/* ------------------------------------------------------------------ */
@@ -65,14 +56,8 @@ const revealViewport = { once: true, amount: 0.15 } as const;
export function SecuritySection() {
return (
-
- {/* Subtle background gradient */}
-
+
+
{/* Heading */}
@@ -81,40 +66,47 @@ export function SecuritySection() {
whileInView={revealVisible}
viewport={revealViewport}
transition={{ duration: 0.5, ease: "easeOut" }}
- className="text-center mb-14"
+ className="text-center mb-12"
>
- Security & Privacy
+ Privacy
-
- Built with trust at the core
+
+ You decide what's shared
- DevScope handles real developer activity. We take that responsibility
- seriously — here's exactly how we protect your team's data.
+ Every kind of sharing has an off switch.
- {/* Commitment grid */}
-
- {COMMITMENTS.map((item, index) => (
-
+
+ {PROMISES.map((item, index) => (
+
))}
+
+
+ {TRUST.map((t) => (
+
+
+ {t}
+
+ ))}
+
);
}
/* ------------------------------------------------------------------ */
-/* Individual commitment card */
+/* Individual card */
/* ------------------------------------------------------------------ */
-function CommitmentCard({ item, index }: { item: Commitment; index: number }) {
+function PromiseCard({ item, index }: { item: PrivacyPromise; index: number }) {
const Icon = item.icon;
return (
@@ -123,18 +115,14 @@ function CommitmentCard({ item, index }: { item: Commitment; index: number }) {
whileInView={revealVisible}
viewport={revealViewport}
transition={{ delay: index * 0.07, duration: 0.45, ease: "easeOut" }}
- className="rounded-xl border border-border bg-card p-6 flex flex-col gap-3 hover:border-emerald-500/40 hover:bg-emerald-500/5 transition-colors duration-200"
+ className="rounded-xl border border-border bg-card p-6 flex flex-col gap-3"
>
-
- {item.title}
-
-
- {item.description}
-
+
{item.title}
+
{item.description}
);
diff --git a/packages/dashboard/src/components/landing/StatsSection.tsx b/packages/dashboard/src/components/landing/StatsSection.tsx
index cad8a17..ba7bbbc 100644
--- a/packages/dashboard/src/components/landing/StatsSection.tsx
+++ b/packages/dashboard/src/components/landing/StatsSection.tsx
@@ -21,7 +21,7 @@ interface Stat {
const FALLBACK_STATS: readonly Stat[] = [
{ value: "< 5 min", label: "Setup time" },
- { value: "0 ms", label: "Impact on workflow" },
+ { value: "3", label: "Privacy modes" },
{ value: "Real-time", label: "Event streaming" },
{ value: "Open Source", label: "Self-hostable" },
] as const;
diff --git a/packages/dashboard/src/components/landing/TopologyDemoSection.tsx b/packages/dashboard/src/components/landing/TopologyDemoSection.tsx
index d35b0a0..405cf0a 100644
--- a/packages/dashboard/src/components/landing/TopologyDemoSection.tsx
+++ b/packages/dashboard/src/components/landing/TopologyDemoSection.tsx
@@ -4,17 +4,38 @@ import { ReactFlow, Background } from "@xyflow/react";
import type { Node } from "@xyflow/react";
import "@xyflow/react/dist/style.css";
import { nodeTypes } from "../flow/nodeTypes";
-import { buildDemoLayout, tickSimulation } from "./demoTopologyData";
+import { DetailPanel } from "../flow/DetailPanel";
+import { FilterToggle } from "../flow/FlowView";
+import type { AgentSummaryNodeData } from "../flow/flowTypes";
+import { applyDemoView, buildDemoLayout, tickSimulation, type DemoFilters } from "./demoTopologyData";
import { usePersona } from "./PersonaContext";
+import { Backdrop } from "./Backdrop";
const revealInitial = { opacity: 0, y: 24 } as const;
const revealVisible = { opacity: 1, y: 0 } as const;
const revealViewport = { once: true, amount: 0.2 } as const;
+/** What the demo shows off, in the order a visitor meets it on the graph. */
+const HIGHLIGHTS = [
+ "Branch and task on every card",
+ "Your turn, waiting and inactive at a glance",
+ "Tool calls and failures, live",
+ "Tokens and cost on your own sessions",
+ "Click any card for its details",
+];
+
+/** Same as the dashboard: a finished-subagents card opens its session. */
+function selectionFor(node: Node): string | null {
+ if (node.type === "session" || node.type === "agent") return node.id;
+ if (node.type === "agentSummary") return `session-${(node.data as AgentSummaryNodeData).sessionId}`;
+ return null;
+}
+
export function TopologyDemoSection() {
const layout = useMemo(() => buildDemoLayout(), []);
const [nodes, setNodes] = useState
(layout.nodes);
- const edges = layout.edges;
+ const [filters, setFilters] = useState({ hideInactive: false, hideDoneAgents: false });
+ const [selectedId, setSelectedId] = useState(null);
const { persona } = usePersona();
// Simulation loop: tick every 1.5–3s (randomized for organic feel)
@@ -42,8 +63,22 @@ export function TopologyDemoSection() {
};
}, [tick]);
+ const view = useMemo(() => applyDemoView(nodes, layout.edges, filters), [nodes, layout.edges, filters]);
+ const selectedNode = selectedId ? view.nodes.find((n) => n.id === selectedId && !n.hidden) : undefined;
+ const shownNodes = useMemo(
+ () => view.nodes.map((n) => (n.id === selectedNode?.id ? { ...n, selected: true } : n)),
+ [view.nodes, selectedNode?.id],
+ );
+ const toggle = (key: keyof DemoFilters) => setFilters((f) => ({ ...f, [key]: !f[key] }));
+
return (
-
+
+
{/* Heading */}
-
- Visualize your entire team
+
+ See every session and subagent, live
- See every developer, session, and agent in a real-time topology view.
- Spot patterns, catch anti-patterns, and find learning opportunities at a glance.
+ One view of what's running across your team: which branch each session is on,
+ what each subagent was asked to do, and which sessions are waiting on you.
+
+ {HIGHLIGHTS.map((h) => (
+
+ {h}
+
+ ))}
+
{/* Fake window chrome */}
@@ -90,26 +132,45 @@ export function TopologyDemoSection() {
{/* ReactFlow container */}
-
+
setSelectedId(selectionFor(node))}
+ onPaneClick={() => setSelectedId(null)}
nodesDraggable={false}
nodesConnectable={false}
elementsSelectable={false}
- panOnDrag
- zoomOnScroll
- zoomOnPinch
+ panOnDrag={false}
+ zoomOnScroll={false}
+ zoomOnPinch={false}
+ preventScrolling={false}
zoomOnDoubleClick={false}
fitView
- fitViewOptions={{ padding: 0.3 }}
+ fitViewOptions={{ padding: 0.2 }}
proOptions={{ hideAttribution: true }}
>
+
+ toggle("hideInactive")} />
+ toggle("hideDoneAgents")} />
+
+ {selectedNode ? (
+
setSelectedId(null)}
+ showSessionLink={false}
+ />
+ ) : null}
+
+ Demo data. Alice is "you": only your own sessions show model, tokens and cost.
+ The lock marks a session in private mode.
+
diff --git a/packages/dashboard/src/components/landing/demoTopologyData.ts b/packages/dashboard/src/components/landing/demoTopologyData.ts
index 591ebe6..7b51214 100644
--- a/packages/dashboard/src/components/landing/demoTopologyData.ts
+++ b/packages/dashboard/src/components/landing/demoTopologyData.ts
@@ -1,12 +1,14 @@
import type { Node, Edge } from "@xyflow/react";
import type {
DeveloperNodeData,
+ ProjectNodeData,
SessionNodeData,
AgentNodeData,
AgentSummaryNodeData,
SessionActivityState,
} from "../flow/flowTypes";
import { getLayoutedElements } from "../flow/layout";
+import { WORKING_STATES } from "../flow/useFlowLayout";
import type { Developer, Session, FeedEvent, ToolEventPayload, PromptEventPayload } from "@devscope/shared";
import type { Persona } from "./PersonaContext";
@@ -17,6 +19,14 @@ function minutesAgo(m: number): string {
// --- Tool names that cycle through the simulation ---
const TOOL_NAMES = ["Edit", "Read", "Bash", "Write", "Grep", "Glob", "Agent", "WebSearch"];
+const PROMPTS = [
+ "Fix the failing test",
+ "Add error handling",
+ "Refactor this function",
+ "Update the API endpoint",
+ "Implement pagination",
+];
+
// --- Non-technical friendly labels ---
const NT_PROMPTS = [
"Working on authentication flow",
@@ -37,6 +47,9 @@ const NT_ACTIVITIES: Record = {
"response.complete": "Finished task",
};
+/** Events kept per node for the detail panel, newest first (matches the dashboard). */
+const RECENT_EVENT_LIMIT = 15;
+
function pick(arr: readonly T[]): T {
return arr[Math.floor(Math.random() * arr.length)];
}
@@ -77,34 +90,118 @@ interface SessionDef {
session: Session;
devId: string;
devName: string;
+ /** State the card starts in, so the first frame already shows a mix. */
+ initialState: SessionActivityState;
+ toolCalls: number;
+ toolFailures: number;
+}
+
+function session(fields: Partial & Pick): Session {
+ return {
+ projectPath: fields.projectName ? `/app/${fields.projectName}` : null,
+ startedAt: minutesAgo(30),
+ endedAt: null,
+ status: "active",
+ permissionMode: null,
+ privacyMode: "standard",
+ ...fields,
+ };
+}
+
+/** Alice is "you" in the demo: only your own sessions show model, tokens and cost. */
+function ownUsage(model: string, input: number, output: number, cacheRead: number, cost: number): Partial {
+ return {
+ model,
+ tokenSource: "exact",
+ totalInputTokens: input,
+ totalOutputTokens: output,
+ totalCacheCreationTokens: 0,
+ totalCacheReadTokens: cacheRead,
+ estimatedCostUsd: cost,
+ };
}
const sessionDefs: SessionDef[] = [
- { session: { id: "s1", gitBranch: "feat/auth-form", developerId: "alice", projectPath: "/app/frontend", projectName: "frontend", startedAt: minutesAgo(45), endedAt: null, status: "active", permissionMode: null, privacyMode: null }, devId: "alice", devName: "Alice Chen" },
- { session: { id: "s2", gitBranch: "fix/rate-limit", developerId: "alice", projectPath: "/app/api", projectName: "api-service", startedAt: minutesAgo(20), endedAt: null, status: "active", permissionMode: null, privacyMode: null }, devId: "alice", devName: "Alice Chen" },
- { session: { id: "s3", gitBranch: "main", developerId: "bob", projectPath: "/app/backend", projectName: "backend", startedAt: minutesAgo(30), endedAt: null, status: "active", permissionMode: null, privacyMode: null }, devId: "bob", devName: "Bob Martinez" },
- { session: { id: "s4", gitBranch: "exp/embeddings", developerId: "carol", projectPath: "/app/ml", projectName: "ml-pipeline", startedAt: minutesAgo(60), endedAt: null, status: "active", permissionMode: null, privacyMode: null }, devId: "carol", devName: "Carol Singh" },
- { session: { id: "s5", gitBranch: "chore/terraform", developerId: "carol", projectPath: "/app/infra", projectName: "infra", startedAt: minutesAgo(15), endedAt: null, status: "active", permissionMode: null, privacyMode: null }, devId: "carol", devName: "Carol Singh" },
- { session: { id: "s6", gitBranch: "docs/onboarding", developerId: "carol", projectPath: "/app/docs", projectName: "docs", startedAt: minutesAgo(8), endedAt: null, status: "active", permissionMode: null, privacyMode: null }, devId: "carol", devName: "Carol Singh" },
- { session: { id: "s7", gitBranch: "feat/offline-mode", developerId: "dave", projectPath: "/app/mobile", projectName: "mobile-app", startedAt: minutesAgo(25), endedAt: null, status: "active", permissionMode: null, privacyMode: null }, devId: "dave", devName: "Dave Kim" },
+ {
+ session: session({
+ id: "s1", developerId: "alice", projectName: "frontend", gitBranch: "feat/oauth-login",
+ currentTitle: "Add OAuth sign-in to the login form", startedAt: minutesAgo(45),
+ ...ownUsage("claude-opus-5-5", 182_000, 41_000, 1_240_000, 4.82),
+ }),
+ devId: "alice", devName: "Alice Chen", initialState: "running", toolCalls: 64, toolFailures: 2,
+ },
+ {
+ session: session({
+ id: "s2", developerId: "alice", projectName: "api-service", gitBranch: "fix/rate-limit",
+ currentTitle: "Rate limiter rejects plugin traffic", startedAt: minutesAgo(20),
+ ...ownUsage("claude-sonnet-5-5", 48_000, 9_500, 310_000, 0.71),
+ }),
+ devId: "alice", devName: "Alice Chen", initialState: "idle", toolCalls: 23, toolFailures: 0,
+ },
+ {
+ session: session({
+ id: "s3", developerId: "bob", projectName: "backend", gitBranch: "feat/events-pagination",
+ currentTitle: "Paginate the events endpoint", startedAt: minutesAgo(30),
+ }),
+ devId: "bob", devName: "Bob Martinez", initialState: "thinking", toolCalls: 41, toolFailures: 5,
+ },
+ {
+ session: session({
+ id: "s4", developerId: "carol", projectName: "ml-pipeline", gitBranch: "exp/embeddings",
+ currentTitle: "Index prompts with pgvector", startedAt: minutesAgo(60),
+ }),
+ devId: "carol", devName: "Carol Singh", initialState: "running", toolCalls: 88, toolFailures: 3,
+ },
+ {
+ session: session({
+ id: "s8", developerId: "carol", projectName: "ml-pipeline", gitBranch: "feat/rerank",
+ currentTitle: "Rerank search results", startedAt: minutesAgo(12),
+ }),
+ devId: "carol", devName: "Carol Singh", initialState: "idle", toolCalls: 9, toolFailures: 0,
+ },
+ {
+ // Private mode: no branch, title or prompt text ever leaves the machine.
+ session: session({
+ id: "s5", developerId: "carol", projectName: "infra", privacyMode: "private", startedAt: minutesAgo(15),
+ }),
+ devId: "carol", devName: "Carol Singh", initialState: "thinking", toolCalls: 17, toolFailures: 1,
+ },
+ {
+ session: session({
+ id: "s7", developerId: "dave", projectName: "mobile-app", gitBranch: "feat/offline-mode",
+ currentTitle: "Queue writes while offline", startedAt: minutesAgo(40),
+ }),
+ devId: "dave", devName: "Dave Kim", initialState: "inactive", toolCalls: 31, toolFailures: 4,
+ },
];
const agentDefs = [
- { agentId: "agent-1", agentType: "general-purpose", description: "Refactor the auth form", model: "sonnet", sessionId: "s1", startedAt: minutesAgo(5) },
+ { agentId: "agent-1", agentType: "general-purpose", description: "Refactor the auth form into hooks", model: "sonnet", sessionId: "s1", startedAt: minutesAgo(5) },
];
const doneAgentDefs: AgentSummaryNodeData[] = [
- { sessionId: "s4", total: 2, types: [{ agentType: "Explore", count: 2 }] },
+ { sessionId: "s4", total: 3, types: [{ agentType: "Explore", count: 2 }, { agentType: "Plan", count: 1 }] },
];
// --- Per-session simulation state ---
-type SimPhase = "idle" | "prompt" | "tool_start" | "tool_complete" | "thinking";
+type SimPhase = "idle" | "prompt" | "tool_start" | "tool_complete" | "waiting" | "thinking";
interface SessionSimState {
phase: SimPhase;
toolName: string | null;
event: FeedEvent | null;
+ toolCalls: number;
+ toolFailures: number;
+ recentEvents: FeedEvent[];
+}
+
+function initialPhase(state: SessionActivityState): SimPhase {
+ switch (state) {
+ case "running": return "tool_start";
+ case "thinking": return "thinking";
+ default: return "idle";
+ }
}
// --- Build layout (runs once) ---
@@ -113,39 +210,56 @@ export function buildDemoLayout(): { nodes: Node[]; edges: Edge[] } {
const nodes: Node[] = [];
const edges: Edge[] = [];
- const devSessionCounts = new Map();
- for (const s of sessionDefs) {
- devSessionCounts.set(s.devId, (devSessionCounts.get(s.devId) ?? 0) + 1);
- }
-
for (const dev of developers) {
- const data: DeveloperNodeData = {
- developer: dev,
- activeCount: devSessionCounts.get(dev.id) ?? 0,
- inactiveCount: 0,
- };
+ const own = sessionDefs.filter((s) => s.devId === dev.id);
+ const inactiveCount = own.filter((s) => s.initialState === "inactive").length;
+ const data: DeveloperNodeData = { developer: dev, activeCount: own.length - inactiveCount, inactiveCount };
nodes.push({ id: `dev-${dev.id}`, type: "developer", position: { x: 0, y: 0 }, data });
}
+ // A developer's sessions sharing a project hang under one project node, as in the dashboard.
+ const parentOf = new Map();
+ const groups = new Map();
+ for (const s of sessionDefs) {
+ const key = `project-${s.devId}-${s.session.projectName}`;
+ groups.set(key, [...(groups.get(key) ?? []), s]);
+ }
+ for (const [projectNodeId, defs] of groups) {
+ if (defs.length < 2) continue;
+ const data: ProjectNodeData = { projectName: defs[0].session.projectName!, sessionCount: defs.length };
+ nodes.push({ id: projectNodeId, type: "project", position: { x: 0, y: 0 }, data });
+ edges.push({
+ id: `edge-${defs[0].devId}-${projectNodeId}`,
+ source: `dev-${defs[0].devId}`,
+ target: projectNodeId,
+ type: "smoothstep",
+ data: { sessionIds: defs.map((d) => d.session.id) },
+ style: { stroke: "#4b5563" },
+ });
+ for (const d of defs) parentOf.set(d.session.id, projectNodeId);
+ }
+
for (const s of sessionDefs) {
+ const inactive = s.initialState === "inactive";
const data: SessionNodeData = {
session: s.session,
recentEvents: [],
latestEvent: null,
isToolRunning: false,
currentToolName: null,
- activityState: "idle",
- lastActivityAt: minutesAgo(0),
- toolCalls: null,
- toolFailures: null,
+ activityState: s.initialState,
+ lastActivityAt: minutesAgo(inactive ? 6 : 0),
+ toolCalls: s.toolCalls,
+ toolFailures: s.toolFailures,
};
nodes.push({ id: `session-${s.session.id}`, type: "session", position: { x: 0, y: 0 }, data });
+ const source = parentOf.get(s.session.id) ?? `dev-${s.devId}`;
edges.push({
- id: `edge-${s.devId}-${s.session.id}`,
- source: `dev-${s.devId}`,
+ id: `edge-${source}-${s.session.id}`,
+ source,
target: `session-${s.session.id}`,
type: "smoothstep",
- animated: true,
+ data: { sessionIds: [s.session.id] },
style: { stroke: "#4b5563" },
});
}
@@ -192,17 +306,28 @@ export function buildDemoLayout(): { nodes: Node[]; edges: Edge[] } {
const sessionSimStates = new Map();
for (const s of sessionDefs) {
- sessionSimStates.set(s.session.id, { phase: "idle", toolName: null, event: null });
+ sessionSimStates.set(s.session.id, {
+ phase: initialPhase(s.initialState),
+ toolName: s.initialState === "running" ? "Edit" : null,
+ event: null,
+ toolCalls: s.toolCalls,
+ toolFailures: s.toolFailures,
+ recentEvents: [],
+ });
}
// Agent simulation state (only for active agent)
-const agentSimState: SessionSimState = { phase: "idle", toolName: null, event: null };
+const agentSimState: SessionSimState = { phase: "idle", toolName: null, event: null, toolCalls: 0, toolFailures: 0, recentEvents: [] };
+
+/** Sessions the simulation advances; the inactive one stays put so its state is visible. */
+const liveDefs = sessionDefs.filter((s) => s.initialState !== "inactive");
function nextPhase(current: SimPhase): SimPhase {
switch (current) {
case "idle": return "prompt";
case "prompt": return "tool_start";
- case "tool_start": return "tool_complete";
+ case "tool_start": return Math.random() > 0.85 ? "waiting" : "tool_complete";
+ case "waiting": return "tool_complete";
case "tool_complete": return Math.random() > 0.4 ? "tool_start" : "thinking";
case "thinking": return "idle";
}
@@ -213,11 +338,17 @@ function phaseToActivityState(phase: SimPhase): SessionActivityState {
case "idle": return "idle";
case "prompt": return "thinking";
case "tool_start": return "running";
+ case "waiting": return "waiting";
case "tool_complete": return "thinking";
case "thinking": return "thinking";
}
}
+function remember(state: SessionSimState, event: FeedEvent | null) {
+ state.event = event;
+ if (event) state.recentEvents = [event, ...state.recentEvents].slice(0, RECENT_EVENT_LIMIT);
+}
+
/**
* Advance simulation by one tick. Call from setInterval.
* Returns updated nodes (positions unchanged, data updated).
@@ -230,7 +361,7 @@ export function tickSimulation(baseNodes: Node[], persona?: Persona | null): Nod
const count = 1 + Math.floor(Math.random() * 3);
const toAdvance = new Set();
for (let i = 0; i < count; i++) {
- toAdvance.add(pick(sessionDefs).session.id);
+ toAdvance.add(pick(liveDefs).session.id);
}
// Maybe advance the active agent too
@@ -242,27 +373,30 @@ export function tickSimulation(baseNodes: Node[], persona?: Persona | null): Nod
state.phase = nextPhase(state.phase);
const sDef = sessionDefs.find((s) => s.session.id === sid)!;
+ const isPrivate = sDef.session.privacyMode === "private";
+ const event = (type: FeedEvent["eventType"], payload: FeedEvent["payload"]) =>
+ makeEvent(sid, sDef.devId, sDef.devName, sDef.session.projectName, type, payload);
switch (state.phase) {
case "prompt": {
state.toolName = null;
- const promptText = isNT
- ? pick(NT_PROMPTS)
- : pick(["Fix the failing test", "Add error handling", "Refactor this function", "Update the API endpoint", "Implement pagination"]);
- state.event = makeEvent(sid, sDef.devId, sDef.devName, sDef.session.projectName, "prompt.submit", {
+ // Private sessions never send prompt text, so the card shows only its length.
+ const promptText = isPrivate ? undefined : isNT ? pick(NT_PROMPTS) : pick(PROMPTS);
+ remember(state, event("prompt.submit", {
promptLength: 20 + Math.floor(Math.random() * 200),
isContinuation: false,
promptText,
- } satisfies PromptEventPayload);
+ } satisfies PromptEventPayload));
break;
}
case "tool_start": {
- const rawToolName = pick(TOOL_NAMES);
- const toolName = isNT ? (NT_ACTIVITIES["tool.start"]) : rawToolName;
+ const toolName = isNT ? NT_ACTIVITIES["tool.start"] : pick(TOOL_NAMES);
state.toolName = toolName;
- state.event = makeEvent(sid, sDef.devId, sDef.devName, sDef.session.projectName, "tool.start", {
- toolName,
- } satisfies ToolEventPayload);
+ remember(state, event("tool.start", { toolName } satisfies ToolEventPayload));
+ break;
+ }
+ case "waiting": {
+ remember(state, event("permission.request", { toolName: state.toolName ?? "Bash" } satisfies ToolEventPayload));
break;
}
case "tool_complete": {
@@ -270,20 +404,22 @@ export function tickSimulation(baseNodes: Node[], persona?: Persona | null): Nod
const completedLabel = isNT
? (success ? NT_ACTIVITIES["tool.complete"] : NT_ACTIVITIES["tool.fail"])
: (state.toolName ?? "Edit");
- state.event = makeEvent(sid, sDef.devId, sDef.devName, sDef.session.projectName, success ? "tool.complete" : "tool.fail", {
+ state.toolCalls += 1;
+ if (!success) state.toolFailures += 1;
+ remember(state, event(success ? "tool.complete" : "tool.fail", {
toolName: completedLabel,
success,
duration: 100 + Math.floor(Math.random() * 2000),
- } satisfies ToolEventPayload);
+ } satisfies ToolEventPayload));
state.toolName = null;
break;
}
case "thinking": {
state.toolName = null;
- state.event = makeEvent(sid, sDef.devId, sDef.devName, sDef.session.projectName, "response.complete", {
+ remember(state, event("response.complete", {
responseLength: 50 + Math.floor(Math.random() * 500),
toolsUsed: [],
- });
+ }));
break;
}
case "idle": {
@@ -298,27 +434,27 @@ export function tickSimulation(baseNodes: Node[], persona?: Persona | null): Nod
if (advanceAgent) {
const activeAgent = agentDefs[0]; // agent-1 is active
agentSimState.phase = nextPhase(agentSimState.phase);
+ if (agentSimState.phase === "waiting") agentSimState.phase = "tool_complete";
const sDef = sessionDefs.find((s) => s.session.id === activeAgent.sessionId)!;
switch (agentSimState.phase) {
case "tool_start": {
- const rawToolName = pick(TOOL_NAMES);
- const toolName = isNT ? NT_ACTIVITIES["tool.start"] : rawToolName;
+ const toolName = isNT ? NT_ACTIVITIES["tool.start"] : pick(TOOL_NAMES);
agentSimState.toolName = toolName;
- agentSimState.event = makeEvent(activeAgent.sessionId, sDef.devId, sDef.devName, sDef.session.projectName, "tool.start", {
+ remember(agentSimState, makeEvent(activeAgent.sessionId, sDef.devId, sDef.devName, sDef.session.projectName, "tool.start", {
toolName,
agentId: activeAgent.agentId,
- } satisfies ToolEventPayload);
+ } satisfies ToolEventPayload));
break;
}
case "tool_complete": {
const completedLabel = isNT ? NT_ACTIVITIES["tool.complete"] : (agentSimState.toolName ?? "Read");
- agentSimState.event = makeEvent(activeAgent.sessionId, sDef.devId, sDef.devName, sDef.session.projectName, "tool.complete", {
+ remember(agentSimState, makeEvent(activeAgent.sessionId, sDef.devId, sDef.devName, sDef.session.projectName, "tool.complete", {
toolName: completedLabel,
success: true,
duration: 200 + Math.floor(Math.random() * 1500),
agentId: activeAgent.agentId,
- } satisfies ToolEventPayload);
+ } satisfies ToolEventPayload));
agentSimState.toolName = null;
break;
}
@@ -336,18 +472,34 @@ export function tickSimulation(baseNodes: Node[], persona?: Persona | null): Nod
const data = node.data as SessionNodeData;
const sid = data.session.id;
const state = sessionSimStates.get(sid);
- if (!state) return node;
+ if (!state || data.activityState === "inactive") return node;
+
+ // Your own sessions accrue tokens and cost as replies come in.
+ let session = data.session;
+ if (session.tokenSource && toAdvance.has(sid) && state.phase === "thinking") {
+ const output = 400 + Math.floor(Math.random() * 1600);
+ session = {
+ ...session,
+ totalInputTokens: (session.totalInputTokens ?? 0) + output * 3,
+ totalOutputTokens: (session.totalOutputTokens ?? 0) + output,
+ totalCacheReadTokens: (session.totalCacheReadTokens ?? 0) + output * 20,
+ estimatedCostUsd: (session.estimatedCostUsd ?? 0) + output * 0.00004,
+ };
+ }
return {
...node,
data: {
...data,
+ session,
latestEvent: state.event,
+ recentEvents: state.recentEvents,
isToolRunning: state.phase === "tool_start",
currentToolName: state.toolName,
activityState: phaseToActivityState(state.phase),
- // Demo sessions are always live.
- lastActivityAt: new Date().toISOString(),
+ toolCalls: state.toolCalls,
+ toolFailures: state.toolFailures,
+ lastActivityAt: toAdvance.has(sid) ? new Date().toISOString() : data.lastActivityAt,
},
};
}
@@ -360,6 +512,7 @@ export function tickSimulation(baseNodes: Node[], persona?: Persona | null): Nod
data: {
...data,
latestEvent: agentSimState.event,
+ recentEvents: agentSimState.recentEvents,
isToolRunning: agentSimState.phase === "tool_start",
currentToolName: agentSimState.toolName,
},
@@ -369,3 +522,53 @@ export function tickSimulation(baseNodes: Node[], persona?: Persona | null): Nod
return node;
});
}
+
+export interface DemoFilters {
+ hideInactive: boolean;
+ hideDoneAgents: boolean;
+}
+
+/**
+ * Applies the toolbar filters and animates an edge only while a session below it
+ * is working, the same rule the dashboard uses. Layout positions are untouched.
+ */
+export function applyDemoView(
+ nodes: Node[],
+ edges: Edge[],
+ filters: DemoFilters,
+): { nodes: Node[]; edges: Edge[] } {
+ const states = new Map();
+ for (const n of nodes) {
+ if (n.type === "session") {
+ const d = n.data as SessionNodeData;
+ states.set(d.session.id, d.activityState);
+ }
+ }
+
+ const hidden = new Set();
+ for (const n of nodes) {
+ if (filters.hideInactive && n.type === "session" && (n.data as SessionNodeData).activityState === "inactive") {
+ hidden.add(n.id);
+ }
+ if (filters.hideDoneAgents && n.type === "agentSummary") hidden.add(n.id);
+ }
+ // A developer with nothing left visible goes too.
+ if (filters.hideInactive) {
+ for (const n of nodes) {
+ if (n.type !== "developer") continue;
+ const children = edges.filter((e) => e.source === n.id).map((e) => e.target);
+ if (children.length > 0 && children.every((c) => hidden.has(c))) hidden.add(n.id);
+ }
+ }
+
+ return {
+ nodes: nodes.map((n) => (hidden.has(n.id) ? { ...n, hidden: true } : n.hidden ? { ...n, hidden: false } : n)),
+ edges: edges.map((e) => {
+ const sessionIds = (e.data as { sessionIds?: string[] } | undefined)?.sessionIds;
+ const animated = sessionIds
+ ? sessionIds.some((id) => WORKING_STATES.has(states.get(id) ?? "idle"))
+ : e.animated;
+ return { ...e, animated, hidden: hidden.has(e.source) || hidden.has(e.target) };
+ }),
+ };
+}
diff --git a/packages/dashboard/src/components/landing/personaContent.ts b/packages/dashboard/src/components/landing/personaContent.ts
index 985f883..cd2914d 100644
--- a/packages/dashboard/src/components/landing/personaContent.ts
+++ b/packages/dashboard/src/components/landing/personaContent.ts
@@ -1,19 +1,19 @@
import type { LucideIcon } from "lucide-react";
import {
Activity,
- AlertTriangle,
BarChart3,
- BrainCircuit,
+ BookOpen,
Briefcase,
- GitBranch,
- Lightbulb,
- LineChart,
+ History,
+ MessageSquareText,
+ Network,
+ Search,
+ ShieldCheck,
Sparkles,
- Target,
Terminal,
- TrendingUp,
- Workflow,
- Zap,
+ Users,
+ Volume2,
+ Wrench,
} from "lucide-react";
import type { Persona } from "./PersonaContext";
@@ -32,18 +32,18 @@ interface HeroContent {
const HERO: Record = {
technical: {
- badge: "Open Source AI Upskilling",
- headline: "Level up how you use Claude Code.",
- headlineAccent: "Ship smarter.",
+ badge: "Open source toolkit for Claude Code",
+ headline: "Get more out of Claude Code.",
+ headlineAccent: "Spend less time babysitting it.",
subtext:
- "DevScope analyzes your Claude Code sessions to reveal what's working and what isn't — discover effective patterns, break out of anti-patterns, and build better AI workflows over time.",
+ "DevScope adds the tools Claude Code is missing: a voice that tells you when a session needs you, a live view of every session and subagent, fixes recalled from errors you've hit before, and search across everything you've done.",
},
"non-technical": {
- badge: "AI Development Upskilling Platform",
- headline: "Help your team master AI-assisted development.",
- headlineAccent: "Faster.",
+ badge: "For teams adopting Claude Code",
+ headline: "What one developer figures out,",
+ headlineAccent: "the whole team gets.",
subtext:
- "DevScope turns AI usage data into actionable team skills — surface effective patterns, identify anti-patterns to avoid, and accelerate adoption with data-driven coaching.",
+ "DevScope puts your team's proven prompts, skills and fixes in front of every developer while they work, and shows you where tools and workflows slow the team down. No rankings, no surveillance.",
},
};
@@ -67,88 +67,88 @@ interface FeaturesContent {
const FEATURES: Record = {
technical: {
- heading: "Build better AI skills, session by session",
+ heading: "The tools around Claude Code",
subheading:
- "DevScope turns your Claude Code usage into a personal learning tool — revealing patterns, flagging anti-patterns, and suggesting better workflows.",
+ "Small, focused helpers that run inside Claude Code and fail open. Turn on what you want, switch off what you don't.",
items: [
{
- icon: Activity,
- title: "Session Replay & Timeline",
+ icon: Volume2,
+ title: "Know when a session needs you",
description:
- "Review every prompt and tool call in chronological order. Spot what works, learn from what doesn't, and refine your approach.",
+ "A voice tells you when Claude is waiting on a permission prompt or a question, so you can work elsewhere and stop checking tabs.",
},
{
- icon: GitBranch,
- title: "Pattern Library",
+ icon: Network,
+ title: "Every session at a glance",
description:
- "See which tool sequences and prompting styles lead to success. Build a personal playbook of effective AI workflows.",
+ "All your sessions and subagents live, with branch, task, state, tool failures, tokens and cost.",
},
{
- icon: BrainCircuit,
- title: "Anti-Pattern Alerts",
+ icon: History,
+ title: "Fixes you've already found",
description:
- "Get flagged when you hit common pitfalls — retry loops, high-failure tools, or inefficient sequences — with suggestions to break out.",
+ "When a tool call fails with an error you've hit before, Claude gets the call that fixed it last time.",
},
{
- icon: Lightbulb,
- title: "AI-Powered Suggestions",
+ icon: Search,
+ title: "Search everything you've done",
description:
- "Receive personalized tips based on your session patterns — concrete techniques to improve how you work with Claude Code.",
+ "Find any past prompt or reply by meaning, not just keywords, from the dashboard or /devscope:search.",
},
{
- icon: Zap,
- title: "Skill Progress",
+ icon: Terminal,
+ title: "Slash commands",
description:
- "See how your AI workflows improve over time. Track which tools you've mastered and where you're still learning.",
+ "/devscope:review critiques the current session, /devscope:upskill proposes CLAUDE.md fixes, /devscope:ask answers questions about your history.",
},
{
- icon: Terminal,
- title: "Zero-Friction Plugin",
+ icon: MessageSquareText,
+ title: "Next steps that worked before",
description:
- "Install with a single command. Non-blocking hooks mean zero overhead — your workflow stays untouched.",
+ "After a PR or a skill, get the step you usually take next, and prompts that worked for your team as you type.",
},
],
},
"non-technical": {
- heading: "Upskill your team's AI development",
+ heading: "Your team's best sessions, shared",
subheading:
- "DevScope helps teams learn from their AI usage — surfacing effective patterns, catching anti-patterns, and accelerating skill development.",
+ "DevScope turns what works in one developer's sessions into help for everyone, and shows you where the team gets stuck.",
items: [
{
- icon: TrendingUp,
- title: "Adoption & Skill Trends",
+ icon: Users,
+ title: "Shared know-how",
description:
- "Understand how your team's AI skills are developing over time. See adoption curves, tool mastery, and areas where coaching can help.",
+ "A prompt, skill or fix that worked for one developer is offered to the next one when they need it.",
},
{
- icon: LineChart,
- title: "Pattern & Anti-Pattern Reports",
+ icon: Network,
+ title: "Live team view",
description:
- "Identify which AI workflows succeed across your team and which common anti-patterns are costing time.",
+ "See what's running across the team and which sessions are waiting on someone.",
},
{
- icon: Briefcase,
- title: "Team Learning Reports",
+ icon: Wrench,
+ title: "Tooling friction",
description:
- "AI-generated summaries highlighting team patterns to adopt, anti-patterns to avoid, and skills to develop next.",
+ "Find the tools and projects where sessions keep failing. Problems are tied to tools, never to people.",
},
{
- icon: Target,
- title: "Project-Level Insights",
+ icon: BookOpen,
+ title: "Team skills and playbooks",
description:
- "See which projects benefit most from AI-assisted development and where teams can improve their approach.",
+ "Turn effective patterns into skills Claude Code can follow, shared across your organisation.",
},
{
- icon: AlertTriangle,
- title: "Blocker Detection",
+ icon: Sparkles,
+ title: "AI team reports",
description:
- "Automatically surface sessions with high failure rates — identify tooling issues and workflow blockers early.",
+ "Summaries of what's working, what isn't, and what to try next, across the whole team.",
},
{
- icon: Workflow,
- title: "Shareable Playbooks",
+ icon: ShieldCheck,
+ title: "Trust built in",
description:
- "Turn successful patterns into team knowledge. Share what works so everyone can level up together.",
+ "Developers choose what they share. Team views are aggregate, with no rankings or productivity scores.",
},
],
},
@@ -230,15 +230,15 @@ interface CtaContent {
const CTA: Record = {
technical: {
- heading: "Start leveling up your AI workflow today",
+ heading: "Get more out of Claude Code",
subtext:
- "Set up DevScope in under 5 minutes. Open source, self-hosted, zero overhead on your development flow.",
+ "Install the plugin in under 5 minutes. Open source, self-hostable, and you choose what's shared.",
buttonLabel: "Get Started Free",
},
"non-technical": {
- heading: "Start upskilling your team's AI development",
+ heading: "Make every session count for the whole team",
subtext:
- "Deploy DevScope in minutes. Self-hosted, open source, and designed for teams that want to get better at AI-assisted development.",
+ "Roll DevScope out in minutes. Open source, self-hostable, and every developer controls what they share.",
buttonLabel: "Get Started Free",
},
};
@@ -259,12 +259,17 @@ const FAQ: Record = {
{
question: "Will DevScope slow down my Claude Code sessions?",
answer:
- "No. The plugin uses async, non-blocking bash hooks with zero milliseconds of overhead. Your sessions run exactly as fast as before.",
+ "No. Event capture runs in the background and never waits on the network. The only hooks that run inline are prompt recall, error recall and next-step hints, each capped at 5 seconds and skipped on any error, and each can be turned off.",
},
{
question: "What data does DevScope collect?",
answer:
- "DevScope captures session lifecycle events, tool usage patterns, and prompt metadata. It does not collect prompt content or your code — only structural information about how sessions progress.",
+ "That's your choice. In the default standard mode the plugin sends session events, tool calls with their inputs, and your prompt text. Set DEVSCOPE_PRIVACY=private to send only tool names, file paths and durations, or open to add Claude's responses for full replay. Your teammates see none of your content unless you turn on team sharing.",
+ },
+ {
+ question: "How do I opt out?",
+ answer:
+ "Use private mode to keep prompts and responses on your machine. Leave team sharing off (the default) so teammates only see that you're active. Turn off recall or hints individually with DEVSCOPE_PREFLIGHT, DEVSCOPE_ERROR_RECALL or DEVSCOPE_HINTS set to off. You can request an export or deletion of your data from the dashboard at any time.",
},
{
question: "Can I self-host DevScope?",
@@ -274,7 +279,7 @@ const FAQ: Record = {
{
question: "How does it help me improve?",
answer:
- "DevScope analyzes your session patterns and highlights effective workflows, flags anti-patterns like retry loops, and generates AI-powered suggestions to help you build better AI development skills over time.",
+ "Mostly in the moment: it recalls fixes and earlier answers as you work, and suggests next steps that worked before. Looking back, /devscope:upskill reads where your sessions got stuck and proposes changes to your CLAUDE.md and memory.",
},
{
question: "Does it work with any IDE?",
@@ -286,7 +291,7 @@ const FAQ: Record = {
{
question: "What is DevScope?",
answer:
- "DevScope is an open-source upskilling platform for AI-assisted development. It analyzes team-wide Claude Code sessions to surface effective patterns, flag anti-patterns, and help your team build better AI workflows over time.",
+ "DevScope is an open-source companion for Claude Code. It remembers your team's sessions and brings what worked back to each developer while they work, and gives you a live, aggregate view of how the team uses Claude Code.",
},
{
question: "How does rollout work for my team?",
@@ -301,7 +306,7 @@ const FAQ: Record = {
{
question: "Is the data secure?",
answer:
- "DevScope is fully self-hosted — your data never leaves your infrastructure. It captures session metadata only, not source code or prompt content.",
+ "Developers control what is sent. By default the plugin sends prompt text and tool activity; private mode sends metadata only. Each developer decides whether teammates can see their sessions, and it is off by default. Self-host DevScope to keep the data on your infrastructure. AI-generated summaries use an external model provider and only see what each developer's privacy mode allows.",
},
{
question: "How does it help upskill my team?",