forgeos 0.1.0-alpha.65 → 0.1.0-alpha.66

package/AGENTS.md

@@ -1,4 +1,4 @@
-// @forge-generated generator=0.1.0-alpha.65 input=dbf2c962fa9cf8e2fa9dc988c6cf3a4e462e8f7dd759f143418b9538a08f4a85 content=721818a6f9a664aa898092d4aa5cd68cbbd8ad6e150c7d3ad3ef785a2e3fcf53
+// @forge-generated generator=0.1.0-alpha.66 input=57341432921f2c43eddb033a05cc7ad25dabd9813fcf2fd64c67f74ae5f61859 content=721818a6f9a664aa898092d4aa5cd68cbbd8ad6e150c7d3ad3ef785a2e3fcf53
 # AGENTS.md
 
 <!-- forge-generated:start -->

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # forgeos
 
+## 0.1.0-alpha.66
+
+### Patch Changes
+
+- [#66](https://github.com/Stahldavid/forge/pull/66) [`472cde3`](https://github.com/Stahldavid/forge/commit/472cde3647cf055afd627460bf015ab5467ab8d5) Thanks [@Stahldavid](https://github.com/Stahldavid)! - Add a local Agent Fabric change-review flow for Codex App authored diffs. It
+  captures an exact staged, unstaged, and new-file snapshot, runs a bounded
+  read-only Codex CLI reviewer on an isolated checkout, and keeps digest-bound
+  review rounds and findings. CLI and MCP expose proposal and evidence while
+  reviewer dispatch remains an explicit CLI action.
+
 ## 0.1.0-alpha.65
 
 ### Patch Changes

package/docs/agent-fabric.md

@@ -375,6 +375,45 @@ it does not prove the human popup flow or coding quality on real projects.
 exercises the service, approved verification, Docker Desktop, durable readback,
 and acceptance with a synthetic approval callback.
 
+### Codex App implementation with adversarial review (local preview)
+
+The Codex App may implement a change in the current checkout. Register the work
+before editing with a JSON request such as
+`{"objective":"Change the parser","acceptanceCriteria":["The new case is handled"],"implementer":"codex-app"}`.
+Place the request under the ignored `.forge/local/` directory, then use:
+
+```bash
+node bin/forge.mjs fabric change-propose --file .forge/local/change-request.json --json
+node bin/forge.mjs fabric change-status --task-id <change-id> --json
+node bin/forge.mjs fabric change-review --task-id <change-id> --json
+node bin/forge.mjs fabric change-evidence --task-id <change-id> --json
+```
+
+`change-review` is an explicit owner CLI action that starts a **new Codex CLI
+review turn** using the machine's existing Codex login. That turn may consume
+Codex usage. The MCP tools `fabric_change_propose`, `fabric_change_status`, and
+`fabric_change_evidence` can register and inspect a change but cannot start a
+review or mark it accepted. The request pins the base commit; review later
+captures staged, unstaged, and non-ignored new files without modifying the
+user's Git index. Local Forge state under `.forge/local` and `.forge/delta` is
+excluded. A review is limited to 1 MiB, 100 paths, and eight rounds; binary
+patches, symlinks, and submodules are rejected.
+
+Each round records an immutable diff and request digest before dispatch. The
+reviewer runs against a separate checkout of that exact diff in read-only
+sandbox mode. A valid structured report bound to the request digest is required;
+process exit zero alone is insufficient. `canAccept` becomes true only for a
+passing report on the **current** diff. Editing the checkout after a pass makes
+it `needs_review`, and the next review creates a new round. An interrupted
+review remains uncertain and will not automatically spend another turn. An
+inconclusive completed review may be retried explicitly. For an interrupted
+review, inspect its evidence and create a fresh change request if another paid
+turn is warranted; the uncertain intent remains in the original record.
+`canAccept` is evidence for the human workflow; this preview does not intercept
+Git merges or edits made outside the CLI. Same-account shell access can alter
+the local ledger and is outside the pilot's security boundary. The Codex CLI
+review protocol has fake-process tests but no paid, real-model smoke yet.
+
 ### Local Evolution Registry (single owner)
 
 The local extension workflow pins a candidate's bytes before evaluation. A

package/package.json

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

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.65","releaseId":"forgeos@0.1.0-alpha.65+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.66","releaseId":"forgeos@0.1.0-alpha.66+unknown","schemaVersion":"0.1.0"}

package/src/forge/_generated/releaseManifest.ts

@@ -1,4 +1,4 @@
-// @forge-generated generator=0.1.0-alpha.65 input=dbf2c962fa9cf8e2fa9dc988c6cf3a4e462e8f7dd759f143418b9538a08f4a85 content=f04ed7266bc22851fbf9c2570af65d25c3718c8ab8133af3bce480d49f6df516
+// @forge-generated generator=0.1.0-alpha.66 input=57341432921f2c43eddb033a05cc7ad25dabd9813fcf2fd64c67f74ae5f61859 content=1c305c2f9d3a0ad52157e8b8858790d338296f1d0cc59c0d70f93c65d9c19fc0
 export const releaseManifest = {
   "defaultProvider": "local",
   "diagnostics": [],
@@ -19,7 +19,7 @@ export const releaseManifest = {
     "custom"
   ],
   "packageName": "forgeos",
-  "packageVersion": "0.1.0-alpha.65",
-  "releaseId": "forgeos@0.1.0-alpha.65+unknown",
+  "packageVersion": "0.1.0-alpha.66",
+  "releaseId": "forgeos@0.1.0-alpha.66+unknown",
   "schemaVersion": "0.1.0"
 } as const;

package/src/forge/agent-fabric/codex-adversarial-review.ts

@@ -0,0 +1,229 @@
+import { spawn, type ChildProcessWithoutNullStreams, type SpawnOptionsWithoutStdio } from "node:child_process";
+import { createHash } from "node:crypto";
+import { realpathSync, statSync } from "node:fs";
+import type { Digest } from "./types.ts";
+
+const DIGEST_PATTERN = /^sha256:[0-9a-f]{64}$/u;
+const MAX_TIMEOUT_MS = 10 * 60_000;
+const MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
+const MAX_PROMPT_BYTES = 64 * 1024;
+const MAX_FINDINGS = 100;
+
+export interface CodexAdversarialFinding {
+  severity: "blocker" | "high" | "medium" | "low";
+  path: string;
+  line?: number;
+  title: string;
+  explanation: string;
+}
+
+export interface CodexAdversarialReport {
+  requestDigest: Digest;
+  verdict: "pass" | "changes_requested" | "inconclusive";
+  summary: string;
+  findings: readonly CodexAdversarialFinding[];
+}
+
+export interface CodexReviewUsage {
+  inputTokens: number;
+  outputTokens: number;
+  cachedInputTokens?: number;
+}
+
+export type CodexAdversarialReviewResult =
+  | { state: "reported"; report: CodexAdversarialReport; outputDigest: Digest; usage?: CodexReviewUsage }
+  | { state: "inconclusive"; error: string; report?: CodexAdversarialReport; outputDigest?: Digest; usage?: CodexReviewUsage };
+
+export interface CodexAdversarialReviewOptions {
+  /** A prepared, exact review checkout. The caller must verify its Git identity and diff before and after this call. */
+  workspaceRoot: string;
+  /** Canonical digest of the review request and exact diff, supplied by the caller. */
+  requestDigest: Digest;
+  prompt: string;
+  timeoutMs: number;
+  maxOutputBytes: number;
+  executable?: string;
+  signal?: AbortSignal;
+  /** Injection point for tests; production uses node:child_process.spawn. */
+  spawnProcess?: (command: string, args: string[], options: SpawnOptionsWithoutStdio) => ChildProcessWithoutNullStreams;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function exactKeys(value: Record<string, unknown>, required: readonly string[], optional: readonly string[] = []): boolean {
+  return required.every((key) => Object.hasOwn(value, key)) &&
+    Object.keys(value).every((key) => required.includes(key) || optional.includes(key));
+}
+
+function nonEmptyText(value: unknown, maxLength: number): value is string {
+  return typeof value === "string" && value.trim().length > 0 && value.length <= maxLength && !value.includes("\u0000");
+}
+
+function validFinding(value: unknown): value is CodexAdversarialFinding {
+  if (!isRecord(value) || !exactKeys(value, ["severity", "path", "title", "explanation"], ["line"])) return false;
+  if (!["blocker", "high", "medium", "low"].includes(String(value.severity))) return false;
+  if (!nonEmptyText(value.path, 512) || value.path.includes("\\") || value.path.startsWith("/") ||
+      /^[a-z]:/iu.test(value.path) || value.path.split("/").some((segment) => segment === "" || segment === "." || segment === "..")) return false;
+  if (!nonEmptyText(value.title, 500) || !nonEmptyText(value.explanation, 4_000)) return false;
+  return value.line === undefined || (Number.isSafeInteger(value.line) && Number(value.line) > 0);
+}
+
+function parseReport(text: string, requestDigest: Digest): CodexAdversarialReport | undefined {
+  let value: unknown;
+  try { value = JSON.parse(text); } catch { return undefined; }
+  if (!isRecord(value) || !exactKeys(value, ["requestDigest", "verdict", "summary", "findings"])) return undefined;
+  if (value.requestDigest !== requestDigest || !["pass", "changes_requested", "inconclusive"].includes(String(value.verdict)) ||
+      !nonEmptyText(value.summary, 4_000) || !Array.isArray(value.findings) ||
+      value.findings.length > MAX_FINDINGS || !value.findings.every(validFinding)) return undefined;
+  if ((value.verdict === "pass" && value.findings.length !== 0) ||
+      (value.verdict === "changes_requested" && value.findings.length === 0)) return undefined;
+  return value as unknown as CodexAdversarialReport;
+}
+
+function parseUsage(value: unknown): CodexReviewUsage | undefined {
+  if (!isRecord(value)) return undefined;
+  const input = value.input_tokens;
+  const output = value.output_tokens;
+  const cached = value.cached_input_tokens;
+  if (!Number.isSafeInteger(input) || Number(input) < 0 ||
+      !Number.isSafeInteger(output) || Number(output) < 0) return undefined;
+  return {
+    inputTokens: Number(input), outputTokens: Number(output),
+    ...(Number.isSafeInteger(cached) && Number(cached) >= 0 ? { cachedInputTokens: Number(cached) } : {}),
+  };
+}
+
+function parseCodexEvents(stdout: string, requestDigest: Digest):
+  { report?: CodexAdversarialReport; usage?: CodexReviewUsage; error?: string } {
+  let finalText: string | undefined;
+  let usage: CodexReviewUsage | undefined;
+  let completed = false;
+  let failure = false;
+  for (const line of stdout.split(/\r?\n/u)) {
+    if (!line) continue;
+    let event: unknown;
+    try { event = JSON.parse(line); } catch { return { error: "invalid_jsonl" }; }
+    if (!isRecord(event) || typeof event.type !== "string") return { error: "invalid_event" };
+    if (event.type === "item.completed" && isRecord(event.item) && event.item.type === "agent_message") {
+      if (typeof event.item.text !== "string") return { error: "invalid_agent_message" };
+      finalText = event.item.text;
+    }
+    if (event.type === "turn.completed") {
+      completed = true;
+      usage = parseUsage(event.usage);
+    }
+    if (event.type === "turn.failed" || event.type === "error") failure = true;
+  }
+  if (failure) return { error: "codex_turn_failed", usage };
+  if (!completed) return { error: "missing_completed_turn", usage };
+  if (finalText === undefined) return { error: "missing_agent_report", usage };
+  const report = parseReport(finalText, requestDigest);
+  if (!report) return { error: "invalid_agent_report", usage };
+  return { report, usage };
+}
+
+function digestOutput(stdout: Buffer, stderr: Buffer): Digest {
+  const hash = createHash("sha256");
+  hash.update(stdout);
+  hash.update(stderr);
+  return `sha256:${hash.digest("hex")}`;
+}
+
+/** Codex's read-only sandbox is defense in depth; the caller owns checkout isolation and exact-diff verification. */
+export async function runCodexAdversarialReview(options: CodexAdversarialReviewOptions): Promise<CodexAdversarialReviewResult> {
+  if (!DIGEST_PATTERN.test(options.requestDigest) || !nonEmptyText(options.prompt, MAX_PROMPT_BYTES) ||
+      Buffer.byteLength(options.prompt, "utf8") > MAX_PROMPT_BYTES ||
+      !Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 1 || options.timeoutMs > MAX_TIMEOUT_MS ||
+      !Number.isSafeInteger(options.maxOutputBytes) || options.maxOutputBytes < 1 || options.maxOutputBytes > MAX_OUTPUT_BYTES) {
+    throw new TypeError("Invalid Codex review bounds or request");
+  }
+  const workspaceRoot = realpathSync(options.workspaceRoot);
+  if (!statSync(workspaceRoot).isDirectory()) throw new TypeError("Codex review workspace must be a directory");
+  if (options.signal?.aborted) return { state: "inconclusive", error: "cancelled" };
+
+  const args = ["--sandbox", "read-only", "--ask-for-approval", "never", "exec", "review",
+    "--uncommitted", "--json", "--ephemeral", "-"];
+  const prompt = `${options.prompt.trimEnd()}\n\nReturn ONLY a JSON object as the final answer with exactly these keys: ` +
+    `requestDigest, verdict, summary, findings. Set requestDigest to ${options.requestDigest}. ` +
+    `verdict is pass, changes_requested, or inconclusive. Each finding has severity ` +
+    `(blocker, high, medium, low), repository-relative path, optional positive line, title, and explanation. ` +
+    `Use an empty findings array only for pass or inconclusive. Do not use Markdown fences.\n`;
+
+  return await new Promise((resolve) => {
+    let child: ChildProcessWithoutNullStreams;
+    try {
+      child = (options.spawnProcess ?? spawn)(options.executable ?? "codex", args, {
+        cwd: workspaceRoot, shell: false, windowsHide: true, stdio: ["pipe", "pipe", "pipe"],
+      });
+    } catch {
+      resolve({ state: "inconclusive", error: "spawn_failed" });
+      return;
+    }
+
+    const stdout: Buffer[] = [];
+    const stderr: Buffer[] = [];
+    let captured = 0;
+    let reason: string | undefined;
+    let settled = false;
+    let hardTimer: ReturnType<typeof setTimeout> | undefined;
+    const finish = (code: number | null) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (hardTimer) clearTimeout(hardTimer);
+      options.signal?.removeEventListener("abort", cancel);
+      const out = Buffer.concat(stdout);
+      const err = Buffer.concat(stderr);
+      const outputDigest = digestOutput(out, err);
+      if (reason) {
+        resolve({ state: "inconclusive", error: reason, outputDigest });
+        return;
+      }
+      if (code !== 0) {
+        resolve({ state: "inconclusive", error: "codex_nonzero_exit", outputDigest });
+        return;
+      }
+      const parsed = parseCodexEvents(out.toString("utf8"), options.requestDigest);
+      if (!parsed.report) {
+        resolve({ state: "inconclusive", error: parsed.error ?? "invalid_agent_report", outputDigest,
+          ...(parsed.usage ? { usage: parsed.usage } : {}) });
+        return;
+      }
+      if (parsed.report.verdict === "inconclusive") {
+        resolve({ state: "inconclusive", error: "reviewer_inconclusive", report: parsed.report, outputDigest,
+          ...(parsed.usage ? { usage: parsed.usage } : {}) });
+        return;
+      }
+      resolve({ state: "reported", report: parsed.report, outputDigest,
+        ...(parsed.usage ? { usage: parsed.usage } : {}) });
+    };
+    const stop = (why: string) => {
+      if (reason || settled) return;
+      reason = why;
+      child.kill();
+      hardTimer = setTimeout(() => finish(null), 2_000);
+    };
+    const capture = (chunk: Buffer, target: Buffer[]) => {
+      if (reason || settled) return;
+      const remaining = options.maxOutputBytes - captured;
+      if (remaining > 0) {
+        const part = chunk.subarray(0, remaining);
+        target.push(part);
+        captured += part.length;
+      }
+      if (chunk.length > remaining) stop("output_limit");
+    };
+    const cancel = () => stop("cancelled");
+    child.stdout.on("data", (chunk: Buffer) => capture(chunk, stdout));
+    child.stderr.on("data", (chunk: Buffer) => capture(chunk, stderr));
+    child.on("error", () => stop("spawn_failed"));
+    child.on("close", finish);
+    const timer = setTimeout(() => stop("timeout"), options.timeoutMs);
+    options.signal?.addEventListener("abort", cancel, { once: true });
+    if (options.signal?.aborted) cancel();
+    child.stdin.on("error", () => stop("stdin_failed"));
+    try { child.stdin.end(prompt); } catch { stop("stdin_failed"); }
+  });
+}

package/src/forge/agent-fabric/local-change-review-service.ts

@@ -0,0 +1,374 @@
+import { execFileSync } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { closeSync, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, realpathSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { sha256Digest, stableStringify } from "./canonical.ts";
+import { runCodexAdversarialReview } from "./codex-adversarial-review.ts";
+import { AgentFabricError } from "./errors.ts";
+import { localFabricPath } from "./local-paths.ts";
+
+const MAX_DIFF_BYTES = 1024 * 1024;
+const MAX_PATHS = 100;
+const MAX_ROUNDS = 8;
+
+export interface LocalChangeProposal {
+  objective: string;
+  acceptanceCriteria: string[];
+  implementer: string;
+}
+
+interface Contract extends LocalChangeProposal {
+  schemaVersion: 1;
+  changeId: string;
+  repositoryRoot: string;
+  baseCommit: string;
+  createdAt: string;
+  digest: string;
+}
+
+interface RoundIntent {
+  schemaVersion: 1;
+  round: number;
+  baseCommit: string;
+  contractDigest: string;
+  diffDigest: string;
+  diffBytes: number;
+  changedPaths: string[];
+  requestDigest: string;
+  reviewer: "codex-cli";
+  startedAt: string;
+  digest: string;
+}
+
+interface RoundResult {
+  schemaVersion: 1;
+  intentDigest: string;
+  finishedAt: string;
+  state: "reported" | "inconclusive";
+  report?: unknown;
+  outputDigest?: string;
+  usage?: unknown;
+  error?: string;
+  digest: string;
+}
+
+export interface LocalChangeStatus {
+  changeId: string;
+  state: "proposed" | "needs_review" | "review_uncertain" | "changes_requested" | "inconclusive" | "ready";
+  contractDigest: string;
+  baseCommit: string;
+  currentDiffDigest: string | null;
+  latestRound: number;
+  reviewedDiffDigest: string | null;
+  reviewerVerdict: string | null;
+  canAccept: boolean;
+}
+
+function git(root: string, args: string[], options: { index?: string; input?: Buffer; maxBuffer?: number } = {}): Buffer {
+  try {
+    return execFileSync("git", ["-c", "core.fsmonitor=false", "-c", "core.hooksPath=NUL", ...args], {
+      cwd: root, env: options.index ? { ...process.env, GIT_INDEX_FILE: options.index } : process.env,
+      input: options.input, encoding: "buffer", windowsHide: true, timeout: 30_000,
+      maxBuffer: options.maxBuffer ?? MAX_DIFF_BYTES + 4096, stdio: ["pipe", "pipe", "ignore"],
+    });
+  } catch {
+    throw new AgentFabricError("AF_INVALID_STATE", `Git operation failed: ${args[0] ?? "unknown"}`);
+  }
+}
+
+function gitText(root: string, args: string[], options?: { index?: string; maxBuffer?: number }): string {
+  return git(root, args, options).toString("utf8").trim();
+}
+
+function inertFilterOptions(root: string): string[] {
+  let names = "";
+  try {
+    names = execFileSync("git", ["config", "--name-only", "--get-regexp",
+      "^filter\\..*\\.(process|smudge|clean)$"], {
+      cwd: root, encoding: "utf8", windowsHide: true, timeout: 10_000,
+      maxBuffer: 64 * 1024, stdio: ["ignore", "pipe", "ignore"],
+    });
+  } catch (error) {
+    if ((error as { status?: number }).status !== 1) {
+      throw new AgentFabricError("AF_INVALID_STATE", "Cannot inspect Git filters");
+    }
+  }
+  const options: string[] = [];
+  for (const name of new Set(names.split(/\r?\n/u).filter(Boolean))) {
+    if (!/^filter\.[a-z0-9_.-]+\.(?:process|smudge|clean)$/iu.test(name)) {
+      throw new AgentFabricError("AF_INVALID_STATE", "Unsupported Git filter configuration");
+    }
+    options.push("-c", `${name}=`);
+  }
+  return options;
+}
+
+function digestBytes(bytes: Buffer): string { return `sha256:${createHash("sha256").update(bytes).digest("hex")}`; }
+
+function checkedObject(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new AgentFabricError("AF_INVALID_STATE", "Invalid change proposal");
+  return value as Record<string, unknown>;
+}
+
+function validateProposal(value: unknown): LocalChangeProposal {
+  const object = checkedObject(value);
+  if (Object.keys(object).sort().join(",") !== "acceptanceCriteria,implementer,objective" ||
+      typeof object.objective !== "string" || !object.objective.trim() || object.objective.length > 4000 ||
+      !Array.isArray(object.acceptanceCriteria) || object.acceptanceCriteria.length < 1 || object.acceptanceCriteria.length > 20 ||
+      !object.acceptanceCriteria.every((item) => typeof item === "string" && item.trim() && item.length <= 1000) ||
+      typeof object.implementer !== "string" || !/^[a-z][a-z0-9-]{1,63}$/u.test(object.implementer)) {
+    throw new AgentFabricError("AF_INVALID_STATE", "Change proposal requires bounded objective, acceptanceCriteria, and implementer");
+  }
+  return object as unknown as LocalChangeProposal;
+}
+
+function sealed<T extends object>(value: T): T & { digest: string } {
+  return { ...value, digest: sha256Digest(stableStringify(value)) };
+}
+
+function readSealed<T extends { digest: string }>(path: string): T {
+  const bytes = readFileSync(path);
+  if (bytes.length > MAX_DIFF_BYTES) throw new AgentFabricError("AF_CONFLICT", "Change record exceeds limit");
+  let value: T;
+  try { value = JSON.parse(bytes.toString("utf8")) as T; }
+  catch { throw new AgentFabricError("AF_CONFLICT", "Change record is invalid JSON"); }
+  if (!value || typeof value !== "object" || typeof value.digest !== "string") {
+    throw new AgentFabricError("AF_CONFLICT", "Change record is invalid");
+  }
+  const { digest, ...unsigned } = value;
+  if (sha256Digest(stableStringify(unsigned)) !== digest) throw new AgentFabricError("AF_CONFLICT", "Change record digest mismatch");
+  return value;
+}
+
+function writeNew(path: string, value: unknown): void {
+  writeFileSync(path, Buffer.isBuffer(value) ? value : JSON.stringify(value), { flag: "wx", mode: 0o600 });
+}
+
+function recordPath(root: string, id: string, filename: string): string {
+  if (!/^change:[0-9a-f-]{36}$/u.test(id)) throw new AgentFabricError("AF_INVALID_STATE", "Invalid change ID");
+  return localFabricPath(root, "change-reviews", id.slice(7), filename);
+}
+
+function roundName(round: number, suffix: string): string { return `round-${String(round).padStart(3, "0")}.${suffix}`; }
+
+function reviewPrompt(contract: Contract, diffDigest: string, paths: string[]): string {
+  return `Adversarially review this exact change against its acceptance criteria. Report only concrete findings. Do not edit files.\nObjective: ${contract.objective}\nAcceptance criteria: ${JSON.stringify(contract.acceptanceCriteria)}\nBase commit: ${contract.baseCommit}\nDiff digest: ${diffDigest}\nChanged paths: ${JSON.stringify(paths)}`;
+}
+
+interface CapturedDiff { bytes: Buffer; digest: string; paths: string[] }
+
+function capture(root: string, baseCommit: string): CapturedDiff {
+  if (gitText(root, ["rev-parse", "HEAD"]) !== baseCommit) {
+    throw new AgentFabricError("AF_CONFLICT", "Change checkout moved from its pinned base commit");
+  }
+  // A separate index captures staged, unstaged, and non-ignored new files without changing the user's index.
+  const tempParent = localFabricPath(root, "change-reviews", "tmp");
+  mkdirSync(tempParent, { recursive: true, mode: 0o700 });
+  const temp = mkdtempSync(join(tempParent, "index-"));
+  try {
+    const index = join(temp, "index");
+    git(root, ["read-tree", baseCommit], { index });
+    git(root, [...inertFilterOptions(root), "add", "-A", "--", ".", ":(exclude).forge/local/**", ":(exclude).forge/delta/**"], { index });
+    const paths = git(root, ["diff", "--cached", "--name-only", "-z", baseCommit], { index }).toString("utf8").split("\0").filter(Boolean);
+    if (paths.length > MAX_PATHS || paths.some((path) => path.startsWith(".forge/local/") || path.startsWith(".forge/delta/") || path.includes("\0"))) {
+      throw new AgentFabricError("AF_INVALID_STATE", "Change contains too many paths or local state");
+    }
+    for (const path of paths) {
+      const mode = gitText(root, ["ls-files", "-s", "--", path], { index }).split(" ")[0];
+      if (mode && mode !== "100644" && mode !== "100755") {
+        throw new AgentFabricError("AF_INVALID_STATE", "Change contains a symlink or submodule");
+      }
+    }
+    git(root, ["diff", "--cached", "--check", baseCommit], { index });
+    const bytes = git(root, ["diff", "--cached", "--no-ext-diff", "--no-textconv", "--binary", "--full-index", baseCommit], { index });
+    if (bytes.length > MAX_DIFF_BYTES || bytes.includes(Buffer.from("GIT binary patch"))) {
+      throw new AgentFabricError("AF_INVALID_STATE", "Change diff exceeds limit or contains binary data");
+    }
+    return { bytes, digest: digestBytes(bytes), paths };
+  } finally {
+    rmSync(temp, { recursive: true, force: true });
+  }
+}
+
+function materialize(root: string, id: string, round: number, base: string, diff: CapturedDiff): string {
+  const checkout = localFabricPath(root, "change-reviews", id.slice(7), `checkout-${round}`);
+  const hooks = localFabricPath(root, "change-reviews", "empty-hooks");
+  mkdirSync(hooks, { recursive: true });
+  git(root, ["-c", `core.hooksPath=${hooks}`, "worktree", "add", "--detach", "--no-checkout", "--", checkout, base]);
+  git(checkout, ["-c", `core.hooksPath=${hooks}`, ...inertFilterOptions(checkout), "reset", "--hard", base]);
+  git(checkout, [...inertFilterOptions(checkout), "apply", "--index", "--binary", "-"], { input: diff.bytes });
+  const staged = git(checkout, ["diff", "--cached", "--no-ext-diff", "--no-textconv", "--binary", "--full-index", base]);
+  if (digestBytes(staged) !== diff.digest) throw new AgentFabricError("AF_CONFLICT", "Review snapshot differs from captured change");
+  return checkout;
+}
+
+function verifySnapshot(checkout: string, base: string, expected: string): void {
+  if (gitText(checkout, ["rev-parse", "HEAD"]) !== base ||
+      git(checkout, ["diff", "--no-ext-diff", "--binary"]).length ||
+      git(checkout, ["ls-files", "--others", "--exclude-standard"]).length ||
+      digestBytes(git(checkout, ["diff", "--cached", "--no-ext-diff", "--no-textconv", "--binary", "--full-index", base])) !== expected) {
+    throw new AgentFabricError("AF_CONFLICT", "Reviewer snapshot was modified");
+  }
+}
+
+export class LocalChangeReviewService {
+  private constructor(readonly repositoryRoot: string,
+    private readonly reviewRunner: typeof runCodexAdversarialReview) {}
+
+  static async open(repositoryRoot: string, options: { reviewRunner?: typeof runCodexAdversarialReview } = {}): Promise<LocalChangeReviewService> {
+    const root = realpathSync(repositoryRoot);
+    if (realpathSync(gitText(root, ["rev-parse", "--show-toplevel"])) !== root) {
+      throw new AgentFabricError("AF_INVALID_STATE", "Change review requires a repository root");
+    }
+    return new LocalChangeReviewService(root, options.reviewRunner ?? runCodexAdversarialReview);
+  }
+
+  async close(): Promise<void> { /* filesystem records do not retain handles */ }
+
+  private contract(id: string): Contract {
+    const contract = readSealed<Contract>(recordPath(this.repositoryRoot, id, "contract.json"));
+    if (contract.changeId !== id || contract.repositoryRoot !== this.repositoryRoot || contract.schemaVersion !== 1) {
+      throw new AgentFabricError("AF_CONFLICT", "Change contract identity mismatch");
+    }
+    return contract;
+  }
+
+  private withLock<T>(id: string, fn: () => Promise<T>): Promise<T> {
+    const path = recordPath(this.repositoryRoot, id, "operation.lock");
+    let fd: number;
+    try { fd = openSync(path, "wx", 0o600); }
+    catch { throw new AgentFabricError("AF_CONFLICT", "Change operation already active or interrupted; inspect evidence before recovery"); }
+    return fn().finally(() => { closeSync(fd); unlinkSync(path); });
+  }
+
+  async propose(value: unknown): Promise<LocalChangeStatus> {
+    const request = validateProposal(value);
+    const changeId = `change:${randomUUID()}`;
+    const directory = localFabricPath(this.repositoryRoot, "change-reviews", changeId.slice(7));
+    mkdirSync(localFabricPath(this.repositoryRoot, "change-reviews"), { recursive: true, mode: 0o700 });
+    mkdirSync(directory, { recursive: false, mode: 0o700 });
+    const contract = sealed({ schemaVersion: 1 as const, ...request, changeId,
+      repositoryRoot: this.repositoryRoot, baseCommit: gitText(this.repositoryRoot, ["rev-parse", "HEAD"]),
+      createdAt: new Date().toISOString() });
+    writeNew(join(directory, "contract.json"), contract);
+    return this.status(changeId);
+  }
+
+  async status(id: string): Promise<LocalChangeStatus> {
+    const contract = this.contract(id);
+    const directory = localFabricPath(this.repositoryRoot, "change-reviews", id.slice(7));
+    const names = readdirSync(directory).filter((name) => /^round-\d{3}\.intent\.json$/u.test(name)).sort();
+    if (names.length > MAX_ROUNDS) throw new AgentFabricError("AF_CONFLICT", "Change has too many review rounds");
+    let last: RoundIntent | undefined;
+    let result: RoundResult | undefined;
+    for (let index = 0; index < names.length; index += 1) {
+      const intent = readSealed<RoundIntent>(join(directory, names[index]!));
+      if (intent.round !== index + 1 || intent.baseCommit !== contract.baseCommit ||
+          intent.contractDigest !== contract.digest || intent.schemaVersion !== 1) {
+        throw new AgentFabricError("AF_CONFLICT", "Review round chain is inconsistent");
+      }
+      const prompt = reviewPrompt(contract, intent.diffDigest, intent.changedPaths);
+      if (intent.requestDigest !== sha256Digest(stableStringify({ contractDigest: contract.digest,
+        diffDigest: intent.diffDigest, round: intent.round, prompt }))) {
+        throw new AgentFabricError("AF_CONFLICT", "Review request digest mismatch");
+      }
+      const diff = readFileSync(join(directory, roundName(intent.round, "patch")));
+      if (diff.length !== intent.diffBytes || digestBytes(diff) !== intent.diffDigest) {
+        throw new AgentFabricError("AF_CONFLICT", "Recorded review diff was modified");
+      }
+      last = intent;
+      const resultPath = join(directory, roundName(intent.round, "result.json"));
+      result = existsSync(resultPath) ? readSealed<RoundResult>(resultPath) : undefined;
+      if (result && result.intentDigest !== intent.digest) throw new AgentFabricError("AF_CONFLICT", "Review result is detached from its intent");
+      if (result?.state === "reported") {
+        const report = result.report as { requestDigest?: string; verdict?: string; findings?: unknown[] } | undefined;
+        if (!report || report.requestDigest !== intent.requestDigest ||
+            !["pass", "changes_requested"].includes(report.verdict ?? "") ||
+            !Array.isArray(report.findings) ||
+            (report.verdict === "pass" ? report.findings.length !== 0 : report.findings.length === 0) ||
+            !/^sha256:[0-9a-f]{64}$/u.test(result.outputDigest ?? "")) {
+          throw new AgentFabricError("AF_CONFLICT", "Stored reviewer report is invalid");
+        }
+      } else if (result && result.state !== "inconclusive") {
+        throw new AgentFabricError("AF_CONFLICT", "Stored reviewer state is invalid");
+      }
+      if (!result && index < names.length - 1) throw new AgentFabricError("AF_CONFLICT", "New round follows unfinished review");
+    }
+    const current = capture(this.repositoryRoot, contract.baseCommit);
+    const same = !!last && current.digest === last.diffDigest;
+    const verdict = result?.state === "reported" && result.report && typeof result.report === "object"
+      ? (result.report as { verdict?: string }).verdict ?? null : null;
+    const state: LocalChangeStatus["state"] = !last ? "proposed" : !same ? "needs_review" : !result ? "review_uncertain"
+      : result.state === "inconclusive" ? "inconclusive" : verdict === "pass" ? "ready" : "changes_requested";
+    return { changeId: id, state, contractDigest: contract.digest, baseCommit: contract.baseCommit,
+      currentDiffDigest: current.bytes.length ? current.digest : null, latestRound: last?.round ?? 0,
+      reviewedDiffDigest: last?.diffDigest ?? null, reviewerVerdict: verdict, canAccept: state === "ready" };
+  }
+
+  async evidence(id: string): Promise<{ status: LocalChangeStatus; rounds: unknown[] }> {
+    const status = await this.status(id);
+    const directory = localFabricPath(this.repositoryRoot, "change-reviews", id.slice(7));
+    const rounds: unknown[] = [];
+    for (let round = 1; round <= status.latestRound; round += 1) {
+      const intent = readSealed<RoundIntent>(join(directory, roundName(round, "intent.json")));
+      const resultPath = join(directory, roundName(round, "result.json"));
+      const result = existsSync(resultPath) ? readSealed<RoundResult>(resultPath) : undefined;
+      rounds.push({ round, diffDigest: intent.diffDigest, changedPaths: intent.changedPaths,
+        requestDigest: intent.requestDigest, reviewer: intent.reviewer, startedAt: intent.startedAt,
+        state: result?.state ?? "uncertain", report: result?.report ?? null, error: result?.error ?? null,
+        outputDigest: result?.outputDigest ?? null, usage: result?.usage ?? null });
+    }
+    return { status, rounds };
+  }
+
+  async review(id: string): Promise<LocalChangeStatus> {
+    const contract = this.contract(id);
+    if (contract.implementer === "codex-cli") throw new AgentFabricError("AF_CONFLICT", "Implementer cannot review its own change");
+    return this.withLock(id, async () => {
+      const previous = await this.status(id);
+      if (previous.state === "review_uncertain") throw new AgentFabricError("AF_CONFLICT", "Interrupted review requires owner inspection");
+      if (previous.latestRound >= MAX_ROUNDS) throw new AgentFabricError("AF_RESOURCE_EXHAUSTED", "Review round limit reached");
+      const diff = capture(this.repositoryRoot, contract.baseCommit);
+      if (!diff.bytes.length) throw new AgentFabricError("AF_INVALID_STATE", "No change diff to review");
+      if (previous.reviewedDiffDigest === diff.digest && previous.state !== "inconclusive") {
+        throw new AgentFabricError("AF_CONFLICT", "This exact diff was already reviewed");
+      }
+      const round = previous.latestRound + 1;
+      const directory = localFabricPath(this.repositoryRoot, "change-reviews", id.slice(7));
+      const prompt = reviewPrompt(contract, diff.digest, diff.paths);
+      const requestDigest = sha256Digest(stableStringify({ contractDigest: contract.digest, diffDigest: diff.digest, round, prompt }));
+      const intent = sealed({ schemaVersion: 1 as const, round, baseCommit: contract.baseCommit,
+        contractDigest: contract.digest, diffDigest: diff.digest, diffBytes: diff.bytes.length,
+        changedPaths: diff.paths, requestDigest, reviewer: "codex-cli" as const,
+        startedAt: new Date().toISOString() });
+      const patchPath = join(directory, roundName(round, "patch"));
+      if (existsSync(patchPath)) {
+        // An orphan patch means a prior process stopped before recording its intent,
+        // which is before model dispatch. The operation lock prevents a live peer.
+        if (!lstatSync(patchPath).isFile() || existsSync(join(directory, roundName(round, "intent.json")))) {
+          throw new AgentFabricError("AF_CONFLICT", "Review patch already has an intent or unsafe file type");
+        }
+        if (!readFileSync(patchPath).equals(diff.bytes)) unlinkSync(patchPath);
+      }
+      if (!existsSync(patchPath)) writeNew(patchPath, diff.bytes);
+      writeNew(join(directory, roundName(round, "intent.json")), intent);
+      // From this point a crash leaves an uncertain durable intent. Never auto-dispatch a duplicate paid turn.
+      let outcome: Awaited<ReturnType<typeof runCodexAdversarialReview>>;
+      try {
+        const checkout = materialize(this.repositoryRoot, id, round, contract.baseCommit, diff);
+        outcome = await this.reviewRunner({ workspaceRoot: checkout, prompt, requestDigest,
+          timeoutMs: 120_000, maxOutputBytes: 256 * 1024 });
+        verifySnapshot(checkout, contract.baseCommit, diff.digest);
+      } catch (error) {
+        outcome = { state: "inconclusive", error: error instanceof Error ? error.message : "Review failed" };
+      }
+      const result = sealed({ schemaVersion: 1 as const, intentDigest: intent.digest,
+        finishedAt: new Date().toISOString(), state: outcome.state,
+        ...(outcome.outputDigest ? { outputDigest: outcome.outputDigest } : {}),
+        ...(outcome.usage ? { usage: outcome.usage } : {}),
+        ...(outcome.state === "reported" ? { report: outcome.report } : { error: outcome.error ?? "Review inconclusive" }) });
+      writeNew(join(directory, roundName(round, "result.json")), result);
+      return this.status(id);
+    });
+  }
+}

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

@@ -5,6 +5,7 @@ import { buildAgentMemoryContext } from "./context-pack.ts";
 import { ingestEnvelope } from "./bridge.ts";
 import { normalizeAgentEvent } from "./normalize.ts";
 import { requestLocalTask } from "../agent-fabric/local-task-server.ts";
+import { LocalChangeReviewService } from "../agent-fabric/local-change-review-service.ts";
 
 interface JsonRpcRequest {
   jsonrpc?: "2.0";
@@ -55,6 +56,28 @@ export async function handleMcpRequest(workspaceRoot: string, request: JsonRpcRe
             inputSchema: { type: "object", properties: { taskId: { type: "string" } },
               required: ["taskId"], additionalProperties: false },
           },
+          {
+            name: "fabric_change_propose",
+            description: "Register a change request for independent review. The exact diff is pinned when the owner runs the reviewer; this tool does not start a paid reviewer or approve the change.",
+            inputSchema: { type: "object", properties: { request: {
+              type: "object",
+              properties: { objective: { type: "string" }, acceptanceCriteria: { type: "array", items: { type: "string" } },
+                implementer: { type: "string" } },
+              required: ["objective", "acceptanceCriteria", "implementer"], additionalProperties: false,
+            } }, required: ["request"], additionalProperties: false },
+          },
+          {
+            name: "fabric_change_status",
+            description: "Read the current state of a pinned change review without starting a reviewer.",
+            inputSchema: { type: "object", properties: { changeId: { type: "string" } },
+              required: ["changeId"], additionalProperties: false },
+          },
+          {
+            name: "fabric_change_evidence",
+            description: "Read exact-diff and review evidence for a pinned change without starting a reviewer.",
+            inputSchema: { type: "object", properties: { changeId: { type: "string" } },
+              required: ["changeId"], additionalProperties: false },
+          },
           {
             name: "agent_context",
             description: "Read the ForgeOS Agent Memory context pack for the current work or a runtime entry.",
@@ -154,6 +177,9 @@ async function runTool(workspaceRoot: string, name: string, args: Record<string,
       cancellation: "owner_cli_only_best_effort",
       taskMutationTools: ["fabric_propose"],
       taskReadTools: ["fabric_status", "fabric_evidence"],
+      changeMutationTools: ["fabric_change_propose"],
+      changeReadTools: ["fabric_change_status", "fabric_change_evidence"],
+      changeReviewDispatch: "owner_cli_only",
       cli: "forge fabric capabilities --json",
     };
   }
@@ -172,6 +198,28 @@ async function runTool(workspaceRoot: string, name: string, args: Record<string,
     }
     return { ok: true, status };
   }
+  if (name === "fabric_change_propose" || name === "fabric_change_status" || name === "fabric_change_evidence") {
+    const keys = Object.keys(args).sort().join(",");
+    if (name === "fabric_change_propose" &&
+        (keys !== "request" || !args.request || typeof args.request !== "object" || Array.isArray(args.request))) {
+      throw new Error("fabric_change_propose requires only request");
+    }
+    if (name !== "fabric_change_propose" &&
+        (keys !== "changeId" || typeof args.changeId !== "string" || args.changeId.length === 0)) {
+      throw new Error(`${name} requires only changeId`);
+    }
+    const service = await LocalChangeReviewService.open(realpathSync(workspaceRoot));
+    try {
+      const result = name === "fabric_change_propose"
+        ? await service.propose(args.request as Parameters<LocalChangeReviewService["propose"]>[0])
+        : name === "fabric_change_status"
+          ? await service.status(args.changeId as string)
+          : await service.evidence(args.changeId as string);
+      return { ok: true, ...(name === "fabric_change_evidence" ? { evidence: result } : { status: result }) };
+    } finally {
+      await service.close();
+    }
+  }
   if (name === "agent_context") {
     return buildAgentMemoryContext({
       workspaceRoot,

package/src/forge/cli/fabric.ts

@@ -1,12 +1,13 @@
 import { readFileSync, realpathSync, statSync } from "node:fs";
 import { isAbsolute, relative, resolve } from "node:path";
 import { LocalTaskService } from "../agent-fabric/local-task-service.ts";
+import { LocalChangeReviewService } from "../agent-fabric/local-change-review-service.ts";
 import { LOCAL_CODING_MODEL, LOCAL_CODING_TARGET } from "../agent-fabric/local-task-contract.ts";
 import { requestLocalMemory, requestLocalTask, serveLocalTasks, type LocalMemoryAction, type LocalTaskAction } from "../agent-fabric/local-task-server.ts";
 import { runAdaptiveCommand, type AdaptiveCliOptions } from "./adaptive.ts";
 
 export interface FabricCliOptions {
-  subcommand: "capabilities" | "propose" | "status" | "evidence" | "review" | "run" | "cancel" | "reconcile" | "verify" | "recover-verification" | "review-result" | "serve" | "memory-add" | "memory-list" | "memory-delete" | AdaptiveCliOptions["subcommand"];
+  subcommand: "capabilities" | "propose" | "status" | "evidence" | "review" | "run" | "cancel" | "reconcile" | "verify" | "recover-verification" | "review-result" | "serve" | "memory-add" | "memory-list" | "memory-delete" | "change-propose" | "change-status" | "change-review" | "change-evidence" | AdaptiveCliOptions["subcommand"];
   workspaceRoot: string;
   json: boolean;
   file?: string;
@@ -30,6 +31,8 @@ export async function runFabricCommand(options: FabricCliOptions): Promise<numbe
       privateMemory: "owner_cli_only",
       adaptiveHarness: { twoProcessDataOnly: true, ownerReview: true, durableReadback: true,
         selectedDataProfile: "optional_canary_or_stable" },
+      adversarialChangeReview: { propose: true, status: true, evidence: true,
+        reviewer: "codex_cli_owner_command_only", automaticPaidReview: false },
       mcpTaskMutation: "proposal_only", mcpEvidence: true,
       nativeCodexHookProofRequired: true,
     };
@@ -39,6 +42,7 @@ export async function runFabricCommand(options: FabricCliOptions): Promise<numbe
   }
 
   let service: LocalTaskService | undefined;
+  let changeService: LocalChangeReviewService | undefined;
   try {
     const repositoryRoot = realpathSync(options.workspaceRoot);
     if (options.subcommand === "serve") {
@@ -55,6 +59,31 @@ export async function runFabricCommand(options: FabricCliOptions): Promise<numbe
       }
       return 0;
     }
+    if (options.subcommand === "change-propose" || options.subcommand === "change-status" ||
+        options.subcommand === "change-review" || options.subcommand === "change-evidence") {
+      let request: unknown;
+      if (options.subcommand === "change-propose") {
+        if (!options.file) throw new Error("A change request file is required");
+        const file = realpathSync(resolve(repositoryRoot, options.file));
+        const relation = relative(repositoryRoot, file);
+        if (!relation || relation.startsWith("..") || isAbsolute(relation)) {
+          throw new Error("Change request file must be inside the current repository");
+        }
+        if (statSync(file).size > 32 * 1024) throw new Error("Change request file exceeds byte limit");
+        request = JSON.parse(readFileSync(file, "utf8")) as unknown;
+      }
+      changeService = await LocalChangeReviewService.open(repositoryRoot);
+      const changeId = options.taskId ?? "";
+      const status = options.subcommand === "change-propose"
+        ? await changeService.propose(request as Parameters<LocalChangeReviewService["propose"]>[0])
+        : options.subcommand === "change-status"
+          ? await changeService.status(changeId)
+          : options.subcommand === "change-evidence"
+            ? await changeService.evidence(changeId)
+            : await changeService.review(changeId);
+      process.stdout.write(`${JSON.stringify({ ok: true, status }, null, 2)}\n`);
+      return 0;
+    }
     let proposal: unknown;
     if (options.subcommand === "propose" || options.subcommand === "memory-add" || options.subcommand === "memory-list") {
       if (!options.file) throw new Error("A request file is required");
@@ -127,5 +156,6 @@ export async function runFabricCommand(options: FabricCliOptions): Promise<numbe
     return 1;
   } finally {
     await service?.close();
+    await changeService?.close();
   }
 }

package/src/forge/cli/main.ts

@@ -43,6 +43,10 @@ function formatHelp(): string {
     "  forge fabric memory-delete <memory-id> --json  Delete a private note",
     "  forge fabric status <task-id> --json  Read durable task control state",
     "  forge fabric evidence <task-id> --json  Read bounded task provenance and result digests",
+    "  forge fabric change-propose --file request.json --json  Register a change request for independent review",
+    "  forge fabric change-status --task-id <change-id> --json  Read pinned change review state",
+    "  forge fabric change-evidence --task-id <change-id> --json  Read exact-diff review evidence",
+    "  forge fabric change-review --task-id <change-id> --json  Run the owner-invoked Codex CLI reviewer (uses Codex credits)",
     "  forge fabric review <task-id> --json  Open the local owner review window",
     "  forge fabric run <task-id> --json  Run one approved local Ollama attempt",
     "  forge fabric cancel <task-id> --json  Request best-effort task cancellation",

package/src/forge/cli/parse.ts

@@ -277,7 +277,7 @@ export type ForgeCommand =
   | { kind: "bench"; options: BenchCommandOptions }
   | { kind: "cair"; options: CairCommandOptions }
   | { kind: "agent"; options: AgentCommandOptions }
-  | { kind: "fabric"; subcommand: "capabilities" | "propose" | "status" | "evidence" | "review" | "run" | "cancel" | "reconcile" | "verify" | "recover-verification" | "review-result" | "serve" | "memory-add" | "memory-list" | "memory-delete" | "adaptive-propose" | "adaptive-review" | "adaptive-run" | "adaptive-status"; workspaceRoot: string; json: boolean; file?: string; taskId?: string; channel?: "canary" | "stable" }
+  | { kind: "fabric"; subcommand: "capabilities" | "propose" | "status" | "evidence" | "review" | "run" | "cancel" | "reconcile" | "verify" | "recover-verification" | "review-result" | "serve" | "memory-add" | "memory-list" | "memory-delete" | "adaptive-propose" | "adaptive-review" | "adaptive-run" | "adaptive-status" | "change-propose" | "change-status" | "change-review" | "change-evidence"; workspaceRoot: string; json: boolean; file?: string; taskId?: string; channel?: "canary" | "stable" }
   | ({ kind: "evolution" } & EvolutionCliOptions)
   | { kind: "mcp"; subcommand: "serve"; workspaceRoot: string }
   | { kind: "review"; options: ReviewCommandOptions }
@@ -1272,15 +1272,19 @@ export function parseCli(argv: string[]): ParsedCli {
     }
     case "fabric": {
       const subcommand = rest[0];
-      if (subcommand !== "capabilities" && subcommand !== "propose" && subcommand !== "status" && subcommand !== "evidence" && subcommand !== "review" && subcommand !== "run" && subcommand !== "cancel" && subcommand !== "reconcile" && subcommand !== "verify" && subcommand !== "recover-verification" && subcommand !== "review-result" && subcommand !== "serve" && subcommand !== "memory-add" && subcommand !== "memory-list" && subcommand !== "memory-delete" && subcommand !== "adaptive-propose" && subcommand !== "adaptive-review" && subcommand !== "adaptive-run" && subcommand !== "adaptive-status") {
+      if (subcommand !== "capabilities" && subcommand !== "propose" && subcommand !== "status" && subcommand !== "evidence" && subcommand !== "review" && subcommand !== "run" && subcommand !== "cancel" && subcommand !== "reconcile" && subcommand !== "verify" && subcommand !== "recover-verification" && subcommand !== "review-result" && subcommand !== "serve" && subcommand !== "memory-add" && subcommand !== "memory-list" && subcommand !== "memory-delete" && subcommand !== "adaptive-propose" && subcommand !== "adaptive-review" && subcommand !== "adaptive-run" && subcommand !== "adaptive-status" && subcommand !== "change-propose" && subcommand !== "change-status" && subcommand !== "change-review" && subcommand !== "change-evidence") {
         errors.push("forge fabric requires a supported task or memory subcommand");
         return { command: null, workspaceRoot, errors };
       }
       const file = parseOptionValue(argv, "--file");
       const adaptiveChannel = parseOptionValue(argv, "--channel");
       if (adaptiveChannel && (subcommand !== "adaptive-propose" || (adaptiveChannel !== "canary" && adaptiveChannel !== "stable"))) errors.push("--channel requires adaptive-propose and canary or stable");
-      const taskId = subcommand === "status" || subcommand === "evidence" || subcommand === "review" || subcommand === "run" || subcommand === "cancel" || subcommand === "reconcile" || subcommand === "verify" || subcommand === "recover-verification" || subcommand === "review-result" || subcommand === "memory-delete" || subcommand === "adaptive-review" || subcommand === "adaptive-run" || subcommand === "adaptive-status" ? rest[1] : undefined;
+      const isChangeReadOrReview = subcommand === "change-status" || subcommand === "change-review" || subcommand === "change-evidence";
+      const taskId = isChangeReadOrReview ? parseOptionValue(argv, "--task-id")
+        : subcommand === "status" || subcommand === "evidence" || subcommand === "review" || subcommand === "run" || subcommand === "cancel" || subcommand === "reconcile" || subcommand === "verify" || subcommand === "recover-verification" || subcommand === "review-result" || subcommand === "memory-delete" || subcommand === "adaptive-review" || subcommand === "adaptive-run" || subcommand === "adaptive-status" ? rest[1] : undefined;
       if (subcommand === "propose" && (!file || file.startsWith("--"))) errors.push("forge fabric propose requires --file <proposal.json>");
+      if (subcommand === "change-propose" && (!file || file.startsWith("--"))) errors.push("forge fabric change-propose requires --file <request.json>");
+      if (isChangeReadOrReview && (!taskId || taskId.startsWith("--"))) errors.push(`forge fabric ${subcommand} requires --task-id <change-id>`);
       if (subcommand === "adaptive-propose" && (!file || file.startsWith("--"))) errors.push("forge fabric adaptive-propose requires --file <input.json>");
       if ((subcommand === "memory-add" || subcommand === "memory-list") && (!file || file.startsWith("--"))) errors.push(`forge fabric ${subcommand} requires --file <request.json>`);
       if ((subcommand === "status" || subcommand === "evidence" || subcommand === "review" || subcommand === "run" || subcommand === "cancel" || subcommand === "reconcile" || subcommand === "verify" || subcommand === "recover-verification" || subcommand === "review-result" || subcommand === "memory-delete") && !taskId) errors.push(`forge fabric ${subcommand} requires an id`);

package/src/forge/version.ts

@@ -1,3 +1,3 @@
-export const FORGEOS_VERSION = "0.1.0-alpha.65";
+export const FORGEOS_VERSION = "0.1.0-alpha.66";
 export const GENERATOR_VERSION = FORGEOS_VERSION;
 export const CLI_VERSION = FORGEOS_VERSION;