forgeos 0.1.0-alpha.21 → 0.1.0-alpha.22

package/AGENTS.md

@@ -1,4 +1,4 @@
-// @forge-generated generator=0.1.0-alpha.21 input=e2f2a360a9fd4118a2d21dd1353365628fe3927c40f9f9ce870f448f3e221f90 content=0d493cf0e41b71cb652d5e0e1b0c1f83d2a1281b748321f0b00f0773ba93074e
+// @forge-generated generator=0.1.0-alpha.22 input=d8837238db9cf8868eceae3e3cc5a7d9bb46a0955c55f0143caa802597d5a3a5 content=0d493cf0e41b71cb652d5e0e1b0c1f83d2a1281b748321f0b00f0773ba93074e
 # AGENTS.md
 
 <!-- forge-generated:start -->

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # forgeos
 
+## Unreleased
+
+## 0.1.0-alpha.22
+
+### Patch Changes
+
+- Improve the post-alpha.21 agent workflow without adding new MCP tools.
+
+  - Add `forge agent context` scopes for entry, change, proof, and handoff context packs.
+  - Add DeltaDB verbose health details for queue redaction, operation age, semantic projection state, and overhead posture.
+  - Add `forge delta compact`, `forge delta prune`, and redacted `forge delta export` for local Delta maintenance and support bundles.
+  - Add `forge doctor delta` for recorder writability, queue drain, redaction, and gitignore checks.
+  - Add Semantic Timeline summary data for stale proofs and causal chains.
+  - Record CAIR snapshot/query/action activity as Delta timeline events without adding new MCP tools.
+  - Add a Studio snapshot handoff block and a dedicated CAIR Protocol documentation page.
+  - Add an official `nuxt-web` template with a Forge notes backend, client/server Nuxt plugins, a `useNotes` composable, a Nitro runtime-config route, and generated Vue composables.
+
 ## 0.1.0-alpha.21
 
 ### Patch Changes
@@ -23,8 +40,6 @@
   - Preserve empty stdio command arguments, diagnose malformed command strings, and support structured `service.commandArgs` in external manifests.
   - Include the basic example client demo in typecheck coverage.
 
-## Unreleased
-
 ## 0.1.0-alpha.19
 
 Alpha hardening:

package/docs/changelog.md

@@ -6,6 +6,19 @@ The canonical source file in the repository is `CHANGELOG.md`.
 
 ## Unreleased
 
+## 0.1.0-alpha.22
+
+- Added focused post-alpha.21 workflow improvements without expanding MCP tools:
+  scoped Agent Memory context packs, DeltaDB verbose health details, Semantic
+  Timeline stale-proof/causal summaries, Studio snapshot handoff metadata,
+  local Delta maintenance commands (`compact`, `prune`, redacted `export`),
+  `forge doctor delta`, CAIR timeline events, and a dedicated CAIR Protocol
+  documentation page.
+- Added an official `nuxt-web` template: a Forge notes backend plus Nuxt app
+  using client/server Forge plugins, `web/composables/useNotes.ts`, generated
+  Vue composables, a Nitro runtime-config route, and
+  `NUXT_PUBLIC_FORGE_URL`.
+
 ## 0.1.0-alpha.21
 
 Alpha.21 hardens external-agent privacy and brownfield import polish:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forgeos",
-  "version": "0.1.0-alpha.21",
+  "version": "0.1.0-alpha.22",
   "description": "Agent-native application framework and compiler for building Forge apps without a mandatory dashboard.",
   "type": "module",
   "files": [

package/src/forge/_generated/releaseManifest.json

@@ -1 +1 @@
-{"defaultProvider":"local","diagnostics":[],"env":{"deployEnv":"FORGE_DEPLOY_ENV","deployId":"FORGE_DEPLOY_ID","publicReleaseId":"NEXT_PUBLIC_FORGE_RELEASE_ID","releaseId":"FORGE_RELEASE_ID"},"gitSha":"unknown","optionalProviders":["local","sentry-compatible","sentry","glitchtip","bugsink","otel","custom"],"packageName":"forgeos","packageVersion":"0.1.0-alpha.21","releaseId":"forgeos@0.1.0-alpha.21+unknown","schemaVersion":"0.1.0"}
+{"defaultProvider":"local","diagnostics":[],"env":{"deployEnv":"FORGE_DEPLOY_ENV","deployId":"FORGE_DEPLOY_ID","publicReleaseId":"NEXT_PUBLIC_FORGE_RELEASE_ID","releaseId":"FORGE_RELEASE_ID"},"gitSha":"unknown","optionalProviders":["local","sentry-compatible","sentry","glitchtip","bugsink","otel","custom"],"packageName":"forgeos","packageVersion":"0.1.0-alpha.22","releaseId":"forgeos@0.1.0-alpha.22+unknown","schemaVersion":"0.1.0"}

package/src/forge/_generated/releaseManifest.ts

@@ -1,4 +1,4 @@
-// @forge-generated generator=0.1.0-alpha.21 input=e2f2a360a9fd4118a2d21dd1353365628fe3927c40f9f9ce870f448f3e221f90 content=dcf914c56ed71bee812d0015d689e1dbf4e952b17ad03cd835f396f5fc8fee1a
+// @forge-generated generator=0.1.0-alpha.22 input=d8837238db9cf8868eceae3e3cc5a7d9bb46a0955c55f0143caa802597d5a3a5 content=bb05ee3635ddeea2d84168f8bf728e07f82e896061e8494b17f56dea26000770
 export const releaseManifest = {
   "defaultProvider": "local",
   "diagnostics": [],
@@ -19,7 +19,7 @@ export const releaseManifest = {
     "custom"
   ],
   "packageName": "forgeos",
-  "packageVersion": "0.1.0-alpha.21",
-  "releaseId": "forgeos@0.1.0-alpha.21+unknown",
+  "packageVersion": "0.1.0-alpha.22",
+  "releaseId": "forgeos@0.1.0-alpha.22+unknown",
   "schemaVersion": "0.1.0"
 } as const;

package/src/forge/agent-adapters/types.ts

@@ -34,6 +34,9 @@ export interface AgentCommandOptions {
   hookAction?: "smoke" | "status" | string;
   input?: unknown;
   entry?: string;
+  change?: string;
+  proof?: string;
+  handoff?: boolean;
   current?: boolean;
   limit?: number;
   watch?: boolean;

package/src/forge/agent-memory/bridge.ts

@@ -29,6 +29,9 @@ export interface AgentMemoryCommandOptions {
   eventName?: string;
   input?: unknown;
   entry?: string;
+  change?: string;
+  proof?: string;
+  handoff?: boolean;
   current?: boolean;
   dryRun?: boolean;
   force?: boolean;
@@ -308,6 +311,9 @@ export async function runAgentMemoryCommand(options: AgentMemoryCommandOptions):
       return await buildAgentMemoryContext({
         workspaceRoot: options.workspaceRoot,
         entry: options.entry,
+        change: options.change,
+        proof: options.proof,
+        handoff: options.handoff,
         limit: options.limit,
       });
     } catch (error) {
@@ -1052,6 +1058,12 @@ function formatAgentMemoryContextHuman(result: AgentMemoryContextPack): string {
       lines.push(`  - ${question}`);
     }
   }
+  if (result.recommendedCommands.length > 0) {
+    lines.push("", "Next:");
+    for (const command of result.recommendedCommands.slice(0, 6)) {
+      lines.push(`  ${command}`);
+    }
+  }
   return `${lines.join("\n")}\n`;
 }
 

package/src/forge/agent-memory/context-pack.ts

@@ -4,14 +4,26 @@ import type { AgentMemoryContextEvent, AgentMemoryContextPack, AgentMemoryEventR
 export async function buildAgentMemoryContext(input: {
   workspaceRoot: string;
   entry?: string;
+  change?: string;
+  proof?: string;
+  handoff?: boolean;
   limit?: number;
 }): Promise<AgentMemoryContextPack> {
   const store = await DeltaStore.open(input.workspaceRoot, { access: "read" });
   try {
-    const target = input.entry;
-    const events = await store.listAgentMemoryEvents({ target, limit: input.limit ?? 50 });
-    const timeline = target ? await store.semanticTimeline({ target, limit: input.limit ?? 50 }) : undefined;
-    const current = target ? timeline?.currentState ?? {} : await currentSessionState(store);
+    const scope = contextScope(input);
+    const target = contextTarget(input, scope);
+    const currentSession = await store.currentWorkSession();
+    const sessionId = scope === "change" && (input.change === "current" || !input.change)
+      ? currentSession?.id
+      : undefined;
+    const events = await store.listAgentMemoryEvents({ target: eventTarget(input, scope), limit: input.limit ?? 50 });
+    const timeline = target || sessionId
+      ? await store.semanticTimeline({ target, workSessionId: sessionId, limit: input.limit ?? 50 })
+      : undefined;
+    const current = timeline?.currentState && Object.keys(timeline.currentState).length > 0
+      ? timeline.currentState
+      : await currentSessionState(store, currentSession);
     const goals = events
       .filter((event) => event.normalizedKind === "agent.prompt.submitted")
       .map((event) => ({
@@ -35,9 +47,12 @@ export async function buildAgentMemoryContext(input: {
     const openQuestions = timeline?.openQuestions ?? [];
     return {
       ok: true,
-      scope: target ? "entry" : "current",
-      entry: target,
+      scope,
+      entry: input.entry,
+      change: input.change,
+      proof: input.proof,
       currentState: current,
+      recommendedCommands: recommendedCommands(scope, input, currentSession?.id),
       agentMemory: {
         summary: {
           events: contextEventItems.length,
@@ -68,6 +83,84 @@ export async function buildAgentMemoryContext(input: {
   }
 }
 
+function contextScope(input: {
+  entry?: string;
+  change?: string;
+  proof?: string;
+  handoff?: boolean;
+}): AgentMemoryContextPack["scope"] {
+  if (input.handoff) {
+    return "handoff";
+  }
+  if (input.proof) {
+    return "proof";
+  }
+  if (input.change) {
+    return "change";
+  }
+  return input.entry ? "entry" : "current";
+}
+
+function contextTarget(
+  input: { entry?: string; change?: string; proof?: string },
+  scope: AgentMemoryContextPack["scope"],
+): string | undefined {
+  if (scope === "entry") {
+    return input.entry;
+  }
+  if (scope === "proof") {
+    return input.proof?.includes(":") ? input.proof : `proof:${input.proof}`;
+  }
+  if (scope === "change" && input.change && input.change !== "current") {
+    return input.change.includes(":") ? input.change : `session:${input.change}`;
+  }
+  return undefined;
+}
+
+function eventTarget(
+  input: { entry?: string; change?: string; proof?: string },
+  scope: AgentMemoryContextPack["scope"],
+): string | undefined {
+  if (scope === "entry") {
+    return input.entry;
+  }
+  if (scope === "proof") {
+    return input.proof;
+  }
+  if (scope === "change" && input.change !== "current") {
+    return input.change;
+  }
+  return undefined;
+}
+
+function recommendedCommands(
+  scope: AgentMemoryContextPack["scope"],
+  input: { entry?: string; change?: string; proof?: string },
+  currentSessionId: string | undefined,
+): string[] {
+  const commands = [
+    "forge agent timeline --json",
+    "forge delta status --verbose --json",
+  ];
+  if (scope === "entry" && input.entry) {
+    commands.push(`forge timeline ${input.entry} --json`);
+    commands.push(`forge explain ${input.entry} --json`);
+  }
+  if (scope === "proof" && input.proof) {
+    commands.push(`forge timeline proof:${input.proof.replace(/^proof:/u, "")} --json`);
+  }
+  if (scope === "change") {
+    commands.push(`forge timeline --session ${input.change === "current" || !input.change ? "current" : input.change} --json`);
+    commands.push("forge changed --json");
+  }
+  if (scope === "handoff") {
+    commands.push("forge handoff --json");
+    commands.push(`forge timeline --session ${currentSessionId ?? "current"} --json`);
+    commands.push("forge changed --json");
+  }
+  return [...new Set(commands)];
+}
+
 function contextEvents(events: AgentMemoryEventRecord[]): AgentMemoryContextEvent[] {
   return events.map((event) => {
     const eventBindings = bindings(event);
@@ -92,8 +185,8 @@ function contextEvents(events: AgentMemoryEventRecord[]): AgentMemoryContextEven
   });
 }
 
-async function currentSessionState(store: DeltaStore): Promise<Record<string, unknown>> {
-  const session = await store.currentWorkSession();
+async function currentSessionState(store: DeltaStore, currentSession?: Awaited<ReturnType<DeltaStore["currentWorkSession"]>>): Promise<Record<string, unknown>> {
+  const session = currentSession ?? await store.currentWorkSession();
   return session
     ? {
         sessionId: session.id,
@@ -101,6 +194,11 @@ async function currentSessionState(store: DeltaStore): Promise<Record<string, un
         inferredIntent: session.inferredIntent,
         confidence: session.confidence,
         status: session.status,
+        reasons: session.reasons.slice(0, 5).map((reason) => ({
+          signal: reason.signal,
+          weight: reason.weight,
+          ...(reason.value ? { value: reason.value } : {}),
+        })),
       }
     : {};
 }

package/src/forge/agent-memory/types.ts

@@ -92,9 +92,12 @@ export interface AgentMemoryContextEvent {
 
 export interface AgentMemoryContextPack {
   ok: true;
-  scope: "current" | "entry";
+  scope: "current" | "entry" | "change" | "proof" | "handoff";
   entry?: string;
+  change?: string;
+  proof?: string;
   currentState: Record<string, unknown>;
+  recommendedCommands: string[];
   agentMemory: {
     summary: {
       events: number;

package/src/forge/cli/commands.ts

@@ -128,6 +128,14 @@ import {
 import {
   formatDeltaExplainHuman,
   formatDeltaExplainJson,
+  formatDeltaCompactHuman,
+  formatDeltaCompactJson,
+  formatDeltaDoctorHuman,
+  formatDeltaDoctorJson,
+  formatDeltaExportHuman,
+  formatDeltaExportJson,
+  formatDeltaPruneHuman,
+  formatDeltaPruneJson,
   formatDeltaRepairHuman,
   formatDeltaRepairJson,
   formatDeltaStatusHuman,
@@ -137,6 +145,10 @@ import {
   formatDeltaTimelineHuman,
   formatDeltaTimelineJson,
   runDeltaExplain,
+  runDeltaCompact,
+  runDeltaDoctor,
+  runDeltaExport,
+  runDeltaPrune,
   runDeltaRepair,
   runDeltaSessionCommand,
   runDeltaStatus,
@@ -1641,6 +1653,11 @@ export async function executeCommand(command: ForgeCommand): Promise<number> {
         }
         return result.exitCode;
       }
+      if (command.target === "delta") {
+        const result = await runDeltaDoctor(command.workspaceRoot);
+        process.stdout.write(command.json ? formatDeltaDoctorJson(result) : formatDeltaDoctorHuman(result));
+        return result.exitCode;
+      }
       const result = await runDoctorCommand({ workspaceRoot: command.workspaceRoot });
       if (command.json) {
         process.stdout.write(formatDoctorJson(result));
@@ -1808,6 +1825,34 @@ export async function executeCommand(command: ForgeCommand): Promise<number> {
       return result.exitCode;
     }
     case "delta": {
+      if (command.subcommand === "compact") {
+        const result = await runDeltaCompact({
+          workspaceRoot: command.workspaceRoot,
+          dryRun: command.dryRun,
+        });
+        process.stdout.write(command.json ? formatDeltaCompactJson(result) : formatDeltaCompactHuman(result));
+        return result.exitCode;
+      }
+      if (command.subcommand === "prune") {
+        const result = await runDeltaPrune({
+          workspaceRoot: command.workspaceRoot,
+          olderThan: command.olderThan,
+          dryRun: command.dryRun,
+          yes: command.yes,
+        });
+        process.stdout.write(command.json ? formatDeltaPruneJson(result) : formatDeltaPruneHuman(result));
+        return result.exitCode;
+      }
+      if (command.subcommand === "export") {
+        const result = await runDeltaExport({
+          workspaceRoot: command.workspaceRoot,
+          redacted: command.redacted,
+          output: command.output,
+          limit: command.limit,
+        });
+        process.stdout.write(command.json ? formatDeltaExportJson(result) : formatDeltaExportHuman(result));
+        return result.exitCode;
+      }
       if (command.subcommand === "repair") {
         const result = await runDeltaRepair({
           workspaceRoot: command.workspaceRoot,
@@ -1842,6 +1887,8 @@ export async function executeCommand(command: ForgeCommand): Promise<number> {
         session: command.sessionId,
         limit: command.limit,
         rebuild: command.rebuild,
+        causal: command.causal,
+        staleProofs: command.staleProofs,
       });
       process.stdout.write(command.json ? formatDeltaTimelineJson(result) : formatDeltaTimelineHuman(result));
       return result.exitCode;

package/src/forge/cli/main.ts

@@ -18,6 +18,7 @@ function formatHelp(): string {
     "  forge handoff --json      Compact work handoff for the next external code agent",
     "  forge agent onboard --target codex --json  Prepare adapter, hooks, memory, and dev snapshot",
     "  forge doctor agent --target codex --json  Check adapter, hooks, and Agent Memory readiness",
+    "  forge doctor delta --json  Check DeltaDB writability, queue drain, redaction, and gitignore posture",
     "  forge agent ingest codex --watch --file .forge/agent/events.ndjson --json",
     "  forge docs check --json  Check public docs, ReadTheDocs config, links, and local MkDocs tooling",
     "  forge docs check --build --install-venv --json  Build docs strictly in a local RTD-style venv",
@@ -25,6 +26,9 @@ function formatHelp(): string {
     "  forge release check --allow-missing-local-release --json  Gate release readiness without failing on unprepared local artifacts",
     "  forge self-host check --prepared-only --json  Report compose readiness without creating deploy files",
     "  forge delta status --verbose --json  Include Delta schema, lock, and aggregate count details",
+    "  forge delta compact --json  Compact redacted local agent queue history",
+    "  forge delta prune --older-than 30d --dry-run --json  Plan local Delta operational retention",
+    "  forge delta export --redacted --json  Export redacted Delta status, timeline, and agent memory",
     "  forge studio open <app-path> --preview-port 5174 --target codex --json",
     "  forge studio snapshot <app-path> --preview-port 5174 --target codex --probe-codex-server --json",
     "  forge studio bridge <app-path> --preview-port 5174 --target codex --studio-url http://127.0.0.1:3765 --probe-codex-server --json",

package/src/forge/cli/new.ts

@@ -8,7 +8,7 @@ import { run as runGenerate } from "../compiler/orchestrator/run.ts";
 import { resolvePackageManagerArgv } from "../compiler/package-manager/executor.ts";
 import { moduleDir } from "../platform/module.ts";
 
-export type NewTemplateName = "agent-workroom" | "b2b-support-web" | "minimal-web";
+export type NewTemplateName = "agent-workroom" | "b2b-support-web" | "minimal-web" | "nuxt-web";
 export type NewPackageManager = "bun" | "npm" | "pnpm" | "yarn";
 
 export interface NewCommandOptions {
@@ -46,6 +46,8 @@ const REQUIRED_GITIGNORE_PATHS = [
   ".forge/cache/",
   ".forge/pglite/",
   ".forge/delta/",
+  ".forge/agent/*.ndjson",
+  ".forge/agent/*.history",
   ".forge/local/",
   ".forge/test-cache/",
   ".forge/test-runs/",

package/src/forge/cli/parse.ts

@@ -112,7 +112,7 @@ export type ForgeCommand =
       json: boolean;
       workspaceRoot: string;
     }
-  | { kind: "doctor"; target?: "project" | "windows" | "agent"; agentTarget?: AgentAdapterTarget; json: boolean; workspaceRoot: string }
+  | { kind: "doctor"; target?: "project" | "windows" | "agent" | "delta"; agentTarget?: AgentAdapterTarget; json: boolean; workspaceRoot: string }
   | { kind: "setup"; target: "windows"; json: boolean; yes: boolean; workspaceRoot: string }
   | {
       kind: "security";
@@ -183,7 +183,19 @@ export type ForgeCommand =
   | { kind: "ui"; options: UiCommandOptions }
   | { kind: "manifest"; subcommand: "validate" | "import"; path: string; json: boolean; workspaceRoot: string }
   | { kind: "import"; options: BrownfieldImportCommandOptions }
-  | { kind: "delta"; subcommand: "status" | "repair"; json: boolean; workspaceRoot: string; dryRun: boolean; yes: boolean; verbose: boolean }
+  | {
+      kind: "delta";
+      subcommand: "status" | "repair" | "compact" | "prune" | "export";
+      json: boolean;
+      workspaceRoot: string;
+      dryRun: boolean;
+      yes: boolean;
+      verbose: boolean;
+      olderThan?: string;
+      output?: string;
+      limit?: number;
+      redacted: boolean;
+    }
   | { kind: "status"; json: boolean; workspaceRoot: string }
   | { kind: "changed"; json: boolean; authoredOnly: boolean; workspaceRoot: string }
   | { kind: "diff"; target: "authored" | "generated" | "full"; json: boolean; workspaceRoot: string }
@@ -212,7 +224,7 @@ export type ForgeCommand =
       force: boolean;
       workspaceRoot: string;
     }
-  | { kind: "timeline"; target?: string; kindFilter?: string; sessionId?: string; limit?: number; json: boolean; rebuild: boolean; forAgent: boolean; workspaceRoot: string }
+  | { kind: "timeline"; target?: string; kindFilter?: string; sessionId?: string; limit?: number; json: boolean; rebuild: boolean; forAgent: boolean; causal: boolean; staleProofs: boolean; workspaceRoot: string }
   | { kind: "explain"; thing: string; json: boolean; workspaceRoot: string }
   | {
       kind: "session";
@@ -480,7 +492,7 @@ export const INSPECT_TARGETS: InspectTarget[] = [
   "map",
 ];
 
-const NEW_TEMPLATES: NewTemplateName[] = ["agent-workroom", "b2b-support-web", "minimal-web"];
+const NEW_TEMPLATES: NewTemplateName[] = ["agent-workroom", "b2b-support-web", "minimal-web", "nuxt-web"];
 const NEW_PACKAGE_MANAGERS: NewPackageManager[] = ["bun", "npm", "pnpm", "yarn"];
 const SELF_HOST_SUBCOMMANDS: SelfHostSubcommand[] = ["compose", "env", "check", "clean"];
 const AGENT_CONTRACT_SUBCOMMANDS: AgentContractSubcommand[] = [
@@ -1015,6 +1027,22 @@ export function parseCli(argv: string[]): ParsedCli {
         (subcommand === "timeline" ? rest[1] : undefined) ??
         (subcommand === "timeline" ? "all" : undefined) ??
         (subcommand === "hooks" || subcommand === "onboard" ? "codex" : "generic");
+      const contextOptionValues = new Set(
+        [
+          parseOptionValue(argv, "--entry"),
+          parseOptionValue(argv, "--change"),
+          parseOptionValue(argv, "--proof"),
+          parseOptionValue(argv, "--event"),
+          parseOptionValue(argv, "--input"),
+          parseOptionValue(argv, "--target"),
+          parseOptionValue(argv, "--file"),
+          limitRaw,
+          pollIntervalRaw,
+        ].filter((value): value is string => typeof value === "string"),
+      );
+      const contextEntry = subcommand === "context"
+        ? rest.slice(1).find((part) => !part.startsWith("--") && !contextOptionValues.has(part))
+        : undefined;
       return {
         command: {
           kind: "agent",
@@ -1031,7 +1059,10 @@ export function parseCli(argv: string[]): ParsedCli {
             eventName: parseOptionValue(argv, "--event"),
             hookAction: subcommand === "hooks" ? rest[1] : undefined,
             input,
-            entry: parseOptionValue(argv, "--entry") ?? (subcommand === "context" && rest[1] !== "--current" ? rest[1] : undefined),
+            entry: parseOptionValue(argv, "--entry") ?? contextEntry,
+            change: parseOptionValue(argv, "--change"),
+            proof: parseOptionValue(argv, "--proof"),
+            handoff: parseFlag(argv, "--handoff"),
             current: parseFlag(argv, "--current"),
             limit: limit ? Math.floor(limit) : undefined,
             watch: parseFlag(argv, "--watch"),
@@ -1152,14 +1183,14 @@ export function parseCli(argv: string[]): ParsedCli {
       };
     }
     case "doctor":
-      if (rest[0] && rest[0] !== "windows" && rest[0] !== "agent") {
-        errors.push("forge doctor supports subcommand: windows or agent");
+      if (rest[0] && rest[0] !== "windows" && rest[0] !== "agent" && rest[0] !== "delta") {
+        errors.push("forge doctor supports subcommand: windows, agent, or delta");
         return { command: null, workspaceRoot, errors };
       }
       return {
         command: {
           kind: "doctor",
-          target: rest[0] === "windows" ? "windows" : rest[0] === "agent" ? "agent" : "project",
+          target: rest[0] === "windows" ? "windows" : rest[0] === "agent" ? "agent" : rest[0] === "delta" ? "delta" : "project",
           agentTarget: rest[0] === "agent"
             ? (parseOptionValue(argv, "--target") as AgentAdapterTarget | undefined) ?? (rest[1] as AgentAdapterTarget | undefined) ?? "codex"
             : undefined,
@@ -1882,10 +1913,12 @@ export function parseCli(argv: string[]): ParsedCli {
     }
     case "delta": {
       const subcommand = rest[0];
-      if (subcommand !== "status" && subcommand !== "repair") {
-        errors.push("forge delta requires subcommand: status or repair");
+      if (subcommand !== "status" && subcommand !== "repair" && subcommand !== "compact" && subcommand !== "prune" && subcommand !== "export") {
+        errors.push("forge delta requires subcommand: status, repair, compact, prune, or export");
         return { command: null, workspaceRoot, errors };
       }
+      const limitRaw = parseOptionValue(argv, "--limit");
+      const limit = limitRaw ? Number(limitRaw) : undefined;
       return {
         command: {
           kind: "delta",
@@ -1894,6 +1927,10 @@ export function parseCli(argv: string[]): ParsedCli {
           dryRun: parseFlag(argv, "--dry-run"),
           yes: parseFlag(argv, "--yes"),
           verbose: parseFlag(argv, "--verbose"),
+          olderThan: parseOptionValue(argv, "--older-than"),
+          output: parseOptionValue(argv, "--output"),
+          limit: Number.isFinite(limit) ? limit : undefined,
+          redacted: parseFlag(argv, "--redacted"),
           workspaceRoot,
         },
         workspaceRoot,
@@ -1933,7 +1970,10 @@ export function parseCli(argv: string[]): ParsedCli {
       const kindFilter = parseOptionValue(argv, "--kind");
       const sessionId = parseOptionValue(argv, "--session");
       const rebuild = rest[0] === "rebuild";
-      const target = rebuild ? undefined : rest.find((item) => item !== kindFilter && item !== limitRaw && item !== sessionId);
+      const optionValues = new Set([limitRaw, kindFilter, sessionId].filter((value): value is string => typeof value === "string"));
+      const target = rebuild
+        ? undefined
+        : rest.find((item) => !item.startsWith("--") && !optionValues.has(item));
       const limit = limitRaw ? Number(limitRaw) : undefined;
       if (limitRaw !== undefined && (!Number.isFinite(limit) || limit! < 1)) {
         errors.push("--limit must be a number >= 1");
@@ -1948,6 +1988,8 @@ export function parseCli(argv: string[]): ParsedCli {
             json: parseFlag(argv, "--json"),
             rebuild,
             forAgent: parseFlag(argv, "--for-agent"),
+            causal: parseFlag(argv, "--causal"),
+            staleProofs: parseFlag(argv, "--stale-proofs"),
             workspaceRoot,
           },
         workspaceRoot,
@@ -2642,6 +2684,8 @@ export function hasUnknownOption(argv: string[]): string | null {
     "--json",
     "--human",
     "--for-agent",
+    "--causal",
+    "--stale-proofs",
     "--dry-run",
     "--plan",
     "--staged",
@@ -2698,6 +2742,9 @@ export function hasUnknownOption(argv: string[]): string | null {
     "--emit",
     "--event",
     "--entry",
+    "--change",
+    "--proof",
+    "--handoff",
     "--current",
     "--trigger",
     "--component",
@@ -2794,6 +2841,8 @@ export function hasUnknownOption(argv: string[]): string | null {
     "--env-file",
     "--skip-startup-console",
     "--redacted",
+    "--older-than",
+    "--output",
     "--mock-ai",
     "--ai",
     "--provider",
@@ -2857,6 +2906,8 @@ export function hasUnknownOption(argv: string[]): string | null {
         arg === "--emit" ||
         arg === "--event" ||
         arg === "--entry" ||
+        arg === "--change" ||
+        arg === "--proof" ||
         arg === "--trigger" ||
         arg === "--component" ||
         arg === "--package" ||
@@ -2901,6 +2952,8 @@ export function hasUnknownOption(argv: string[]): string | null {
         arg === "--db" ||
         arg === "--database-url" ||
         arg === "--limit" ||
+        arg === "--older-than" ||
+        arg === "--output" ||
         arg === "--kind" ||
         arg === "--session" ||
         arg === "--input" ||