forgeos 0.1.0-alpha.21 → 0.1.0-alpha.23

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.23 input=43fbd897d0f0a003e2f63e7048eb3281a5871034827653640e010161c0385d44 content=0d493cf0e41b71cb652d5e0e1b0c1f83d2a1281b748321f0b00f0773ba93074e
 # AGENTS.md
 
 <!-- forge-generated:start -->

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # forgeos
 
+## Unreleased
+
+## 0.1.0-alpha.23
+
+### Patch Changes
+
+- Tighten the post-alpha.22 release surface and package evidence.
+
+  - Add a dedicated Nuxt template smoke workflow that installs `nuxt-web`, runs Forge generation/checks, runs Nuxt typecheck, and probes `forge dev --once`.
+  - Include `nuxt-web` in the default field-test template matrix.
+  - Add explicit `scopeTarget` metadata and human-readable target output for `forge agent context --change`, `--proof`, and `--handoff`.
+  - Teach `forge explain` to fall back to the current generated agent contract when DeltaDB has no runtime history, while marking the result as contract-defined instead of executed.
+  - Downgrade read-only observation commands such as `forge status`, `forge changed`, `forge handoff`, `forge explain`, `forge timeline`, and CAIR queries to low-confidence context-gathering sessions in DeltaDB.
+  - Package `docs/cair-protocol.md` in the npm tarball and expand the public security/threat-model docs for DeltaDB, agent memory, CAIR, Studio bridge, brownfield import, and Nuxt surfaces.
+
+## 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 +53,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/cair-protocol.md

@@ -0,0 +1,103 @@
+# CAIR Protocol
+
+CAIR is ForgeOS' compact agent interface for reading code structure, querying symbols, and planning safe edits without loading the whole repository into an agent context window.
+
+CAIR is intentionally CLI-first. It does not add a second mutating tool surface. Agents should use CAIR to inspect structure and create reviewable plans, then apply those plans through the ForgeOS CLI with hash checks and rollback journals.
+
+## Read Workflow
+
+Start with a compact snapshot:
+
+```bash
+forge cair snapshot
+forge cair query "Q STATUS"
+forge cair query "Q ST"
+```
+
+Use symbol, definition, reference, impact, and dependency API queries before opening large files:
+
+```bash
+forge cair query "Q S name=createTicket"
+forge cair query "Q D S#1"
+forge cair query "Q R S#1"
+forge cair query "Q I S#1"
+forge cair query "Q DEP.API package=zod symbol=object"
+```
+
+The goal is to make agent navigation evidence-backed: CAIR gives stable ids for modules, symbols, packages, APIs, and tests so an agent can select a small file set instead of scanning the whole project.
+
+## Action Safety
+
+Mutating CAIR actions should be planned first:
+
+```bash
+forge cair action --plan "A RN t=S#1 nn=openTicket"
+```
+
+The plan lives under `.forge/cair/plans/` and records the target files and expected hashes. Applying a plan checks those hashes before editing:
+
+```bash
+forge cair action "A APPLY plan=<P#|.forge/cair/plans/...json>"
+```
+
+Applied plans write rollback journals under `.forge/cair/journal/`:
+
+```bash
+forge cair action "A ROLLBACK journal=.forge/cair/journal/<journal>.json"
+```
+
+Use `--dry-run` when exploring an action shape without creating a plan:
+
+```bash
+forge cair action --dry-run "A CREATE.SYMBOL path=src/example.ts kind=function name=example export=true createFile=true"
+```
+
+Generated files stay protected by default. Use `--include-generated` only when the edit is intentionally about generated artifacts.
+
+## DeltaDB Evidence
+
+Successful CAIR CLI runs are recorded in DeltaDB as sanitized operational events:
+
+| CAIR command | Delta event |
+|--------------|-------------|
+| `forge cair snapshot` | `cair.snapshot.created` |
+| `forge cair query ...` | `cair.query.run` |
+| `forge cair action --plan ...` | `cair.plan.created` |
+| `forge cair action "A APPLY ..."` | `cair.plan.applied` |
+| `forge cair action --dry-run ...` | `cair.action.previewed` |
+
+The recorder stores compact verbs such as `Q ST` or `A APPLY`; it does not need to store full action bodies as first-class timeline data. Use:
+
+```bash
+forge timeline cair:protocol --json
+forge timeline --kind cair.plan.applied --json
+```
+
+This makes CAIR navigation and guarded edits visible beside file changes, proofs, and agent activity.
+
+## Compact Aliases
+
+| Long form | Compact |
+|-----------|---------|
+| `Q STATUS` | `Q ST` |
+| `Q SYMBOL` | `Q S` |
+| `Q DEF` | `Q D` |
+| `Q REFS` | `Q R` |
+| `Q IMPACT` | `Q I` |
+| `A RENAME.SYMBOL target=S#1 newName=x` | `A RN t=S#1 nn=x` |
+
+## Agent Posture
+
+Use this loop for code work:
+
+```bash
+forge cair snapshot
+forge cair query "Q ST"
+forge cair query "Q S name=<symbol>"
+forge cair query "Q I S#1"
+forge cair action --plan "A RN t=S#1 nn=<newName>"
+forge cair action "A APPLY plan=<P#|path>"
+forge check --json
+```
+
+Do not use CAIR as a bypass around ForgeOS rules. Commands remain transactional writes, queries and liveQueries remain read-only, side effects still belong in actions and workflows, and generated artifacts remain derived.

package/docs/changelog.md

@@ -6,6 +6,36 @@ The canonical source file in the repository is `CHANGELOG.md`.
 
 ## Unreleased
 
+## 0.1.0-alpha.23
+
+- Tightened the post-alpha.22 release surface and package evidence:
+  added a dedicated Nuxt template smoke workflow, included `nuxt-web` in the
+  default field-test template matrix, packaged `docs/cair-protocol.md`, and
+  expanded the security/threat-model docs for DeltaDB, agent memory, CAIR,
+  Studio bridge, brownfield import, and Nuxt surfaces.
+- `forge agent context` now returns explicit `scopeTarget` metadata and prints
+  the resolved context target for entry, change, proof, and handoff packs.
+- `forge explain` now falls back to the current generated agent contract when
+  DeltaDB has no runtime history, marking the entry as contract-defined rather
+  than executed.
+- DeltaDB work-session inference now treats read-only observation commands such
+  as `forge status`, `forge changed`, `forge handoff`, `forge explain`,
+  `forge timeline`, and CAIR queries as low-confidence context-gathering
+  sessions.
+
+## 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,11 +1,12 @@
 {
   "name": "forgeos",
-  "version": "0.1.0-alpha.21",
+  "version": "0.1.0-alpha.23",
   "description": "Agent-native application framework and compiler for building Forge apps without a mandatory dashboard.",
   "type": "module",
   "files": [
     "adapters/",
     "bin/",
+    "docs/cair-protocol.md",
     "docs/forge-protocol.md",
     "examples/go-billing/",
     "examples/java-billing/",

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.23","releaseId":"forgeos@0.1.0-alpha.23+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.23 input=43fbd897d0f0a003e2f63e7048eb3281a5871034827653640e010161c0385d44 content=8b537f90580f28c1630850bc7b7199e17d0bc62d05e9565fdf84da4bdbf9f6dc
 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.23",
+  "releaseId": "forgeos@0.1.0-alpha.23+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) {
@@ -1015,6 +1021,7 @@ function formatAgentMemoryContextHuman(result: AgentMemoryContextPack): string {
   const lines = [
     `Forge Agent Context (${result.scope}${result.entry ? `: ${result.entry}` : ""})`,
     "",
+    `target: ${formatAgentContextTarget(result)}`,
     `events: ${summary.events}`,
     `sources: ${summary.sources.length > 0 ? summary.sources.join(", ") : "none"}`,
     `tools: ${summary.tools.length > 0 ? summary.tools.join(", ") : "none"}`,
@@ -1052,9 +1059,30 @@ 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`;
 }
 
+function formatAgentContextTarget(result: AgentMemoryContextPack): string {
+  const target = result.scopeTarget;
+  const parts: string[] = [target.kind];
+  if (target.value) {
+    parts.push(target.value);
+  }
+  if (target.semanticTarget && target.semanticTarget !== target.value) {
+    parts.push(`semantic=${target.semanticTarget}`);
+  }
+  if (target.currentSessionId) {
+    parts.push(`session=${target.currentSessionId}`);
+  }
+  return parts.join(" ");
+}
+
 function formatAgentMemoryEventsHuman(events: AgentMemoryEventRecord[]): string {
   const sources = uniqueStrings(events.map((event) => event.sourceName));
   const tools = uniqueStrings(events.flatMap((event) => {

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,13 @@ export async function buildAgentMemoryContext(input: {
     const openQuestions = timeline?.openQuestions ?? [];
     return {
       ok: true,
-      scope: target ? "entry" : "current",
-      entry: target,
+      scope,
+      scopeTarget: contextScopeTarget(input, scope, target, currentSession?.id),
+      entry: input.entry,
+      change: input.change,
+      proof: input.proof,
       currentState: current,
+      recommendedCommands: recommendedCommands(scope, input, currentSession?.id),
       agentMemory: {
         summary: {
           events: contextEventItems.length,
@@ -68,6 +84,111 @@ 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 contextScopeTarget(
+  input: { entry?: string; change?: string; proof?: string; handoff?: boolean },
+  scope: AgentMemoryContextPack["scope"],
+  semanticTarget: string | undefined,
+  currentSessionId: string | undefined,
+): AgentMemoryContextPack["scopeTarget"] {
+  if (scope === "entry") {
+    return { kind: "entry", value: input.entry, semanticTarget };
+  }
+  if (scope === "proof") {
+    return { kind: "proof", value: input.proof, semanticTarget };
+  }
+  if (scope === "change") {
+    const value = input.change ?? "current";
+    return {
+      kind: "change",
+      value,
+      ...(semanticTarget ? { semanticTarget } : {}),
+      ...(value === "current" && currentSessionId ? { currentSessionId } : {}),
+    };
+  }
+  if (scope === "handoff") {
+    return { kind: "handoff", value: "handoff", currentSessionId };
+  }
+  return { kind: "current-session", value: "current", currentSessionId };
+}
+
+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 +213,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 +222,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,18 @@ export interface AgentMemoryContextEvent {
 
 export interface AgentMemoryContextPack {
   ok: true;
-  scope: "current" | "entry";
+  scope: "current" | "entry" | "change" | "proof" | "handoff";
+  scopeTarget: {
+    kind: "current-session" | "entry" | "change" | "proof" | "handoff";
+    value?: string;
+    semanticTarget?: string;
+    currentSessionId?: string;
+  };
   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/",