crewhaus 0.2.3 → 0.3.0

package/dist/index.js

@@ -9,19 +9,24 @@ import { SpecParseError, compile, lower } from "@crewhaus/compiler";
 import { buildContextBundle, discoverRoots } from "@crewhaus/context-bundle";
 import { DEFAULT_PRICING, classifyPricingStaleness, computeCacheSavingsMicros, parsePricingFeed, pickNewestPricing, resolvePricing, } from "@crewhaus/cost-tracker";
 import { compareVersions, createFileBackedRegistry, latestVersion, } from "@crewhaus/dataset-registry";
-import { CrewhausError } from "@crewhaus/errors";
+import { CrewhausError, RunFailedError } from "@crewhaus/errors";
 import { loadDataset } from "@crewhaus/eval-dataset";
 import { parseGradersConfig } from "@crewhaus/eval-grader";
 import { extractCurrentPrompt as extractInstructions, optimizeSpec, } from "@crewhaus/eval-optimizer-orchestrator";
 import { buildMatrix, diffReports, formatUsd, hashDatasetFile, loadRun, readBaselines, readRunIndex, renderMatrix, renderReport, setBaseline, } from "@crewhaus/eval-report";
-import { runEval as runEvalLib } from "@crewhaus/eval-runner";
+import { createExamRunner, runEval as runEvalLib, } from "@crewhaus/eval-runner";
 import { openEventLog } from "@crewhaus/event-log";
 import { loadHooks, runHooks } from "@crewhaus/hooks-engine";
 import { ArgParseError, parseArgs, } from "@crewhaus/infra-utils";
 import { GENERATED_README_MARKER } from "@crewhaus/ir";
 import { createLogger } from "@crewhaus/logging";
-import { McpHost } from "@crewhaus/mcp-host";
-import { captureFacts, createMemoryStore, deriveMemoryDecision, summarizeDurableFacts, } from "@crewhaus/memory-store";
+import { McpHost, resolveMcpServerConfig } from "@crewhaus/mcp-host";
+// PR 10 — the memory fabric's composition root: `crewhaus run` makes the
+// same one stable wireMemory call compiled bundles emit. PR 16 adds
+// connectThredz (the §4.3 backend flip's boot helper — bare-name MCP tool
+// aliases + degrade-on-failure).
+import { connectThredz, memoryFragmentFromIr, runDreamBootCatchUp, wireMemory, } from "@crewhaus/memory-service";
+import { createMemoryStore } from "@crewhaus/memory-store";
 import { BUILTIN_DEFAULT_RULES, PermissionConfigError, parsePermissionsConfig, tagRules, } from "@crewhaus/permission-engine";
 // Adaptive model routing — `crewhaus route status|reset` inspects/clears the
 // per-(routeKey, model) reward scoreboard behind `agent.model_pool`; advise
@@ -36,9 +41,11 @@ import { specHasPath } from "@crewhaus/spec-patch";
 import { spawnSubAgent } from "@crewhaus/sub-agent-spawner";
 import { ToolCatalog } from "@crewhaus/tool-catalog";
 import { registerMcpServer } from "@crewhaus/tool-mcp";
-import { createMemoryTools } from "@crewhaus/tool-memory";
 import { createTaskTool } from "@crewhaus/tool-task";
 import { TraceEventBus } from "@crewhaus/trace-event-bus";
+// 0.3.0 memory release (design §3.1, PR 9) — the local wiki substrate behind
+// `crewhaus wiki list|show|search|stats`.
+import { createWikiStore } from "@crewhaus/wiki-store";
 import { parseDocument } from "yaml";
 // Item 15 — `optimize --from-advice` (eval-gated apply of the advisor's
 // SpecPatches: suggestions-file validation, the accept/reject/compose loop
@@ -113,6 +120,12 @@ import { buildChannelEnvChecks, buildCredentialChecks, extractSpecModel, provide
 // (which runs an argv switch on import) stays testable.
 import { buildInventory, claudeDesktopConfigPath, formatInventory, } from "./doctor-detect";
 import { formatFixPlan, planCrewhausDirs, planEnvStubs, planScaffoldSpec, planScopeFix, } from "./doctor-fix";
+// v0.3.0 Goal 6 — `doctor --probe`: opt-in ~1-token live call per
+// configured provider, catching unfunded/invalid keys before a long run.
+import { buildProbePlan, probeResultsToChecks, runProviderProbes } from "./doctor-probe";
+// v0.3.0 PR 14 — `crewhaus dream run|status|init` (design §6.3), in a
+// side-effect-free module; only the dispatch registration lives here.
+import { DREAM_CLI_SCHEMA, runDreamCommand } from "./dream-cli";
 // FR-006 — Pillar 3 sink-side egress-matcher selection (the substring/semantic
 // selector lowered to ir.security.egressMatcher). Side-effect-free + lazily
 // imports the optional semantic package only when "semantic" is selected, so
@@ -157,7 +170,7 @@ import { formatFewShotForPrompt, harvestFewShot, isFewShotExample, mergePools, p
 // module so it is unit-testable (this entry file runs an argv switch on
 // import). Discovery + aggregation are pure reads; the bulk runner spawns
 // per-harness `crewhaus` invocations through an injected seam.
-import { FleetError, buildFleetInventory, buildHarnessHealth, formatBulkReport, formatInventory as formatFleetInventory, formatHealth, runFleetBulk, } from "./fleet";
+import { FleetError, buildFleetInventory, buildHarnessHealth, fleetSelfInvokeArgv, formatBulkReport, formatInventory as formatFleetInventory, formatHealth, runFleetBulk, } from "./fleet";
 // Item 45 — `crewhaus flywheel init|run`: the packaged nightly
 // self-improvement loop (knob/default resolution, the accept-then-write
 // loop with injected steps, the report, and the workflow scaffold), in a
@@ -173,10 +186,12 @@ import { DEFAULT_SUGGESTED_GRADERS_FILE, DEFAULT_SUGGEST_RUNS, FLOOR_GRADER_HINT
 // join, cost summary, eval-report-styled render), in a side-effect-free module
 // so it is unit-testable (this entry file runs an argv switch on import).
 import { assembleIncidentBundle, matchAuditRecordsByWindow, summarizeCost, } from "./incident";
-// Item 39 — `crewhaus init --interactive`: the harness-designer interview
-// (validate-and-retry loop + scripted no-credentials fallback) in a
-// side-effect-free module so this entry file stays testable.
-import { EMIT_SPEC_TOOL, buildInterviewSystemPrompt, buildScriptedSpec, isScriptedShape, runInterview, } from "./init-interactive";
+// Item 39 / v0.3.0 §2.9 — `crewhaus init --interactive`: the conversational
+// harness-designer interview (persisted, resumable runChatLoop session) plus
+// the scripted no-credentials fallback, in importable modules so this entry
+// file stays testable.
+import { INIT_INTERVIEW_SAVED_NOTE, conversationalPathAllowed, runConversationalInterview, } from "./init-conversation";
+import { buildScriptedSpec, isScriptedShape, } from "./init-interactive";
 // Item 67 — `crewhaus intents`: cluster user_message inputs across sessions +
 // rank by frequency / satisfaction / failure. Side-effect-free (this entry file
 // reads sessions + feedback and redacts the rendered examples).
@@ -220,6 +235,9 @@ import { MarketplaceCliError, buildPublishPrPlan, computeOutdated, createHttpMod
 // drift diff, quarantine decision — in a side-effect-free module (this entry
 // file runs an argv switch on import) mirroring doctor-checks.ts.
 import { buildSnapshot, decideQuarantine, diffSnapshots, formatDriftReport, formatHealthReport, quarantineNotice, safeMcpFileName, scoreMcpHealth, } from "./mcp-doctor";
+// 0.3.0 memory release (design §3.4) — `crewhaus memory list|show|forget|sweep`
+// helpers + the `crewhaus migrate memories` schema-v2 backfill.
+import { MEMORIES_SUBDIR, formatMigrateMemoriesReport, listMemorySpecs, migrateMemories, renderMemoryList, renderMemoryShow, resolveMemorySpec, } from "./memory-cli";
 // Item 24 — market scan + doctor --models + pricing sync core, in a
 // side-effect-free module (this entry file runs an argv switch on import).
 import { buildMarketScan, buildModelChecks, buildProposalArtifact, buildScanCandidates, writeModelField, } from "./model-scan";
@@ -266,6 +284,11 @@ import { RetireError, buildRetirementPlan, formatPlan, formatRetirementResult, r
 // projection + $/score ranking); side-effect-free so it is unit-testable.
 import { buildRightSizeReport, enumerateSlotCandidates, } from "./right-size";
 import { runRoute } from "./route";
+// v0.3.0 Goal 6 — canonical terminal-failure rendering: die() and the
+// `crewhaus run` failure path both route through renderCliFailure so a
+// RunFailedError prints its structured report + coded exit while every
+// other fatal keeps the classic `crewhaus: <message>` one-liner + exit 1.
+import { CONTINUE_NOTE, renderCliFailure } from "./run-failure";
 // Item 13 — `crewhaus scaffold-evals` + `init --with-evals`: day-one eval
 // assets generated from the spec (deterministic template / one-shot model
 // sample stubs + a single spec-goal llm_judge or floor grader), in a
@@ -303,6 +326,9 @@ import { buildSloSink, intakeGatePayload, lastKnownGoodFromAuditRecords } from "
 // import-time side effects so it is unit-testable (this entry file runs an
 // argv switch on import).
 import { StateBackupError, createStateBackup, defaultBackupFileName, mergeAllFromArchive, mergeFeedbackFromArchive, parseExcludeGlobs, restoreStateArchive, } from "./state-backup";
+// v0.3.0 Goal 3 — `doctor --probe`'s thredz check (wiki_stats round-trip
+// through the spec's synthesized/user-declared thredz MCP server).
+import { probeThredz, thredzProbeTarget, thredzProbeToCheck } from "./thredz-probe";
 // Item 18 — `crewhaus tools` namespace (list/suggest/audit + the loadToolMap
 // ↔ BUILTIN_TOOL_MAP sync floor), in a side-effect-free module so it is
 // unit-testable (this entry file runs an argv switch on import).
@@ -324,6 +350,9 @@ import { cliVersion } from "./version";
 // (this entry file reads the replay JSONLs + writes the report).
 import { DEFAULT_VOICE_THRESHOLDS, VoiceEvalError, aggregateVoiceEval, gradeVoiceSession, parseReplayLog, renderVoiceReport, } from "./voice-eval";
 import { createWatchController, formatCycleLine } from "./watch";
+// 0.3.0 memory release (design §3.1/§3.2, PR 9) — `crewhaus wiki
+// list|show|search|stats` helpers over @crewhaus/wiki-store.
+import { WIKI_SUBDIR, listWikiSpecs, renderWikiList, renderWikiSearch, renderWikiShow, renderWikiStats, resolveWikiSpec, } from "./wiki-cli";
 /**
  * crewhaus — slice-scope CLI.
  * Subcommands:
@@ -465,6 +494,13 @@ const INIT_SCHEMA = {
         // prefill the model from what's reachable.
         { name: "interactive", short: "i", takesValue: false },
         { name: "detect", takesValue: false },
+        // v0.3.0 §2.9 — restart a persisted interview session (the conversation
+        // is a runChatLoop session; a crashed/interrupted interview resumes with
+        // its ledger and transcript intact).
+        { name: "resume", takesValue: false },
+        // v0.3.0 §2.9 — skip the conversational interview (scripted
+        // questionnaire), mirroring the non-TTY behavior.
+        { name: "yes", short: "y", takesValue: false },
         { name: "help", short: "h" },
     ],
 };
@@ -546,6 +582,12 @@ const DOCTOR_SCHEMA = {
         // tools scope:external, append commented .env stubs). Dry-run is the
         // DEFAULT: without --fix, doctor prints the diff it WOULD apply.
         { name: "fix", takesValue: false },
+        // v0.3.0 Goal 6 — `--probe`: opt-in ~1-token live call per configured
+        // provider, catching present-but-invalid keys and unfunded accounts
+        // BEFORE a long run dies on them. Distinct from --detect's --no-probe
+        // (a localhost reachability knob): this one spends real (fractional-
+        // cent) tokens, so it is never on by default.
+        { name: "probe", takesValue: false },
         { name: "help", short: "h" },
     ],
 };
@@ -958,6 +1000,47 @@ const SESSIONS_SCHEMA = {
         { name: "help", short: "h" },
     ],
 };
+// 0.3.0 memory release (design §3.4) — `crewhaus memory list|show|forget|sweep`.
+const MEMORY_SCHEMA = {
+    flags: [
+        // Which spec's memory file to operate on. `list`/`sweep` default to every
+        // file under .crewhaus/memories/; `show`/`forget` auto-resolve only when a
+        // single file exists.
+        { name: "spec", takesValue: true },
+        // forget — a text query instead of an exact id (forgets EVERY match).
+        { name: "query", short: "q", takesValue: true },
+        // forget / sweep --compact — skip the confirmation prompt (scripted/CI).
+        { name: "yes", takesValue: false },
+        // sweep — additionally rewrite the file(s) dropping tombstoned/expired
+        // lines (atomic tmp+rename; the growth-bounding compaction).
+        { name: "compact", takesValue: false },
+        { name: "help", short: "h" },
+    ],
+};
+// 0.3.0 memory release — `crewhaus migrate memories [--dry-run]`: backfill
+// schemaVersion + derivable provenance onto v1 entries, stamp .crewhaus/meta.json.
+const MIGRATE_MEMORIES_SCHEMA = {
+    flags: [
+        { name: "dry-run", takesValue: false },
+        { name: "help", short: "h" },
+    ],
+};
+// 0.3.0 memory release (design §3.1, PR 9) — `crewhaus wiki list|show|search|stats`.
+const WIKI_SCHEMA = {
+    flags: [
+        // Which spec's wiki to operate on. `list`/`stats` default to every wiki
+        // under .crewhaus/wiki/; `show`/`search` auto-resolve only when a single
+        // wiki exists.
+        { name: "spec", takesValue: true },
+        // list — filter to articles carrying EVERY listed tag (comma-separated).
+        { name: "tags", takesValue: true },
+        // list — filter by article status (draft|published|review|archived|all).
+        { name: "status", takesValue: true },
+        // search — max results to print. Default 10.
+        { name: "k", short: "k", takesValue: true },
+        { name: "help", short: "h" },
+    ],
+};
 // Item 12 — the dataset-registry CLI face (`datasets list|get|put`).
 const DATASETS_SCHEMA = {
     flags: [
@@ -1452,6 +1535,22 @@ function usageText() {
         "  lessons update [--sessions N|all]    mine corrections + failures into an auto-loaded LESSONS.md (#56)",
         "       [--low-score F] [-o <LESSONS.md>]  + per-user prefs under .crewhaus/preferences/",
         "  sessions summarize [--before <date>] summarize sessions into a durable index before TTL eviction (#57)",
+        "  memory list [--spec <name>]          inspect the per-spec fact stores: id/age/tags/provenance/status",
+        "  memory show <mem_id>                 full detail for one memory (provenance, expiry, supersededBy)",
+        "  memory forget <mem_id>|--query <q>   explicitly forget memories (append-only supersede tombstones;",
+        "       [--spec <name>] [--yes]             a query forgets EVERY match; prompts unless --yes)",
+        "  memory sweep [--compact] [--yes]     tombstone TTL-expired memories; --compact rewrites the file",
+        "                                       dropping dead lines (atomic; the growth-bounding compaction)",
+        "  migrate memories [--dry-run]         backfill the v2 memory schema + provenance; stamps .crewhaus/meta.json",
+        "  wiki list [--spec <name>]            inspect the per-spec local wikis, stalest first (versions, signals,",
+        "       [--tags <t1,t2>] [--status <s>]     tags; articles live under .crewhaus/wiki/<spec>/articles/)",
+        "  wiki show <slug>                     full frontmatter + body for one article (priors in versions/<slug>/)",
+        "  wiki search <q> [-k <n>]             BM25 keyword search over a spec's articles",
+        "  wiki stats                           corpus health: articles/status/versions/tags/verified/links",
+        "  dream [run] <spec.yaml> [--force]    scheduled memory consolidation (§6): deterministic pass + budget-",
+        "                                       capped model synthesis per memory.dream (cron-safe, window-idempotent)",
+        "  dream status <spec.yaml>             schedule state + next due (.crewhaus/dream/<spec>/state.json)",
+        "  dream init <spec.yaml> [--force]     scaffold the nightly consolidation cron (crewhaus-dream.yml)",
         "       [--evicted] [--ttl-days N]        --evicted indexes each session just before it is deleted",
         "  datasets list                        all registered datasets + versions (Section 29)",
         "  datasets get <name>[@version]        print a dataset's samples as JSONL",
@@ -1547,9 +1646,17 @@ function help() {
     process.stdout.write(usageText());
     process.exit(0);
 }
+/**
+ * Fatal-error exit. A plain string (or any non-RunFailed CrewhausError)
+ * keeps the classic one-liner `crewhaus: <message>` + exit 1; a
+ * `RunFailedError` (v0.3.0 Goal 6) renders its structured report via
+ * `formatRunFailure()` and exits with the report's coded status, so
+ * callers can simply `die(err)` and the taxonomy does the rest.
+ */
 function die(message) {
-    process.stderr.write(`crewhaus: ${message}\n`);
-    process.exit(1);
+    const rendered = renderCliFailure(message);
+    process.stderr.write(`${rendered.text}\n`);
+    process.exit(rendered.exitCode);
 }
 function printVersion() {
     // Resolution (embedded --define constant → apps/cli/package.json) lives in
@@ -2527,17 +2634,24 @@ function createLineReader() {
     };
 }
 /**
- * Item 39 — `crewhaus init --interactive`. Promotes the demos harness-designer
- * into core: interview the user and emit a `parseSpec`-validated crewhaus.yaml.
+ * Item 39 / v0.3.0 §2.9 — `crewhaus init --interactive`. Interview the user
+ * and emit a `parseSpec`-validated crewhaus.yaml.
  *
- * Two paths, chosen by credential availability (like the merged scaffold path):
- *   - Credentials present → the MODEL interview. `runInterview` (side-effect-
- *     free) drives a validate-and-retry loop: the model calls `emit_spec` with
- *     a draft, `parseSpec` validates it in-process, and any structured error is
- *     fed back for a corrected re-emit. No demos dependency — the shape
- *     guidance is bundled in `init-interactive.ts`.
- *   - No credentials → a scripted stdin questionnaire (name/shape/model/tools)
- *     that still emits a `parseSpec`-validated spec via `buildScriptedSpec`.
+ * Three paths:
+ *   - Credentials + a TTY → the CONVERSATIONAL interview (PR 18): a
+ *     persisted, resumable `runChatLoop` session with `ask_user` +
+ *     `emit_spec` and no forced toolChoice, the continuity fabric on
+ *     (requirements ledger, focus pinning, handoff) spec-scoped as
+ *     `init-<dirname>` under the target directory. Validation errors return
+ *     to the conversation as tool errors; a terminal failure prints the
+ *     classified FailureReport plus the saved-interview resume hint;
+ *     `--resume` restarts the session with the ledger intact.
+ *   - Credentials but no TTY (or `--yes`) → the conversational path is
+ *     refused (same convention as the other interactive verbs) and the
+ *     scripted questionnaire runs instead.
+ *   - No credentials → the scripted stdin questionnaire
+ *     (name/shape/model/tools), byte-identical to pre-0.3.0, still emitting
+ *     a `parseSpec`-validated spec via `buildScriptedSpec`.
  *
  * Reuses `runInit`'s exists-check/refuse-overwrite + standalone-dir guidance,
  * and composes with `--detect` (#40) to prefill the default model from a
@@ -2545,12 +2659,14 @@ function createLineReader() {
  */
 async function runInitInteractive(args) {
     if (args.flags["help"]) {
-        process.stdout.write("usage: crewhaus init --interactive [name] [--detect]\n" +
-            "  Interview-driven spec authoring. With credentials, an agent interviews you\n" +
-            "  and emits a validated crewhaus.yaml (every draft is checked against the live\n" +
-            "  spec schema and retried on error). Without credentials, a scripted\n" +
+        process.stdout.write("usage: crewhaus init --interactive [name] [--detect] [--resume] [--yes]\n" +
+            "  Interview-driven spec authoring. With credentials and a TTY, an agent runs a\n" +
+            "  real multi-turn interview (persisted + resumable; every draft is validated\n" +
+            "  against the live spec schema in-conversation). Without credentials, a scripted\n" +
             "  questionnaire (name/shape/model/tools) still emits a validated spec.\n" +
-            "  --detect  prefill the default model from a reachable local endpoint/provider.\n");
+            "  --detect  prefill the default model from a reachable local endpoint/provider.\n" +
+            "  --resume  continue a saved interview session where it stopped.\n" +
+            "  --yes     skip the conversation; use the scripted questionnaire.\n");
         return;
     }
     const nameArg = args.positional[0];
@@ -2571,35 +2687,70 @@ async function runInitInteractive(args) {
         if (prefill !== undefined)
             defaultModel = prefill;
     }
-    // Credential-gated path selection: try to resolve the default model's adapter.
-    // A resolution failure (no credentials / missing optional adapter) degrades
-    // to the scripted questionnaire.
+    // Credential-gated path selection: try to resolve the default model's
+    // adapter. A resolution failure (no credentials / missing optional adapter)
+    // degrades to the scripted questionnaire — byte-identical messaging.
     const interviewer = await tryBuildInterviewer(defaultModel);
-    const reader = createLineReader();
+    const conversational = conversationalPathAllowed({
+        stdinIsTTY: process.stdin.isTTY === true,
+        assumeYes: args.flags["yes"] === true,
+    });
     let yaml;
-    try {
-        if (interviewer !== undefined) {
-            process.stdout.write(`interactive spec authoring (model: ${interviewer.modelId}). Describe the agent you want to build.\n`);
-            const description = await reader.ask("> ");
-            if (description === "")
-                die("no description given — aborting");
-            const result = await runInterview({
-                proposeSpec: (feedback) => interviewer.propose(description, feedback),
+    let mappingLines = [];
+    if (interviewer !== undefined && conversational.allowed) {
+        // v0.3.0 §2.9 — the conversational interview owns stdin via runChatLoop's
+        // REPL (no line reader here: a second readline would steal input).
+        process.stdout.write(args.flags["resume"] === true
+            ? `interactive spec authoring (model: ${interviewer.modelId}) — resuming your saved interview.\n`
+            : `interactive spec authoring (model: ${interviewer.modelId}). Describe the agent you want to build.\n`);
+        try {
+            const result = await runConversationalInterview({
+                targetDir,
+                specName: `init-${basename(targetDir)}`,
+                model: defaultModel,
+                resume: args.flags["resume"] === true,
             });
             yaml = result.yaml;
-            process.stdout.write(`validated after ${result.attempts} draft(s).\n`);
+            mappingLines = result.mappingLines;
         }
-        else {
-            process.stdout.write("no model credentials detected — falling back to the scripted questionnaire.\n");
-            yaml = (await runScriptedQuestionnaire({ reader, specName, defaultModel })).yaml;
+        catch (err) {
+            // A classified terminal failure (billing/auth/token exhaustion) prints
+            // the PR-3 FailureReport with the saved-interview hint and the coded
+            // exit — the session + ledger are on disk, `--resume` continues.
+            if (err instanceof RunFailedError) {
+                const rendered = renderCliFailure(err, { notes: [INIT_INTERVIEW_SAVED_NOTE] });
+                process.stderr.write(`${rendered.text}\n`);
+                process.exit(rendered.exitCode);
+            }
+            throw err;
         }
     }
-    finally {
-        reader.close();
+    else {
+        if (args.flags["resume"] === true) {
+            die("crewhaus init --interactive --resume needs the conversational interview (model credentials and an interactive terminal)");
+        }
+        const reader = createLineReader();
+        try {
+            if (interviewer === undefined) {
+                process.stdout.write("no model credentials detected — falling back to the scripted questionnaire.\n");
+            }
+            else {
+                process.stdout.write(`${conversational.reason ?? "conversational interview unavailable"} — falling back to the scripted questionnaire.\n`);
+            }
+            yaml = (await runScriptedQuestionnaire({ reader, specName, defaultModel })).yaml;
+        }
+        finally {
+            reader.close();
+        }
     }
     mkdirSync(targetDir, { recursive: true });
     writeFileSync(targetFile, yaml);
     process.stdout.write(`wrote ${targetFile}\n`);
+    // v0.3.0 §2.9 — the REQ → spec-field mapping the model produced before
+    // emit_spec, surfaced as the interview's closing summary.
+    if (mappingLines.length > 0) {
+        process.stdout.write(`requirements → spec mapping (from the interview):\n${mappingLines.map((l) => `  ${l}`).join("\n")}\n`);
+    }
     const rel = relative(process.cwd(), targetDir);
     const cd = rel === "" ? "" : `cd ${rel} && `;
     process.stdout.write(`next: ${cd}crewhaus run crewhaus.yaml\n`);
@@ -2639,38 +2790,19 @@ async function runScriptedQuestionnaire(opts) {
     return buildScriptedSpec(answers);
 }
 /**
- * Item 39 — attempt to build the model interviewer for `model`. Resolves the
- * adapter via the same `resolveModel` path the scaffold-evals/mutator use;
- * returns undefined when no credentials/adapter are available so the caller
- * degrades to the scripted questionnaire. The returned `propose` closure runs
- * one interview turn: it sends the system prompt + description + the running
- * validation-feedback log and returns the `emit_spec` YAML (or undefined).
+ * Item 39 / v0.3.0 §2.9 — credential gate for the conversational interview.
+ * Resolves the model's adapter via the same `resolveModel` path the
+ * scaffold-evals/mutator use; returns undefined when no credentials/adapter
+ * are available so the caller degrades to the scripted questionnaire. The
+ * interview itself runs on `runChatLoop` (init-conversation.ts), which
+ * resolves the model again through the normal router path — the single-shot
+ * forced-`emit_spec` propose closure this used to carry is gone (PR 18).
  */
 async function tryBuildInterviewer(model) {
     try {
         const { resolveModel } = await import("@crewhaus/model-router");
-        const { collectFinalMessage, extractToolUse } = await import("@crewhaus/adapter-anthropic");
         const resolution = await resolveModel(model);
-        const system = buildInterviewSystemPrompt();
-        const propose = async (desc, feedback) => {
-            const feedbackText = feedback.length > 0
-                ? `\n\nYour previous draft(s) failed validation with:\n${feedback
-                    .map((f) => `- ${f}`)
-                    .join("\n")}\nEmit a corrected spec.`
-                : "";
-            const final = await collectFinalMessage(resolution.adapter.stream({
-                model: resolution.modelId,
-                system: [{ type: "text", text: system }],
-                messages: [{ role: "user", content: `Build this agent: ${desc}${feedbackText}` }],
-                tools: [EMIT_SPEC_TOOL],
-                toolChoice: { type: "tool", name: EMIT_SPEC_TOOL.name },
-                maxTokens: 4096,
-            }));
-            const toolUse = extractToolUse(final, EMIT_SPEC_TOOL.name);
-            const yaml = toolUse?.input?.yaml;
-            return typeof yaml === "string" && yaml.length > 0 ? yaml : undefined;
-        };
-        return { modelId: resolution.modelId, propose };
+        return { modelId: resolution.modelId };
     }
     catch {
         return undefined;
@@ -3020,16 +3152,33 @@ async function runRunCli(args, ir, specPath) {
     // Item 38 — synthetic notice appended to the agent instructions when the MCP
     // auto-quarantine withdraws a server's tools (built in the block below).
     let mcpQuarantineNotice;
+    // v0.3.0 Goal 3 — the thredz server (synthesized by the compiler, or the
+    // user's own vendored entry) boots through connectThredz: its wiki+goals
+    // tools land under their BARE names (§4.3, one vocabulary across
+    // backends) and boot failure DEGRADES (null → wireMemory falls back to
+    // local files with a warning) instead of failing the run.
+    let thredzConn = null;
+    const thredzWired = ir.thredz !== undefined && ir.mcp_servers["thredz"] !== undefined;
     if (Object.keys(ir.mcp_servers).length > 0) {
         const host = new McpHost({ logger });
         mcpHost = host;
         for (const [name, cfg] of Object.entries(ir.mcp_servers)) {
-            host.addServer(name, cfg);
+            // 0.3.0 — env/header values are IrSecretRef; resolve them from the
+            // interpreter process's environment (fail-fast, names the variable).
+            host.addServer(name, resolveMcpServerConfig(cfg, { name }));
         }
         const tempCatalog = new ToolCatalog();
         for (const t of tools)
             tempCatalog.register(t);
-        await Promise.all(Object.keys(ir.mcp_servers).map((name) => registerMcpServer(host, name, tempCatalog, {
+        if (thredzWired) {
+            thredzConn = await connectThredz(host, tempCatalog, {
+                log: (line) => process.stdout.write(line),
+                ...(ir.thredz?.agentName !== undefined ? { agentName: ir.thredz.agentName } : {}),
+            });
+        }
+        await Promise.all(Object.keys(ir.mcp_servers)
+            .filter((name) => !(thredzWired && name === "thredz"))
+            .map((name) => registerMcpServer(host, name, tempCatalog, {
             onRegister: ({ fullName }) => process.stdout.write(`[mcp] registered ${fullName}\n`),
         })));
         tools = tempCatalog.list().slice();
@@ -3134,11 +3283,77 @@ async function runRunCli(args, ir, specPath) {
     // a synthetic `Skill(name)` tool is appended to the tool list so the
     // model can lazily fetch each skill's body.
     const cwd = process.cwd();
-    const [hooks, skills, slashCommands] = await Promise.all([
+    const [hooks, discoveredSkills, discoveredCommands] = await Promise.all([
         loadHooks({ cwd }),
         discoverSkills({ cwd }),
         loadCommands({ cwd }),
     ]);
+    // Feature #53 / v0.3.0 PR 11 — memory + continuity, wired through the
+    // composition root. The SAME `wireMemory(fragment, deps)` call a compiled
+    // bundle emits runs here: it constructs the stores, registers the tools
+    // (into this run's local tool list via the registrar shim), and returns
+    // the runChatLoop seams. Continuity is DEFAULT-ON for the cli target —
+    // `ir.continuity` is present unless the spec opted out with
+    // `continuity: false` (the compiler dropped the key at lower time, so
+    // opted-out specs run exactly the pre-0.3.0 path — no flag needed).
+    // When continuity is on, the composition root owns the skill/command
+    // surface (builtin `continuity` skill + commands merged at LOWEST
+    // precedence with ~/.crewhaus + project entries) and the interpreter
+    // adopts it wholesale, exactly like a compiled bundle — registering the
+    // Skill tool from its own discovery would strand the builtin skill.
+    let skills = discoveredSkills;
+    let slashCommands = discoveredCommands;
+    let memoryRunOpt;
+    let continuityRunOpt;
+    if ((ir.memory !== undefined && ir.memory.enabled !== false) ||
+        ir.continuity !== undefined ||
+        ir.thredz !== undefined) {
+        const wiredMemory = await wireMemory(memoryFragmentFromIr(ir), {
+            catalog: {
+                register: (tool) => {
+                    tools.push(tool);
+                },
+            },
+            cwd: process.cwd(),
+            log: (line) => process.stdout.write(line),
+            // v0.3.0 Goal 3 — the live connection (or null after a boot failure,
+            // which wireMemory degrades from). Absent when thredz is off.
+            ...(ir.thredz !== undefined ? { thredz: thredzConn } : {}),
+            // v0.3.0 Goal 2 (§3.3, PR 17) — the first-class exam: `/exam` drives
+            // the run_exam tool, which invokes the eval library programmatically
+            // (no agent-shells-to-`crewhaus` hack, no Bash permission needed).
+            ...(ir.learning?.exam !== undefined
+                ? {
+                    examRunner: createExamRunner({
+                        specName: ir.name,
+                        model,
+                        instructions: ir.agent.instructions,
+                        fragment: memoryFragmentFromIr(ir),
+                        cwd: process.cwd(),
+                        ...(ir.thredz !== undefined ? { thredz: thredzConn } : {}),
+                    }),
+                }
+                : {}),
+        });
+        memoryRunOpt = wiredMemory.options.memory;
+        continuityRunOpt = wiredMemory.options.continuity;
+        if (wiredMemory.options.skills !== undefined)
+            skills = wiredMemory.options.skills;
+        if (wiredMemory.options.slashCommands !== undefined) {
+            slashCommands = wiredMemory.options.slashCommands;
+        }
+        // v0.3.0 PR 14 (§6.3) — boot-time dream catch-up: when the schedule is
+        // overdue, run the DETERMINISTIC phase only (sub-second, zero spend).
+        // Unattended model spend is never a side effect of starting a session —
+        // the full consolidation stays behind `crewhaus dream`.
+        if (ir.memory?.dream !== undefined) {
+            const dreamNote = await runDreamBootCatchUp(memoryFragmentFromIr(ir), {
+                cwd: process.cwd(),
+            });
+            if (dreamNote !== null)
+                process.stdout.write(`${dreamNote}\n`);
+        }
+    }
     if (skills.length > 0) {
         tools.push(createSkillTool(skills));
         process.stdout.write(`[skills] ${skills.length} available: ${skills.map((s) => s.name).join(", ")}\n`);
@@ -3298,48 +3513,6 @@ async function runRunCli(args, ir, specPath) {
                 : {}),
         });
     }
-    // Feature #53 — first-class `memory:` block. Its presence wires Remember/
-    // Recall into the tool list (no hand-editing) and — via the auto-* switches
-    // — the runtime's auto-recall (system-prompt injection) and auto-capture
-    // (summarize durable outcomes into the store at teardown). Mirrors the
-    // codegen registration in @crewhaus/target-cli.
-    let memoryRunOpt;
-    if (ir.memory !== undefined && ir.memory.enabled !== false) {
-        const memoryStore = createMemoryStore({ specName: ir.name });
-        const memoryBundle = createMemoryTools({ specName: ir.name, store: memoryStore });
-        tools.push(memoryBundle.remember, memoryBundle.recall);
-        const decision = deriveMemoryDecision(ir.memory, Number.MAX_SAFE_INTEGER);
-        process.stdout.write(`[memory] Remember/Recall wired (autoRecall=${decision.recall}, autoCapture=${ir.memory.autoCapture === true})\n`);
-        memoryRunOpt = {
-            ...(decision.recall
-                ? {
-                    autoRecall: true,
-                    recallK: decision.recallK,
-                    recall: async (query, k) => {
-                        const results = await memoryStore.recall(query, k);
-                        return results.map((r) => r.entry.text);
-                    },
-                }
-                : {}),
-            ...(ir.memory.autoCapture === true
-                ? {
-                    autoCapture: true,
-                    onCapture: async (completedTurns, sessionId) => {
-                        const { capture } = deriveMemoryDecision(ir.memory, completedTurns);
-                        if (!capture)
-                            return;
-                        const events = parseJsonlObjects(readFileSync(sessionJsonlPath(sessionId), "utf-8"));
-                        const turns = deriveTurns(events);
-                        const facts = summarizeDurableFacts(turns);
-                        const written = await captureFacts(memoryStore, facts, ["auto-capture", sessionId]);
-                        if (written.length > 0) {
-                            process.stdout.write(`[memory] auto-captured ${written.length} durable fact(s) into ${memoryStore.path()}\n`);
-                        }
-                    },
-                }
-                : {}),
-        };
-    }
     // Item #56 — resolve the current user's preference file (flag > env) so the
     // runtime injects `.crewhaus/preferences/<user>.md` at run start. Absent when
     // no user is identified or the file doesn't exist yet.
@@ -3393,6 +3566,11 @@ async function runRunCli(args, ir, specPath) {
         }
     }
     let oneShotResult;
+    // v0.3.0 Goal 6 — a RunFailedError is remembered (not rethrown) so the
+    // finally still disconnects MCP servers, then rendered below with the
+    // resume hint + the report's coded exit. Everything else propagates to
+    // the `case "run"` catch → die() one-liner, exactly as before.
+    let runFailure;
     try {
         oneShotResult = await runChatLoop({
             model,
@@ -3478,16 +3656,45 @@ async function runRunCli(args, ir, specPath) {
             // (gated by CREWHAUS_INCIDENTS inside runtime-core).
             incidentSpec: { name: ir.name },
             ...(memoryRunOpt !== undefined ? { memory: memoryRunOpt } : {}),
+            // v0.3.0 Goal 1 — the continuity seam (plan tail + requirements ledger
+            // + teardown handoff), default-on unless the spec said
+            // `continuity: false`.
+            ...(continuityRunOpt !== undefined ? { continuity: continuityRunOpt } : {}),
             // Item #56 — inject the current user's preference file at run start (via
             // the project-memory auto-load path). LESSONS.md is auto-loaded already
             // as a canonical memory file, so no extra wiring is needed for it.
             ...(preferenceFiles.length > 0 ? { preferenceFiles } : {}),
         });
     }
+    catch (err) {
+        if (!(err instanceof RunFailedError))
+            throw err;
+        runFailure = err;
+    }
     finally {
         if (mcpHost)
             await mcpHost.disconnectAll();
     }
+    // v0.3.0 Goal 6 — render the classified terminal report (billing/auth/
+    // rate-limit/…) with the resume hint when this spec has a persisted
+    // session, then exit with the report's coded status. The design §8.2
+    // out-of-funding example ends exactly like this.
+    if (runFailure !== undefined) {
+        const notes = [];
+        try {
+            const store = createSessionStore();
+            const sessions = await store.list();
+            if (sessions.some((s) => s.name === ir.name)) {
+                notes.push(CONTINUE_NOTE);
+            }
+        }
+        catch {
+            // Best-effort: the resume hint must never mask the real failure.
+        }
+        const rendered = renderCliFailure(runFailure, { notes });
+        process.stderr.write(`${rendered.text}\n`);
+        process.exit(rendered.exitCode);
+    }
     // One-shot (`--prompt`): emit the final assistant message to stdout so it
     // can be piped/captured. The REPL path streams as it goes and returns the
     // same trailing text, so only print it in one-shot mode.
@@ -3721,7 +3928,7 @@ function runContext(args) {
 async function runDoctor(args) {
     if (args.flags["help"]) {
         process.stdout.write("usage: crewhaus doctor [--philosophy-alignment [--json] [--baseline | --accept-baseline]]\n" +
-            "                       [--liveness] [--context-pressure [--sessions N]]\n" +
+            "                       [--liveness] [--context-pressure [--sessions N]] [--probe]\n" +
             "  --philosophy-alignment   audit the codebase + examples against the three architectural pillars\n" +
             "  --json                   persist findings (stable ids) to .crewhaus/scope-audit/<date>.json\n" +
             "                           and print the snapshot JSON (item 49)\n" +
@@ -3752,6 +3959,16 @@ async function runDoctor(args) {
             "                           mark outward tools scope:external via a CST spec-patch, and\n" +
             "                           append commented .env stubs. DRY-RUN IS THE DEFAULT — without\n" +
             "                           --fix, doctor prints the diff it WOULD apply.\n" +
+            "  --probe                  OPT-IN live credential probe: one ~1-token call per\n" +
+            "                           configured provider (the cwd spec's model verbatim, plus a\n" +
+            "                           cheap default for other providers with env set), catching\n" +
+            "                           unfunded accounts (billing) and invalid keys (auth) before\n" +
+            "                           a long run dies on them. Spends fractional-cent tokens, so\n" +
+            "                           it is never on by default. Failures fail doctor (exit 1).\n" +
+            "                           When the cwd spec carries `thredz:`, also runs one live\n" +
+            "                           wiki_stats round-trip through the thredz MCP server —\n" +
+            "                           disabled keys (thredz_billing) and plan caps (thredz_quota)\n" +
+            "                           surface here instead of degrading a long run.\n" +
             "\n" +
             "  Credential checks are model-aware: doctor parses the cwd crewhaus.yaml's\n" +
             "  agent.model (claude-*, openai/*, gemini/*, bedrock/*, local/<m>@<url>) and\n" +
@@ -3815,6 +4032,30 @@ async function runDoctor(args) {
     if (specText !== undefined) {
         checks.push(...buildChannelEnvChecks(specText, process.env));
     }
+    // v0.3.0 Goal 6 — `--probe`: opt-in ~1-token live call per configured
+    // provider (the spec's model verbatim + cheap defaults for other
+    // configured providers), catching unfunded/invalid keys pre-run. Failures
+    // classify through recovery-engine (billing/auth/rate_limit) so the ✗
+    // line names the fix class, and they gate doctor's exit like any check.
+    if (args.flags["probe"]) {
+        const plan = buildProbePlan(specModel, process.env);
+        if (plan.length === 0) {
+            process.stdout.write("~ live probe: no configured providers to probe\n");
+        }
+        else {
+            checks.push(...probeResultsToChecks(await runProviderProbes(plan)));
+        }
+        // v0.3.0 Goal 3 (§4.4) — when the cwd spec carries `thredz:`, probe the
+        // configured server with one live wiki_stats round-trip so a disabled
+        // key (billing lapse) or plan cap surfaces BEFORE a long run degrades
+        // on it. Classified through the same choke point the run path uses.
+        if (specText !== undefined) {
+            const thredzTarget = thredzProbeTarget(specText);
+            if (thredzTarget !== undefined) {
+                checks.push(thredzProbeToCheck(await probeThredz(thredzTarget)));
+            }
+        }
+    }
     const bunCheck = checkBunVersion(Bun.version);
     checks.push({
         label: `Bun runtime (${Bun.version})`,
@@ -4241,6 +4482,9 @@ async function collectPhilosophyFindings() {
         { name: "compaction-autocompact", path: "packages/compaction-autocompact/src/index.ts" },
         { name: "federation-router", path: "packages/federation-router/src/index.ts" },
         { name: "channel-adapter-base", path: "packages/channel-adapter-base/src/index.ts" },
+        // 0.3.0 memory release: recalled wiki bodies re-enter the model context
+        // across a session boundary — classified at the "memory" origin.
+        { name: "tool-wiki", path: "packages/tool-wiki/src/index.ts" },
     ];
     for (const site of boundarySites) {
         const filePath = join(process.cwd(), site.path);
@@ -8687,6 +8931,268 @@ async function runSessions(args) {
     }
     process.stdout.write(`[sessions] summarized ${indexed} session(s) into ${indexDir}\n`);
 }
+// -------- 0.3.0 memory release: crewhaus memory + migrate memories --------
+/**
+ * `crewhaus memory list|show <id>|forget <id|--query <q>>|sweep [--compact]`
+ * (design §3.4) — inspect and explicitly forget the per-spec fact stores
+ * under `.crewhaus/memories/`. Forgetting is append-only (supersede
+ * tombstones, never a hard delete); `sweep --compact` is the growth-bounding
+ * rewrite. Destructive verbs prompt unless `--yes`. NOTE: `clear|restore`
+ * (trash + undo) deliberately do NOT live here — they arrive with the
+ * continuity store (design §2.6).
+ */
+async function runMemory(args) {
+    const action = args.positional[0];
+    if (args.flags["help"] === true && action === undefined) {
+        process.stdout.write("usage: crewhaus memory list [--spec <name>]\n" +
+            "       crewhaus memory show <mem_id> [--spec <name>]\n" +
+            "       crewhaus memory forget <mem_id> | --query <q> [--spec <name>] [--yes]\n" +
+            "       crewhaus memory sweep [--compact] [--spec <name>] [--yes]\n" +
+            "  Inspect + explicitly forget the per-spec memory stores under .crewhaus/memories/.\n" +
+            "  forget appends supersede tombstones (append-only; never a hard delete); a --query\n" +
+            "  forgets EVERY matching memory. sweep tombstones TTL-expired entries; --compact\n" +
+            "  additionally rewrites the file dropping dead lines (atomic tmp+rename).\n");
+        return;
+    }
+    const memoriesDir = join(process.cwd(), MEMORIES_SUBDIR);
+    const nowMs = Date.now();
+    const specFlag = strFlag(args, "spec");
+    const assumeYes = args.flags["yes"] === true;
+    const storeFor = (specName) => createMemoryStore({ specName, rootDir: memoriesDir });
+    const confirmOrDie = async (prompt) => {
+        if (assumeYes)
+            return true;
+        if (process.stdin.isTTY !== true) {
+            die(`memory ${action}: refusing a destructive operation without --yes in a non-TTY session`);
+        }
+        return await promptYesNo(prompt);
+    };
+    switch (action) {
+        case "list": {
+            const specs = specFlag !== undefined
+                ? [resolveMemorySpec(memoriesDir, specFlag)]
+                : listMemorySpecs(memoriesDir);
+            if (specs.length === 0)
+                die(`no memory files under ${memoriesDir}`);
+            for (const spec of specs) {
+                const items = await storeFor(spec).list();
+                for (const line of renderMemoryList(spec, items, nowMs)) {
+                    process.stdout.write(`${line}\n`);
+                }
+            }
+            return;
+        }
+        case "show": {
+            const id = args.positional[1];
+            if (id === undefined)
+                die("usage: crewhaus memory show <mem_id> [--spec <name>]");
+            const specs = specFlag !== undefined
+                ? [resolveMemorySpec(memoriesDir, specFlag)]
+                : listMemorySpecs(memoriesDir);
+            for (const spec of specs) {
+                const item = (await storeFor(spec).list()).find((i) => i.entry.id === id);
+                if (item !== undefined) {
+                    process.stdout.write(`spec:          ${spec}\n`);
+                    for (const line of renderMemoryShow(item))
+                        process.stdout.write(`${line}\n`);
+                    return;
+                }
+            }
+            die(`no memory with id ${id} under ${memoriesDir}`);
+            return;
+        }
+        case "forget": {
+            const id = args.positional[1];
+            const query = strFlag(args, "query");
+            if ((id === undefined) === (query === undefined)) {
+                die("memory forget: provide exactly one of <mem_id> or --query <q>");
+            }
+            if (id !== undefined && !/^mem_[0-9a-f]{16}$/.test(id)) {
+                die(`memory forget: "${id}" is not a memory id (mem_…) — text goes via --query`);
+            }
+            const spec = resolveMemorySpec(memoriesDir, specFlag);
+            const store = storeFor(spec);
+            // Preview the exact match set forget() will tombstone: for an id the
+            // live entry, for a query every positive BM25 match (recall's set).
+            const items = await store.list();
+            const matches = id !== undefined
+                ? items.filter((i) => i.status === "live" && i.entry.id === id)
+                : (await store.recall(query, 10_000)).map((r) => ({
+                    entry: r.entry,
+                    status: "live",
+                }));
+            if (matches.length === 0) {
+                process.stdout.write(`[memory] nothing to forget — no live memory matched ${id ?? `"${query}"`} in ${spec}\n`);
+                return;
+            }
+            process.stdout.write(`[memory] will forget ${matches.length} memory(ies) from ${spec}:\n`);
+            for (const line of renderMemoryList(spec, matches, nowMs).slice(1)) {
+                process.stdout.write(`${line}\n`);
+            }
+            const go = await confirmOrDie(`forget ${matches.length} memory(ies) from ${spec}? [y/N] `);
+            if (!go) {
+                process.stdout.write("[memory] aborted — nothing forgotten\n");
+                return;
+            }
+            const forgotten = await store.forget((id ?? query), {
+                reason: "crewhaus memory forget",
+            });
+            process.stdout.write(`[memory] forgot ${forgotten.length} memory(ies) (superseded tombstones in ${store.path()})\n`);
+            return;
+        }
+        case "sweep": {
+            const specs = specFlag !== undefined
+                ? [resolveMemorySpec(memoriesDir, specFlag)]
+                : listMemorySpecs(memoriesDir);
+            if (specs.length === 0)
+                die(`no memory files under ${memoriesDir}`);
+            for (const spec of specs) {
+                const result = await storeFor(spec).sweep();
+                process.stdout.write(`[memory] ${spec}: swept ${result.swept} expired memory(ies), ${result.live} live\n`);
+            }
+            if (args.flags["compact"] === true) {
+                const go = await confirmOrDie(`compact ${specs.length} memory file(s) (rewrites dropping tombstoned/expired lines)? [y/N] `);
+                if (!go) {
+                    process.stdout.write("[memory] compact aborted — files untouched\n");
+                    return;
+                }
+                for (const spec of specs) {
+                    const result = await storeFor(spec).compact();
+                    process.stdout.write(`[memory] ${spec}: compacted — kept ${result.kept} line(s), dropped ${result.dropped}\n`);
+                }
+            }
+            return;
+        }
+        default:
+            die(`memory: unknown action "${action ?? ""}" — supported: list, show, forget, sweep`);
+    }
+}
+/**
+ * `crewhaus migrate memories [--dry-run]` — the schema-v2 backfill over
+ * `.crewhaus/memories/*.jsonl` via the Section-28 migration-engine chain:
+ * stamps `schemaVersion: 2` on v1 entries, derives `provenance.sessionId`
+ * where the v1 auto-capture tags carry it, preserves every other line
+ * verbatim, and records the store version in `.crewhaus/meta.json`.
+ * Idempotent — a re-run migrates 0 entries.
+ */
+async function runMigrateMemories(args) {
+    if (args.flags["help"] === true) {
+        process.stdout.write("usage: crewhaus migrate memories [--dry-run]\n" +
+            "  Backfill the v2 memory-entry schema (schemaVersion + derivable provenance)\n" +
+            "  onto .crewhaus/memories/*.jsonl and stamp .crewhaus/meta.json. Idempotent;\n" +
+            "  --dry-run reports the plan without writing.\n");
+        return;
+    }
+    const report = migrateMemories(process.cwd(), {
+        dryRun: args.flags["dry-run"] === true,
+    });
+    if (report.files.length === 0) {
+        process.stdout.write(`[migrate] no memory files under ${join(process.cwd(), MEMORIES_SUBDIR)} — nothing to do\n`);
+        return;
+    }
+    for (const line of formatMigrateMemoriesReport(report))
+        process.stdout.write(`${line}\n`);
+}
+// -------- 0.3.0 memory release: crewhaus wiki --------
+/**
+ * `crewhaus wiki list|show <slug>|search <q>|stats` (design §3.1/§3.2, PR 9)
+ * — inspect the per-spec local wikis under `.crewhaus/wiki/`. Read-only
+ * verbs only: articles are written by the wiki_write tool (versioned,
+ * supersede-never-delete), `clear|restore` ride the continuity trash
+ * machinery, and `push|pull --thredz` arrives with the Thredz PR.
+ */
+async function runWiki(args) {
+    const action = args.positional[0];
+    if (args.flags["help"] === true && action === undefined) {
+        process.stdout.write("usage: crewhaus wiki list [--spec <name>] [--tags <t1,t2>] [--status <s>]\n" +
+            "       crewhaus wiki show <slug> [--spec <name>]\n" +
+            "       crewhaus wiki search <q> [--spec <name>] [-k <n>]\n" +
+            "       crewhaus wiki stats [--spec <name>]\n" +
+            "  Inspect the per-spec local wikis under .crewhaus/wiki/ (versioned articles;\n" +
+            "  priors are kept under versions/<slug>/ — superseded, never deleted). list is\n" +
+            "  stalest-first (the REFLECT order); search is BM25 keyword ranking.\n");
+        return;
+    }
+    const wikiDir = join(process.cwd(), WIKI_SUBDIR);
+    const nowMs = Date.now();
+    const specFlag = strFlag(args, "spec");
+    const storeFor = (specName) => createWikiStore({ specName, rootDir: wikiDir });
+    switch (action) {
+        case "list": {
+            const specs = specFlag !== undefined ? [resolveWikiSpec(wikiDir, specFlag)] : listWikiSpecs(wikiDir);
+            if (specs.length === 0)
+                die(`no wikis under ${wikiDir}`);
+            const statusFlag = strFlag(args, "status");
+            const status = statusFlag === "draft" ||
+                statusFlag === "published" ||
+                statusFlag === "review" ||
+                statusFlag === "archived" ||
+                statusFlag === "all"
+                ? statusFlag
+                : undefined;
+            if (statusFlag !== undefined && status === undefined) {
+                die(`wiki list: unknown --status "${statusFlag}" (draft|published|review|archived|all)`);
+            }
+            const tags = (strFlag(args, "tags") ?? "")
+                .split(",")
+                .map((t) => t.trim())
+                .filter((t) => t !== "");
+            for (const spec of specs) {
+                const refs = await storeFor(spec).list({
+                    staleFirst: true,
+                    ...(status !== undefined ? { status } : {}),
+                    ...(tags.length > 0 ? { tags } : {}),
+                });
+                for (const line of renderWikiList(spec, refs, nowMs)) {
+                    process.stdout.write(`${line}\n`);
+                }
+            }
+            return;
+        }
+        case "show": {
+            const slug = args.positional[1];
+            if (slug === undefined)
+                die("usage: crewhaus wiki show <slug> [--spec <name>]");
+            const specs = specFlag !== undefined ? [resolveWikiSpec(wikiDir, specFlag)] : listWikiSpecs(wikiDir);
+            for (const spec of specs) {
+                const article = await storeFor(spec).get(slug);
+                if (article !== null) {
+                    process.stdout.write(`spec:        ${spec}\n`);
+                    for (const line of renderWikiShow(article))
+                        process.stdout.write(`${line}\n`);
+                    return;
+                }
+            }
+            die(`no wiki article with slug "${slug}" under ${wikiDir}`);
+            return;
+        }
+        case "search": {
+            const query = args.positional[1];
+            if (query === undefined)
+                die("usage: crewhaus wiki search <q> [--spec <name>] [-k <n>]");
+            const k = Math.max(1, Number.parseInt(strFlag(args, "k") ?? "10", 10) || 10);
+            const spec = resolveWikiSpec(wikiDir, specFlag);
+            const refs = await storeFor(spec).search(query);
+            for (const line of renderWikiSearch(spec, query, refs.slice(0, k))) {
+                process.stdout.write(`${line}\n`);
+            }
+            return;
+        }
+        case "stats": {
+            const specs = specFlag !== undefined ? [resolveWikiSpec(wikiDir, specFlag)] : listWikiSpecs(wikiDir);
+            if (specs.length === 0)
+                die(`no wikis under ${wikiDir}`);
+            for (const spec of specs) {
+                for (const line of renderWikiStats(spec, await storeFor(spec).stats())) {
+                    process.stdout.write(`${line}\n`);
+                }
+            }
+            return;
+        }
+        default:
+            die(`wiki: unknown action "${action ?? ""}" — supported: list, show, search, stats`);
+    }
+}
 // -------- item 4: crewhaus graders suggest --------
 /**
  * Item 4 — `crewhaus graders suggest`: cluster the failure rationale
@@ -9276,10 +9782,14 @@ async function runFleet(args, action) {
             const assumeYes = args.flags["yes"] === true;
             // Production runner: spawn `crewhaus <argv>` in the harness dir (the cwd
             // every subcommand resolves `.crewhaus/` state from). No shell — an argv
-            // array through Bun.spawn. The child inherits this process's argv[0]
-            // (the running CLI) so a bulk `doctor` runs the SAME binary.
+            // array through Bun.spawn. `fleetSelfInvokeArgv` re-invokes THIS CLI so a
+            // bulk `doctor` runs the SAME binary, correct under both `bun run` and a
+            // `bun build --compile` single-file binary: the compiled binary
+            // re-injects its own `/$bunfs/…` entry, so we must NOT pass our `Bun.main`
+            // as a subcommand (see fleet.ts — that was the v0.2.4 fleet-run bug).
             const runner = async ({ cwd, argv }) => {
-                const proc = Bun.spawn([process.execPath, process.argv[1], ...argv], {
+                const spawnArgv = fleetSelfInvokeArgv({ execPath: process.execPath, entryPath: Bun.main }, argv);
+                const proc = Bun.spawn(spawnArgv, {
                     cwd,
                     stdin: "ignore",
                     stdout: "pipe",
@@ -11033,6 +11543,9 @@ async function runUpgrade(args) {
             "  Detect the spec's schema-version drift vs this CLI's current spec version\n" +
             "  and run the migration chain (each migrated spec is validated via parseSpec\n" +
             "  before it can be written). Defaults to ./crewhaus.yaml and to a dry-run diff.\n" +
+            "  Also prints the 0.2.x → 0.3.0 release notes that apply to this spec\n" +
+            "  (default-on continuity + the `continuity: false` pin, `crewhaus migrate\n" +
+            "  memories`, MCP env/header secret lowering) — informational only.\n" +
             "  --write   apply the migration in place (rewrites the spec file).\n");
         return;
     }
@@ -11523,10 +12036,26 @@ async function runMcpDoctor(args) {
         if (Object.keys(mcpServers).length > 0) {
             mkdirSync(mcpDir, { recursive: true });
             const host = new McpHost({ logger });
-            for (const [name, cfg] of Object.entries(mcpServers))
-                host.addServer(name, cfg);
+            for (const [name, cfg] of Object.entries(mcpServers)) {
+                // 0.3.0 — env/header values are IrSecretRef; an unresolvable env
+                // ref becomes a per-server probe failure (named variable) rather
+                // than crashing the whole doctor run.
+                try {
+                    host.addServer(name, resolveMcpServerConfig(cfg, { name }));
+                }
+                catch (err) {
+                    driftEntries.push({
+                        server: name,
+                        lines: [
+                            `  ✗ ${name}: probe failed — ${err instanceof Error ? err.message : String(err)}`,
+                        ],
+                    });
+                    driftDetected = true;
+                }
+            }
+            const probeNames = Object.keys(mcpServers).filter((name) => host.has(name));
             const nowIso = new Date().toISOString();
-            await Promise.all(Object.keys(mcpServers).map(async (name) => {
+            await Promise.all(probeNames.map(async (name) => {
                 const lines = [];
                 try {
                     const client = host.getClient(name);
@@ -12914,15 +13443,16 @@ switch (subcommand) {
         // Mirror runCompile's policy: every structured failure in the run
         // pipeline (ConfigError from the model-router, ProviderAuthError from
         // an adapter, RuntimeError, …) extends CrewhausError — route the
-        // family through die() for a clean one-line error + exit 1 instead of
-        // a raw stack trace. A non-CrewhausError (a genuine bug) still
-        // propagates with its full stack for debugging.
+        // family through die(), which prints the classic one-liner + exit 1
+        // for most of them and (v0.3.0 Goal 6) the full structured report +
+        // coded exit for a RunFailedError. A non-CrewhausError (a genuine
+        // bug) still propagates with its full stack for debugging.
         try {
             await runRun(parseFor(rest, RUN_SCHEMA));
         }
         catch (err) {
             if (err instanceof CrewhausError)
-                die(err.message);
+                die(err);
             throw err;
         }
         break;
@@ -13129,6 +13659,64 @@ switch (subcommand) {
             throw err;
         }
         break;
+    case "memory":
+        // 0.3.0 memory release (design §3.4) — inspect/forget/sweep the per-spec
+        // fact stores. Structured failures route through die().
+        try {
+            await runMemory(parseFor(rest, MEMORY_SCHEMA));
+        }
+        catch (err) {
+            if (err instanceof CrewhausError)
+                die(err.message);
+            throw err;
+        }
+        break;
+    case "wiki":
+        // 0.3.0 memory release (design §3.1, PR 9) — inspect the per-spec local
+        // wikis (read-only verbs). Structured failures route through die().
+        try {
+            await runWiki(parseFor(rest, WIKI_SCHEMA));
+        }
+        catch (err) {
+            if (err instanceof CrewhausError)
+                die(err.message);
+            throw err;
+        }
+        break;
+    case "dream": {
+        // 0.3.0 memory release (design §6.3, PR 14) — scheduled consolidation
+        // verbs. A bare `crewhaus dream <spec>` defaults to `run` (the design's
+        // transcript); the verbs themselves live in dream-cli.ts.
+        const dreamFirst = rest[0];
+        const dreamAction = dreamFirst === "run" || dreamFirst === "status" || dreamFirst === "init" ? dreamFirst : "run";
+        const dreamRest = dreamFirst === dreamAction ? rest.slice(1) : rest;
+        try {
+            await runDreamCommand(parseFor(dreamRest, DREAM_CLI_SCHEMA), dreamAction);
+        }
+        catch (err) {
+            if (err instanceof CrewhausError)
+                die(err.message);
+            throw err;
+        }
+        break;
+    }
+    case "migrate": {
+        // 0.3.0 memory release — `migrate memories`: the v2 schema backfill over
+        // .crewhaus/memories/. Spec migrations stay on migrate-all/upgrade.
+        const migrateAction = rest[0] ?? "";
+        if (migrateAction !== "memories") {
+            die(`migrate action must be "memories" (got "${migrateAction}") — spec migrations use migrate-all/upgrade`);
+        }
+        try {
+            await runMigrateMemories(parseFor(rest.slice(1), MIGRATE_MEMORIES_SCHEMA));
+        }
+        catch (err) {
+            if (err instanceof CrewhausError)
+                die(err.message);
+            throw err;
+        }
+        break;
+    }
     case "scaffold-evals":
         // Mirror `run`'s policy: structured failures (SpecParseError, model
         // routing/auth on the one-shot generation call) extend CrewhausError —