haansi 0.1.55 → 0.1.57

package/dist/haansi.js

@@ -95,7 +95,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "haansi",
-      version: "0.1.55",
+      version: "0.1.57",
       description: "Haansi CLI - Session collector and MCP server for Claude Code & OpenAI Codex",
       bin: {
         haansi: "./dist/haansi.js"
@@ -19220,6 +19220,34 @@ var init_exclusions = __esm({
         model: ["operational", "The model name the replay ran with."],
         run_ref: ["not-personal", "A link to the customer's CI run."]
       }),
+      ...exchangeExclusions(INTEL, "replay_sessions", {
+        excluded_process_ids: [
+          "join-key",
+          "process_registry.process_id of the replayed workstream, matched by equality."
+        ],
+        excluded_family_ids: [
+          "join-key",
+          "problem_families ids holding the replayed workstream, matched by equality."
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "replay_session_calls", {
+        server: ["operational", "The MCP server's name, e.g. haansi-skills."],
+        tool: ["operational", "The MCP tool's name, e.g. search_skills."],
+        returned_ids: [
+          "join-key",
+          "Ids of the solutions, skills and revisions a tool returned."
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "replay_task_results", {
+        inputs_fingerprint: [
+          "derived",
+          "A SHA-256 of the task's inputs the replay ran on; not reversible."
+        ],
+        arm: ["operational", "Closed CHECK vocabulary (baseline, haansi)."],
+        agent: ["operational", "The agent CLI's name, e.g. claude-code."],
+        model: ["operational", "The model name the replay ran with."],
+        run_ref: ["not-personal", "A link to the customer's CI run."]
+      }),
       ...exchangeExclusions(INTEL, "replay_tasks", {
         process_id: [
           "join-key",
@@ -19305,7 +19333,11 @@ var init_exclusions = __esm({
           "The CI's setup and test commands an org admin or CI owner typed, runtime versions, the runner image and the CLI version."
         ],
         calibration_runs: ["operational", "Exit codes of the test runs."],
-        calibration_run_ref: ["not-personal", "A link to the customer's CI run."]
+        calibration_run_ref: ["not-personal", "A link to the customer's CI run."],
+        review_state: [
+          "operational",
+          "Closed CHECK vocabulary (approved, excluded)."
+        ]
       }),
       ...exchangeExclusions(INTEL, "problem_family_members", {
         process_id: [
@@ -26570,6 +26602,15 @@ var init_table_registry = __esm({
       entry("intelligence", INTELLIGENCE_DB, "stored_replay_tasks", "direct", {
         scopingColumn: "organization_id"
       }),
+      entry("intelligence", INTELLIGENCE_DB, "replay_task_results", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      entry("intelligence", INTELLIGENCE_DB, "replay_sessions", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      entry("intelligence", INTELLIGENCE_DB, "replay_session_calls", "direct", {
+        scopingColumn: "organization_id"
+      }),
       // A person's revert verdicts, the checks that validate a change and the
       // replay commands, per repository (outcome evidence v2 plan).
       entry("intelligence", INTELLIGENCE_DB, "revert_labels", "direct", {
@@ -83591,7 +83632,7 @@ function resolveToken3() {
   return null;
 }
 function triggerCollectInBackground() {
-  if (isCollecting) return;
+  if (isCollecting || REPLAY_SESSION) return;
   isCollecting = true;
   collect({}).then(() => {
     lastCollectTime = Date.now();
@@ -83608,7 +83649,8 @@ function maybeCollect() {
 async function apiGet2(path2, options) {
   const headers = {
     Authorization: `Bearer ${TOKEN}`,
-    ...options?.extraHeaders
+    ...options?.extraHeaders,
+    ...REPLAY_HEADERS
   };
   const response = await fetchWithTimeout(`${API_URL}/api/v1${path2}`, {
     headers
@@ -83623,7 +83665,8 @@ async function apiPost(path2, body, options) {
   const headers = {
     Authorization: `Bearer ${TOKEN}`,
     "Content-Type": "application/json",
-    ...options?.extraHeaders
+    ...options?.extraHeaders,
+    ...REPLAY_HEADERS
   };
   const response = await fetchWithTimeout(`${API_URL}/api/v1${path2}`, {
     method: "POST",
@@ -83668,7 +83711,7 @@ async function main3() {
   }
   warmupInBackground();
 }
-var import_dotenv3, import_path5, import_fs6, import_os5, DEFAULT_API_URL3, CREDENTIALS_FILE5, API_URL, AGENT_SOURCE, DEFAULT_SOURCE_TOOL, TOKEN, contextSchema, isCollecting, lastCollectTime, COLLECT_COOLDOWN_MS, mcpServer, server;
+var import_dotenv3, import_path5, import_fs6, import_os5, DEFAULT_API_URL3, CREDENTIALS_FILE5, API_URL, REPLAY_SESSION, REPLAY_HEADERS, AGENT_SOURCE, DEFAULT_SOURCE_TOOL, TOKEN, contextSchema, isCollecting, lastCollectTime, COLLECT_COOLDOWN_MS, mcpServer, server;
 var init_mcp_server2 = __esm({
   "../service-capture/agent-sessions/mcp-server.ts"() {
     "use strict";
@@ -83687,6 +83730,10 @@ var init_mcp_server2 = __esm({
     DEFAULT_API_URL3 = SERVICE_URL_DEFAULTS.haansiApiBaseUrl;
     CREDENTIALS_FILE5 = (0, import_path5.join)((0, import_os5.homedir)(), ".haansi", "credentials.json");
     API_URL = process.env.HAANSI_API_URL ?? DEFAULT_API_URL3;
+    REPLAY_SESSION = /^[0-9a-f-]{36}$/i.test(
+      process.env.HAANSI_REPLAY_SESSION?.trim() ?? ""
+    ) ? process.env.HAANSI_REPLAY_SESSION.trim() : null;
+    REPLAY_HEADERS = REPLAY_SESSION ? { "X-Haansi-Replay-Session": REPLAY_SESSION } : {};
     AGENT_SOURCE = process.env.HAANSI_AGENT_SOURCE?.toLowerCase();
     DEFAULT_SOURCE_TOOL = AGENT_SOURCE === "codex" ? "codex-mcp" : "claude-code-mcp";
     TOKEN = resolveToken3();
@@ -83907,6 +83954,13 @@ var init_mcp_server2 = __esm({
             };
           }
           case "save_solution": {
+            if (REPLAY_SESSION) {
+              return {
+                content: [
+                  { type: "text", text: "Not saved: nothing is recorded here." }
+                ]
+              };
+            }
             const {
               problem_description,
               solution_summary,
@@ -85201,8 +85255,11 @@ __export(replay_calibrate_exports, {
   RUNTIMES: () => RUNTIMES,
   calibrate: () => calibrate,
   calibrateTask: () => calibrateTask,
+  calibrateTaskOptions: () => calibrateTaskOptions,
+  cliVersion: () => cliVersion,
   environmentOf: () => environmentOf,
   parseCalibrateArgs: () => parseCalibrateArgs,
+  repositoryOf: () => repositoryOf,
   runCalibration: () => runCalibration,
   runnerOf: () => runnerOf
 });
@@ -85245,6 +85302,19 @@ function parseCalibrateArgs(argv) {
     errors.push("--timeout-min must be a positive number.");
   return { options, errors };
 }
+function calibrateTaskOptions(run3, commands) {
+  return {
+    setupCmd: commands.setupCmd,
+    testCmd: commands.testCmd,
+    repoCommands: false,
+    runs: 2,
+    force: false,
+    limit: run3.limit,
+    timeoutMs: run3.timeoutMs,
+    runRef: run3.runRef,
+    dryRun: run3.dryRun
+  };
+}
 function runnerOf(env) {
   if (env.ImageOS && env.ImageVersion)
     return `${env.ImageOS}-${env.ImageVersion}`;
@@ -85357,12 +85427,16 @@ async function calibrateTask(deps, options, commands, task) {
   }
   return done("fails_at_base_passes_at_target");
 }
-async function runCalibration(options, deps) {
+async function repositoryOf(deps) {
   const remote = await deps.git(["remote", "get-url", "origin"], deps.repoDir);
   const repository = remote.code === 0 ? repositoryFromRemote(remote.output) : null;
   if (!repository)
     throw new Error("Run from a clone of the repository (no origin remote).");
-  const set2 = await deps.getReplaySet(repository);
+  return repository;
+}
+async function runCalibration(options, deps, preloaded) {
+  const repository = await repositoryOf(deps);
+  const set2 = preloaded ?? await deps.getReplaySet(repository);
   const repo = options.repoCommands ? set2.repoCommands : null;
   const setupCmd = options.setupCmd ?? repo?.setupCommand ?? null;
   const testCmd = options.testCmd || repo?.testCommand || "";
@@ -85372,17 +85446,12 @@ async function runCalibration(options, deps) {
     );
   const environment = await environmentOf(deps, { setupCmd, testCmd });
   const calibrations = [];
+  const states = /* @__PURE__ */ new Map();
   let reused = 0;
   let skipped = 0;
   const tasks = options.limit ? set2.tasks.slice(0, options.limit) : set2.tasks;
   for (const task of tasks) {
     const label = task.name ?? task.taskKey;
-    const c = task.calibration;
-    if (!options.force && c && c.inputsFingerprint === task.inputsFingerprint && c.envFingerprint === environment.fingerprint) {
-      reused += 1;
-      deps.log(`= ${c.state.padEnd(7)} ${label} (calibrated already)`);
-      continue;
-    }
     if (!SHA.test(task.baseSha) || !SHA.test(task.targetSha)) {
       skipped += 1;
       deps.log(`skip ${label}: its commits are not commit ids`);
@@ -85400,6 +85469,13 @@ async function runCalibration(options, deps) {
       deps.log(`skip ${label}: a test path is not usable`);
       continue;
     }
+    const c = task.calibration;
+    if (!options.force && c && c.inputsFingerprint === task.inputsFingerprint && c.envFingerprint === environment.fingerprint) {
+      reused += 1;
+      states.set(task.taskId, c.state);
+      deps.log(`= ${c.state.padEnd(7)} ${label} (calibrated already)`);
+      continue;
+    }
     if (!await ensureCommit(deps, task.baseSha) || !await ensureCommit(deps, task.targetSha)) {
       skipped += 1;
       deps.log(`skip ${label}: its commits are not reachable from origin`);
@@ -85412,12 +85488,13 @@ async function runCalibration(options, deps) {
       task
     );
     calibrations.push(result);
+    states.set(task.taskId, result.state);
     deps.log(
       `${result.state.padEnd(7)} ${label}: ${result.reason.replace(/_/g, " ")} (base ${result.runs.base.join(",") || "-"}; target ${result.runs.target.join(",") || "-"})`
     );
   }
   if (options.dryRun || calibrations.length === 0)
-    return { calibrations, reused, skipped, recorded: null };
+    return { calibrations, reused, skipped, recorded: null, states };
   let recorded = 0;
   for (let i = 0; i < calibrations.length; i += REPORT_CHUNK) {
     const out = await deps.report({
@@ -85431,7 +85508,7 @@ async function runCalibration(options, deps) {
         `Haansi did not record ${out.refused.length} calibration(s): their task changed since it was listed.`
       );
   }
-  return { calibrations, reused, skipped, recorded };
+  return { calibrations, reused, skipped, recorded, states };
 }
 async function calibrate(argv) {
   if (argv.includes("--help")) {
@@ -85526,6 +85603,227 @@ them all.`;
   }
 });
 
+// src/commands/replay-tasks.ts
+var replay_tasks_exports = {};
+__export(replay_tasks_exports, {
+  HAANSI_LINE: () => HAANSI_LINE,
+  areaOf: () => areaOf,
+  cardPrompt: () => cardPrompt,
+  changedFiles: () => changedFiles,
+  haansiText: () => haansiText,
+  haansiUseOf: () => haansiUseOf,
+  mcpConfig: () => mcpConfig,
+  overlapOf: () => overlapOf,
+  runStoredReplays: () => runStoredReplays
+});
+function cardPrompt(task, feedback, arm = "baseline") {
+  return [
+    "# Task",
+    "",
+    task.card.problem,
+    "",
+    "## Done when",
+    "",
+    task.card.acceptance,
+    ...task.card.area ? ["", "## Part of the code", "", task.card.area] : [],
+    "",
+    ...arm === "haansi" ? [HAANSI_LINE, ""] : [],
+    ...feedback ? [FEEDBACK_HEADER, "", "```", feedback, "```", ""] : [],
+    "Work in this repository as it is now. Do not look at later commits or other branches."
+  ].join("\n");
+}
+function mcpConfig(arm, session) {
+  if (arm !== "haansi" || !session) return JSON.stringify({ mcpServers: {} });
+  const base = session.apiUrl.replace(/\/+$/, "");
+  return JSON.stringify(
+    {
+      mcpServers: {
+        "haansi-solutions": {
+          command: "haansi",
+          args: ["mcp-server"],
+          env: {
+            HAANSI_API_URL: base,
+            HAANSI_TOKEN: session.token,
+            HAANSI_REPLAY_SESSION: session.sessionId
+          }
+        },
+        "haansi-skills": {
+          type: "http",
+          url: `${base}/api/v1/memory/skills/mcp`,
+          headers: {
+            Authorization: `Bearer ${session.token}`,
+            "X-Haansi-Replay-Session": session.sessionId
+          }
+        }
+      }
+    },
+    null,
+    2
+  );
+}
+function areaOf(path2) {
+  const dirs = path2.split("/").slice(0, -1);
+  return dirs.length ? dirs.slice(0, 2).join("/") : ".";
+}
+async function changedFiles(deps, dir, baseSha) {
+  const lines = (out) => out.code === 0 ? out.output.split("\n").map((l) => l.trim()).filter(Boolean) : [];
+  const diff = await deps.git(
+    ["diff", "--name-only", "--no-renames", baseSha],
+    dir
+  );
+  const added = await deps.git(
+    ["ls-files", "--others", "--exclude-standard"],
+    dir
+  );
+  return [.../* @__PURE__ */ new Set([...lines(diff), ...lines(added)])].filter((f) => !f.startsWith(".haansi-replay/")).sort();
+}
+function overlapOf(changed, task) {
+  const tests = new Set(task.testFiles);
+  const mine = new Set(changed.filter((f) => !tests.has(f)));
+  const theirs = new Set(task.targetFiles.filter((f) => !tests.has(f)));
+  const both = [...mine].filter((f) => theirs.has(f)).length;
+  const myAreas = new Set([...mine].map(areaOf));
+  const theirAreas = new Set([...theirs].map(areaOf));
+  const bothAreas = [...myAreas].filter((a) => theirAreas.has(a)).length;
+  const known = mine.size > 0 && theirs.size > 0;
+  return {
+    filePrecision: known ? share(both, mine.size) : null,
+    fileRecall: known ? share(both, theirs.size) : null,
+    areaPrecision: known ? share(bothAreas, myAreas.size) : null,
+    areaRecall: known ? share(bothAreas, theirAreas.size) : null,
+    changedFiles: mine.size
+  };
+}
+async function runStoredReplays(options, deps) {
+  const repository = await repositoryOf(deps);
+  const set2 = await deps.getReplaySet(repository);
+  const repo = options.repoCommands ? set2.repoCommands : null;
+  const setupCmd = options.setupCmd ?? repo?.setupCommand ?? null;
+  const testCmd = options.testCmd || repo?.testCommand || "";
+  if (!testCmd)
+    throw new Error(
+      `No test command: pass --test-cmd, or set one for ${repository} in Haansi.`
+    );
+  if (set2.tasks.length === 0) {
+    deps.log(
+      `No replay tasks for ${repository} yet: they need a card (replay task cards on for the organization).`
+    );
+    return { results: [], notValid: 0, recorded: null };
+  }
+  const { states } = await runCalibration(
+    calibrateTaskOptions(options, { setupCmd, testCmd }),
+    { ...deps, report: deps.reportCalibration },
+    set2
+  );
+  const valid = set2.tasks.filter(
+    (t) => states.get(t.taskId) === "valid" && t.testFiles.length > 0 && t.testFiles.every(safeTestFile) && SHA.test(t.baseSha) && SHA.test(t.targetSha)
+  );
+  const notValid = set2.tasks.length - valid.length;
+  const arms = options.arms;
+  const chosen = options.limit ? valid.slice(0, options.limit) : valid;
+  const results = [];
+  for (const task of chosen) {
+    const label = task.name ?? task.taskKey;
+    const asTask = {
+      taskId: task.taskId,
+      // Names the clone's directory.
+      processId: task.taskId,
+      name: label,
+      repository: task.repository,
+      baseSha: task.baseSha,
+      targetPr: task.targetPr,
+      targetSha: task.targetSha,
+      testFiles: task.testFiles,
+      context: []
+    };
+    for (const arm of arms) {
+      let changed = [];
+      try {
+        const session = arm === "haansi" ? {
+          ...await deps.openSession(task.taskId),
+          apiUrl: deps.apiUrl,
+          token: deps.token
+        } : null;
+        const configPath = `${deps.workDir()}/${task.taskId}-${arm}.mcp.json`;
+        deps.writeFile(configPath, mcpConfig(arm, session));
+        const r = await replayArm(
+          deps,
+          { ...options, setupCmd, testCmd },
+          asTask,
+          arm,
+          null,
+          (feedback) => cardPrompt(task, feedback, arm),
+          async (dir) => {
+            changed = await changedFiles(deps, dir, task.baseSha);
+          },
+          { HAANSI_REPLAY_MCP_CONFIG: configPath }
+        );
+        deps.removeFile(configPath);
+        const haansi = session ? haansiUseOf((await deps.getCalls(session.sessionId)).calls) : null;
+        const overlap = overlapOf(changed, task);
+        results.push({
+          taskId: task.taskId,
+          cardVersion: task.card.version,
+          inputsFingerprint: task.inputsFingerprint,
+          arm,
+          passed: r.passed,
+          attempts: r.attempts,
+          maxAttempts: r.maxAttempts,
+          durationMs: r.durationMs,
+          overlap,
+          haansi
+        });
+        deps.log(
+          `${r.passed ? "pass" : "fail"} ${arm.padEnd(8)} ${label} (${r.attempts}/${r.maxAttempts} attempts; files ${pct(overlap.fileRecall)} of the target's, ${pct(overlap.filePrecision)} of its own on target${haansi ? `; ${haansiText(haansi)}` : ""})`
+        );
+      } catch (err2) {
+        deps.log(
+          `error ${arm} ${label}: ${err2 instanceof Error ? err2.message : String(err2)}`
+        );
+      }
+    }
+  }
+  if (options.dryRun || results.length === 0)
+    return { results, notValid, recorded: null };
+  let recorded = 0;
+  for (let i = 0; i < results.length; i += REPORT_CHUNK2) {
+    const out = await deps.reportResults({
+      agent: options.agentName,
+      model: options.model,
+      runRef: options.runRef,
+      results: results.slice(i, i + REPORT_CHUNK2)
+    });
+    recorded += out.recorded;
+    if (out.refused.length)
+      deps.log(
+        `Haansi did not record ${out.refused.length} result(s): their task's card or inputs changed during the run.`
+      );
+  }
+  return { results, notValid, recorded };
+}
+function haansiUseOf(calls) {
+  return {
+    calls: calls.length,
+    returned: calls.reduce((n, c) => n + c.returnedIds.length, 0)
+  };
+}
+function haansiText(use) {
+  return use.calls === 0 ? "did not call Haansi" : `called Haansi ${use.calls}\xD7, ${use.returned} item${use.returned === 1 ? "" : "s"} returned`;
+}
+var FEEDBACK_HEADER, REPORT_CHUNK2, HAANSI_LINE, share, pct;
+var init_replay_tasks = __esm({
+  "src/commands/replay-tasks.ts"() {
+    "use strict";
+    init_replay_calibrate();
+    init_replay();
+    FEEDBACK_HEADER = "Your previous attempt did not pass the tests. Their output ends with:";
+    REPORT_CHUNK2 = 200;
+    HAANSI_LINE = "Haansi's MCP servers are available to you: they give access to your organization's knowledge (solutions to past problems, team skills, digests, guides and Exchange). Use them if they help.";
+    share = (part, whole) => whole === 0 ? null : Math.round(part / whole * 1e3) / 1e3;
+    pct = (v) => v === null ? "n/a" : `${Math.round(v * 100)}%`;
+  }
+});
+
 // src/commands/replay.ts
 var replay_exports = {};
 __export(replay_exports, {
@@ -85585,8 +85883,8 @@ function parseReplayArgs(argv) {
     else if (!sub && !a.startsWith("-")) sub = a;
     else errors.push(`Unknown option: ${a}`);
   }
-  if (!/^[0-9a-f-]{36}$/i.test(options.familyId))
-    errors.push("--family <id> is required (the family's id).");
+  if (options.familyId && !/^[0-9a-f-]{36}$/i.test(options.familyId))
+    errors.push("--family must be a family's id.");
   if (!options.agentCmd) errors.push("--agent-cmd is required.");
   if (!options.testCmd && !options.repoCommands)
     errors.push(
@@ -85694,7 +85992,7 @@ async function cleanClone(deps, dir, sha, unreachable) {
 function cleanCheckout(deps, dir, task) {
   return cleanClone(deps, dir, task.baseSha, task.targetSha);
 }
-async function replayArm(deps, options, task, arm, playbook) {
+async function replayArm(deps, options, task, arm, playbook, promptOf = (feedback) => replayPrompt(task, arm, feedback), inspect, agentEnv = {}) {
   const started = deps.now();
   const dir = (0, import_node_path10.join)(
     deps.workDir(),
@@ -85723,6 +86021,11 @@ async function replayArm(deps, options, task, arm, playbook) {
       deps.log(`\u2026 ${label}: set up in ${since(at)}`);
     }
     const promptFile = (0, import_node_path10.join)(dir, ".haansi-replay", "prompt.md");
+    let mcpConfigFile = agentEnv.HAANSI_REPLAY_MCP_CONFIG;
+    if (!mcpConfigFile) {
+      mcpConfigFile = `${dir}.mcp.json`;
+      deps.writeFile(mcpConfigFile, JSON.stringify({ mcpServers: {} }));
+    }
     if (arm === "haansi" && playbook)
       deps.writeFile(
         (0, import_node_path10.join)(dir, ".haansi-replay", "playbook.md"),
@@ -85730,7 +86033,7 @@ async function replayArm(deps, options, task, arm, playbook) {
       );
     let feedback = null;
     for (let attempt = 1; attempt <= options.attempts; attempt++) {
-      const prompt2 = replayPrompt(task, arm, feedback);
+      const prompt2 = promptOf(feedback);
       deps.writeFile(promptFile, prompt2);
       const agentAt = deps.now();
       deps.log(
@@ -85739,7 +86042,12 @@ async function replayArm(deps, options, task, arm, playbook) {
       await deps.shell(
         options.agentCmd,
         dir,
-        { HAANSI_REPLAY_PROMPT: prompt2, HAANSI_REPLAY_PROMPT_FILE: promptFile },
+        {
+          ...agentEnv,
+          HAANSI_REPLAY_MCP_CONFIG: mcpConfigFile,
+          HAANSI_REPLAY_PROMPT: prompt2,
+          HAANSI_REPLAY_PROMPT_FILE: promptFile
+        },
         options.timeoutMs
       );
       const own = new Map(files.map((f) => [f, deps.readFile((0, import_node_path10.join)(dir, f))]));
@@ -85764,6 +86072,7 @@ async function replayArm(deps, options, task, arm, playbook) {
           deps.log(`    ${line}`);
       }
       if (test.code === 0) {
+        if (inspect) await inspect(dir);
         return {
           processId: task.processId,
           arm,
@@ -85780,6 +86089,7 @@ async function replayArm(deps, options, task, arm, playbook) {
       }
       feedback = test.output.slice(-FEEDBACK_CHARS);
     }
+    if (inspect) await inspect(dir);
     return {
       processId: task.processId,
       arm,
@@ -85791,6 +86101,7 @@ async function replayArm(deps, options, task, arm, playbook) {
     };
   } finally {
     deps.removeDir(dir);
+    if (!agentEnv.HAANSI_REPLAY_MCP_CONFIG) deps.removeFile(`${dir}.mcp.json`);
   }
 }
 async function runReplays(options, deps) {
@@ -85949,6 +86260,10 @@ async function replay(argv) {
   }
   const token = resolveToken5();
   const apiUrl2 = apiUrl();
+  if (!options.familyId) {
+    await replayStored(options, token, apiUrl2);
+    return;
+  }
   const work = (0, import_node_fs11.mkdtempSync)((0, import_node_path10.join)((0, import_node_os10.tmpdir)(), "haansi-replay-"));
   try {
     const { results, skipped, recorded } = await runReplays(options, {
@@ -85983,6 +86298,64 @@ Baseline: ${passed("baseline")}/${ran("baseline")} passed \xB7 With Haansi: ${pa
     (0, import_node_fs11.rmSync)(work, { recursive: true, force: true });
   }
 }
+async function replayStored(options, token, apiUrl2) {
+  const { runStoredReplays: runStoredReplays2 } = await Promise.resolve().then(() => (init_replay_tasks(), replay_tasks_exports));
+  const { cliVersion: cliVersion2 } = await Promise.resolve().then(() => (init_replay_calibrate(), replay_calibrate_exports));
+  const work = (0, import_node_fs11.mkdtempSync)((0, import_node_path10.join)((0, import_node_os10.tmpdir)(), "haansi-replay-"));
+  try {
+    const { results, notValid, recorded } = await runStoredReplays2(options, {
+      ...localDeps(work),
+      getReplaySet: (repository) => apiGet3(
+        `/memory/replays/tasks?repository=${encodeURIComponent(repository)}`,
+        token,
+        apiUrl2
+      ),
+      reportCalibration: async (body) => await apiPost2(
+        "/memory/replays/tasks/calibration",
+        body,
+        token,
+        apiUrl2
+      ),
+      reportResults: async (body) => await apiPost2(
+        "/memory/replays/tasks/results",
+        body,
+        token,
+        apiUrl2
+      ),
+      env: process.env,
+      cliVersion: cliVersion2(),
+      openSession: async (taskId) => await apiPost2(
+        `/memory/replays/tasks/${encodeURIComponent(taskId)}/sessions`,
+        {},
+        token,
+        apiUrl2
+      ),
+      getCalls: (sessionId) => apiGet3(
+        `/memory/replays/sessions/${encodeURIComponent(sessionId)}/calls`,
+        token,
+        apiUrl2
+      ),
+      apiUrl: apiUrl2,
+      token
+    });
+    const arm = (a) => {
+      const mine = results.filter((r) => r.arm === a);
+      return `${mine.filter((r) => r.passed).length}/${mine.length}`;
+    };
+    console.log(
+      `
+Baseline: ${arm("baseline")} passed \xB7 With Haansi: ${arm("haansi")} passed \xB7 ${notValid} task(s) not valid to replay`
+    );
+    console.log(
+      recorded === null ? options.dryRun ? "Dry run: nothing reported." : "Nothing to report." : `Reported ${recorded} result(s) to Haansi.`
+    );
+  } catch (err2) {
+    console.error(err2 instanceof Error ? err2.message : String(err2));
+    process.exitCode = 1;
+  } finally {
+    (0, import_node_fs11.rmSync)(work, { recursive: true, force: true });
+  }
+}
 var import_node_child_process4, import_node_fs11, import_node_os10, import_node_path10, SHA, ARMS, FEEDBACK_CHARS, FAILURE_LINES2, REPLAY_BRANCH, USAGE2;
 var init_replay = __esm({
   "src/commands/replay.ts"() {
@@ -85998,7 +86371,7 @@ var init_replay = __esm({
     FEEDBACK_CHARS = 6e3;
     FAILURE_LINES2 = 8;
     REPLAY_BRANCH = "replay";
-    USAGE2 = `Usage: haansi replay run --family <id> --agent-cmd "<cmd>" --test-cmd "<cmd>"
+    USAGE2 = `Usage: haansi replay run [--family <id>] --agent-cmd "<cmd>" --test-cmd "<cmd>"
                          [--setup-cmd "<cmd>"] [--attempts 3] [--arms baseline,haansi] [--limit n]
                          [--cutoff <date>] [--timeout-min 30]
                          [--agent-name <name>] [--model <name>] [--run-ref <url>] [--dry-run]
@@ -86006,12 +86379,17 @@ var init_replay = __esm({
 
        haansi replay calibrate --test-cmd "<cmd>" [--setup-cmd "<cmd>"] (see --help)
 
+Without --family, runs this repository's stored replay tasks: calibrates them
+first, then replays the valid ones with their task card as the prompt, graded
+by the target's tests and where the change landed. With --family, replays that
+problem family's tasks with and without its playbook.
+
 --repo-commands uses the setup and test commands an org admin set for the
 repository in Haansi (Settings \u2192 Data sources) for any not given here.
 
 Run from a clone of the repository. Example (GitHub Actions):
   haansi replay run --family "$FAMILY_ID" --setup-cmd 'npm ci' \\
-    --agent-cmd 'claude -p "$HAANSI_REPLAY_PROMPT" --permission-mode acceptEdits' \\
+    --agent-cmd 'claude -p "$HAANSI_REPLAY_PROMPT" --permission-mode acceptEdits --mcp-config "$HAANSI_REPLAY_MCP_CONFIG"' \\
     --test-cmd 'npx vitest run $HAANSI_REPLAY_TEST_FILES' \\
     --agent-name claude-code --model claude-sonnet-5-5`;
   }
@@ -86231,9 +86609,10 @@ Commands:
                              digest. [--date YYYY-MM-DD] [--workstream <id>]
   digest [--week|--month|--since YYYY-MM-DD]
                              Your weekly digest (default: the latest week)
-  replay run --family <id> --agent-cmd "<cmd>" --test-cmd "<cmd>"
-                             Replay a problem family's tasks in your CI, with and
-                             without its playbook, and report the results
+  replay run --agent-cmd "<cmd>" --test-cmd "<cmd>" [--family <id>]
+                             Replay this repository's tasks in your CI (or a
+                             problem family's, with and without its playbook)
+                             and report the results
   replay calibrate --test-cmd "<cmd>"
                              Check this repository's replay tasks are valid: their
                              tests fail at the start and pass at the fix

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "haansi",
-  "version": "0.1.55",
+  "version": "0.1.57",
   "description": "Haansi CLI - Session collector and MCP server for Claude Code & OpenAI Codex",
   "bin": {
     "haansi": "./dist/haansi.js"