forgeos 0.1.0-alpha.20 → 0.1.0-alpha.22

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/brownfield-import/index.ts

@@ -8,6 +8,7 @@ import type {
   ImportedDependencyInventory,
   ImportedFrontendCall,
   ImportedInventory,
+  ImportedEntryKind,
   ImportedRiskFinding,
   ImportedRiskReport,
   ImportedRoute,
@@ -365,7 +366,53 @@ function collectEnv(workspaceRoot: string, files: SourceFile[]): ImportedInvento
 }
 
 function sourceTextForRoute(route: ImportedRoute, files: SourceFile[]): string {
-  return files.find((file) => file.relativePath === route.file)?.text ?? "";
+  const text = files.find((file) => file.relativePath === route.file)?.text ?? "";
+  if (!text) {
+    return "";
+  }
+  return scopedSourceTextForRoute(route, text) ?? text;
+}
+
+function scopedSourceTextForRoute(route: ImportedRoute, text: string): string | null {
+  if (route.source === "next-app-router" && route.handler) {
+    return sliceUntilNextMatch(
+      text,
+      new RegExp(`export\\s+(?:async\\s+)?function\\s+${escapeRegExp(route.handler)}\\b`, "u"),
+      /export\s+(?:async\s+)?function\s+(?:GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\b/gu,
+    );
+  }
+  if (route.source === "express") {
+    const method = route.method.toLowerCase();
+    const matcher = new RegExp(`\\b(?:app|router)\\s*\\.\\s*${escapeRegExp(method)}\\s*\\(\\s*["'\`]${escapeRegExp(route.path)}["'\`]`, "u");
+    return sliceUntilNextMatch(
+      text,
+      matcher,
+      /\b(?:app|router)\s*\.\s*(?:get|post|put|patch|delete|all)\s*\(\s*["'`][^"'`]+["'`]/giu,
+    );
+  }
+  if (route.source === "nest") {
+    const method = route.method.charAt(0).toUpperCase() + route.method.slice(1).toLowerCase();
+    return sliceUntilNextMatch(
+      text,
+      new RegExp(`@${escapeRegExp(method)}\\s*\\(`, "u"),
+      /@(Get|Post|Put|Patch|Delete|All)\s*\(/gu,
+    );
+  }
+  return null;
+}
+
+function sliceUntilNextMatch(text: string, startPattern: RegExp, nextPattern: RegExp): string | null {
+  const start = text.search(startPattern);
+  if (start < 0) {
+    return null;
+  }
+  nextPattern.lastIndex = start + 1;
+  const next = nextPattern.exec(text);
+  return text.slice(start, next?.index ?? text.length);
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
 
 function classifyCandidate(route: ImportedRoute, text: string): Pick<ImportedCandidateEntry, "kind" | "confidence" | "risks" | "evidence" | "needsApproval"> {
@@ -381,9 +428,17 @@ function classifyCandidate(route: ImportedRoute, text: string): Pick<ImportedCan
   const auth = /(auth|session|currentuser|getserversession|clerk|nextauth|requireuser|requireauth)/u.test(lowerText);
   const tenant = /(tenantid|tenant_id|organizationid|orgid|accountid)/u.test(lowerText);
   const methodUnknown = method === "ANY" || method === "ALL";
-  if (!isQuery || writes) {
+  const ambiguousPostQuery = method === "POST" &&
+    /(?:^|\/)(search|query|filter|lookup|graphql)(?:$|\/)/u.test(lowerPath) &&
+    !writes &&
+    !isDestructive &&
+    !external;
+  if ((!isQuery && !ambiguousPostQuery) || writes) {
     risks.add("writes-state");
   }
+  if (ambiguousPostQuery) {
+    risks.add("ambiguous-post-query");
+  }
   if (isDestructive) {
     risks.add("destructive");
   }
@@ -403,6 +458,15 @@ function classifyCandidate(route: ImportedRoute, text: string): Pick<ImportedCan
     risks.add("method-unknown");
   }
   const commandLike = !isQuery || writes || isDestructive || external;
+  if (ambiguousPostQuery) {
+    return {
+      kind: "command-candidate",
+      confidence: 0.55,
+      risks: Array.from(risks).sort(),
+      evidence,
+      needsApproval: true,
+    };
+  }
   return {
     kind: commandLike ? "command" : "query",
     confidence: commandLike ? (isDestructive ? 0.9 : 0.78) : 0.86,
@@ -412,7 +476,7 @@ function classifyCandidate(route: ImportedRoute, text: string): Pick<ImportedCan
   };
 }
 
-function nameForCandidate(route: ImportedRoute, kind: "command" | "query" | "unknown"): string {
+function nameForCandidate(route: ImportedRoute, kind: ImportedEntryKind): string {
   const nouns = route.path
     .replace(/^\/api\//u, "")
     .replace(/:\w+\*?/gu, "byId")
@@ -424,6 +488,7 @@ function nameForCandidate(route: ImportedRoute, kind: "command" | "query" | "unk
   const method = route.method.toUpperCase();
   const action =
     kind === "query" ? "read" :
+    kind === "command-candidate" ? "candidate" :
     method === "POST" ? "create" :
     method === "PUT" || method === "PATCH" ? "update" :
     method === "DELETE" ? "delete" :

package/src/forge/brownfield-import/types.ts

@@ -11,7 +11,7 @@ export interface BrownfieldImportCommandOptions {
 
 export type ImportedAssurance = "static-scan";
 export type ImportedReviewStatus = "needs-review" | "approved" | "rejected";
-export type ImportedEntryKind = "command" | "query" | "unknown";
+export type ImportedEntryKind = "command" | "command-candidate" | "query" | "unknown";
 export type ImportedRouteSource = "next-app-router" | "next-pages-api" | "express" | "nest" | "unknown";
 
 export interface ImportedDependencyInventory {

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" ||

package/src/forge/cli/studio.ts

@@ -139,6 +139,15 @@ export interface StudioSnapshotResult {
     commands: string[];
     diffPlan?: DevConsoleDiffPlan;
   };
+  handoff: {
+    previewUrl: string;
+    currentSession?: { id?: string; title?: string; status?: string; confidence?: number };
+    changedFiles?: number;
+    generatedState?: string;
+    deltaHealth?: string;
+    agentContextCommand: string;
+    recommendedCommands: string[];
+  };
   proofs: {
     preview: StudioAttachResult["preview"]["status"];
     generated: StudioAttachResult["posture"]["generated"];
@@ -981,6 +990,13 @@ export async function runStudioSnapshotCommand(options: StudioAttachOptions): Pr
     : undefined;
   const delta = await runDeltaStatus(appRoot);
   const contextPacket = contextPacketFor({ appRoot, posture, commands });
+  const handoff = studioHandoffFor({
+    previewUrl: preview.url,
+    posture,
+    changed: changed.data,
+    delta,
+    commands,
+  });
   const gitState = (changed.data as { git?: { available?: boolean } }).git;
   const changedReadable = changed.ok || gitState?.available === false;
   const ok = posture.state !== "needs-attention" && changedReadable &&
@@ -1006,6 +1022,7 @@ export async function runStudioSnapshotCommand(options: StudioAttachOptions): Pr
     changed: changed.data,
     commands,
     contextPacket,
+    handoff,
     proofs: {
       preview: preview.status,
       generated: posture.generated,
@@ -1019,6 +1036,43 @@ export async function runStudioSnapshotCommand(options: StudioAttachOptions): Pr
   };
 }
 
+function studioHandoffFor(input: {
+  previewUrl: string;
+  posture: StudioSnapshotResult["posture"];
+  changed: Record<string, unknown>;
+  delta: unknown;
+  commands: StudioSnapshotResult["commands"];
+}): StudioSnapshotResult["handoff"] {
+  const changedSummary = input.changed.summary as { changedFiles?: unknown } | undefined;
+  const deltaRecord = input.delta && typeof input.delta === "object" && !Array.isArray(input.delta)
+    ? input.delta as { workSession?: { id?: unknown; title?: unknown; status?: unknown; confidence?: unknown }; details?: { health?: { status?: unknown } } }
+    : undefined;
+  const workSession = deltaRecord?.workSession;
+  return {
+    previewUrl: input.previewUrl,
+    ...(workSession
+      ? {
+          currentSession: {
+            ...(typeof workSession.id === "string" ? { id: workSession.id } : {}),
+            ...(typeof workSession.title === "string" ? { title: workSession.title } : {}),
+            ...(typeof workSession.status === "string" ? { status: workSession.status } : {}),
+            ...(typeof workSession.confidence === "number" ? { confidence: workSession.confidence } : {}),
+          },
+        }
+      : {}),
+    ...(typeof changedSummary?.changedFiles === "number" ? { changedFiles: changedSummary.changedFiles } : {}),
+    generatedState: input.posture.generated?.state,
+    deltaHealth: typeof deltaRecord?.details?.health?.status === "string" ? deltaRecord.details.health.status : undefined,
+    agentContextCommand: "forge agent context --handoff --json",
+    recommendedCommands: [
+      input.commands.handoff,
+      "forge agent context --handoff --json",
+      input.commands.changed,
+      input.commands.doctor,
+    ],
+  };
+}
+
 export async function runStudioWatchCommand(options: StudioAttachOptions): Promise<StudioWatchResult> {
   const snapshot = await runStudioSnapshotCommand(options);
   const intervalMs = Math.max(1000, Math.floor(options.intervalMs ?? 5000));

package/src/forge/cli/verify.ts

@@ -695,6 +695,7 @@ const STRICT_TEST_FALLBACK_MS_BY_PATH: Array<{ pattern: RegExp; estimatedMs: num
   { pattern: /^tests\/templates\/new-b2b-support-web\.test\.ts$/, estimatedMs: 12_000 },
   { pattern: /^tests\/templates\/new-agent-workroom\.test\.ts$/, estimatedMs: 12_000 },
   { pattern: /^tests\/templates\/new-minimal-web\.test\.ts$/, estimatedMs: 12_000 },
+  { pattern: /^tests\/templates\/new-nuxt-web\.test\.ts$/, estimatedMs: 12_000 },
   { pattern: /^tests\/templates\/create-forge-app\.test\.ts$/, estimatedMs: 8_000 },
 ];
 const STRICT_ISOLATED_TEST_PATTERNS = [
@@ -730,6 +731,7 @@ const STRICT_ISOLATED_TEST_PATTERNS = [
   /^tests\/templates\/new-b2b-support-web\.test\.ts$/,
   /^tests\/templates\/new-agent-workroom\.test\.ts$/,
   /^tests\/templates\/new-minimal-web\.test\.ts$/,
+  /^tests\/templates\/new-nuxt-web\.test\.ts$/,
   /^tests\/telemetry\/telemetry-dev-server\.test\.ts$/,
 ];
 const STRICT_SERIAL_TEST_PATTERNS: RegExp[] = [];

package/src/forge/compiler/frontend-graph/build.ts

@@ -229,6 +229,58 @@ function detectRouteUses(file: string, text: string, clientManifest: ClientManif
   return uses;
 }
 
+function localComposableNames(file: string, text: string): string[] {
+  const relName = componentNameForFile(file);
+  const names = [relName.startsWith("use") ? relName : `use${relName.slice(0, 1).toUpperCase()}${relName.slice(1)}`];
+  for (const match of text.matchAll(/export\s+function\s+(use[A-Z][A-Za-z0-9_]*)\s*\(/g)) {
+    if (match[1]) {
+      names.push(match[1]);
+    }
+  }
+  return uniqueSorted(names);
+}
+
+function buildComposableUseIndex(
+  webRoot: string,
+  sourceFiles: string[],
+  clientManifest: ClientManifest,
+): Map<string, ReturnType<typeof detectUses>> {
+  const index = new Map<string, ReturnType<typeof detectUses>>();
+  for (const file of sourceFiles) {
+    const rel = toPosix(relative(webRoot, file));
+    if (!rel.startsWith("composables/") && !rel.startsWith("src/composables/")) {
+      continue;
+    }
+    if (rel.endsWith("/forge.ts") || rel === "composables/forge.ts" || rel === "src/composables/forge.ts") {
+      continue;
+    }
+    const text = nodeFileSystem.readText(file) ?? "";
+    const uses = detectUses(text, clientManifest);
+    for (const name of localComposableNames(file, text)) {
+      index.set(name, uses);
+    }
+  }
+  return index;
+}
+
+function detectLocalComposableUses(
+  text: string,
+  composableUseIndex: Map<string, ReturnType<typeof detectUses>>,
+): ReturnType<typeof detectUses> {
+  let uses: ReturnType<typeof detectUses> = {
+    usesCommands: [],
+    usesQueries: [],
+    usesLiveQueries: [],
+    rawForgeFetches: [],
+  };
+  for (const [name, composableUses] of composableUseIndex) {
+    if (new RegExp(`\\b${name}\\s*\\(`).test(text)) {
+      uses = mergeUses(uses, composableUses);
+    }
+  }
+  return uses;
+}
+
 function devCommandFor(webRoot: string, framework: FrontendGraph["framework"]): string {
   const pkg = readJson<{ scripts?: Record<string, string> }>(join(webRoot, "package.json"));
   if (pkg?.scripts?.dev) {
@@ -347,6 +399,7 @@ export function buildFrontendGraph(input: {
   const bridgeFiles: string[] = [];
   const diagnostics: FrontendGraph["diagnostics"] = [];
   const textByRel = new Map<string, string>();
+  const composableUseIndex = buildComposableUseIndex(webRoot, sourceFiles, input.clientManifest);
 
   for (const file of sourceFiles) {
     const rel = toPosix(relative(input.workspaceRoot, file));
@@ -359,7 +412,10 @@ export function buildFrontendGraph(input: {
       rel === "web/composables/forge.ts" ||
       rel === "web/plugins/forge.ts";
     textByRel.set(rel, text);
-    const uses = detectUses(text, input.clientManifest);
+    const uses = mergeUses(
+      detectUses(text, input.clientManifest),
+      detectLocalComposableUses(text, composableUseIndex),
+    );
     if (isComponentFile(webRoot, file, text)) {
       components.push({ name: componentNameForText(file, text), file: rel, ...uses });
     }
@@ -469,7 +525,7 @@ export function buildFrontendGraph(input: {
         ? "Nuxt app does not expose a Forge plugin; generated composables may not be wired"
         : "web app does not expose a ForgeProvider; generated hooks may not be wired",
       fixHint: framework === "nuxt"
-        ? "Create web/plugins/forge.ts and call provideForge with runtimeConfig.public.forgeUrl and devAuth for local development."
+        ? "Create web/plugins/forge.client.ts and web/plugins/forge.server.ts and install ForgeVuePlugin with runtimeConfig.public.forgeUrl and devAuth for local development."
         : "Mount ForgeProvider once in the web app root/provider layer and pass devAuth for local development.",
       suggestedCommands: ["forge inspect frontend --json", `forge make ui --framework ${framework === "nuxt" ? "nuxt" : "vite"} --dry-run --json`],
       docs: ["src/forge/_generated/frontendGraph.json", "AGENTS.md"],

package/src/forge/delta/index.ts

@@ -1,10 +1,22 @@
 export {
   runDeltaStatus,
   runDeltaRepair,
+  runDeltaCompact,
+  runDeltaPrune,
+  runDeltaExport,
+  runDeltaDoctor,
   formatDeltaStatusHuman,
   formatDeltaStatusJson,
   formatDeltaRepairHuman,
   formatDeltaRepairJson,
+  formatDeltaDoctorHuman,
+  formatDeltaDoctorJson,
+  formatDeltaCompactHuman,
+  formatDeltaCompactJson,
+  formatDeltaPruneHuman,
+  formatDeltaPruneJson,
+  formatDeltaExportHuman,
+  formatDeltaExportJson,
 } from "./status.ts";
 export { runDeltaTimeline, formatDeltaTimelineHuman, formatDeltaTimelineJson } from "./timeline.ts";
 export { runDeltaExplain, formatDeltaExplainHuman, formatDeltaExplainJson } from "./explain.ts";