@inetafrica/open-claudia 2.14.8 → 3.0.0

package/test-fixtures/current-provider-parity.json

@@ -0,0 +1,132 @@
+{
+  "schemaVersion": 1,
+  "sourceCommit": "6de1711",
+  "purpose": "Green characterization of known provider-parity defects; owning tasks must invert these assertions before fixing them.",
+  "generated": false,
+  "environmentValuesCaptured": false,
+  "prompt": {
+    "knownDefect": true,
+    "invertInTask": 8,
+    "sentinel": "OPEN_CLAUDIA_PROMPT_PARITY_SENTINEL",
+    "observed": "raw-user-prompt-only",
+    "target": "provider-neutral core instructions plus dynamic context plus the user sentinel"
+  },
+  "environment": {
+    "knownDefect": true,
+    "invertInTask": 4,
+    "capture": "boolean-key-presence-only",
+    "keys": [
+      "AGENTSPACE_POD_TOKEN",
+      "ANTHROPIC_API_KEY",
+      "BOT_CONTROL_TOKEN",
+      "CLAUDE_CODE_OAUTH_TOKEN",
+      "CLAUDE_CONFIG_DIR",
+      "CODEX_HOME",
+      "CURSOR_API_KEY",
+      "ELEVENLABS_API_KEY",
+      "KAZEE_BOT_TOKEN",
+      "OC_SEND_TOKEN",
+      "OPENAI_API_KEY",
+      "OPEN_CLAUDIA_KEYRING_CANARY",
+      "TELEGRAM_BOT_TOKEN",
+      "VOICE_BRIDGE_TOKEN",
+      "WEB_PASSWORD"
+    ],
+    "observed": {
+      "claude": {
+        "AGENTSPACE_POD_TOKEN": true,
+        "ANTHROPIC_API_KEY": true,
+        "BOT_CONTROL_TOKEN": false,
+        "CLAUDE_CODE_OAUTH_TOKEN": true,
+        "CLAUDE_CONFIG_DIR": true,
+        "CODEX_HOME": true,
+        "CURSOR_API_KEY": true,
+        "ELEVENLABS_API_KEY": true,
+        "KAZEE_BOT_TOKEN": false,
+        "OC_SEND_TOKEN": true,
+        "OPENAI_API_KEY": true,
+        "OPEN_CLAUDIA_KEYRING_CANARY": true,
+        "TELEGRAM_BOT_TOKEN": false,
+        "VOICE_BRIDGE_TOKEN": true,
+        "WEB_PASSWORD": true
+      },
+      "codex": {
+        "AGENTSPACE_POD_TOKEN": true,
+        "ANTHROPIC_API_KEY": true,
+        "BOT_CONTROL_TOKEN": false,
+        "CLAUDE_CODE_OAUTH_TOKEN": true,
+        "CLAUDE_CONFIG_DIR": true,
+        "CODEX_HOME": true,
+        "CURSOR_API_KEY": true,
+        "ELEVENLABS_API_KEY": true,
+        "KAZEE_BOT_TOKEN": false,
+        "OC_SEND_TOKEN": true,
+        "OPENAI_API_KEY": true,
+        "OPEN_CLAUDIA_KEYRING_CANARY": true,
+        "TELEGRAM_BOT_TOKEN": false,
+        "VOICE_BRIDGE_TOKEN": true,
+        "WEB_PASSWORD": true
+      }
+    },
+    "target": {
+      "claude": {
+        "AGENTSPACE_POD_TOKEN": false,
+        "ANTHROPIC_API_KEY": true,
+        "BOT_CONTROL_TOKEN": false,
+        "CLAUDE_CODE_OAUTH_TOKEN": true,
+        "CLAUDE_CONFIG_DIR": true,
+        "CODEX_HOME": false,
+        "CURSOR_API_KEY": false,
+        "ELEVENLABS_API_KEY": false,
+        "KAZEE_BOT_TOKEN": false,
+        "OC_SEND_TOKEN": false,
+        "OPENAI_API_KEY": false,
+        "OPEN_CLAUDIA_KEYRING_CANARY": false,
+        "TELEGRAM_BOT_TOKEN": false,
+        "VOICE_BRIDGE_TOKEN": false,
+        "WEB_PASSWORD": false
+      },
+      "codex": {
+        "AGENTSPACE_POD_TOKEN": false,
+        "ANTHROPIC_API_KEY": false,
+        "BOT_CONTROL_TOKEN": false,
+        "CLAUDE_CODE_OAUTH_TOKEN": false,
+        "CLAUDE_CONFIG_DIR": false,
+        "CODEX_HOME": true,
+        "CURSOR_API_KEY": false,
+        "ELEVENLABS_API_KEY": false,
+        "KAZEE_BOT_TOKEN": false,
+        "OC_SEND_TOKEN": false,
+        "OPENAI_API_KEY": true,
+        "OPEN_CLAUDIA_KEYRING_CANARY": false,
+        "TELEGRAM_BOT_TOKEN": false,
+        "VOICE_BRIDGE_TOKEN": false,
+        "WEB_PASSWORD": false
+      }
+    },
+    "scopedRuntimeTokenDecision": "Task 4 must remove ambient OC_SEND_TOKEN; any later delivery capability must be explicitly scoped without restoring generic provider credential inheritance.",
+    "securityScope": "Environment isolation only; native same-UID child processes are not filesystem-isolated."
+  },
+  "codexResumedPlan": {
+    "knownDefect": true,
+    "invertInTask": 7,
+    "sessionId": "resume-session-sentinel",
+    "promptSentinel": "OPEN_CLAUDIA_PROMPT_PARITY_SENTINEL",
+    "observedArgv": [
+      "exec",
+      "resume",
+      "resume-session-sentinel",
+      "--json",
+      "--skip-git-repo-check",
+      "--sandbox",
+      "read-only",
+      "OPEN_CLAUDIA_PROMPT_PARITY_SENTINEL"
+    ],
+    "targetConstraints": {
+      "configurationFlag": "-c",
+      "configurationValue": "sandbox_mode=\"read-only\"",
+      "configurationBeforeSessionId": true,
+      "forbiddenResumeFlag": "--sandbox"
+    }
+  }
+}

package/test-fixtures/fake-agent-cli.js

@@ -0,0 +1,477 @@
+#!/usr/bin/env node
+
+"use strict";
+
+// Hermetic stand-in for Claude Code and Codex. Its control surface is entirely
+// environment-driven so production argument builders can invoke it unchanged.
+// Captures deliberately reduce environment inspection to key-presence booleans.
+
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { spawn, spawnSync } = require("child_process");
+
+const argv = process.argv.slice(2);
+const kind = process.env.FAKE_AGENT_KIND;
+const scenario = process.env.FAKE_AGENT_SCENARIO || "success";
+const text = process.env.FAKE_AGENT_TEXT || "fixture says café 👋";
+let invocationCapturePath = null;
+let invocationCapture = null;
+
+const DEFAULT_ENV_KEYS = [
+  "ANTHROPIC_API_KEY",
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "CLAUDE_CONFIG_DIR",
+  "CODEX_HOME",
+  "CURSOR_API_KEY",
+  "OPENAI_API_KEY",
+  "TELEGRAM_BOT_TOKEN",
+  "KAZEE_BOT_TOKEN",
+  "BOT_CONTROL_TOKEN",
+  "OC_SEND_TOKEN",
+  "VOICE_BRIDGE_TOKEN",
+  "ELEVENLABS_API_KEY",
+  "AGENTSPACE_POD_TOKEN",
+  "WEB_PASSWORD",
+  "OPEN_CLAUDIA_KEYRING_CANARY",
+];
+
+function integerControl(name, fallback, { min = 0, max = 60000 } = {}) {
+  if (process.env[name] == null || process.env[name] === "") return fallback;
+  const value = Number(process.env[name]);
+  if (!Number.isSafeInteger(value) || value < min || value > max) {
+    throw new Error(`${name} must be an integer from ${min} to ${max}`);
+  }
+  return value;
+}
+
+function boolControl(name, fallback = false) {
+  if (process.env[name] == null) return fallback;
+  return /^(?:1|true|yes|on)$/i.test(process.env[name]);
+}
+
+function requestedEnvKeys() {
+  const configured = String(process.env.FAKE_AGENT_ENV_KEYS || "")
+    .split(",")
+    .map((key) => key.trim())
+    .filter(Boolean);
+  const keys = configured.length ? configured : DEFAULT_ENV_KEYS;
+  for (const key of keys) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+      throw new Error(`invalid environment key name: ${key}`);
+    }
+  }
+  return [...new Set(keys)].sort();
+}
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+}
+
+function captureInvocation() {
+  const capturePath = process.env.FAKE_AGENT_CAPTURE;
+  if (!capturePath) return;
+  const envPresence = {};
+  for (const key of requestedEnvKeys()) {
+    envPresence[key] = Object.prototype.hasOwnProperty.call(process.env, key);
+  }
+  invocationCapturePath = capturePath;
+  invocationCapture = { kind, argv, envPresence };
+  writeJson(invocationCapturePath, invocationCapture);
+}
+
+function captureWritePlan(writePlan) {
+  if (!invocationCapturePath) return;
+  invocationCapture = { ...invocationCapture, writePlan };
+  writeJson(invocationCapturePath, invocationCapture);
+}
+
+function captureStdin(stdin) {
+  if (!invocationCapturePath) return;
+  const bytes = Buffer.byteLength(stdin);
+  invocationCapture = {
+    ...invocationCapture,
+    stdin: {
+      present: bytes > 0,
+      bytes,
+      // Content is intentionally never captured. The hash lets tests prove
+      // protected transport without writing prompts or secrets to disk.
+      sha256: bytes ? crypto.createHash("sha256").update(stdin).digest("hex") : null,
+    },
+  };
+  writeJson(invocationCapturePath, invocationCapture);
+}
+
+function configOverrides() {
+  const values = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    if ((argv[index] === "-c" || argv[index] === "--config") && argv[index + 1]) {
+      values.push(argv[index + 1]);
+      index += 1;
+    }
+  }
+  return values;
+}
+
+function hookCommandFromOverride(value) {
+  const match = String(value || "").match(/\bcommand\s*=\s*("(?:\\.|[^"\\])*")/);
+  if (!match) return null;
+  try { return JSON.parse(match[1]); } catch (_) { return null; }
+}
+
+function handleCompatibilityCommand() {
+  if (argv.length === 1 && argv[0] === "--version") {
+    process.stdout.write(kind === "claude" ? "1.2.3\n" : "codex-cli 0.144.0\n");
+    return true;
+  }
+  if (kind === "claude" && argv.length === 1 && argv[0] === "--help") {
+    process.stdout.write("--append-system-prompt --output-format --resume --permission-mode --settings\n");
+    return true;
+  }
+  if (kind === "codex" && (
+    argv.join(" ") === "exec --help" || argv.join(" ") === "exec resume --help"
+  )) {
+    process.stdout.write([
+      "--config", "--json", "--sandbox", "--image", "--model", "--skip-git-repo-check",
+      "--strict-config", "--ignore-user-config", "--dangerously-bypass-hook-trust",
+    ].join(" ") + "\n");
+    return true;
+  }
+  if (kind === "codex" && argv[0] === "features" && argv.at(-1) === "list") {
+    const overrides = configOverrides();
+    process.stdout.write([
+      `hooks stable ${overrides.includes("features.hooks=true")}`,
+      `plugins stable ${!overrides.includes("features.plugins=false")}`,
+      `unified_exec stable ${!overrides.includes("features.unified_exec=false")}`,
+    ].join("\n") + "\n");
+    return true;
+  }
+  return false;
+}
+
+function runHookProbe() {
+  const overrides = configOverrides();
+  const hookOverrides = overrides.filter((value) => value.startsWith("hooks.PreToolUse="));
+  const hookCommand = hookCommandFromOverride(hookOverrides[0]);
+  const generatedOnly = argv.includes("--ignore-user-config")
+    && argv.includes("--strict-config")
+    && argv.includes("--dangerously-bypass-hook-trust")
+    && !argv.includes("--profile")
+    && overrides.includes("features.hooks=true")
+    && overrides.includes("features.plugins=false")
+    && overrides.includes("features.unified_exec=false")
+    && overrides.some((value) => /^projects=\{.+trust_level="untrusted".+\}$/.test(value))
+    && hookOverrides.length === 1
+    && /matcher\s*=\s*"\^Bash\$"/.test(hookOverrides[0]);
+
+  if (!generatedOnly && process.env.FAKE_AGENT_ARBITRARY_HOOK_MARKER) {
+    fs.writeFileSync(process.env.FAKE_AGENT_ARBITRARY_HOOK_MARKER, "untrusted hook executed\n");
+  }
+
+  const command = process.env.OPEN_CLAUDIA_HOOK_PROBE_COMMAND || "printf fixture";
+  const hook = hookCommand
+    ? spawnSync(hookCommand, {
+        shell: true,
+        input: JSON.stringify({ tool_name: "Bash", tool_input: { command } }),
+        encoding: "utf8",
+        env: process.env,
+        timeout: 10000,
+      })
+    : { status: null, stderr: "missing generated hook" };
+  const hookExit = Number.isInteger(hook.status) ? hook.status : null;
+  if (hookExit !== 2) {
+    spawnSync(command, { shell: true, encoding: "utf8", env: process.env, timeout: 10000 });
+  }
+  if (invocationCapturePath) {
+    invocationCapture = {
+      ...invocationCapture,
+      hookProbe: {
+        generatedOnly,
+        hookConfigured: !!hookCommand,
+        hookExit,
+      },
+    };
+    writeJson(invocationCapturePath, invocationCapture);
+  }
+}
+
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+function spawnDescendantFixture() {
+  const capturePath = process.env.FAKE_AGENT_DESCENDANT_CAPTURE;
+  if (!capturePath) return null;
+  const descendantScript = boolControl("FAKE_AGENT_DESCENDANT_IGNORE_SIGTERM")
+    ? "process.on('SIGTERM', () => {}); setInterval(() => {}, 1000)"
+    : "setInterval(() => {}, 1000)";
+  const detached = boolControl("FAKE_AGENT_DESCENDANT_DETACHED");
+  const descendant = spawn(process.execPath, ["-e", descendantScript], {
+    stdio: "ignore",
+    detached,
+  });
+  if (detached) descendant.unref();
+  writeJson(capturePath, { pid: descendant.pid });
+  if (!boolControl("FAKE_AGENT_LEAVE_DESCENDANT")) {
+    process.once("exit", () => {
+      try { descendant.kill("SIGKILL"); } catch (_) {}
+    });
+  }
+  return descendant;
+}
+
+function inferSessionId() {
+  if (process.env.FAKE_AGENT_SESSION_ID) return process.env.FAKE_AGENT_SESSION_ID;
+  if (kind === "claude") {
+    const resumeAt = argv.indexOf("--resume");
+    if (resumeAt >= 0 && argv[resumeAt + 1]) return argv[resumeAt + 1];
+    if (argv.includes("--continue")) return "claude-continued-session";
+    return "claude-fresh-session";
+  }
+  const resumeAt = argv.indexOf("resume");
+  if (resumeAt >= 0) {
+    const optionsWithValues = new Set([
+      "-c", "--config", "-m", "--model", "-s", "--sandbox",
+      "-C", "--cd", "--color", "--add-dir",
+    ]);
+    for (let index = resumeAt + 1; index < argv.length; index += 1) {
+      const value = argv[index];
+      if (optionsWithValues.has(value)) {
+        index += 1;
+        continue;
+      }
+      if (value.startsWith("-")) continue;
+      return value;
+    }
+  }
+  return "codex-fresh-thread";
+}
+
+function claudeEvents(sessionId) {
+  const init = { type: "system", subtype: "init", session_id: sessionId };
+  if (scenario === "auth-failure") {
+    return [
+      init,
+      {
+        type: "result",
+        subtype: "error_during_execution",
+        is_error: true,
+        session_id: sessionId,
+        result: "Authentication failed",
+        errors: ["Authentication failed"],
+      },
+    ];
+  }
+
+  const events = [init];
+  if (boolControl("FAKE_AGENT_TOOL")) {
+    events.push({
+      type: "assistant",
+      message: {
+        role: "assistant",
+        content: [{ type: "tool_use", id: "tool-1", name: "Read", input: { file_path: "fixture.txt" } }],
+      },
+      session_id: sessionId,
+    });
+    events.push({
+      type: "user",
+      message: {
+        role: "user",
+        content: [{ type: "tool_result", tool_use_id: "tool-1", content: "fixture tool output", is_error: false }],
+      },
+      session_id: sessionId,
+    });
+  }
+  events.push({
+    type: "assistant",
+    message: {
+      role: "assistant",
+      content: [{ type: "text", text }],
+      usage: { input_tokens: 12, cache_read_input_tokens: 3, cache_creation_input_tokens: 2, output_tokens: 7 },
+    },
+    session_id: sessionId,
+  });
+  const resultEvent = {
+    type: "result",
+    subtype: "success",
+    is_error: false,
+    session_id: sessionId,
+    result: text,
+    total_cost_usd: 0,
+    usage: { input_tokens: 12, cache_read_input_tokens: 3, cache_creation_input_tokens: 2, output_tokens: 7 },
+  };
+  if (process.env.FAKE_AGENT_STRUCTURED_JSON) {
+    resultEvent.structured_output = JSON.parse(process.env.FAKE_AGENT_STRUCTURED_JSON);
+  }
+  events.push(resultEvent);
+  return events;
+}
+
+function codexEvents(sessionId) {
+  const started = { type: "thread.started", thread_id: sessionId };
+  if (scenario === "auth-failure") {
+    return [
+      started,
+      { type: "error", message: "Authentication failed" },
+      { type: "turn.failed", error: { message: "Authentication failed" } },
+    ];
+  }
+
+  const events = [started, { type: "turn.started" }];
+  if (boolControl("FAKE_AGENT_TOOL")) {
+    const command = {
+      id: "item-1",
+      type: "command_execution",
+      command: "printf fixture",
+      aggregated_output: "",
+      exit_code: null,
+      status: "in_progress",
+    };
+    events.push({ type: "item.started", item: command });
+    events.push({
+      type: "item.completed",
+      item: { ...command, aggregated_output: "fixture", exit_code: 0, status: "completed" },
+    });
+  }
+  events.push({
+    type: "item.completed",
+    item: { id: "item-final", type: "agent_message", text },
+  });
+  events.push({
+    type: "turn.completed",
+    usage: { input_tokens: 12, cached_input_tokens: 3, output_tokens: 7 },
+  });
+  return events;
+}
+
+function sleep(ms) {
+  return ms > 0 ? new Promise((resolve) => setTimeout(resolve, ms)) : Promise.resolve();
+}
+
+async function emitEvents(events) {
+  if (boolControl("FAKE_AGENT_DUPLICATE_TERMINAL") && events.length > 0) {
+    events.push(structuredClone(events.at(-1)));
+  }
+  const ending = process.env.FAKE_AGENT_LINE_ENDING === "crlf" ? "\r\n" : "\n";
+  const finalNewline = process.env.FAKE_AGENT_FINAL_NEWLINE !== "0";
+  const lines = events.map((event) => JSON.stringify(event));
+  const framed = lines.map((line, index) => (
+    line + (index < lines.length - 1 || finalNewline ? ending : "")
+  ));
+  const mode = process.env.FAKE_AGENT_CHUNK_MODE || "lines";
+  const delayMs = integerControl("FAKE_AGENT_CHUNK_DELAY_MS", 0);
+
+  if (mode === "coalesce") {
+    const payload = framed.join("");
+    captureWritePlan({
+      mode,
+      recordCount: events.length,
+      lineEnding: ending === "\r\n" ? "crlf" : "lf",
+      finalNewline,
+      writes: [Buffer.byteLength(payload)],
+    });
+    process.stdout.write(payload);
+    return;
+  }
+  if (mode === "split") {
+    const payload = Buffer.from(framed.join(""), "utf8");
+    const marker = Buffer.from("👋", "utf8");
+    const markerAt = payload.indexOf(marker);
+    const splitAt = markerAt >= 0 ? markerAt + 1 : Math.max(1, Math.floor(payload.length / 2));
+    captureWritePlan({
+      mode,
+      recordCount: events.length,
+      lineEnding: ending === "\r\n" ? "crlf" : "lf",
+      finalNewline,
+      writes: [splitAt, payload.length - splitAt],
+      splitOffset: splitAt,
+      splitInsideUtf8: markerAt >= 0,
+    });
+    process.stdout.write(payload.subarray(0, splitAt));
+    await sleep(delayMs || 10);
+    process.stdout.write(payload.subarray(splitAt));
+    return;
+  }
+  if (mode !== "lines") throw new Error(`unknown FAKE_AGENT_CHUNK_MODE: ${mode}`);
+
+  captureWritePlan({
+    mode,
+    recordCount: events.length,
+    lineEnding: ending === "\r\n" ? "crlf" : "lf",
+    finalNewline,
+    writes: framed.map((frame) => Buffer.byteLength(frame)),
+  });
+  for (const frame of framed) {
+    process.stdout.write(frame);
+    await sleep(delayMs);
+  }
+}
+
+function installSignalControls() {
+  const signalCapture = process.env.FAKE_AGENT_SIGNAL_CAPTURE;
+  const onSignal = (signal) => {
+    if (signalCapture) writeJson(signalCapture, { signal });
+    if (signal === "SIGTERM" && boolControl("FAKE_AGENT_IGNORE_SIGTERM")) return;
+    process.removeAllListeners(signal);
+    process.kill(process.pid, signal);
+  };
+  process.on("SIGTERM", () => onSignal("SIGTERM"));
+  process.on("SIGINT", () => onSignal("SIGINT"));
+}
+
+async function main() {
+  if (kind !== "claude" && kind !== "codex") {
+    throw new Error("FAKE_AGENT_KIND must be claude or codex");
+  }
+  if (handleCompatibilityCommand()) return;
+  captureInvocation();
+  installSignalControls();
+  spawnDescendantFixture();
+  const stdin = await readStdin();
+  captureStdin(stdin);
+
+  if (scenario === "hook-probe") {
+    runHookProbe();
+    process.exitCode = 0;
+    return;
+  }
+
+  const sessionId = inferSessionId();
+  const events = kind === "claude" ? claudeEvents(sessionId) : codexEvents(sessionId);
+  await emitEvents(events);
+
+  if (scenario === "auth-failure") {
+    process.stderr.write(`${kind} authentication failed\n`);
+  }
+  if (process.env.FAKE_AGENT_STDERR) process.stderr.write(process.env.FAKE_AGENT_STDERR);
+
+  const eofDelayMs = integerControl("FAKE_AGENT_EOF_DELAY_MS", 0);
+  await sleep(eofDelayMs);
+  await new Promise((resolve) => process.stdout.end(resolve));
+
+  const closeDelayMs = integerControl("FAKE_AGENT_CLOSE_DELAY_MS", 0);
+  await sleep(closeDelayMs);
+
+  if (scenario === "forced-termination") {
+    setInterval(() => {}, 1000);
+    return;
+  }
+  if (scenario === "auth-failure") {
+    process.exitCode = 1;
+    return;
+  }
+  if (scenario === "non-zero") {
+    process.exitCode = integerControl("FAKE_AGENT_EXIT_CODE", 2, { min: 1, max: 255 });
+    return;
+  }
+  if (scenario !== "success") throw new Error(`unknown FAKE_AGENT_SCENARIO: ${scenario}`);
+  process.exitCode = integerControl("FAKE_AGENT_EXIT_CODE", 0, { min: 0, max: 255 });
+}
+
+main().catch((error) => {
+  process.stderr.write(`fake-agent-cli: ${error.message}\n`);
+  process.exitCode = 64;
+});

package/test-fixtures/migrations/claude-only/jobs.json

@@ -0,0 +1,3 @@
+[
+  { "id": "job-claude", "kind": "wakeup", "project": "alpha", "sessionKey": "lastSessionId", "sessionId": "claude-session-alpha", "prompt": "continue alpha" }
+]

package/test-fixtures/migrations/claude-only/sessions.json

@@ -0,0 +1,5 @@
+{
+  "alpha": [
+    { "id": "claude-session-alpha", "title": "Alpha", "created": "2026-01-01T00:00:00.000Z", "lastUsed": "2026-01-02T00:00:00.000Z" }
+  ]
+}

package/test-fixtures/migrations/claude-only/state.json

@@ -0,0 +1,5 @@
+{
+  "currentSession": { "name": "alpha", "dir": "/workspace/alpha" },
+  "lastSessionId": "claude-session-alpha",
+  "settings": { "backend": "claude", "model": "claude-sonnet" }
+}

package/test-fixtures/migrations/cursor-selected/crons.json

@@ -0,0 +1,3 @@
+[
+  { "id": "legacy-cron", "schedule": "0 9 * * 1-5", "project": "legacy-cursor", "prompt": "legacy cursor status" }
+]

package/test-fixtures/migrations/cursor-selected/jobs.json

@@ -0,0 +1,3 @@
+[
+  { "id": "job-cursor", "kind": "wakeup", "project": "legacy-cursor", "sessionKey": "cursorSessionId", "sessionId": "cursor-session-unresolved", "prompt": "SECRET_SENTINEL_DO_NOT_MANIFEST" }
+]

package/test-fixtures/migrations/cursor-selected/sessions.json

@@ -0,0 +1,5 @@
+{
+  "legacy-cursor": [
+    { "id": "cursor-or-claude-ambiguous", "title": "Do not guess", "created": "2026-03-01T00:00:00.000Z", "lastUsed": "2026-03-02T00:00:00.000Z" }
+  ]
+}

package/test-fixtures/migrations/cursor-selected/state.json

@@ -0,0 +1,6 @@
+{
+  "currentSession": { "name": "legacy-cursor", "dir": "/workspace/legacy-cursor" },
+  "lastSessionId": "claude-neighbor",
+  "cursorSessionId": "cursor-session-unresolved",
+  "settings": { "backend": "cursor", "model": "cursor-model" }
+}

package/test-fixtures/migrations/dual-provider/jobs.json

@@ -0,0 +1,3 @@
+[
+  { "id": "job-codex", "kind": "cron", "project": "parity", "sessionKey": "codexSessionId", "sessionId": "codex-thread-parity", "prompt": "inspect parity" }
+]

package/test-fixtures/migrations/dual-provider/sessions.json

@@ -0,0 +1,7 @@
+{
+  "owner@example.test": {
+    "parity": [
+      { "id": "claude-session-parity", "title": "Parity", "created": "2026-02-01T00:00:00.000Z", "lastUsed": "2026-02-02T00:00:00.000Z" }
+    ]
+  }
+}

package/test-fixtures/migrations/dual-provider/state.json

@@ -0,0 +1,10 @@
+{
+  "users": {
+    "owner@example.test": {
+      "currentSession": { "name": "parity", "dir": "/workspace/parity" },
+      "lastSessionId": "claude-session-parity",
+      "codexSessionId": "codex-thread-parity",
+      "settings": { "backend": "codex", "model": "gpt-fixture" }
+    }
+  }
+}

package/test-fixtures/migrations/malformed-partial/jobs.json

@@ -0,0 +1 @@
+[{"id":"partial-job","kind":"wakeup","project":null

package/test-fixtures/migrations/malformed-partial/sessions.json

@@ -0,0 +1 @@
+{"fallback":[{"id":"truncated-session"

package/test-fixtures/migrations/malformed-partial/sessions.json.bak

@@ -0,0 +1,3 @@
+{
+  "fallback": [{ "id": "fallback-session", "title": "Fallback" }]
+}