@crewhaus/eval-runner 0.2.4 → 0.3.0

package/dist/exam.d.ts

@@ -0,0 +1,66 @@
+import type { ExamRunner, MemoryWiringFragment, ThredzConnection } from "@crewhaus/memory-service";
+import type { RunContext } from "@crewhaus/run-context";
+import type { AgentInvoker } from "./types";
+/** The exam-session preamble appended to the harness instructions — the
+ *  grounding contract the demo's graders (`grounded_not_bluffed`) test. */
+export declare const EXAM_SESSION_PREAMBLE: string;
+/** The exact runChatLoop option subset an exam session uses — a dedicated
+ *  type so tests can inject a capturing `chatLoop` and pin every field
+ *  (the dream-cli `DreamChatLoopOptions` pattern). */
+export type ExamChatLoopOptions = {
+    readonly model: string;
+    readonly instructions: string;
+    readonly runContext: RunContext;
+    readonly singleTurn: true;
+    readonly seedMessages: ReadonlyArray<{
+        readonly role: "user";
+        readonly content: string;
+    }>;
+    readonly sessionName: string;
+    readonly sessionTarget: "eval";
+    readonly sessionRootDir: string;
+    readonly tools: ReadonlyArray<never>;
+    readonly hooks: ReadonlyArray<never>;
+    readonly memory?: {
+        readonly autoRecall: true;
+        readonly recallK: number;
+        readonly recallSeed: string;
+        readonly recall: (query: string, k: number) => Promise<readonly string[]>;
+    };
+    readonly spinner: false;
+};
+export type ExamChatLoopFn = (opts: ExamChatLoopOptions) => Promise<string>;
+export type CreateExamRunnerOptions = {
+    readonly specName: string;
+    /** The harness's own model — exam sessions and (by default) the judge
+     *  grader run on it. */
+    readonly model: string;
+    /** The harness's own instructions — the examinee is THIS harness. */
+    readonly instructions: string;
+    /** The memory fragment (`memoryFragmentFromIr(ir)`) — `wireWiki` grounds
+     *  each question in the same wiki surface the harness runs with. */
+    readonly fragment: MemoryWiringFragment;
+    /** The harness working directory (stores + default artifact root). */
+    readonly cwd: string;
+    /** The live Thredz connection when the wiki backend is hosted (§4.3);
+     *  null/absent → the local store (or no grounding when no wiki). */
+    readonly thredz?: ThredzConnection | null;
+    /** Judge model for `llm_judge` graders. Default: the harness model. */
+    readonly judgeModel?: string;
+    readonly concurrency?: number;
+    /** Wiki lines recalled per question. Default 6 (§9 `wiki.recallK`). */
+    readonly recallK?: number;
+    /** Artifact root override. Default `<cwd>/.crewhaus/evals/exam-<stamp>`. */
+    readonly outDir?: string;
+    /** Full invoker override (tests / bespoke examinees). */
+    readonly invoker?: AgentInvoker;
+    /** Session-runner seam under the default invoker (tests pin options). */
+    readonly chatLoop?: ExamChatLoopFn;
+    readonly now?: () => Date;
+};
+/**
+ * Build the injected exam runner (`wireMemory({ examRunner })`). Pure
+ * construction — nothing is read until the returned runner is invoked by
+ * the `run_exam` tool, so a harness that never sits its exam pays nothing.
+ */
+export declare function createExamRunner(opts: CreateExamRunnerOptions): ExamRunner;

package/dist/exam.js

@@ -0,0 +1,202 @@
+/**
+ * v0.3.0 Goal 2 (design §3.3 EXAM, PR 17) — `createExamRunner`: the
+ * reference implementation of memory-service's injected `ExamRunner` seam.
+ *
+ * The expert demo's `/exam` shelled out to `crewhaus eval` via Bash from
+ * inside the agent — the harness invoking its own CLI, requiring a Bash
+ * permission just to sit an exam. This is the first-class replacement: a
+ * PROGRAMMATIC eval invocation built from this package's own machinery
+ * (`loadDataset` + `parseGradersConfig` + `runSample`/`Semaphore`), consumed
+ * by the `run_exam` tool through `wireMemory({ examRunner })` on both the
+ * `crewhaus run` interpreter path and compiled cli bundles.
+ *
+ * Exam semantics: each dataset question runs in a FRESH single-turn session
+ * — the harness's own model + instructions plus an exam preamble — grounded
+ * in the REAL wiki through the backend-invariant `wireWiki(...).recall` seam
+ * (local store or Thredz MCP client; recall lines are injected through
+ * runChatLoop's `memory` seam, so recalled bodies still cross the boundary
+ * classifier + delimiter escaping like every other recall). No tools are
+ * exposed to the exam session: the question is "can you answer from what the
+ * wiki knows", graded by the spec's own graders — never "can you edit the
+ * wiki mid-exam". Unlike `runEval`'s per-sample fabric isolation (§7.2),
+ * the exam deliberately reads the live wiki — an isolated empty wiki would
+ * examine amnesia.
+ *
+ * Per-sample artifacts land under `.crewhaus/evals/exam-<stamp>/<sampleId>/`
+ * via `runSample` (transcript/events/grades/meta), so failed exams are
+ * triageable with the same tooling as any eval run.
+ */
+import { readFileSync } from "node:fs";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { loadDataset } from "@crewhaus/eval-dataset";
+import { parseGradersConfig } from "@crewhaus/eval-grader";
+import { createJudgeGrader, loadRubric } from "@crewhaus/eval-judge";
+import { wireWiki } from "@crewhaus/memory-service";
+import { runChatLoop } from "@crewhaus/runtime-core";
+import { RunnerError } from "./errors";
+import { runSample } from "./run-sample";
+import { Semaphore } from "./semaphore";
+/** Exam sessions run a couple at a time — an exam is an interactive,
+ *  user-initiated pass, not a benchmark sweep. */
+const DEFAULT_EXAM_CONCURRENCY = 2;
+/** Wiki lines recalled per question (mirrors §9's `wiki.recallK` default). */
+const DEFAULT_EXAM_RECALL_K = 6;
+/** The exam-session preamble appended to the harness instructions — the
+ *  grounding contract the demo's graders (`grounded_not_bluffed`) test. */
+export const EXAM_SESSION_PREAMBLE = [
+    "You are sitting your competency exam. Answer the question in this one turn:",
+    "- answer ONLY from the recalled wiki context above, citing article slugs like (topic/slug);",
+    "- numbers, ranges, and units must be exact;",
+    "- if the recalled context does not support an answer, say plainly what you do not know instead of guessing.",
+].join("\n");
+/**
+ * Build the injected exam runner (`wireMemory({ examRunner })`). Pure
+ * construction — nothing is read until the returned runner is invoked by
+ * the `run_exam` tool, so a harness that never sits its exam pays nothing.
+ */
+export function createExamRunner(opts) {
+    return async ({ datasetPath, gradersPath }) => {
+        // 1. Graders — parse the spec's graders.yaml; `llm_judge` placeholders
+        // bind to the judge model (per-grader override > opts.judgeModel > the
+        // harness model), exactly like runEval's resolution.
+        let gradersYaml;
+        try {
+            gradersYaml = readFileSync(gradersPath, "utf-8");
+        }
+        catch (err) {
+            throw new RunnerError(`exam: cannot read graders "${gradersPath}" (learning.exam.graders): ${err.message}`);
+        }
+        const { compiled } = parseGradersConfig(gradersYaml);
+        const graders = compiled.map((g) => {
+            if (g.judgeSpec) {
+                const rubric = loadRubric(g.judgeSpec.rubric);
+                const model = g.judgeSpec.model ?? opts.judgeModel ?? opts.model;
+                return { name: g.name, grader: createJudgeGrader(rubric, { model }) };
+            }
+            // v0.3.0 final integration (PR 17 ∩ PR 19): `type: registry` graders
+            // resolve against RunEvalOptions.graderRegistry — a seam run_exam does
+            // not carry (the exam is invoked from inside a running harness, which
+            // has no grader registry to hand over). Reject LOUDLY at exam start,
+            // exactly like runEval does, instead of letting the compiled
+            // placeholder throw per-sample as confusing grader-infra noise.
+            if (g.registrySpec) {
+                throw new RunnerError(`exam: grader "${g.name}" is \`type: registry\` (→ "${g.registrySpec.grader}") — registry graders resolve via RunEvalOptions.graderRegistry under \`crewhaus eval\` and are not available to \`run_exam\`; use code/llm_judge graders in learning.exam.graders`);
+            }
+            return { name: g.name, grader: g.grader };
+        });
+        // 2. Dataset — materialized like runEval (exams are small by design).
+        let samples;
+        try {
+            const dataset = await loadDataset(datasetPath);
+            samples = [];
+            for await (const s of dataset.samples)
+                samples.push(s);
+        }
+        catch (err) {
+            throw err instanceof RunnerError
+                ? err
+                : new RunnerError(`exam: cannot load dataset "${datasetPath}" (learning.exam.dataset): ${err.message}`);
+        }
+        if (samples.length === 0) {
+            throw new RunnerError(`exam: dataset "${datasetPath}" yielded zero samples`);
+        }
+        const invoker = opts.invoker ?? buildExamInvoker(opts);
+        const outDir = opts.outDir ?? join(opts.cwd, ".crewhaus", "evals", `exam-${examStamp(opts.now)}`);
+        mkdirSync(outDir, { recursive: true });
+        // 3. Run — per-sample artifacts + grading via the shared runSample path.
+        const sem = new Semaphore(opts.concurrency ?? DEFAULT_EXAM_CONCURRENCY);
+        const results = await Promise.all(samples.map(async (sample) => {
+            const release = await sem.acquire();
+            try {
+                return await runSample({
+                    sample,
+                    invoker,
+                    graders,
+                    outDir,
+                    model: opts.model,
+                    // PR 19's artifact seam: stamp the examinee's spec name so any
+                    // artifact-reading grader addresses the right state root.
+                    specName: opts.specName,
+                });
+            }
+            finally {
+                release();
+            }
+        }));
+        const bySampleId = new Map(samples.map((s) => [s.id, s]));
+        const outcomes = results.map((r) => {
+            const sample = bySampleId.get(r.sampleId);
+            return {
+                sampleId: r.sampleId,
+                input: sample?.input ?? "",
+                passed: r.grades.overall.passed,
+                score: r.grades.overall.score,
+                rationale: r.grades.overall.rationale,
+                agentOutput: r.agentOutput,
+                ...(r.error !== undefined ? { error: r.error } : {}),
+            };
+        });
+        const passed = outcomes.filter((o) => o.passed).length;
+        const report = {
+            total: outcomes.length,
+            passed,
+            failed: outcomes.length - passed,
+            passRate: outcomes.length === 0 ? 0 : passed / outcomes.length,
+            outcomes,
+            outDir,
+        };
+        await Bun.write(join(outDir, "exam.json"), JSON.stringify(report, null, 2));
+        return report;
+    };
+}
+/** The default examinee: one fresh single-turn session per question,
+ *  wiki-grounded through runChatLoop's memory seam, zero tools. */
+function buildExamInvoker(opts) {
+    const chatLoop = opts.chatLoop ?? runChatLoop;
+    const wiki = wireWiki({
+        specName: opts.fragment.specName,
+        ...(opts.fragment.memory !== undefined ? { memory: opts.fragment.memory } : {}),
+        ...(opts.fragment.thredz !== undefined ? { thredz: opts.fragment.thredz } : {}),
+    }, {
+        // A registrar is required by the deps type but the exam session never
+        // advertises the wiki tools — recall is the only surface it gets.
+        catalog: { register: () => undefined },
+        cwd: opts.cwd,
+        ...(opts.thredz !== undefined ? { thredz: opts.thredz } : {}),
+    });
+    const recallK = opts.recallK ?? opts.fragment.memory?.wiki?.recallK ?? DEFAULT_EXAM_RECALL_K;
+    return async (req) => {
+        const agentOutput = await chatLoop({
+            model: opts.model,
+            instructions: `${opts.instructions}\n\n${EXAM_SESSION_PREAMBLE}`,
+            runContext: req.runContext,
+            singleTurn: true,
+            seedMessages: [{ role: "user", content: req.sample.input }],
+            sessionName: `${opts.specName}-exam`,
+            sessionTarget: "eval",
+            sessionRootDir: req.sessionRootDir,
+            tools: [],
+            hooks: [],
+            ...(wiki !== null
+                ? {
+                    memory: {
+                        autoRecall: true,
+                        recallK,
+                        recallSeed: req.sample.input,
+                        recall: wiki.recall,
+                    },
+                }
+                : {}),
+            spinner: false,
+        });
+        return { agentOutput };
+    };
+}
+function examStamp(now) {
+    const d = (now ?? (() => new Date()))();
+    return d
+        .toISOString()
+        .replace(/[:.]/g, "-")
+        .replace(/-\d{3}Z$/, "Z");
+}

package/dist/index.d.ts

@@ -5,11 +5,12 @@ import { aggregate } from "./aggregate";
 import { RunnerError } from "./errors";
 import { runSample } from "./run-sample";
 import { Semaphore } from "./semaphore";
-import type { AgentInvoker, EvalRunSummary, GraderEntry, RunEvalOptions, SampleResult } from "./types";
+import type { AgentInvoker, EvalRunSummary, GraderEntry, GraderLookup, RunEvalOptions, SampleResult } from "./types";
 import { type SharedAgentDeps, wireRunOnce } from "./wire-once";
-export type { AgentInvoker, EvalRunSummary, GraderEntry, RunEvalOptions, SampleResult };
+export type { AgentInvoker, EvalRunSummary, GraderEntry, GraderLookup, RunEvalOptions, SampleResult, };
 export type { SharedAgentDeps };
 export { wireRunOnce };
+export { EXAM_SESSION_PREAMBLE, createExamRunner, type CreateExamRunnerOptions, type ExamChatLoopFn, type ExamChatLoopOptions, } from "./exam";
 export { Semaphore };
 export { aggregate };
 export { RunnerError };

package/dist/index.js

@@ -24,7 +24,9 @@
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { createJudgeGrader, loadRubric } from "@crewhaus/eval-judge";
+import { memoryFragmentFromIr, wireMemory } from "@crewhaus/memory-service";
 import { runChatLoop } from "@crewhaus/runtime-core";
+import { createSkillTool } from "@crewhaus/skills-registry";
 import { currentTenantContext } from "@crewhaus/tenancy";
 import { aggregate } from "./aggregate";
 import { RunnerError } from "./errors";
@@ -32,6 +34,9 @@ import { runSample } from "./run-sample";
 import { Semaphore } from "./semaphore";
 import { wireRunOnce } from "./wire-once";
 export { wireRunOnce };
+// v0.3.0 Goal 2 (§3.3, PR 17) — the first-class competency exam: the
+// reference implementation of memory-service's injected `ExamRunner` seam.
+export { EXAM_SESSION_PREAMBLE, createExamRunner, } from "./exam";
 export { Semaphore };
 export { aggregate };
 export { RunnerError };
@@ -63,7 +68,9 @@ export async function runEval(args) {
     const outDir = resolveEvalOutDir(runId, opts.outDir);
     mkdirSync(outDir, { recursive: true });
     // Resolve graders. Replace any `llm_judge` placeholder with a real judge
-    // grader bound to the runner's judgeModel (or the per-grader override).
+    // grader bound to the runner's judgeModel (or the per-grader override),
+    // and any `registry` placeholder with the named grader from the caller's
+    // grader registry (PR 19 — loud at run start, not per-sample).
     const graders = compiledGraders.map((g) => {
         if (g.judgeSpec) {
             const rubric = loadRubric(g.judgeSpec.rubric);
@@ -71,6 +78,12 @@ export async function runEval(args) {
             const grader = createJudgeGrader(rubric, model !== undefined ? { model } : {});
             return { name: g.name, grader };
         }
+        if (g.registrySpec) {
+            if (opts.graderRegistry === undefined) {
+                throw new RunnerError(`grader "${g.name}" resolves by registry name "${g.registrySpec.grader}" but no graderRegistry was supplied — pass RunEvalOptions.graderRegistry (and register the pack, e.g. registerContinuityGraders(registry))`);
+            }
+            return { name: g.name, grader: opts.graderRegistry.lookup(g.registrySpec.grader) };
+        }
         return { name: g.name, grader: g.grader };
     });
     // The default invoker calls runChatLoop with the per-sample fresh runContext.
@@ -125,6 +138,7 @@ export async function runEval(args) {
                 graders,
                 outDir,
                 model: ir.agent.model,
+                specName: ir.name,
                 ...(opts.seed !== undefined ? { seed: opts.seed } : {}),
             });
             const first = await runOnce();
@@ -194,17 +208,62 @@ export async function runEval(args) {
 }
 async function defaultInvoker(ir, opts) {
     const wired = await wireRunOnce(ir, opts.cwd !== undefined ? { cwd: opts.cwd } : {});
+    // v0.3.0 §7.2 — eval/optimizer state ISOLATION. When the IR carries the
+    // memory fabric (an enabled `memory` block and/or `continuity`, which is
+    // DEFAULT-ON on the cli shape since 0.3.0), each sample gets its OWN
+    // ephemeral stores rooted under its per-sample artifact directory
+    // (`.crewhaus/evals/<runId>/<sampleId>/.crewhaus/…`): plan/focus/handoff/
+    // facts written by sample N must never leak into sample N+1 — Pillar 2
+    // assumes spec patches are the only cross-run channel. The per-sample
+    // `sessionRootDir` doubles as the fabric's session-log root so proof
+    // evidence resolves against the sample's own transcript, and `homeDir`
+    // is pinned inside the sample dir so the operator's `~/.crewhaus` skills
+    // can never bleed into a measurement.
+    const fabricOn = (ir.memory !== undefined && ir.memory.enabled !== false) || ir.continuity !== undefined;
     return async (req) => {
+        let tools = [...wired.tools];
+        let skills = wired.skills;
+        let slashCommands = wired.slashCommands;
+        let memoryOpt;
+        let continuityOpt;
+        if (fabricOn) {
+            const memWired = await wireMemory(memoryFragmentFromIr(ir), {
+                catalog: {
+                    register: (tool) => {
+                        tools.push(tool);
+                    },
+                },
+                cwd: req.sessionRootDir,
+                sessionRootDir: req.sessionRootDir,
+                homeDir: req.sessionRootDir,
+            });
+            memoryOpt = memWired.options.memory;
+            continuityOpt = memWired.options.continuity;
+            if (memWired.options.skills !== undefined) {
+                // The fabric owns the skill surface (builtin `continuity` skill at
+                // lowest precedence): replace any Skill tool wireRunOnce registered
+                // so the tool list never advertises two.
+                skills = memWired.options.skills;
+                tools = tools.filter((t) => t.name !== "Skill");
+                if (skills.length > 0)
+                    tools.push(createSkillTool(skills));
+            }
+            if (memWired.options.slashCommands !== undefined) {
+                slashCommands = memWired.options.slashCommands;
+            }
+        }
         const agentOutput = await runChatLoop({
             model: wired.model,
             instructions: wired.instructions,
-            tools: [...wired.tools],
+            tools,
             hooks: wired.hooks,
-            skills: wired.skills,
-            slashCommands: wired.slashCommands,
+            skills,
+            slashCommands,
             ...(wired.subAgents !== undefined && wired.spawnSubAgent !== undefined
                 ? { subAgents: wired.subAgents, spawnSubAgent: wired.spawnSubAgent }
                 : {}),
+            ...(memoryOpt !== undefined ? { memory: memoryOpt } : {}),
+            ...(continuityOpt !== undefined ? { continuity: continuityOpt } : {}),
             permissionRules: wired.permissionRules,
             permissionMode: "auto",
             sessionName: `${wired.sessionName}_${req.sample.id}`,

package/dist/run-sample.d.ts

@@ -14,6 +14,9 @@ export declare function runSample(args: {
     outDir: string;
     model: string;
     seed?: number;
+    /** The spec name (`ir.name`) — threaded into `RunResult.artifacts` so
+     *  artifact graders can address `.crewhaus/state/<specName>/` directly. */
+    specName?: string;
 }): Promise<SampleResult>;
 /** Helper: produce one combined grader from an array of CompiledGrader. */
 export declare function combineGraderEntries(graders: ReadonlyArray<CompiledGrader>): Grader;

package/dist/run-sample.js

@@ -69,7 +69,12 @@ export async function runSample(args) {
     const turns = transcript.filter((e) => e.kind === "assistant_message").length;
     const toolCalls = extractToolCalls(finalEvents);
     const tokens = sumTokens(finalEvents);
-    // Apply graders.
+    // Apply graders. `artifacts` is the PR-19 seam for artifact-reading
+    // graders (grader-continuity): the sample's own directory — the primary
+    // session's `transcript.jsonl`, any extra session JSONLs a multi-session
+    // invoker wrote, and the isolated `.crewhaus/` fabric root (§7.2) — so
+    // graders measure the finished sample's files, never the host's live
+    // stores.
     const runResult = {
         agentOutput,
         events: finalEvents,
@@ -77,6 +82,13 @@ export async function runSample(args) {
         toolCalls,
         turns,
         latencyMs,
+        artifacts: {
+            sampleDir,
+            sessionId: runContext.sessionId,
+            transcriptPath,
+            stateRootDir: join(sampleDir, ".crewhaus"),
+            ...(args.specName !== undefined ? { specName: args.specName } : {}),
+        },
     };
     const perGrader = [];
     // A grader throwing is grader INFRA noise (judge 429/timeout), not a graded

package/dist/types.d.ts

@@ -104,6 +104,14 @@ export type EvalRunSummary = {
     };
     readonly outDir: string;
 };
+/**
+ * Structural view of `@crewhaus/grader-registry`'s `GraderRegistry` — just
+ * the lookup the runner needs to resolve `type: registry` grader entries,
+ * kept structural so this package takes no grader-registry dependency.
+ */
+export type GraderLookup = {
+    lookup(name: string): Grader;
+};
 export type RunEvalOptions = {
     readonly runId?: string;
     readonly concurrency?: number;
@@ -112,6 +120,14 @@ export type RunEvalOptions = {
     readonly judgeModel?: string;
     readonly invoker?: AgentInvoker;
     readonly cwd?: string;
+    /**
+     * v0.3.0 §7.3 (PR 19) — resolves `type: registry` grader entries by name.
+     * An eval config opts into registered grader packs (`continuity.*` after
+     * `registerContinuityGraders`, `twelve.*` after `register12MetricRubric`)
+     * without this package importing them; omitting the registry while the
+     * config carries a registry entry is a loud `RunnerError` at run start.
+     */
+    readonly graderRegistry?: GraderLookup;
     /**
      * Retry a sample ONCE, within the run, when its result is an ERROR
      * (`SampleResult.error` — the INVOKER failed: provider timeout, 429,

package/dist/wire-once.js

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { loadHooks } from "@crewhaus/hooks-engine";
 import { createLogger } from "@crewhaus/logging";
-import { McpHost } from "@crewhaus/mcp-host";
+import { McpHost, resolveMcpServerConfig } from "@crewhaus/mcp-host";
 import { BUILTIN_DEFAULT_RULES, PermissionConfigError, parsePermissionsConfig, tagRules, } from "@crewhaus/permission-engine";
 import { createSkillTool, discoverSkills } from "@crewhaus/skills-registry";
 import { loadCommands } from "@crewhaus/slash-commands";
@@ -33,8 +33,11 @@ export async function wireRunOnce(ir, opts = {}) {
     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 from the eval
+        // process's environment (fail-fast, names the variable).
+        for (const [name, cfg] of Object.entries(ir.mcp_servers)) {
+            host.addServer(name, resolveMcpServerConfig(cfg, { name }));
+        }
         const tempCatalog = new ToolCatalog();
         for (const t of tools)
             tempCatalog.register(t);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewhaus/eval-runner",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "type": "module",
   "description": "Eval runner — per-sample isolation, concurrency, grading, persistence",
   "main": "dist/index.js",
@@ -15,37 +15,43 @@
     "test": "bun test src"
   },
   "dependencies": {
-    "@crewhaus/agent-context-isolation": "0.2.4",
-    "@crewhaus/compiler": "0.2.4",
-    "@crewhaus/errors": "0.2.4",
-    "@crewhaus/eval-dataset": "0.2.4",
-    "@crewhaus/eval-grader": "0.2.4",
-    "@crewhaus/eval-judge": "0.2.4",
-    "@crewhaus/event-log": "0.2.4",
-    "@crewhaus/hooks-engine": "0.2.4",
-    "@crewhaus/ir": "0.2.4",
-    "@crewhaus/logging": "0.2.4",
-    "@crewhaus/mcp-host": "0.2.4",
-    "@crewhaus/permission-engine": "0.2.4",
-    "@crewhaus/run-context": "0.2.4",
-    "@crewhaus/runtime-core": "0.2.4",
-    "@crewhaus/skills-registry": "0.2.4",
-    "@crewhaus/slash-commands": "0.2.4",
-    "@crewhaus/spec": "0.2.4",
-    "@crewhaus/sub-agent-spawner": "0.2.4",
-    "@crewhaus/tenancy": "0.2.4",
-    "@crewhaus/tool-bash": "0.2.4",
-    "@crewhaus/tool-catalog": "0.2.4",
-    "@crewhaus/tool-fetch": "0.2.4",
-    "@crewhaus/tool-fs": "0.2.4",
-    "@crewhaus/tool-image": "0.2.4",
-    "@crewhaus/tool-mcp": "0.2.4",
-    "@crewhaus/tool-task": "0.2.4",
-    "@crewhaus/tool-todo": "0.2.4",
-    "@crewhaus/tool-web": "0.2.4",
-    "@crewhaus/trace-event-bus": "0.2.4",
+    "@crewhaus/agent-context-isolation": "0.3.0",
+    "@crewhaus/compiler": "0.3.0",
+    "@crewhaus/errors": "0.3.0",
+    "@crewhaus/eval-dataset": "0.3.0",
+    "@crewhaus/eval-grader": "0.3.0",
+    "@crewhaus/eval-judge": "0.3.0",
+    "@crewhaus/event-log": "0.3.0",
+    "@crewhaus/hooks-engine": "0.3.0",
+    "@crewhaus/ir": "0.3.0",
+    "@crewhaus/logging": "0.3.0",
+    "@crewhaus/mcp-host": "0.3.0",
+    "@crewhaus/memory-service": "0.3.0",
+    "@crewhaus/permission-engine": "0.3.0",
+    "@crewhaus/run-context": "0.3.0",
+    "@crewhaus/runtime-core": "0.3.0",
+    "@crewhaus/skills-registry": "0.3.0",
+    "@crewhaus/slash-commands": "0.3.0",
+    "@crewhaus/spec": "0.3.0",
+    "@crewhaus/sub-agent-spawner": "0.3.0",
+    "@crewhaus/tenancy": "0.3.0",
+    "@crewhaus/tool-bash": "0.3.0",
+    "@crewhaus/tool-catalog": "0.3.0",
+    "@crewhaus/tool-fetch": "0.3.0",
+    "@crewhaus/tool-fs": "0.3.0",
+    "@crewhaus/tool-image": "0.3.0",
+    "@crewhaus/tool-mcp": "0.3.0",
+    "@crewhaus/tool-task": "0.3.0",
+    "@crewhaus/tool-todo": "0.3.0",
+    "@crewhaus/tool-web": "0.3.0",
+    "@crewhaus/trace-event-bus": "0.3.0",
+    "@crewhaus/wiki-store": "0.3.0",
     "zod": "^3.23.8"
   },
+  "devDependencies": {
+    "@crewhaus/grader-continuity": "0.3.0",
+    "@crewhaus/grader-registry": "0.3.0"
+  },
   "license": "Apache-2.0",
   "author": {
     "name": "Max Meier",