{ "$schema": "https://ui.shadcn.com/schema/registry-item.json", "name": "agent-plan", "title": "Agent Plan", "description": "An agent's plan while it is still a draft — ordered steps with their rationale, risk chips on the dangerous ones, per-step include/exclude, inline rewriting, a live duration and cost estimate for the steps you kept, and a one-shot Approve or Request changes.", "dependencies": [ "lucide-react", "zod" ], "registryDependencies": [ "badge", "button", "utils" ], "files": [ { "path": "src/registry/ui/agent-plan.tsx", "content": "\"use client\"\n\nimport * as React from \"react\"\nimport {\n Check,\n CircleAlert,\n CircleCheck,\n ClipboardList,\n Clock3,\n Coins,\n Info,\n ListChecks,\n Lock,\n MessageSquare,\n Pencil,\n RefreshCcw,\n Send,\n ShieldAlert,\n TriangleAlert,\n Undo2,\n X,\n} from \"lucide-react\"\n\nimport { cn } from \"@/lib/utils\"\nimport { Badge } from \"@/components/ui/badge\"\nimport { Button } from \"@/components/ui/button\"\nimport type {\n AgentPlanDecisionKind,\n AgentPlanProposal,\n AgentPlanRiskLevel,\n AgentPlanStatus,\n AgentPlanStep,\n} from \"./agent-plan.contract\"\n\n/* --------------------------------------------------------------- formatting */\n\nconst costFormatter = new Intl.NumberFormat(\"en-US\", {\n style: \"currency\",\n currency: \"USD\",\n minimumFractionDigits: 2,\n maximumFractionDigits: 2,\n})\n\n/**\n * A plan estimate is a guess about the future, so it is rounded to the unit a\n * human would say out loud (\"about 12 min\"), never to the millisecond. Anything\n * more precise reads as a promise the agent cannot keep.\n */\nfunction defaultFormatDuration(ms: number): string {\n if (!Number.isFinite(ms) || ms <= 0) return \"0 s\"\n if (ms < 60_000) return `${Math.max(1, Math.round(ms / 1000))} s`\n const minutes = Math.round(ms / 60_000)\n if (minutes < 60) return `${minutes} min`\n const hours = Math.floor(minutes / 60)\n const rest = minutes % 60\n return rest === 0 ? `${hours} h` : `${hours} h ${rest} min`\n}\n\n/**\n * Sub-cent totals are the norm for a short plan, and `$0.00` would read as\n * \"free\" — which is exactly the wrong thing to tell someone who is about to\n * approve spending. Anything above zero that rounds to nothing says so.\n */\nfunction defaultFormatCost(usd: number): string {\n if (!Number.isFinite(usd) || usd < 0) return \"—\"\n if (usd > 0 && usd < 0.01) return \"< $0.01\"\n return costFormatter.format(usd)\n}\n\nconst RISK_WORD: Record = {\n low: \"low risk\",\n medium: \"medium risk\",\n high: \"high risk\",\n}\n\nfunction plural(count: number, one: string, many: string): string {\n return count === 1 ? one : many\n}\n\n/* ------------------------------------------------------------------- pieces */\n\n/**\n * Three levels, three SHAPES (shield / triangle / info) and three tones. Colour\n * alone is unreadable in a monochrome theme and invisible to a colour-blind\n * reviewer — and this is the chip that decides whether someone reads the step\n * twice.\n */\nfunction RiskChip({ level }: { level: AgentPlanRiskLevel }) {\n const Icon = level === \"high\" ? ShieldAlert : level === \"medium\" ? TriangleAlert : Info\n return (\n \n \n {RISK_WORD[level]}\n \n )\n}\n\nfunction SkeletonRow() {\n return (\n
\n
\n
\n
\n
\n
\n
\n )\n}\n\n/* ------------------------------------------------------------------ derived */\n\ninterface PlanRow {\n step: AgentPlanStep\n /** The text as it stands now — the reviewer's edit if there is one, otherwise the agent's. */\n text: string\n included: boolean\n edited: boolean\n /** 1-based position in the run that would actually happen; `null` while excluded. */\n order: number | null\n}\n\nconst NO_STEPS: AgentPlanStep[] = []\n\n/* ---------------------------------------------------------------- component */\n\nexport interface AgentPlanProps extends React.HTMLAttributes {\n /** The proposal to review. `null` is allowed for the loading / empty / error envelopes. */\n plan: AgentPlanProposal | null\n /** Envelope state — whether there is a proposal at all. Not the reviewer's decision. */\n status: AgentPlanStatus\n /**\n * Freeze the draft: no toggling, no editing, no decision. For a transcript of a\n * plan that was already answered, or for a viewer without approval rights.\n */\n readOnly?: boolean\n /** Fired on every inclusion change with the step's NEW inclusion. Purely a notification — the card owns the draft. */\n onToggleStep?: (stepId: string, included: boolean) => void\n /** Fired when an inline edit is saved or reverted, with the text as it now stands. */\n onEditStep?: (stepId: string, text: string) => void\n /** Fired at most once per proposal id, with the included steps in run order, edits applied. */\n onApprove?: (planId: string, steps: AgentPlanStep[]) => void\n /**\n * Fired at most once per proposal id. Gets the note (undefined when blank) and\n * ALL steps with the reviewer's draft applied — what they dropped is half the\n * feedback.\n */\n onRequestChanges?: (planId: string, note: string | undefined, steps: AgentPlanStep[]) => void\n /** Renders \"Try again\" in the `status=\"error\"` branch; omit it to hide the affordance. */\n onRetry?: () => void\n /** Show each step's rationale line. Turn it off for a dense re-read of a plan you already understand. */\n showRationale?: boolean\n /** How many steps must stay in for Approve to be live. Clamped to >= 0. Default 1 — approving nothing is not approving. */\n minIncludedSteps?: number\n /** Override the duration wording (a working-day estimate, a token budget…). */\n formatDuration?: (ms: number) => string\n /** Override the money wording (another currency, credits, \"≈ 3k tokens\"). */\n formatCost?: (usd: number) => string\n /** Replaces the default Approve wording; the step count is appended by default. */\n approveLabel?: string\n /** Replaces the default `status=\"empty\"` body. */\n emptyState?: React.ReactNode\n /** Message shown in the `status=\"error\"` branch. */\n errorMessage?: string\n /** Accessible name prefix for the card region. */\n label?: string\n}\n\n/**\n * A plan the agent wants to run, presented while it is still a draft: ordered\n * steps with the reason each one exists, risk chips on the ones that can hurt,\n * per-step include/exclude, inline rewriting, a live duration/cost estimate for\n * exactly the steps that are still in — and one Approve / Request changes\n * decision that can only be made once.\n */\nexport const AgentPlan = React.forwardRef(\n (\n {\n plan,\n status,\n readOnly = false,\n onToggleStep,\n onEditStep,\n onApprove,\n onRequestChanges,\n onRetry,\n showRationale = true,\n minIncludedSteps = 1,\n formatDuration = defaultFormatDuration,\n formatCost = defaultFormatCost,\n approveLabel,\n emptyState,\n errorMessage = \"This plan couldn't be loaded.\",\n label = \"Proposed plan\",\n className,\n ...props\n },\n ref,\n ) => {\n const uid = React.useId()\n const planId = plan?.id ?? \"\"\n const steps = plan?.steps ?? NO_STEPS\n\n /**\n * The card owns the DRAFT, the consumer owns the plan. Inclusion and text\n * live here as sparse overrides on top of the contract, so a step the\n * reviewer never touched keeps following the data — and the callbacks stay\n * pure notifications instead of a state machine the consumer has to mirror.\n */\n const [overrides, setOverrides] = React.useState>({})\n const [edits, setEdits] = React.useState>({})\n const [editing, setEditing] = React.useState<{ id: string; draft: string } | null>(null)\n const [editBlocked, setEditBlocked] = React.useState(false)\n const [changesOpen, setChangesOpen] = React.useState(false)\n const [note, setNote] = React.useState(\"\")\n const [decision, setDecision] = React.useState<{ kind: AgentPlanDecisionKind; note?: string } | null>(null)\n const [prevPlanId, setPrevPlanId] = React.useState(planId)\n /**\n * Generation of the decision gate. It ticks whenever a NEW proposal arrives,\n * which is what makes \"already answered\" expire by itself.\n */\n const [gate, setGate] = React.useState(0)\n\n /**\n * The one-shot lock. It lives in a REF, not in state: several clicks\n * dispatched inside a single task all read the same stale state, so a\n * state-only guard would let the extra ones through and start the same run\n * twice. Written only from event handlers.\n */\n const answeredGate = React.useRef(-1)\n const editorRef = React.useRef(null)\n const noteRef = React.useRef(null)\n /**\n * Which row's Edit button should take focus once it is back on screen.\n * Handed over in the ref callback rather than an effect: closing an editor\n * unmounts the control that had focus, and the callback runs during the\n * commit that puts the button back — no extra render, no focus flicker.\n */\n const pendingFocus = React.useRef(null)\n\n // Adjust-state-during-render, no effect: there is never a frame where the\n // previous proposal's toggles, edits or decision are applied to a new one.\n if (prevPlanId !== planId) {\n setPrevPlanId(planId)\n setOverrides({})\n setEdits({})\n setEditing(null)\n setEditBlocked(false)\n setChangesOpen(false)\n setNote(\"\")\n setDecision(null)\n setGate(g => g + 1)\n }\n\n const rows = React.useMemo(() => {\n const seen = new Set()\n const out: PlanRow[] = []\n let order = 0\n for (const step of steps) {\n // Duplicate ids would make one toggle move two rows and one edit rewrite\n // two steps, because both are keyed by id. First occurrence wins.\n if (!step.id || seen.has(step.id)) continue\n seen.add(step.id)\n const included = step.required === true ? true : (overrides[step.id] ?? step.included)\n const edit = edits[step.id]\n if (included) order += 1\n out.push({\n step,\n text: edit ?? step.text,\n included,\n edited: edit !== undefined && edit !== step.text,\n order: included ? order : null,\n })\n }\n return out\n }, [steps, overrides, edits])\n\n const effectiveSteps = React.useMemo(\n () => rows.map(row => ({ ...row.step, text: row.text, included: row.included })),\n [rows],\n )\n const includedSteps = React.useMemo(() => effectiveSteps.filter(step => step.included), [effectiveSteps])\n\n /**\n * Totals cover the INCLUDED steps only and are recomputed on every toggle —\n * an estimate that still counts a step you dropped is a lie that gets\n * budgeted against. Steps with no estimate at all are counted separately\n * instead of contributing a silent zero.\n */\n const totals = React.useMemo(() => {\n let ms = 0\n let usd = 0\n let hasDuration = false\n let hasCost = false\n let unestimated = 0\n let highRisk = 0\n for (const row of rows) {\n if (!row.included) continue\n if (row.step.risk?.level === \"high\") highRisk += 1\n const duration = row.step.estimate?.durationMs\n const cost = row.step.estimate?.costUsd\n const okDuration = typeof duration === \"number\" && Number.isFinite(duration)\n const okCost = typeof cost === \"number\" && Number.isFinite(cost)\n if (okDuration) {\n ms += Math.max(0, duration)\n hasDuration = true\n }\n if (okCost) {\n usd += Math.max(0, cost)\n hasCost = true\n }\n if (!okDuration && !okCost) unestimated += 1\n }\n return { ms: hasDuration ? ms : null, usd: hasCost ? usd : null, unestimated, highRisk }\n }, [rows])\n\n const editingId = editing?.id ?? null\n React.useEffect(() => {\n if (editingId === null) return\n const el = editorRef.current\n if (!el) return\n el.focus()\n // Caret at the end, not a full selection: the reviewer is amending the\n // agent's wording, and a select-all makes the first keystroke destroy it.\n const end = el.value.length\n el.setSelectionRange(end, end)\n }, [editingId])\n\n React.useEffect(() => {\n if (!changesOpen) return\n noteRef.current?.focus()\n }, [changesOpen])\n\n const answered = decision !== null\n const locked = readOnly || answered\n const editorOpen = editing !== null\n\n const closeEditor = (focusId: string) => {\n setEditing(null)\n setEditBlocked(false)\n pendingFocus.current = focusId\n }\n\n const openEditor = (row: PlanRow) => {\n if (locked || !row.step.editable) return\n if (editing) {\n if (editing.id === row.step.id) return\n const current = rows.find(item => item.step.id === editing.id)\n const dirty = current ? editing.draft !== current.text : editing.draft.trim() !== \"\"\n // A second editor would have to discard this draft to open, and silently\n // throwing away someone's rewrite is the one thing this card must not do.\n if (dirty) {\n setEditBlocked(true)\n return\n }\n }\n setEditBlocked(false)\n setEditing({ id: row.step.id, draft: row.text })\n }\n\n const saveEditor = () => {\n const draft = editing\n if (!draft) return\n const next = draft.draft.trim()\n // An empty step is not an edit, it is a deletion — and deletion already has\n // a control: the include toggle.\n if (next === \"\") return\n const row = rows.find(item => item.step.id === draft.id)\n const original = row?.step.text\n setEdits(map => {\n const copy = { ...map }\n // Typing the agent's wording back drops the override entirely, so the\n // \"edited\" marker only ever means \"this differs from what was proposed\".\n if (next === original) delete copy[draft.id]\n else copy[draft.id] = next\n return copy\n })\n if (next !== row?.text) onEditStep?.(draft.id, next)\n closeEditor(draft.id)\n }\n\n const revertEdit = (row: PlanRow) => {\n if (locked) return\n setEdits(map => {\n const copy = { ...map }\n delete copy[row.step.id]\n return copy\n })\n onEditStep?.(row.step.id, row.step.text)\n pendingFocus.current = row.step.id\n }\n\n const toggleStep = (row: PlanRow) => {\n if (locked || row.step.required === true) return\n const next = !row.included\n setOverrides(map => ({ ...map, [row.step.id]: next }))\n onToggleStep?.(row.step.id, next)\n }\n\n const minSteps = Math.max(0, Math.floor(Number.isFinite(minIncludedSteps) ? minIncludedSteps : 1))\n const approveBlockedReason = editorOpen\n ? \"Save or cancel the step you're editing before you decide.\"\n : includedSteps.length < minSteps\n ? `Keep at least ${minSteps} ${plural(minSteps, \"step\", \"steps\")} in the run to approve this plan.`\n : null\n\n const decide = (kind: AgentPlanDecisionKind) => {\n if (!plan) return\n if (answeredGate.current === gate) return\n if (editorOpen) return\n if (kind === \"approved\" && includedSteps.length < minSteps) return\n answeredGate.current = gate\n const trimmed = note.trim()\n const noteText = trimmed === \"\" ? undefined : trimmed\n setDecision({ kind, note: kind === \"changes-requested\" ? noteText : undefined })\n if (kind === \"approved\") onApprove?.(plan.id, includedSteps)\n else onRequestChanges?.(plan.id, noteText, effectiveSteps)\n }\n\n /* ------------------------------------------------------------ envelopes */\n\n const rootClass = cn(\"w-full min-w-0 rounded-lg border bg-card text-sm\", className)\n\n if (status === \"loading\") {\n return (\n
\n \n Loading the proposed plan\n \n
\n
\n
\n
\n
\n
\n \n \n \n
\n
\n
\n
\n
\n
\n )\n }\n\n if (status === \"error\") {\n return (\n
\n
\n

\n \n Couldn't load this plan\n

\n

{errorMessage}

\n {onRetry && (\n \n )}\n
\n
\n )\n }\n\n // A proposal with no steps renders the empty body on purpose: a plan with\n // nothing in it is not a plan you can approve, and showing its title with an\n // Approve button under it would invite exactly that.\n if (status === \"empty\" || !plan || rows.length === 0) {\n return (\n
\n {emptyState ?? (\n
\n

\n \n No plan to review yet.\n

\n

\n The agent will propose its steps here before it runs any of them.\n

\n
\n )}\n
\n )\n }\n\n /* ---------------------------------------------------------------- ready */\n\n const total = rows.length\n const includedCount = includedSteps.length\n const durationText = totals.ms === null ? null : formatDuration(totals.ms)\n const costText = totals.usd === null ? null : formatCost(totals.usd)\n const hintId = `${uid}-hint`\n const noteId = `${uid}-note`\n const decisionKind = decision?.kind ?? null\n const decisionNote = decision?.note\n\n const stateWord =\n decisionKind === \"approved\"\n ? \"Approved\"\n : decisionKind === \"changes-requested\"\n ? \"Changes requested\"\n : readOnly\n ? \"Read only\"\n : \"Needs review\"\n\n const announcement = [\n `${includedCount} of ${total} ${plural(total, \"step\", \"steps\")} in the run`,\n durationText ? `about ${durationText}` : null,\n costText ? `about ${costText}` : null,\n totals.highRisk > 0 ? `${totals.highRisk} high risk` : null,\n decisionKind === \"approved\" ? \"plan approved\" : decisionKind === null ? null : \"changes requested\",\n ]\n .filter(Boolean)\n .join(\", \")\n\n return (\n \n {/* One persistent live region, mounted for the whole ready branch, so a\n CHANGE (toggle, edit, decision) is announced from an element the\n screen reader is already watching instead of a fresh node. */}\n

\n {announcement}\n

\n\n
\n \n
\n

{plan.title}

\n {plan.goal &&

{plan.goal}

}\n
\n \n {stateWord}\n \n
\n\n
    \n {rows.map(row => {\n const textId = `${uid}-step-${row.step.id}`\n // The open editor belongs to exactly one row; hold it as a nullable\n // local so the branch below reads the draft without re-checking it.\n const draft = editing !== null && editing.id === row.step.id ? editing : null\n const required = row.step.required === true\n const risk = row.step.risk\n return (\n \n {/* role=checkbox, not aria-pressed: this is \"is this step part of\n the run\", a selection, not a pushed state. A \n\n
    \n
    \n {/* The number is the position in the run that would actually\n happen, so excluding step 2 renumbers everything after it\n instead of leaving a hole in the order. */}\n \n {row.order === null ? \"—\" : `${row.order}.`}\n \n \n {row.text}\n \n {risk && }\n {row.edited && (\n \n \n edited\n \n )}\n
    \n\n {showRationale && row.step.rationale && draft === null && (\n

    \n Why: \n {row.step.rationale}\n

    \n )}\n\n {risk?.note && (\n \n {risk.note}\n

    \n )}\n\n {draft !== null ? (\n // The shortcuts are advertised next to Save/Cancel, so they are\n // bound to the whole editor and not just the field: a reviewer\n // left on the Save button by a refused empty draft must still be\n // able to press Esc to get out.\n {\n if (event.key === \"Escape\") {\n event.preventDefault()\n closeEditor(row.step.id)\n return\n }\n if (event.key === \"Enter\" && (event.metaKey || event.ctrlKey)) {\n event.preventDefault()\n saveEditor()\n }\n }}\n >\n setEditing({ id: row.step.id, draft: event.target.value })}\n ref={editorRef}\n value={draft.draft}\n />\n
    \n \n \n Save step\n \n \n \n {draft.draft.trim() === \"\"\n ? \"A step can't be empty — exclude it instead.\"\n : \"⌘/Ctrl + Enter saves · Esc cancels\"}\n \n
    \n {editBlocked && (\n

    \n Save or cancel this step before editing another one.\n

    \n )}\n
    \n ) : (\n (row.step.estimate || (row.step.editable && !locked) || row.edited) && (\n
    \n {row.step.estimate?.durationMs !== undefined && (\n \n \n {formatDuration(row.step.estimate.durationMs)}\n \n )}\n {row.step.estimate?.costUsd !== undefined && (\n \n \n {formatCost(row.step.estimate.costUsd)}\n \n )}\n {row.step.editable && !locked && (\n openEditor(row)}\n ref={node => {\n if (node && pendingFocus.current === row.step.id) {\n pendingFocus.current = null\n node.focus()\n }\n }}\n size=\"xs\"\n type=\"button\"\n variant=\"ghost\"\n >\n \n Edit\n \n )}\n {row.edited && !locked && (\n \n )}\n
    \n )\n )}\n
\n \n )\n })}\n \n\n
\n \n \n \n {includedCount} of {total} {plural(total, \"step\", \"steps\")}\n \n {durationText && (\n \n ≈ {durationText}\n \n )}\n {costText && (\n \n ≈ {costText}\n \n )}\n {/* Never a silent understatement: the steps that carry no estimate are\n named, so the total is read as \"at least this much\". */}\n {totals.unestimated > 0 && (\n \n {totals.unestimated} {plural(totals.unestimated, \"step has\", \"steps have\")} no estimate\n \n )}\n
\n\n {totals.highRisk > 0 && (\n

\n \n \n {totals.highRisk} high-risk {plural(totals.highRisk, \"step is\", \"steps are\")} still in the run.\n Excluding {plural(totals.highRisk, \"it\", \"them\")} here is cheaper than undoing{\" \"}\n {plural(totals.highRisk, \"it\", \"them\")} later.\n \n

\n )}\n\n {decisionKind !== null ? (\n decisionKind === \"approved\" ? (\n

\n \n \n Plan approved. \n \n {includedCount} {plural(includedCount, \"step\", \"steps\")} went to the agent\n {durationText ? `, about ${durationText}` : \"\"}. The draft is locked — a plan you can still\n edit after approving it is not the plan that runs.\n \n \n

\n ) : (\n
\n

\n \n \n Changes requested. \n \n Sent back with {includedCount} of {total} {plural(total, \"step\", \"steps\")} still selected.\n \n \n

\n

\n {decisionNote ?? \"No note — the agent only learns which steps you dropped.\"}\n

\n
\n )\n ) : readOnly ? (\n

This plan is read-only for you.

\n ) : onApprove || onRequestChanges ? (\n
\n {changesOpen ? (\n
\n \n setNote(event.target.value)}\n placeholder=\"e.g. don't touch production data — stage it first\"\n ref={noteRef}\n value={note}\n />\n
\n decide(\"changes-requested\")}\n size=\"sm\"\n type=\"button\"\n variant=\"destructive\"\n >\n \n Send request\n \n \n
\n
\n ) : (\n
\n {onApprove && (\n // aria-disabled, never the native attribute: `disabled` drops\n // focus to the instant it flips and takes the button\n // out of the tab order, so the reason is never announced.\n decide(\"approved\")}\n size=\"sm\"\n type=\"button\"\n >\n \n {approveLabel ??\n `Approve ${includedCount} ${plural(includedCount, \"step\", \"steps\")}`}\n \n )}\n {onRequestChanges && (\n {\n if (editorOpen) return\n setChangesOpen(true)\n }}\n size=\"sm\"\n type=\"button\"\n variant=\"outline\"\n >\n \n Request changes\n \n )}\n
\n )}\n {/* The \"keep at least N steps\" reason belongs to Approve only, so it\n is not repeated inside the request-changes pane — you are allowed\n to send an empty selection back. */}\n {(editorOpen || !changesOpen) && approveBlockedReason && (\n

\n {approveBlockedReason}\n

\n )}\n
\n ) : (\n // No handler, no buttons: an Approve button that approves nothing is\n // worse than no button at all.\n

Waiting for a decision elsewhere in your app.

\n )}\n \n \n )\n },\n)\n\nAgentPlan.displayName = \"AgentPlan\"\n\nexport default AgentPlan\n", "type": "registry:ui" }, { "path": "src/registry/ui/agent-plan.contract.ts", "content": "import { z } from \"zod\"\n\n/**\n * A plan an agent proposes BEFORE it runs anything.\n *\n * The whole contract is written for the moment where a human is still allowed to\n * say no: every step carries the reason it exists (`rationale`), how badly it can\n * hurt (`risk`), whether it is currently part of the run (`included`) and whether\n * its wording may be rewritten (`editable`). Nothing here describes progress —\n * there is no \"running\", no \"done\", no percentage. A plan that has started\n * executing is a different object, and a different component.\n */\n\n/**\n * How much damage a step can do if it is wrong.\n *\n * Three levels, not a boolean: \"this reads a file\" / \"this posts to a staging\n * webhook\" / \"this drops a production table\" are genuinely three different\n * decisions, and a reviewer shown one warning colour for all of them stops\n * reading warnings.\n */\nexport const AGENT_PLAN_RISK_LEVELS = [\"low\", \"medium\", \"high\"] as const\nexport const agentPlanRiskLevelSchema = z.enum(AGENT_PLAN_RISK_LEVELS)\nexport type AgentPlanRiskLevel = z.infer\n\nexport const agentPlanRiskSchema = z.object({\n level: agentPlanRiskLevelSchema,\n /**\n * The blast radius in the reviewer's words — \"deletes 3 files the billing job\n * still imports\". A level on its own is a colour; the note is the thing people\n * actually decide on.\n */\n note: z.string().optional(),\n})\nexport type AgentPlanRisk = z.infer\n\n/**\n * What one step is expected to cost. Both fields are optional and independent —\n * an agent usually knows one and guesses the other. A missing value is never\n * treated as zero: the footer counts the steps that carry no estimate and says\n * so, because an understated total is worse than no total.\n */\nexport const agentPlanEstimateSchema = z.object({\n /** Expected wall-clock duration in milliseconds. */\n durationMs: z.number().nonnegative().optional(),\n /** Expected spend in USD (token cost, API cost — your definition). */\n costUsd: z.number().nonnegative().optional(),\n})\nexport type AgentPlanEstimate = z.infer\n\nexport const agentPlanStepSchema = z.object({\n /**\n * Stable identity. It keys the React list, the inclusion override and the text\n * edit, so duplicates are dropped (first occurrence wins) instead of letting\n * one toggle move two rows at once.\n */\n id: z.string().min(1),\n /** The instruction itself, as the agent would execute it. Rendered in full, never clamped. */\n text: z.string(),\n /**\n * Why the agent put this step in the plan. This is the difference between a\n * plan you can review and a list you can only trust: without it, excluding a\n * step is a guess.\n */\n rationale: z.string().optional(),\n risk: agentPlanRiskSchema.optional(),\n /** Whether the step starts in the run. Reviewer toggles override this locally until the plan id changes. */\n included: z.boolean(),\n /** Whether the reviewer may rewrite `text` in place. `false` renders no edit affordance at all. */\n editable: z.boolean(),\n /**\n * A step the rest of the plan depends on. Its toggle renders locked and it is\n * always counted as included — `included: false` on a required step is a\n * contradiction, and the component resolves it in favour of \"required\".\n */\n required: z.boolean().optional(),\n estimate: agentPlanEstimateSchema.optional(),\n})\nexport type AgentPlanStep = z.infer\n\nexport const agentPlanProposalSchema = z.object({\n /**\n * Identity of this *proposal*. Changing it is how you hand over a revised plan:\n * the card throws away every local toggle, edit and decision and re-arms the\n * approve gate. Reusing the id while changing the steps leaves the reviewer's\n * draft sitting on top of a plan they never saw.\n */\n id: z.string().min(1),\n title: z.string(),\n /** The request this plan answers, in the user's own words. Shown under the title. */\n goal: z.string().optional(),\n /** Ordered. The numbering the reviewer sees is derived from this order, never stored. */\n steps: z.array(agentPlanStepSchema),\n})\nexport type AgentPlanProposal = z.infer\n\n/**\n * The card's own render state — \"is there a proposal to review at all\". It is\n * independent of what the reviewer then decides: `error` here means the proposal\n * failed to load, not that the plan is bad.\n */\nexport const agentPlanStatusSchema = z.enum([\"loading\", \"empty\", \"error\", \"ready\"])\nexport type AgentPlanStatus = z.infer\n\n/** The envelope a data layer / mock factory hands over; the demo spreads it into the props. */\nexport const agentPlanSchema = z.object({\n status: agentPlanStatusSchema,\n plan: agentPlanProposalSchema.nullable(),\n})\nexport type AgentPlanData = z.infer\n\n/** The two ways a review ends. Both are terminal for one proposal id. */\nexport const agentPlanDecisionKindSchema = z.enum([\"approved\", \"changes-requested\"])\nexport type AgentPlanDecisionKind = z.infer\n", "type": "registry:ui" } ], "type": "registry:ui" }