@mrciphersmith/keryx 0.2.14 → 0.2.16

package/README.md

@@ -93,15 +93,13 @@ it by reading files at random.
 ### What it looks like on a real repository
 
 Real output from a fresh clone of
-[express](https://github.com/expressjs/express) — four commands, nothing edited:
+[express](https://github.com/expressjs/express) — three commands after `init`,
+nothing edited:
 
 ```console
-$ keryx init --yes
-  ✓ gdgraph  ✓ gdctx  ✓ gdwiki  ✓ gdskills
-  ✓ health   ✓ testing  ✓ memory  ✓ tasks  ✓ security
-
 $ keryx gdgraph build
 gdgraph build complete: 139 nodes, 153 edges
+summary: .metaproject/data/gdgraph/artifacts/summary.md
 
 $ keryx gdgraph query cycles
 No cycles found.
@@ -127,6 +125,7 @@ affected graph supplies deterministically, in one command.
 
 ```text
 .metaproject/
+├── metaproject.json      # the module manifest
 ├── index.md              # the routing index every agent reads first
 ├── wiki/                 # architecture, domain models, decisions, flows
 ├── memory/               # lessons, decisions, constraints, known mistakes
@@ -136,7 +135,8 @@ affected graph supplies deterministically, in one command.
 ├── data/gdgraph/         # graph artifacts, module map, query results
 ├── data/testing/         # test context, related tests, normalized reports
 ├── data/health/          # normalized health artifacts and trends
-└── flows/                # task flows with frozen acceptance criteria
+├── flows/                # task flows with frozen acceptance criteria
+└── …                     # per-module config, hooks, templates, dashboard
 ```
 
 All Markdown and JSON. All diffable. All yours. And readable as a dashboard when
@@ -182,31 +182,40 @@ of guessing — the same `ask` the policy engine raises for a guarded action:
 
 What is in it today:
 
-- **Provider-neutral loop.** Anthropic, Ollama, OpenRouter and Grok, plus an
+- **Provider-neutral loop.** Anthropic, Ollama, and any OpenAI-compatible
+  gateway — OpenRouter, DeepSeek, Z.AI, Cerebras, Groq, Moonshot, Grok — plus an
   offline fake provider for deterministic runs. Swapping the model does not
   change the loop, the tools or the policy.
-- **Durable sessions, per project.** Append-only event log on disk, resume across
-  a process restart, branching, and context compaction that keeps the archive.
-  `/resume`, `/compact`, `/new` — and `keryx sessions list|export`.
+- **Durable sessions, per project.** JSONL transcripts on disk, resume across a
+  process restart, and context compaction that keeps the full archive.
+  `/resume`, `/compact`, `/new`, and `keryx sessions list|fork|export` — `fork`
+  branches a conversation into a new session that keeps its ancestry, without
+  editing a transcript by hand.
 - **A policy engine with three answers, not two.** `allow`, `ask`, `deny` over
-  paths, commands, tools, network and resources. Filesystem mutation is
-  path-checked, security-scanned, approval-bound and recorded as evidence.
+  seven risk classes — read, write, shell, network, credential, delegate,
+  destructive — with path and command rules underneath. Shell and destructive
+  actions are default-deny and need an explicit approval before they run.
 - **Kernel-enforced containment underneath.** The OS sandbox sits *below* the
   policy engine — Seatbelt on macOS, bubblewrap on Linux — with network off/on,
   and on macOS a loopback domain allowlist, credential masking behind a per-run
-  sentinel, and opt-in TLS termination. It fails closed when a launcher or a
-  posture is missing rather than quietly doing less.
+  sentinel, and TLS termination where masking requires it. It fails closed when a
+  launcher or a posture is missing rather than quietly doing less.
 - **Child agents with budgets.** Dispatch over the canonical
   `subagent-dispatch`/`subagent-result` contracts, token budgets per child,
-  bounded parallel scheduling, and a fleet monitor (`keryx agents monitor`).
-- **Completion you can audit.** An evidence ledger backs the completion gate: a
+  bounded parallel scheduling, and an offline fleet report over a recorded event
+  log (`keryx agents monitor <events-file>`).
+- **Completion you can audit.** The completion gate blocks on missing evidence: a
   run that cannot produce the evidence its flow requires does not get to claim
   it finished.
-- **Deterministic replay.** Recorded provider and tool fixtures replay a run with
-  no network and no mutation, and report where the state transitions diverge.
-- **Four doors, one loop.** The CLI (`keryx harness run|exec|extension|wave`),
-  JSONL/RPC, the TUI, and the loopback HTTP entry (`keryx serve`) all drive the
-  same execution loop and the same session state.
+- **Four doors.** The CLI (`keryx harness run|exec|extension|wave|replay`), JSONL/RPC
+  and the loopback HTTP entry (`keryx serve`) share one execution loop; the
+  interactive TUI runs its own on the same tool registry and the same policy.
+- **A record you can check.** `keryx harness run --record` writes a run's
+  recomputable hash surface and `keryx harness replay` validates a fixture
+  against it, naming the diverging field when one moves.
+
+The full tour — including what the harness does *not* do yet — is in
+[the harness page](docs/docs/harness.md).
 
 Provider-neutral means what it says — the same loop, the same tool registry and
 the same policy, with the model swapped out from under it:
@@ -226,7 +235,7 @@ Grouped by what you are trying to do, not by internal module layout.
 **Understand the codebase**
 
 - **gdgraph** — language-aware dependency graph for TypeScript/JavaScript, Java
-  (Maven/Gradle) and Python: cycle and orphan queries, concept and symbol lookup,
+  (Maven/Gradle) and Python: cycle and orphan queries, file and symbol search,
   shortest paths, affected-set blast radius, PageRank repo map, and an optional
   tree-sitter symbol/call graph.
 - **gdwiki** — a Markdown architecture wiki with hierarchical indexes, link
@@ -237,7 +246,7 @@ Grouped by what you are trying to do, not by internal module layout.
 **Preserve knowledge**
 
 - **memory** — long-term project memory with indexing, lexical search, dedup and
-  bitemporal validity, so a lesson learned once stays learned.
+  as-of validity queries, so a lesson learned once stays learned.
 - **gdskills** — bundled and project-generated agent skills with routing,
   verification, learning from reviews, and export to different agent runtimes.
 
@@ -246,9 +255,11 @@ Grouped by what you are trying to do, not by internal module layout.
 - **testing** — testing context, related-test selection, changed-scope runs, and
   an opt-in coverage-map Test Impact Analysis.
 - **health** — normalized reports from TypeScript, tests, audit, complexity,
-  coverage and lint (optional SonarQube), plus a quality gate and trends.
-- **review** — managed review packages under `.metaproject/reviews/`, standalone
-  or attached to a flow, so review findings become durable project artifacts.
+  coverage and lint (optional SonarQube issue import), plus a quality gate and
+  trends.
+- **review** — managed review packages, standalone under `.metaproject/reviews/`
+  or inside the flow package when attached to a flow, so review findings become
+  durable project artifacts.
 
 **Operate agents**
 
@@ -258,13 +269,13 @@ Grouped by what you are trying to do, not by internal module layout.
   scanning, redaction, and a policy gate at agent write seams, with a committed
   evaluation corpus.
 - **mcp** — an opt-in [Model Context Protocol](https://modelcontextprotocol.io)
-  server exposing read-only module services to agents.
+  server exposing read-only module services to agents, plus one report-writing
+  security scan.
 
 **Run agents inside boundaries**
 
 - **harness** — the first-party agent runtime described above: provider-neutral
-  loop, durable sessions, policy engine, child agents, evidence-gated completion,
-  deterministic replay.
+  loop, durable sessions, policy engine, child agents, evidence-gated completion.
 - **sandbox** — kernel-enforced containment under the policy engine
   (`keryx harness exec`), with filesystem boundaries, network posture and, on
   macOS, a domain allowlist with credential masking.
@@ -301,7 +312,7 @@ Alternative install paths — the managed installer (`~/.keryx` with a wrapper i
 `~/.local/bin`), project-local installs, and running from source — are in the
 [onboarding guide](docs/docs/onboarding.md).
 
-Bare `keryx` prints the CLI surface; `keryx shell` starts the agent harness
+Bare `keryx` prints the main commands; `keryx shell` starts the agent harness
 described [above](#the-agent-harness).
 
 ## Agent integrations
@@ -323,18 +334,21 @@ keryx agents bootstrap install --runtime claude
 keryx mcp install --runtime cursor          # opt-in read-only MCP server
 ```
 
+Each of those commands has its own `--runtime` vocabulary — run
+`keryx <command> --help` for the values it accepts.
+
 ## Requirements and compatibility
 
 | Requirement | Status |
 |-------------|--------|
 | Bun | >= 1.1.0 |
-| Git | Required |
+| Git | Required for hooks, `--changed` scopes and the managed installer; the core runs without it |
 | ripgrep | Required only for `keryx ctx rg` and the agent's `search_code` tool |
 | Model provider credential | Required only for the optional AI commands below |
 | macOS | Full support, including the complete policy sandbox |
 | Linux | Full core support; filesystem containment and network on/off (needs `bubblewrap`) |
 | Windows | Core CLI is not verified in CI; the OS sandbox is macOS/Linux only |
-| CI | Ubuntu and macOS runners on every push |
+| CI | Ubuntu and macOS runners on every pull request and every push to `main` |
 
 ## Optional AI features
 
@@ -365,7 +379,7 @@ graph falls back to its deterministic resolver when a grammar is absent.
 | Domain allowlist is macOS-only | Domain-level egress policy, credential masking and TLS termination refuse to run on Linux rather than silently doing less | Filesystem containment and network on/off work on both |
 | No bundled embedding runtime | No semantic ranking in memory search | Lexical memory search remains fully available |
 | ripgrep is external | `keryx ctx rg` needs `rg` on `PATH` | Install ripgrep, or let the agent read files directly |
-| Model commands need a credential | The five commands above exit non-zero without one | Everything else runs deterministically offline |
+| Model commands need a credential | Four of the five commands above exit non-zero without one; `wiki enrich` exits `0` and marks the affected pages skipped | Everything else runs deterministically offline |
 
 Full detail, including known defects and platform caveats:
 [limitations](docs/docs/limitations.md).
@@ -383,11 +397,12 @@ keryx serve                      # bind 127.0.0.1 and listen
 keryx serve status --json        # configuration state
 ```
 
-It is off unless you configure it, binds loopback unless you pass
-`--acknowledge-non-loopback`, and authenticates *before* routing, so an
-unauthenticated caller cannot tell a known path from an unknown one. The remote
-policy profile may never be weaker than the local one — it is compared on every
-turn and a weaker profile is refused. See
+It is off unless you configure it, and moving it off loopback takes a `--bind`
+address plus an explicit acknowledgement in *both* the stored config and the
+command line — either one alone refuses to start. It authenticates *before*
+routing, so an unauthenticated caller cannot tell a known path from an unknown
+one. The remote policy profile may never be weaker than the local one — it is
+compared at startup, and a weaker profile refuses to bind at all. See
 [drive keryx remotely](docs/docs/guides/drive-keryx-remotely.md) for routes and
 setup.
 
@@ -405,7 +420,9 @@ keryx dashboard build
 
 `keryx health gate --strict-warn` fails a job on the normalized health gate
 instead of parsing raw linter/test logs, and `keryx security eval --corpus all`
-fails on any detector breaching its committed false-negative threshold. See
+fails on any detector breaching its committed false-negative threshold — from a
+repository checkout, since the evaluation corpus is not shipped in the npm
+package. See
 [run keryx in CI](docs/docs/guides/run-in-ci.md).
 
 ## Documentation
@@ -415,13 +432,12 @@ Full documentation site: **<https://mrciphersmith.github.io/keryx/>**
 - **[Onboarding](docs/docs/onboarding.md)** — install paths, first-run walkthrough, the build loop.
 - **[Architecture](docs/docs/architecture.md)** — the four-layer pattern, invariants, cross-module data flows.
 - **[Module reference](docs/docs/modules.md)** — one section per module: purpose, CLI surface, mechanics, data paths.
-- **[CLI reference](docs/docs/cli-reference.md)** — every command, subcommand, flag and exit code.
+- **[CLI reference](docs/docs/cli-reference.md)** — the command surface: subcommands, flags and exit codes.
 - **[Workspace & lifecycle](docs/docs/workspace-and-lifecycle.md)** — the `.metaproject/` contract and `init`/`update` lifecycle.
 - **[Limitations](docs/docs/limitations.md)** — known gaps, platform caveats, and what to do instead.
 - **[Changelog](CHANGELOG.md)** — what has landed since `v0.1.0`.
 
-Run `keryx <command> --help` (or `keryx` with no arguments) for the live command
-surface.
+Run `keryx <command> --help` for the live flag surface of any command.
 
 ## Local development
 

package/dist/cli.js

@@ -20056,6 +20056,7 @@ async function initCommand(args) {
   if (enableMcp) {
     statusLine("mcp", true, "Model Context Protocol server (opt-in)");
   }
+  const gitHooksRoot = await resolveGitHooksRoot(projectRoot);
   const hookLines = [];
   if (enableGdgraph) {
     hookLines.push(["gdgraph post-commit", enableGdgraphHook]);
@@ -20072,13 +20073,23 @@ async function initCommand(args) {
   }
   if (enableSecurity) {
     hookLines.push(["security pre-push", enableSecurityPrePushHook]);
-    hookLines.push(["security agent (.claude)", enableSecurityAgentHook]);
   }
-  if (hookLines.length > 0) {
+  const agentHookLines = enableSecurity ? [["security agent (.claude)", enableSecurityAgentHook]] : [];
+  if (hookLines.length > 0 || agentHookLines.length > 0) {
     heading("Git hooks");
     for (const [label, on] of hookLines) {
+      if (gitHooksRoot) {
+        statusLine(label, on);
+      } else {
+        statusLine(label, false, "skipped - not a git repository");
+      }
+    }
+    for (const [label, on] of agentHookLines) {
       statusLine(label, on);
     }
+    if (!gitHooksRoot && hookLines.length > 0) {
+      console.log(`  ${style.dim("Run")} ${style.cyan("git init")} ${style.dim("and then")} ${style.cyan("keryx init")} ${style.dim("again to install them.")}`);
+    }
   }
   const wroteSandboxPolicy = writeProjectSandboxPolicySkeletonIfMissing(projectRoot);
   if (wroteSandboxPolicy) {
@@ -22490,6 +22501,9 @@ function parseRuntimeArg2(args) {
   const value = optionValue(args, "--runtime") ?? "claude";
   return value.split(",").map((s) => s.trim()).filter(Boolean);
 }
+function isDryRun(args) {
+  return args.includes("--dry-run");
+}
 async function readSettings4(file) {
   if (!await pathExists(file))
     return {};
@@ -22526,6 +22540,7 @@ function reportUnsupported2(ids) {
 }
 async function handleInstall(args) {
   const cwd = process.cwd();
+  const dryRun = isDryRun(args);
   const { runtimes, unknown, unsupported } = resolveOrientRuntimes(parseRuntimeArg2(args));
   if (unknown.length > 0) {
     console.error(`Unknown runtime(s): ${unknown.join(", ")}`);
@@ -22533,35 +22548,47 @@ async function handleInstall(args) {
     process.exitCode = 1;
     return;
   }
-  console.log("# keryx orientation injector installed");
+  console.log(`# keryx orientation injector ${dryRun ? "install \u2014 dry run, nothing written" : "installed"}`);
   console.log("");
   console.log("injects: compact code-graph map + wiki index + freshness at turn start");
   console.log("");
   for (const runtime of runtimes) {
+    const target = path65.relative(cwd, runtime.locate(cwd));
+    if (dryRun) {
+      console.log(`  \xB7 ${runtime.id} -> would write ${target}`);
+      continue;
+    }
     const errors = await installOne(cwd, runtime);
     if (errors.length > 0) {
       for (const e of errors)
         console.error(`  \u2717 ${e}`);
       process.exitCode = 1;
     } else {
-      console.log(`  \u2713 ${runtime.id} -> ${path65.relative(cwd, runtime.locate(cwd))}`);
+      console.log(`  \u2713 ${runtime.id} -> ${target}`);
     }
   }
   reportUnsupported2(unsupported);
 }
 async function handleUninstall(args) {
   const cwd = process.cwd();
+  const dryRun = isDryRun(args);
   const { runtimes, unknown, unsupported } = resolveOrientRuntimes(parseRuntimeArg2(args));
   if (unknown.length > 0) {
     console.error(`Unknown runtime(s): ${unknown.join(", ")}`);
     process.exitCode = 1;
     return;
   }
-  console.log("# keryx orientation injector uninstall");
+  console.log(`# keryx orientation injector uninstall${dryRun ? " \u2014 dry run, nothing written" : ""}`);
   console.log("");
   for (const runtime of runtimes) {
+    const target = path65.relative(cwd, runtime.locate(cwd));
+    if (dryRun) {
+      const present = await pathExists(runtime.locate(cwd));
+      console.log(`  \xB7 ${runtime.id} ${present ? `-> would strip ${target}` : "nothing to remove"}`);
+      continue;
+    }
     const removed = await uninstallOne(cwd, runtime);
-    console.log(`  ${removed ? "\u2713" : "\xB7"} ${runtime.id} ${removed ? `-> ${path65.relative(cwd, runtime.locate(cwd))}` : "nothing to remove"}`);
+    console.log(`  ${removed ? "\u2713" : "\xB7"} ${runtime.id} ${removed ? `-> ${target}` : "nothing to remove"}`);
   }
   reportUnsupported2(unsupported);
 }
@@ -22570,8 +22597,11 @@ function printHelp5() {
 
 Usage:
   keryx orient [<runtime>]                      emit the orientation block
-  keryx orient install-hook [--runtime <id|all>]
-  keryx orient uninstall-hook [--runtime <id|all>]
+  keryx orient install-hook [--runtime <id|all>] [--dry-run]
+  keryx orient uninstall-hook [--runtime <id|all>] [--dry-run]
+
+Options:
+  --dry-run    report what would be written or stripped; change nothing
 
 Runtimes with a context-injection hook: ${orientRuntimeIds().join(", ")}
 (Windsurf/Zed have no context-injection hook \u2014 use their rules/memories.)
@@ -33807,7 +33837,11 @@ function printMcpHelp() {
 init_fs();
 init_json();
 import path111 from "path";
-async function statusCommand() {
+async function statusCommand(args = []) {
+  if (args.includes("--help") || args.includes("-h")) {
+    printHelp14();
+    return;
+  }
   const root = path111.join(process.cwd(), ".metaproject");
   const manifestPath = path111.join(root, "metaproject.json");
   if (!await pathExists(root)) {
@@ -33836,13 +33870,73 @@ async function statusCommand() {
     console.log(`  ${name}: ${moduleConfig.enabled ? "enabled" : "disabled"}`);
   }
 }
+function printHelp14() {
+  console.log(`keryx status \u2014 whether this project has a .metaproject workspace, and which modules are on
+
+Usage:
+  keryx status
+
+Reports the workspace root and one enabled/disabled line per module. Use
+\`keryx modules\` to toggle a module, and \`keryx init\` to create the workspace.
+`);
+}
 
 // src/commands/harness.ts
-init_make_provider();
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
 import path115 from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 
+// src/security/harness-scan.ts
+init_guard();
+init_config();
+init_detect();
+var PERMISSIVE = {
+  scan: () => ({ hasSecret: false }),
+  available: false
+};
+var CATEGORY_PRECEDENCE = [
+  "secret",
+  "pii",
+  "prompt-injection",
+  "egress",
+  "artifact-safety",
+  "raw-retention"
+];
+async function buildHarnessScanner(cwd) {
+  let config;
+  try {
+    if (!await isSecurityEnabled(cwd)) {
+      return PERMISSIVE;
+    }
+    config = await loadSecurityConfig(cwd);
+  } catch {
+    return PERMISSIVE;
+  }
+  return {
+    available: true,
+    scan: (content) => {
+      if (content.length === 0) {
+        return { hasSecret: false };
+      }
+      let matches2;
+      try {
+        matches2 = runDetectors(content, config);
+      } catch {
+        return { hasSecret: false, scanFailed: true };
+      }
+      if (matches2.length === 0) {
+        return { hasSecret: false };
+      }
+      const present = new Set(matches2.map((m) => m.category));
+      const category = CATEGORY_PRECEDENCE.find((c) => present.has(c)) ?? matches2[0]?.category ?? "unknown";
+      return { hasSecret: true, category };
+    }
+  };
+}
+
+// src/commands/harness.ts
+init_make_provider();
+
 // src/harness/policy/profiles.ts
 import { createHash as createHash8 } from "crypto";
 
@@ -34406,7 +34500,7 @@ async function runOffline(input2, config, deps) {
   const executed = [];
   const blockerIds = [];
   const unresolvedRisks = [];
-  const scan = () => ({ hasSecret: false });
+  const scan = deps.scan ?? (() => ({ hasSecret: false }));
   const toolNameByCall = new Map;
   const actionCounts = new Map;
   let executedToolCalls = 0;
@@ -34538,11 +34632,14 @@ async function runOffline(input2, config, deps) {
       blockerIds.push(`blocker:tool-${result.errorCode ?? "failed"}:${toolCallId}`);
     }
   }
-  const requiredGates = [];
+  const requiredGates = [...deps.completionRequirements?.requiredGates ?? []];
+  const requiredEvidenceRefs = [
+    ...deps.completionRequirements?.requiredEvidenceRefs ?? []
+  ];
   const gate = evaluateCompletion({
     runId,
     requiredGates,
-    requiredEvidenceRefs: [],
+    requiredEvidenceRefs,
     presentEvidenceIds: uniqueInOrder2(presentEvidenceIds),
     undisposedBlockerIds: uniqueInOrder2(blockerIds),
     finalMessageEmitted
@@ -34676,6 +34773,129 @@ function earlyTermination(input2, config, deps, startedAt, reason) {
   };
 }
 
+// src/harness/replay/replay.ts
+var SCHEMA_VERSION5 = 1;
+function recomputeHashes(run) {
+  return {
+    sessionManifestHash: run.sessionManifestHash,
+    eventLogHash: run.eventLogHash,
+    toolRegistryHash: run.toolRegistryHash,
+    transcriptHash: run.transcriptHash,
+    expectedStateHash: run.expectedStateHash
+  };
+}
+function buildReplayFixture(run, deps) {
+  const hashes = recomputeHashes(run);
+  return {
+    schemaVersion: SCHEMA_VERSION5,
+    fixtureId: deps.idSeq(),
+    mode: "validate-log",
+    sessionManifestHash: hashes.sessionManifestHash,
+    eventLogHash: hashes.eventLogHash,
+    toolRegistryHash: hashes.toolRegistryHash,
+    transcriptHash: hashes.transcriptHash,
+    expectedStateHash: hashes.expectedStateHash,
+    noSideEffects: true
+  };
+}
+function toRunRecord(run, meta) {
+  return {
+    schemaVersion: SCHEMA_VERSION5,
+    runId: meta.runId,
+    status: meta.status,
+    recordedAt: meta.recordedAt,
+    sessionManifestHash: run.sessionManifestHash,
+    eventLogHash: run.eventLogHash,
+    toolRegistryHash: run.toolRegistryHash,
+    transcriptHash: run.transcriptHash,
+    expectedStateHash: run.expectedStateHash
+  };
+}
+var HASH_FIELDS = [
+  "sessionManifestHash",
+  "eventLogHash",
+  "toolRegistryHash",
+  "transcriptHash",
+  "expectedStateHash"
+];
+function nonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function hasEveryHash(record) {
+  return HASH_FIELDS.every((field3) => nonEmptyString(record[field3]));
+}
+function parseRunRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return;
+  const record = value;
+  if (!hasEveryHash(record) || !nonEmptyString(record.runId))
+    return;
+  return {
+    schemaVersion: typeof record.schemaVersion === "number" ? record.schemaVersion : SCHEMA_VERSION5,
+    runId: record.runId,
+    status: nonEmptyString(record.status) ? record.status : "unknown",
+    recordedAt: nonEmptyString(record.recordedAt) ? record.recordedAt : "",
+    sessionManifestHash: record.sessionManifestHash,
+    eventLogHash: record.eventLogHash,
+    toolRegistryHash: record.toolRegistryHash,
+    transcriptHash: record.transcriptHash,
+    expectedStateHash: record.expectedStateHash
+  };
+}
+function parseReplayFixture(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return;
+  const record = value;
+  if (!hasEveryHash(record) || !nonEmptyString(record.fixtureId))
+    return;
+  const mode = record.mode;
+  if (mode !== "validate-log" && mode !== "simulate-recorded-results" && mode !== "isolated-re-execute") {
+    return;
+  }
+  return {
+    schemaVersion: typeof record.schemaVersion === "number" ? record.schemaVersion : SCHEMA_VERSION5,
+    fixtureId: record.fixtureId,
+    mode,
+    sessionManifestHash: record.sessionManifestHash,
+    eventLogHash: record.eventLogHash,
+    toolRegistryHash: record.toolRegistryHash,
+    transcriptHash: record.transcriptHash,
+    expectedStateHash: record.expectedStateHash,
+    noSideEffects: record.noSideEffects !== false,
+    ...nonEmptyString(record.isolationProfile) ? { isolationProfile: record.isolationProfile } : {}
+  };
+}
+var HASH_CHECKS = [
+  { field: "sessionManifestHash", kind: "state", detail: "sessionManifestHash diverged on replay (session manifest)" },
+  { field: "eventLogHash", kind: "event-order", detail: "eventLogHash diverged on replay (event order)" },
+  { field: "toolRegistryHash", kind: "tool-result", detail: "toolRegistryHash diverged on replay (tool registry)" },
+  { field: "transcriptHash", kind: "provider-transcript", detail: "transcriptHash diverged on replay (provider transcript)" },
+  { field: "expectedStateHash", kind: "state", detail: "expectedStateHash diverged on replay (terminal state)" }
+];
+function replayOffline(fixture, run, deps) {
+  const actual = recomputeHashes(run);
+  for (const check of HASH_CHECKS) {
+    const expectedHash = fixture[check.field];
+    const actualHash = actual[check.field];
+    if (expectedHash !== actualHash) {
+      return {
+        ok: false,
+        mismatch: {
+          schemaVersion: SCHEMA_VERSION5,
+          mismatchId: deps.idSeq(),
+          fixtureId: fixture.fixtureId,
+          kind: check.kind,
+          expectedHash,
+          actualHash,
+          detectedAt: deps.clock(),
+          detail: check.detail
+        }
+      };
+    }
+  }
+  return { ok: true };
+}
+
 // src/harness/tool/registry.ts
 import { createHash as createHash13 } from "crypto";
 function canonicalize3(value) {
@@ -35208,7 +35428,7 @@ class SandboxedProcessAdapter {
   }
   spawn(command) {
     const { profile, inner, platform, launcherAvailable, bwrapPath } = this.opts;
-    const failClosed = profile.required || (this.opts.failIfUnavailable ?? true);
+    const failClosed = profile.required || profile.network === "restricted" || (this.opts.failIfUnavailable ?? true);
     if (profile.mode === "danger-full-access") {
       return inner.spawn(command);
     }
@@ -36026,7 +36246,8 @@ var USAGE = [
   "         [--allowed-domains a,b] [--mask-env NAME@host] [--tls-terminate] [--mask-mode auto|manual|off] [--auto-mask]",
   "         -- <path> [args...]",
   "       keryx harness extension --spec <path>",
-  "       keryx harness wave --spec <path>"
+  "       keryx harness wave --spec <path>",
+  "       keryx harness replay --record <path> [--fixture <path>] [--write-fixture <path>] [--json]"
 ].join(`
 `);
 function readOnlyProfile() {
@@ -36041,6 +36262,7 @@ function parseArgs2(args) {
   let provider = "";
   let model = "";
   let baseUrl;
+  let record;
   const positional = [];
   for (let i = 1;i < args.length; i++) {
     const arg = args[i];
@@ -36050,6 +36272,8 @@ function parseArgs2(args) {
       model = args[++i] ?? "";
     } else if (arg === "--base-url") {
       baseUrl = args[++i];
+    } else if (arg === "--record") {
+      record = args[++i];
     } else if (arg !== undefined) {
       positional.push(arg);
     }
@@ -36057,6 +36281,8 @@ function parseArgs2(args) {
   const parsed = { provider, model, prompt: positional.join(" ") };
   if (baseUrl !== undefined)
     parsed.baseUrl = baseUrl;
+  if (record !== undefined)
+    parsed.record = record;
   return parsed;
 }
 function toStructured(result) {
@@ -36082,11 +36308,15 @@ async function harnessCommand(args, deps) {
     harnessWave(args, deps);
     return;
   }
+  if (subcommand === "replay") {
+    harnessReplay(args, deps);
+    return;
+  }
   if (subcommand !== "run") {
     console.log(USAGE);
     return;
   }
-  const { provider, model, baseUrl, prompt } = parseArgs2(args);
+  const { provider, model, baseUrl, prompt, record } = parseArgs2(args);
   const validProviders = new Set(["fake", "anthropic", "ollama"]);
   if (!validProviders.has(provider) || prompt.length === 0) {
     console.log(USAGE);
@@ -36129,6 +36359,7 @@ async function harnessCommand(args, deps) {
     policyProfile: "read-only-review",
     limits: { maxRunSeconds: 300, maxConcurrentChildren: 1, maxToolOutputBytes: 65536, maxRetries: 1 }
   };
+  const { scan } = await buildHarnessScanner(process.cwd());
   const runDeps = {
     provider: providerPort,
     toolRegistry: new ToolRegistry,
@@ -36136,12 +36367,21 @@ async function harnessCommand(args, deps) {
     policyProfile: readOnlyProfile(),
     clock,
     idSeq,
-    interactive: false
+    interactive: false,
+    scan
   };
   let structured;
   try {
     const result = await runOffline(input2, config, runDeps);
     structured = toStructured(result);
+    if (record !== undefined && record.length > 0) {
+      writeFileSync6(record, `${JSON.stringify(toRunRecord(result, {
+        runId: result.output.runId,
+        status: result.output.status,
+        recordedAt: result.output.startedAt
+      }), null, 2)}
+`, { encoding: "utf8", mode: 384 });
+    }
   } catch (error) {
     structured = {
       events: [],
@@ -36152,6 +36392,112 @@ async function harnessCommand(args, deps) {
   }
   console.log(JSON.stringify(structured));
 }
+function parseReplayArgs(args) {
+  const parsed = { json: false };
+  for (let i = 1;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--record") {
+      parsed.record = args[++i] ?? "";
+    } else if (arg === "--fixture") {
+      parsed.fixture = args[++i] ?? "";
+    } else if (arg === "--write-fixture") {
+      parsed.writeFixture = args[++i] ?? "";
+    } else if (arg === "--json") {
+      parsed.json = true;
+    }
+  }
+  return parsed;
+}
+function readJsonFile2(file) {
+  let text;
+  try {
+    text = readFileSync7(file, "utf8");
+  } catch (error) {
+    return { ok: false, reason: error instanceof Error ? error.message : String(error) };
+  }
+  try {
+    return { ok: true, value: JSON.parse(text) };
+  } catch (error) {
+    return { ok: false, reason: `not valid JSON (${error instanceof Error ? error.message : String(error)})` };
+  }
+}
+function harnessReplay(args, deps) {
+  const parsed = parseReplayArgs(args);
+  if (parsed.record === undefined || parsed.record.length === 0) {
+    console.log(USAGE);
+    process.exitCode = 1;
+    return;
+  }
+  const recordRead = readJsonFile2(parsed.record);
+  if (!recordRead.ok) {
+    console.error(`Cannot read run record ${parsed.record}: ${recordRead.reason}`);
+    process.exitCode = 1;
+    return;
+  }
+  const run = parseRunRecord(recordRead.value);
+  if (run === undefined) {
+    console.error(`${parsed.record} is not a harness run record (expected runId plus the five recorded hashes; write one with \`keryx harness run --record\`).`);
+    process.exitCode = 1;
+    return;
+  }
+  const clock = deps?.clock ?? (() => new Date().toISOString());
+  let idCounter = 0;
+  const idSeq = deps?.idSeq ?? (() => `${randomUUID5()}-${idCounter++}`);
+  const fixture = (() => {
+    if (parsed.fixture === undefined || parsed.fixture.length === 0) {
+      return { ok: true, value: buildReplayFixture(run, { idSeq }), built: true };
+    }
+    const read = readJsonFile2(parsed.fixture);
+    if (!read.ok) {
+      return { ok: false, reason: `Cannot read fixture ${parsed.fixture}: ${read.reason}` };
+    }
+    const parsedFixture = parseReplayFixture(read.value);
+    if (parsedFixture === undefined) {
+      return {
+        ok: false,
+        reason: `${parsed.fixture} is not a replay fixture (expected fixtureId, mode and the five hashes).`
+      };
+    }
+    return { ok: true, value: parsedFixture, built: false };
+  })();
+  if (!fixture.ok) {
+    console.error(fixture.reason);
+    process.exitCode = 1;
+    return;
+  }
+  if (parsed.writeFixture !== undefined && parsed.writeFixture.length > 0) {
+    writeFileSync6(parsed.writeFixture, `${JSON.stringify(fixture.value, null, 2)}
+`, {
+      encoding: "utf8",
+      mode: 384
+    });
+  }
+  const outcome = replayOffline(fixture.value, run, { clock, idSeq });
+  if (parsed.json) {
+    console.log(JSON.stringify({
+      schemaVersion: 1,
+      mode: fixture.value.mode,
+      runId: run.runId,
+      fixtureId: fixture.value.fixtureId,
+      fixtureSource: fixture.built ? "built-from-record" : parsed.fixture,
+      ok: outcome.ok,
+      ...outcome.ok ? {} : { mismatch: outcome.mismatch }
+    }));
+  } else if (outcome.ok) {
+    console.log(`Replay OK (${fixture.value.mode}): fixture ${fixture.value.fixtureId} matches run ${run.runId}.`);
+    if (fixture.built) {
+      console.log("Fixture was built from this record, so a match is expected; keep it with --write-fixture.");
+    }
+  } else {
+    console.error(`Replay MISMATCH (${outcome.mismatch.kind}) on run ${run.runId}:`);
+    console.error(`  ${outcome.mismatch.detail ?? "hash diverged"}`);
+    console.error(`  expected ${outcome.mismatch.expectedHash}`);
+    console.error(`  actual   ${outcome.mismatch.actualHash}`);
+  }
+  if (!outcome.ok) {
+    process.exitCode = 1;
+  }
+}
 var EXEC_PARENT_REMAINING_MS = 60000;
 var EXEC_DEFAULT_RUNTIME_MS = 30000;
 var EXEC_OUTPUT_LIMIT_BYTES = 1e6;
@@ -36340,6 +36686,7 @@ async function harnessExec(args, deps) {
     }
     effectiveAllowEnvKeys = [...allowEnvKeys, ...Object.keys(net.envAdditions)];
   }
+  const scanner = await buildHarnessScanner(cwd);
   const command = {
     path: commandPath,
     argv: [commandPath, ...commandArgs],
@@ -36362,7 +36709,7 @@ async function harnessExec(args, deps) {
       envAllowlist: effectiveAllowEnvKeys,
       profile: shellAllowProfile(),
       interactive: true,
-      scanAvailable: true,
+      scanAvailable: scanner.available,
       risk: "shell"
     },
     budget,
@@ -39096,7 +39443,7 @@ import {
   mkdirSync as mkdirSync6,
   readdirSync,
   renameSync as renameSync2,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "fs";
 import path117 from "path";
 import { randomUUID as randomUUID7 } from "crypto";
@@ -39137,7 +39484,7 @@ function tighten(target) {
 }
 function atomicWriteText(file, body) {
   const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
-  writeFileSync6(tmp, body, { encoding: "utf8", mode: 384 });
+  writeFileSync7(tmp, body, { encoding: "utf8", mode: 384 });
   renameSync2(tmp, file);
 }
 function atomicWriteJson(file, value) {
@@ -39395,6 +39742,39 @@ function compactSession(handle, context, archive, opts) {
   atomicWriteJson(path117.join(withCount.dir, "summary.json"), withCount.summary);
   return { handle: withCount, context: result.context, result };
 }
+
+class UnknownSessionError extends Error {
+  idOrPrefix;
+  constructor(idOrPrefix) {
+    super(`no session matching "${idOrPrefix}" in this project`);
+    this.idOrPrefix = idOrPrefix;
+    this.name = "UnknownSessionError";
+  }
+}
+function forkSession(opts) {
+  const source = findSession(opts.cwd, opts.sourceIdOrPrefix, opts.dataDir);
+  if (source === undefined) {
+    throw new UnknownSessionError(opts.sourceIdOrPrefix);
+  }
+  const context = loadContext(opts.cwd, source.id, opts.dataDir);
+  const archive = loadArchive(opts.cwd, source.id, opts.dataDir);
+  const title = opts.title !== undefined && opts.title.trim().length > 0 ? opts.title.trim() : `${source.title} (fork)`;
+  const created = createSession({
+    cwd: opts.cwd,
+    parentSessionId: source.id,
+    title,
+    ...opts.dataDir !== undefined ? { dataDir: opts.dataDir } : {},
+    ...source.provider !== undefined ? { provider: source.provider } : {},
+    ...source.model !== undefined ? { model: source.model } : {}
+  });
+  const handle = persistHistory(created, context, {
+    archive,
+    title,
+    ...source.provider !== undefined ? { provider: source.provider } : {},
+    ...source.model !== undefined ? { model: source.model } : {}
+  });
+  return { handle, source, messageCount: context.length, archiveCount: archive.length };
+}
 function openSession(opts) {
   const cwd = opts.cwd;
   const dataDir = opts.dataDir;
@@ -44039,7 +44419,7 @@ async function shellCommand(args2) {
 async function sessionsCommand(args2) {
   const sub = args2[0] ?? "list";
   if (sub === "--help" || sub === "-h" || sub === "help") {
-    printHelp14();
+    printHelp15();
     return;
   }
   const cwd = process.cwd();
@@ -44061,7 +44441,7 @@ async function sessionsCommand(args2) {
     console.log(pad("ID", 10) + pad("UPDATED", 22) + pad("MSGS", 6) + pad("MODEL", 24) + "TITLE");
     for (const s of rows) {
       const model = s.provider !== undefined && s.model !== undefined ? `${s.provider}/${s.model}` : s.model ?? "-";
-      console.log(pad(shortSessionId(s.id), 10) + pad(s.updatedAt.slice(0, 19).replace("T", " "), 22) + pad(String(s.messageCount), 6) + pad(clip4(model, 22), 24) + s.title);
+      console.log(pad(shortSessionId(s.id), 10) + pad(s.updatedAt.slice(0, 19).replace("T", " "), 22) + pad(String(s.messageCount), 6) + pad(clip4(model, 22), 24) + (s.parentSessionId !== undefined ? `\u21B3 ${s.title}` : s.title));
     }
     console.log("");
     console.log("Resume: keryx shell -r <id>   Continue last: keryx shell -c");
@@ -44091,12 +44471,61 @@ async function sessionsCommand(args2) {
     }
     return;
   }
+  if (sub === "fork") {
+    const id = args2[1];
+    if (id === undefined || id.length === 0 || id.startsWith("-")) {
+      console.error('Usage: keryx sessions fork <id> [--title "<t>"]');
+      process.exitCode = 1;
+      return;
+    }
+    const titleIndex = args2.indexOf("--title");
+    const title = titleIndex >= 0 ? args2[titleIndex + 1] : undefined;
+    if (titleIndex >= 0 && (title === undefined || title.length === 0)) {
+      console.error('Usage: keryx sessions fork <id> [--title "<t>"]');
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      const forked = forkSession({ cwd, sourceIdOrPrefix: id, ...title !== undefined ? { title } : {} });
+      if (args2.includes("--json")) {
+        console.log(JSON.stringify({
+          schemaVersion: 1,
+          id: forked.handle.summary.id,
+          parentSessionId: forked.source.id,
+          title: forked.handle.summary.title,
+          messageCount: forked.messageCount,
+          archiveMessageCount: forked.archiveCount,
+          dir: forked.handle.dir
+        }, null, 2));
+        return;
+      }
+      console.log(`Forked ${shortSessionId(forked.source.id)} -> ${shortSessionId(forked.handle.summary.id)}`);
+      console.log(`  title:   ${forked.handle.summary.title}`);
+      console.log(`  parent:  ${forked.source.id}`);
+      console.log(`  history: ${forked.messageCount} context / ${forked.archiveCount} archive`);
+      console.log("");
+      console.log(`Resume: keryx shell -r ${shortSessionId(forked.handle.summary.id)}`);
+    } catch (cause) {
+      if (cause instanceof UnknownSessionError) {
+        console.error(`No session "${id}" in this project. Use \`keryx sessions list\`.`);
+        process.exitCode = 1;
+        return;
+      }
+      if (cause instanceof TranscriptUnreadableError) {
+        console.error(`Cannot fork session "${id}": ${cause.message}`);
+        process.exitCode = 1;
+        return;
+      }
+      throw cause;
+    }
+    return;
+  }
   if (sub === "path") {
     console.log(projectSessionsDir(cwd));
     return;
   }
   console.error(`Unknown sessions subcommand: ${sub}`);
-  printHelp14();
+  printHelp15();
   process.exitCode = 1;
 }
 function pad(s, n) {
@@ -44105,13 +44534,14 @@ function pad(s, n) {
 function clip4(s, n) {
   return s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
 }
-function printHelp14() {
+function printHelp15() {
   console.log(`keryx sessions
 
 Per-project interactive shell sessions (isolated by git root / cwd).
 
 Usage:
   keryx sessions list [--json]     List sessions for the current project
+  keryx sessions fork <id>         Branch a session into a new one (--title, --json)
   keryx sessions export <id>       Export transcript as Markdown
   keryx sessions path              Print the on-disk sessions directory
 
@@ -44160,7 +44590,7 @@ function buildInitFlags(next, profile) {
 async function modulesCommand(args2 = []) {
   const sub = args2[0];
   if (sub === "--help" || sub === "-h" || sub === "help") {
-    printHelp15();
+    printHelp16();
     return;
   }
   const wantsJson = args2.includes("--json") && (sub === undefined || sub === "status" || sub === "list" || sub === "--json");
@@ -44217,7 +44647,7 @@ async function modulesCommand(args2 = []) {
       }
     }
   } else {
-    printHelp15();
+    printHelp16();
     process.exitCode = 1;
     return;
   }
@@ -44260,7 +44690,7 @@ function setsEqual(a, b) {
   }
   return true;
 }
-function printHelp15() {
+function printHelp16() {
   helpTitle("keryx modules", "view and toggle Metaproject modules");
   helpUsage([
     "keryx modules",
@@ -44616,7 +45046,7 @@ import {
   renameSync as renameSync3,
   statSync as statSync5,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync8
 } from "fs";
 import path120 from "path";
 function serveCredentialPath(dir) {
@@ -44695,7 +45125,7 @@ function writeStore(store, dir) {
     ensureKeryxConfigDir(dir);
     const handle = openSync3(temp, "wx", 384);
     try {
-      writeFileSync7(handle, `${JSON.stringify(store, null, 2)}
+      writeFileSync8(handle, `${JSON.stringify(store, null, 2)}
 `, { encoding: "utf8" });
       fsyncSync2(handle);
     } finally {
@@ -45729,7 +46159,7 @@ var ENABLE_FLAG = "--enable";
 var DISABLE_FLAG = "--disable";
 async function serveCommand(args2 = []) {
   if (args2.includes("--help") || args2.includes("-h") || args2[0] === "help") {
-    printHelp16();
+    printHelp17();
     return;
   }
   const sub = args2[0];
@@ -45750,14 +46180,14 @@ async function serveCommand(args2 = []) {
     return;
   }
   console.error(`Unknown serve command: ${sanitizeForDisplay(sub)}`);
-  printHelp16();
+  printHelp17();
   process.exitCode = 1;
 }
 async function runServe(args2) {
   const parsed = parseArgs3(args2, BIND_FLAGS, [ACK_FLAG]);
   if (!parsed.ok) {
     console.error(parsed.message);
-    printHelp16();
+    printHelp17();
     process.exitCode = 1;
     return;
   }
@@ -45859,7 +46289,7 @@ function runStatus6(args2) {
   const parsed = parseArgs3(args2, [], ["--json"]);
   if (!parsed.ok) {
     console.error(parsed.message);
-    printHelp16();
+    printHelp17();
     process.exitCode = 1;
     return;
   }
@@ -45906,7 +46336,7 @@ function runToken(args2) {
   const rest = parseArgs3(args2.slice(1), [], []);
   if (!rest.ok) {
     console.error(rest.message);
-    printHelp16();
+    printHelp17();
     process.exitCode = 1;
     return;
   }
@@ -45947,7 +46377,7 @@ function runToken(args2) {
     return;
   }
   console.error(sub === undefined ? "Missing token subcommand" : `Unknown token command: ${sanitizeForDisplay(sub)}`);
-  printHelp16();
+  printHelp17();
   process.exitCode = 1;
 }
 function printTokenOnce(token) {
@@ -45972,7 +46402,7 @@ function runConfig(args2) {
     const parsed = parseArgs3(args2.slice(1), BIND_FLAGS, [ACK_FLAG, FORCE_FLAG]);
     if (!parsed.ok) {
       console.error(parsed.message);
-      printHelp16();
+      printHelp17();
       process.exitCode = 1;
       return;
     }
@@ -46022,7 +46452,7 @@ function runConfig(args2) {
     const parsed = parseArgs3(args2.slice(1), [], ["--json"]);
     if (!parsed.ok) {
       console.error(parsed.message);
-      printHelp16();
+      printHelp17();
       process.exitCode = 1;
       return;
     }
@@ -46039,14 +46469,14 @@ function runConfig(args2) {
     return;
   }
   console.error(sub === undefined ? "Missing config subcommand" : `Unknown config command: ${sanitizeForDisplay(sub)}`);
-  printHelp16();
+  printHelp17();
   process.exitCode = 1;
 }
 function runConfigSet(args2) {
   const parsed = parseArgs3(args2, BIND_FLAGS, [ACK_FLAG, NO_ACK_FLAG, ENABLE_FLAG, DISABLE_FLAG]);
   if (!parsed.ok) {
     console.error(parsed.message);
-    printHelp16();
+    printHelp17();
     process.exitCode = 1;
     return;
   }
@@ -46117,7 +46547,7 @@ function printConfig(config) {
   console.log(`  approvals:  expire after ${config.approval.expirySeconds}s, max ${config.approval.maxPendingPerSession} pending per session`);
   console.log(`  non-loopback acknowledged: ${config.bind.acknowledgeNonLoopback === true}`);
 }
-function printHelp16() {
+function printHelp17() {
   helpTitle("keryx serve", "loopback-bound HTTP entry over this install (off by default)");
   helpUsage([
     `keryx serve [--bind <addr>] [--port <n>] [--profile <name>] [${ACK_FLAG}]`,
@@ -46162,7 +46592,7 @@ init_git_hooks();
 async function updateCommand(args2 = []) {
   const options = parseUpdateArgs(args2);
   if (options.help) {
-    printHelp17();
+    printHelp18();
     return;
   }
   const projectRoot = process.cwd();
@@ -47272,7 +47702,7 @@ function runtimeSourcePath2(relativePath) {
 function escapeRegExp5(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function printHelp17() {
+function printHelp18() {
   helpTitle("keryx update", "refresh .metaproject service files (data left untouched)");
   helpUsage(["keryx update [--skip-runtime] [--hooks] [--no-tasks]"]);
   heading("Default behavior");
@@ -47300,7 +47730,7 @@ async function dashboardCommand(args2 = []) {
   const options = parseOptions(args2);
   const subcommand = options.positionals[0];
   if (!subcommand || options.help) {
-    printHelp18();
+    printHelp19();
     return;
   }
   if (subcommand === "build") {
@@ -47318,7 +47748,7 @@ async function dashboardCommand(args2 = []) {
     return;
   }
   console.log(`  ${style.red(symbols.cross)} Unknown dashboard command: ${subcommand}`);
-  printHelp18();
+  printHelp19();
   process.exitCode = 1;
 }
 function parseOptions(args2) {
@@ -47343,7 +47773,7 @@ async function openFile(filePath) {
     });
   });
 }
-function printHelp18() {
+function printHelp19() {
   helpTitle("keryx dashboard", "build and open the human dashboard");
   helpUsage([
     "keryx dashboard build",
@@ -48183,7 +48613,7 @@ Usage:
 // package.json
 var package_default = {
   name: "@mrciphersmith/keryx",
-  version: "0.2.14",
+  version: "0.2.16",
   description: "Version-controlled project context for AI coding agents: code graph, architecture wiki, project memory, relevant tests, quality signals, and task flows.",
   private: false,
   publishConfig: {
@@ -48255,7 +48685,7 @@ var package_default = {
 var VERSION2 = package_default.version;
 var CLI_ROUTES = {
   init: initCommand,
-  status: () => statusCommand(),
+  status: statusCommand,
   modules: modulesCommand,
   projects: projectsCommand,
   serve: serveCommand,
@@ -48290,7 +48720,7 @@ async function main() {
   const args2 = process.argv.slice(2);
   const command = args2[0];
   if (command === "--help" || command === "-h" || command === "help" || !command) {
-    printHelp19();
+    printHelp20();
     return;
   }
   if (command === "--version" || command === "-v") {
@@ -48303,22 +48733,25 @@ async function main() {
     return;
   }
   console.error(`Unknown command: ${command}`);
-  printHelp19();
+  printHelp20();
   process.exitCode = 1;
 }
-function printHelp19() {
+function printHelp20() {
   console.log(`keryx ${VERSION2}
 
 Usage:
   keryx                                        Show CLI usage
   keryx shell [-c|--continue] [-r|--resume [id]] [--provider <p>] [--model <m>] [--base-url <url>] [--agent|--chat] [--tui|--no-tui]
                                                Start TUI agent shell (sessions are per-project)
-  keryx sessions list|export <id>|path         List / export sessions for the current project
-  keryx harness run --provider <fake|anthropic|ollama> --model <m> [--base-url <url>] "<prompt>"
+  keryx sessions list|fork <id>|export <id>|path
+                                               List / branch / export sessions for the current project
+  keryx harness run --provider <fake|anthropic|ollama> --model <m> [--base-url <url>] [--record <path>] "<prompt>"
   keryx harness exec [--allow-env KEY]... [--max-runtime-ms N] [--allow-real-subprocess]
                      [--allowed-domains a,b] [--mask-env NAME@host] [--tls-terminate] [--mask-mode auto|manual|off] [--auto-mask] -- <path> [args...]
   keryx harness extension --spec <path>
   keryx harness wave --spec <path>
+  keryx harness replay --record <path> [--fixture <path>] [--write-fixture <path>] [--json]
+                                               Validate a recorded run's log against a fixture (no re-execution)
   keryx init [--yes] [--no-gdgraph] [--no-gdctx] [--no-gdwiki] [--no-gdskills] [--gdskills-profile recommended] [--no-health] [--no-testing] [--no-memory] [--no-gdgraph-hook] [--no-gdskills-hook] [--no-health-hook] [--no-testing-post-commit-hook] [--no-testing-pre-push-hook]
   keryx status
   keryx modules [status | enable <name> | disable <name>]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrciphersmith/keryx",
-  "version": "0.2.14",
+  "version": "0.2.16",
   "description": "Version-controlled project context for AI coding agents: code graph, architecture wiki, project memory, relevant tests, quality signals, and task flows.",
   "private": false,
   "publishConfig": {