recallnest 3.0.0 → 4.0.0

package/src/__tests__/pull-from-macbook-sync-only.test.ts

@@ -1,679 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import {
-  chmodSync,
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  renameSync,
-  statSync,
-  symlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { spawnSync } from "node:child_process";
-
-const REPO_ROOT = resolve(import.meta.dir, "../..");
-const SCRIPT = join(REPO_ROOT, "scripts", "pull-from-macbook.sh");
-const TEST_TIMEOUT_MS = 30_000;
-
-interface Harness {
-  root: string;
-  home: string;
-  remoteHome: string;
-  report: string;
-  rsyncLog: string;
-  sshLog: string;
-  registrarMarker: string;
-  ingestMarker: string;
-  env: NodeJS.ProcessEnv;
-}
-
-interface RsyncCall {
-  args: string[];
-  sourceArg: string;
-  targetArg: string;
-  dryRun: boolean;
-  ignoreTimes: boolean;
-}
-
-function executable(path: string, source: string): void {
-  writeFileSync(path, source, { mode: 0o700 });
-  chmodSync(path, 0o700);
-}
-
-function fixture(path: string, content: string): void {
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, content);
-}
-
-function fakeRsyncSource(): string {
-  return [
-    "#!/usr/bin/env bun",
-    'import { appendFileSync, copyFileSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, renameSync, statSync, symlinkSync, writeFileSync } from "node:fs";',
-    'import { basename, dirname, extname, join, relative, sep } from "node:path";',
-    'const args = process.argv.slice(2);',
-    'const sourceArg = args.at(-2) || "";',
-    'const targetArg = args.at(-1) || "";',
-    'const dryRun = args.includes("--dry-run");',
-    'const ignoreTimes = args.includes("--ignore-times");',
-    'const optionValues = new Set(["-e", "--exclude", "--include", "--out-format", "--rsync-path", "--timeout"]);',
-    'for (let index = 0; index < args.length - 2; index += 1) {',
-    '  const arg = args[index];',
-    '  if (optionValues.has(arg)) { if (index + 1 >= args.length - 2) process.exit(64); index += 1; continue; }',
-    '  if (!arg.startsWith("-")) process.exit(64);',
-    '}',
-    'appendFileSync(process.env.FAKE_RSYNC_LOG, JSON.stringify({ args: args.slice(0, -2), sourceArg, targetArg, dryRun, ignoreTimes }) + "\\n");',
-    'if (!dryRun && process.env.FAKE_CREATE_REPORT_DURING_SYNC && !existsSync(process.env.FAKE_CREATE_REPORT_DURING_SYNC)) writeFileSync(process.env.FAKE_CREATE_REPORT_DURING_SYNC, "racing-writer");',
-    'if (!dryRun && process.env.FAKE_BREAK_MAPPING_TMP) {',
-    '  const report = process.env.FAKE_BREAK_MAPPING_TMP;',
-    '  const prefix = basename(report) + ".tmp.";',
-    '  const temporary = readdirSync(dirname(report))',
-    '    .filter((name) => name.startsWith(prefix) && !name.endsWith(".saved"))',
-    '    .map((name) => join(dirname(report), name))',
-    '    .find((path) => statSync(path).isFile());',
-    '  if (temporary) { renameSync(temporary, temporary + ".saved"); mkdirSync(temporary); }',
-    '}',
-    'if (!sourceArg.startsWith("mac:")) process.exit(64);',
-    'const remoteHome = process.env.FAKE_REMOTE_HOME;',
-    'let remoteRaw = sourceArg.slice(4);',
-    'let sourcePath = remoteRaw;',
-    'if (remoteRaw === "~") sourcePath = remoteHome;',
-    'else if (remoteRaw.startsWith("~/")) sourcePath = join(remoteHome, remoteRaw.slice(2));',
-    'else if (!remoteRaw.startsWith("/")) sourcePath = join(remoteHome, remoteRaw);',
-    'if (!existsSync(sourcePath)) process.exit(23);',
-    'function walk(root) {',
-    '  const files = [];',
-    '  for (const entry of readdirSync(root, { withFileTypes: true })) {',
-    '    const path = join(root, entry.name);',
-    '    if (entry.isDirectory()) files.push(...walk(path));',
-    '    else if (entry.isFile() || entry.isSymbolicLink()) files.push(path);',
-    '  }',
-    '  return files.sort();',
-    '}',
-    'function included(path) {',
-    '  const normalizedSource = sourcePath.split(sep).join("/");',
-    '  const name = basename(path);',
-    '  if (statSync(sourcePath).isFile()) return true;',
-    '  if (normalizedSource.includes("/.gemini/tmp")) return name.startsWith("session-") && extname(name) === ".json";',
-    '  if (normalizedSource.includes("/local-agent-mode-sessions")) return extname(name) === ".jsonl" && name !== "audit.jsonl";',
-    '  if (normalizedSource.includes("/antigravity-cli/brain")) return name === "transcript_full.jsonl";',
-    '  if (normalizedSource.includes("/antigravity-rescue/conversations")) return extname(name) === ".pb";',
-    '  return extname(name) === ".jsonl";',
-    '}',
-    'const sourceIsDirectory = statSync(sourcePath).isDirectory();',
-    'const files = (sourceIsDirectory ? walk(sourcePath) : [sourcePath]).filter(included);',
-    'if (dryRun && !ignoreTimes && process.env.FAKE_RSYNC_MUTATE_ON_VERIFY_SOURCE && sourceArg.includes(process.env.FAKE_RSYNC_MUTATE_ON_VERIFY_SOURCE) && files.length > 0) appendFileSync(files[0], "late-change");',
-    'const prefix = args.some((arg) => arg.includes("__RN_MAP__")) ? "__RN_MAP__" : "__RN_CHANGE__";',
-    'function copySource(source, destination) {',
-    '  mkdirSync(dirname(destination), { recursive: true });',
-    '  if (lstatSync(source).isSymbolicLink()) symlinkSync(readlinkSync(source), destination);',
-    '  else copyFileSync(source, destination);',
-    '}',
-    'const forcedFailure = Boolean(process.env.FAKE_RSYNC_FAIL_SOURCE && sourceArg.includes(process.env.FAKE_RSYNC_FAIL_SOURCE));',
-    'if (!dryRun && forcedFailure && files.length > 0) {',
-    '  const source = files[0];',
-    '  const rel = sourceIsDirectory ? relative(sourcePath, source).split(sep).join("/") : basename(source);',
-    '  const destination = sourceIsDirectory ? join(targetArg, rel) : targetArg;',
-    '  copySource(source, destination);',
-    '  process.exit(23);',
-    '}',
-    'for (const source of files) {',
-    '  const rel = sourceIsDirectory ? relative(sourcePath, source).split(sep).join("/") : basename(source);',
-    '  const destination = sourceIsDirectory ? join(targetArg, rel) : targetArg;',
-    '  if (dryRun) {',
-    '    const changed = !existsSync(destination) || !readFileSync(source).equals(readFileSync(destination));',
-    '    const item = lstatSync(source).isSymbolicLink() ? "cL+++++++++" : ">f+++++++++";',
-    '    if (ignoreTimes || changed) process.stdout.write(prefix + item + "|" + rel + "\\n");',
-    '    continue;',
-    '  }',
-    '  copySource(source, destination);',
-    '}',
-  ].join("\n") + "\n";
-}
-
-function fakeSshSource(): string {
-  return [
-    "#!/usr/bin/env bun",
-    'import { appendFileSync, existsSync, statSync } from "node:fs";',
-    'import { join } from "node:path";',
-    'const args = process.argv.slice(2);',
-    'const command = args.join(" ");',
-    'appendFileSync(process.env.FAKE_SSH_LOG, command + "\\n");',
-    'if (process.env.FAKE_SSH_ONLINE !== "1") process.exit(255);',
-    'if (command.includes("echo online")) { console.log("online"); process.exit(0); }',
-    'if (process.env.FAKE_SSH_FAIL_PROBE && command.includes(process.env.FAKE_SSH_FAIL_PROBE)) process.exit(255);',
-    'if (command.includes("$HOME/.codex") && command.includes("session_index.jsonl")) { const path = join(process.env.FAKE_REMOTE_HOME, ".codex/session_index.jsonl"); process.exit(!existsSync(path) ? 2 : statSync(path).isFile() ? 0 : 3); }',
-    'if (command.includes("$HOME/.kimi-code") && command.includes("session_index.jsonl")) { const path = join(process.env.FAKE_REMOTE_HOME, ".kimi-code/session_index.jsonl"); process.exit(!existsSync(path) ? 2 : statSync(path).isFile() ? 0 : 3); }',
-    'if (command.includes("antigravity-rescue")) { const path = join(process.env.FAKE_REMOTE_HOME, "Downloads/antigravity-rescue/conversations"); process.exit(!existsSync(path) ? 2 : statSync(path).isDirectory() ? 0 : 3); }',
-    'process.exit(0);',
-  ].join("\n") + "\n";
-}
-
-function makeHarness(): Harness {
-  const root = mkdtempSync(join(tmpdir(), "pull-sync-only-"));
-  const home = join(root, "home");
-  const remoteHome = join(root, "remote-home");
-  const fakeBin = join(root, "bin");
-  const report = join(root, "mapping.tsv");
-  const rsyncLog = join(root, "rsync.jsonl");
-  const sshLog = join(root, "ssh.log");
-  const registrarMarker = join(root, "registrar-called");
-  const ingestMarker = join(root, "ingest-called");
-
-  mkdirSync(fakeBin, { recursive: true });
-  mkdirSync(join(home, "recallnest", "scripts"), { recursive: true });
-  executable(join(fakeBin, "rsync"), fakeRsyncSource());
-  executable(join(fakeBin, "ssh"), fakeSshSource());
-  executable(
-    join(home, "recallnest", "scripts", "codex-projectless-register.py"),
-    [
-      "#!/bin/bash",
-      'printf "called\\n" > "$FAKE_REGISTRAR_MARKER"',
-    ].join("\n") + "\n",
-  );
-  executable(
-    join(home, "recallnest", "scripts", "incremental-ingest.sh"),
-    [
-      "#!/bin/bash",
-      'printf "called\\n" > "$FAKE_INGEST_MARKER"',
-    ].join("\n") + "\n",
-  );
-
-  fixture(join(remoteHome, ".claude", "projects", "p", "cc.jsonl"), "{\"source\":\"cc\"}\n");
-  fixture(join(remoteHome, ".codex", "sessions", "2026", "codex.jsonl"), "{\"source\":\"codex\"}\n");
-  fixture(join(remoteHome, ".codex", "archived_sessions", "archived.jsonl"), "{\"source\":\"archive\"}\n");
-  fixture(
-    join(remoteHome, ".codex", "session_index.jsonl"),
-    "{\"id\":\"mac-codex\",\"updated_at\":\"2026-08-03T00:00:00Z\"}\n",
-  );
-  fixture(join(remoteHome, ".kimi-code", "sessions", "k1", "wire.jsonl"), "{\"source\":\"kimi\"}\n");
-  fixture(join(remoteHome, ".kimi-code", "session_index.jsonl"), "{\"sessionId\":\"mac-kimi\"}\n");
-  fixture(join(remoteHome, ".gemini", "tmp", "g1", "chats", "session-g.json"), "{\"source\":\"gemini\"}\n");
-  fixture(
-    join(
-      remoteHome,
-      "Library",
-      "Application Support",
-      "Claude",
-      "local-agent-mode-sessions",
-      "d1",
-      ".claude",
-      "projects",
-      "p",
-      "desktop-one.jsonl",
-    ),
-    "{\"source\":\"desktop\"}\n",
-  );
-  fixture(
-    join(remoteHome, ".gemini", "antigravity-cli", "brain", "b1", "transcript_full.jsonl"),
-    "{\"source\":\"agy-brain\"}\n",
-  );
-  fixture(
-    join(remoteHome, "Downloads", "antigravity-rescue", "conversations", "legacy.pb"),
-    "legacy-original",
-  );
-  fixture(
-    join(remoteHome, ".gemini", "antigravity-cli", "conversations", "remote-cli.db"),
-    "remote-cli-original",
-  );
-  fixture(
-    join(remoteHome, ".gemini", "antigravity", "conversations", "remote-app.db"),
-    "remote-app-original",
-  );
-
-  for (let index = 1; index <= 24; index += 1) {
-    fixture(
-      join(home, "machine-data", "macbook-agy", "conversations", "existing-" + index + ".db"),
-      "mini-existing-" + index,
-    );
-  }
-
-  const env: NodeJS.ProcessEnv = {
-    ...process.env,
-    LC_ALL: "C",
-    PULL_FROM_MACBOOK_HOME: home,
-    PULL_FROM_MACBOOK_RSYNC: join(fakeBin, "rsync"),
-    PULL_FROM_MACBOOK_SSH: join(fakeBin, "ssh"),
-    FAKE_REMOTE_HOME: remoteHome,
-    FAKE_RSYNC_LOG: rsyncLog,
-    FAKE_SSH_LOG: sshLog,
-    FAKE_SSH_ONLINE: "1",
-    FAKE_REGISTRAR_MARKER: registrarMarker,
-    FAKE_INGEST_MARKER: ingestMarker,
-    PULL_FROM_MACBOOK_LOG: join(root, "pull.log"),
-    PULL_FROM_MACBOOK_LOG_DIR: join(root, "logs"),
-  };
-
-  return {
-    root,
-    home,
-    remoteHome,
-    report,
-    rsyncLog,
-    sshLog,
-    registrarMarker,
-    ingestMarker,
-    env,
-  };
-}
-
-function run(harness: Harness, args: string[], extraEnv: NodeJS.ProcessEnv = {}) {
-  return spawnSync("/bin/bash", [SCRIPT, ...args], {
-    env: { ...harness.env, ...extraEnv },
-    encoding: "utf8",
-    timeout: 30_000,
-  });
-}
-
-function syncOnly(harness: Harness) {
-  return run(harness, ["--sync-only", "--mapping-report", harness.report]);
-}
-
-function rsyncCalls(harness: Harness): RsyncCall[] {
-  if (!existsSync(harness.rsyncLog)) return [];
-  return readFileSync(harness.rsyncLog, "utf8")
-    .trim()
-    .split("\n")
-    .filter(Boolean)
-    .map((line) => JSON.parse(line) as RsyncCall);
-}
-
-function normalizedRsyncArgs(args: string[]): string[] {
-  return args.filter(
-    (arg) =>
-      arg !== "--dry-run"
-      && arg !== "--ignore-times"
-      && arg !== "--itemize-changes"
-      && !arg.startsWith("--out-format="),
-  );
-}
-
-function unexpectedPositionalArgs(args: string[]): string[] {
-  const valueOptions = new Set(["-e", "--exclude", "--include", "--out-format", "--rsync-path", "--timeout"]);
-  const unexpected: string[] = [];
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    if (valueOptions.has(arg)) {
-      index += 1;
-      continue;
-    }
-    if (!arg.startsWith("-")) unexpected.push(arg);
-  }
-  return unexpected;
-}
-
-function dbContents(directory: string): Record<string, string> {
-  const result: Record<string, string> = {};
-  for (let index = 1; index <= 24; index += 1) {
-    const name = "existing-" + index + ".db";
-    result[name] = readFileSync(join(directory, name), "utf8");
-  }
-  return result;
-}
-
-describe("pull-from-macbook --sync-only", () => {
-  it("syncs allowed sources, verifies identical rsync arguments, and emits per-file mappings without ingest", () => {
-    const harness = makeHarness();
-    expect(harness.env.HOME).toBe(process.env.HOME);
-    const localDbDir = join(harness.home, "machine-data", "macbook-agy", "conversations");
-    const localDbBefore = dbContents(localDbDir);
-    const remoteCliDb = join(harness.remoteHome, ".gemini", "antigravity-cli", "conversations", "remote-cli.db");
-    const remoteAppDb = join(harness.remoteHome, ".gemini", "antigravity", "conversations", "remote-app.db");
-    const remoteCliBefore = readFileSync(remoteCliDb, "utf8");
-    const remoteAppBefore = readFileSync(remoteAppDb, "utf8");
-
-    const result = syncOnly(harness);
-
-    expect(result.status).toBe(0);
-    expect(existsSync(harness.ingestMarker)).toBe(false);
-    expect(existsSync(harness.registrarMarker)).toBe(false);
-    expect(readFileSync(join(harness.home, ".claude", "projects", "p", "cc.jsonl"), "utf8")).toContain("cc");
-    expect(
-      readFileSync(
-        join(harness.home, "recallnest", "data", "desktop-import", "desktop-one.jsonl"),
-        "utf8",
-      ),
-    ).toContain("desktop");
-    expect(readFileSync(join(harness.home, ".codex", "session_index.jsonl"), "utf8")).toContain("mac-codex");
-    expect(readFileSync(join(harness.home, ".kimi-code", "session_index.jsonl"), "utf8")).toContain("mac-kimi");
-
-    const mapping = readFileSync(harness.report, "utf8");
-    expect(mapping.split("\n")[0]).toBe(
-      "source_kind\tsource_file\tlocal_target\tderived_target\tstatus",
-    );
-    expect(mapping).toContain("claude-code\tmac:~/.claude/projects/p/cc.jsonl");
-    expect(mapping).toContain(
-      join(harness.home, "recallnest", "data", "desktop-import", "desktop-one.jsonl"),
-    );
-    expect(mapping).toContain("desktop-flat\t");
-    expect(mapping).toContain("codex-index-merge\t");
-    for (const line of mapping.trim().split("\n").slice(1)) {
-      expect(line.split("\t")).toHaveLength(5);
-    }
-    const desktopTransportRows = mapping
-      .trim()
-      .split("\n")
-      .slice(1)
-      .map((line) => line.split("\t"))
-      .filter(([sourceKind]) => sourceKind === "claude-desktop");
-    expect(desktopTransportRows.length).toBeGreaterThan(0);
-    expect(
-      desktopTransportRows.every((fields) => fields[4] === "local-verified:derived-pending"),
-    ).toBe(true);
-    expect(statSync(harness.report).mode & 0o777).toBe(0o600);
-    expect(existsSync(join(harness.home, ".codex", ".codex-global-state.json"))).toBe(false);
-
-    const calls = rsyncCalls(harness);
-    const grouped = new Map<string, RsyncCall[]>();
-    for (const call of calls) {
-      grouped.set(call.sourceArg, [...(grouped.get(call.sourceArg) || []), call]);
-    }
-    expect(grouped.size).toBe(10);
-    for (const sourceCalls of grouped.values()) {
-      expect(sourceCalls).toHaveLength(3);
-      const real = sourceCalls.find((call) => !call.dryRun);
-      const verify = sourceCalls.find((call) => call.dryRun && !call.ignoreTimes);
-      const inventory = sourceCalls.find((call) => call.dryRun && call.ignoreTimes);
-      expect(real).toBeDefined();
-      expect(verify).toBeDefined();
-      expect(inventory).toBeDefined();
-      expect(normalizedRsyncArgs(verify!.args)).toEqual(real!.args);
-      expect(normalizedRsyncArgs(inventory!.args)).toEqual(real!.args);
-      expect(verify!.targetArg).toBe(real!.targetArg);
-      expect(inventory!.targetArg).toBe(real!.targetArg);
-      expect(unexpectedPositionalArgs(real!.args)).toEqual([]);
-    }
-    const desktopSource = "mac:Library/Application Support/Claude/local-agent-mode-sessions/";
-    const desktopCalls = grouped.get(desktopSource);
-    expect(desktopCalls).toHaveLength(3);
-    expect(desktopCalls!.every((call) => call.args.includes("-s"))).toBe(true);
-    expect(
-      calls.some((call) =>
-        call.sourceArg.includes("/.gemini/antigravity-cli/conversations/")
-        || call.sourceArg.includes("/.gemini/antigravity/conversations/")
-      ),
-    ).toBe(false);
-    const wrapperSource = readFileSync(SCRIPT, "utf8");
-    expect(wrapperSource).not.toContain("mac:~/.gemini/antigravity-cli/conversations/");
-    expect(wrapperSource).not.toContain("mac:~/.gemini/antigravity/conversations/");
-
-    expect(dbContents(localDbDir)).toEqual(localDbBefore);
-    expect(readFileSync(remoteCliDb, "utf8")).toBe(remoteCliBefore);
-    expect(readFileSync(remoteAppDb, "utf8")).toBe(remoteAppBefore);
-    const sshCalls = readFileSync(harness.sshLog, "utf8");
-    expect(sshCalls).toContain("echo online");
-    expect(sshCalls).toContain("$HOME/.codex");
-    expect(sshCalls).toContain("$HOME/.kimi-code");
-    expect(sshCalls).toContain("antigravity-rescue");
-  }, TEST_TIMEOUT_MS);
-
-  it("fails offline in sync-only mode but keeps the routine offline run successful", () => {
-    const syncHarness = makeHarness();
-    const syncResult = run(
-      syncHarness,
-      ["--sync-only", "--mapping-report", syncHarness.report],
-      { FAKE_SSH_ONLINE: "0" },
-    );
-    expect(syncResult.status).not.toBe(0);
-    expect(readFileSync(syncHarness.report, "utf8")).toContain("transport\tmac\t-\t-\toffline");
-    expect(existsSync(syncHarness.registrarMarker)).toBe(false);
-    expect(existsSync(syncHarness.ingestMarker)).toBe(false);
-    expect(rsyncCalls(syncHarness)).toHaveLength(0);
-
-    const routineHarness = makeHarness();
-    const routineResult = run(routineHarness, [], { FAKE_SSH_ONLINE: "0" });
-    expect(routineResult.status).toBe(0);
-    expect(existsSync(routineHarness.registrarMarker)).toBe(true);
-    expect(existsSync(routineHarness.ingestMarker)).toBe(false);
-
-    const existingReportHarness = makeHarness();
-    fixture(existingReportHarness.report, "keep-existing-report");
-    const existingReportResult = syncOnly(existingReportHarness);
-    expect(existingReportResult.status).not.toBe(0);
-    expect(readFileSync(existingReportHarness.report, "utf8")).toBe("keep-existing-report");
-    expect(existsSync(existingReportHarness.sshLog)).toBe(false);
-
-    const racingReportHarness = makeHarness();
-    const racingReportResult = run(
-      racingReportHarness,
-      ["--sync-only", "--mapping-report", racingReportHarness.report],
-      { FAKE_CREATE_REPORT_DURING_SYNC: racingReportHarness.report },
-    );
-    expect(racingReportResult.status).not.toBe(0);
-    expect(readFileSync(racingReportHarness.report, "utf8")).toBe("racing-writer");
-  }, TEST_TIMEOUT_MS);
-
-  it("fails before flattening when Desktop basenames collide", () => {
-    const harness = makeHarness();
-    fixture(
-      join(
-        harness.remoteHome,
-        "Library",
-        "Application Support",
-        "Claude",
-        "local-agent-mode-sessions",
-        "d2",
-        ".claude",
-        "projects",
-        "other",
-        "Desktop-One.jsonl",
-      ),
-      "{\"source\":\"collision\"}\n",
-    );
-
-    const result = syncOnly(harness);
-
-    expect(result.status).not.toBe(0);
-    expect(readFileSync(harness.report, "utf8")).toContain("basename-collision");
-    expect(
-      existsSync(join(harness.home, "recallnest", "data", "desktop-import", "desktop-one.jsonl")),
-    ).toBe(false);
-    expect(existsSync(harness.ingestMarker)).toBe(false);
-
-    const symlinkHarness = makeHarness();
-    const linkedContent = join(symlinkHarness.remoteHome, "linked-content.jsonl");
-    fixture(linkedContent, "{\"source\":\"must-not-follow\"}\n");
-    const linkedSession = join(
-      symlinkHarness.remoteHome,
-      "Library",
-      "Application Support",
-      "Claude",
-      "local-agent-mode-sessions",
-      "d2",
-      ".claude",
-      "projects",
-      "other",
-      "linked.jsonl",
-    );
-    mkdirSync(dirname(linkedSession), { recursive: true });
-    symlinkSync(linkedContent, linkedSession);
-
-    const symlinkResult = syncOnly(symlinkHarness);
-
-    expect(symlinkResult.status).not.toBe(0);
-    expect(readFileSync(symlinkHarness.report, "utf8")).toContain("unsafe-symlink");
-    expect(
-      existsSync(join(symlinkHarness.home, "recallnest", "data", "desktop-import", "linked.jsonl")),
-    ).toBe(false);
-
-    const destinationHarness = makeHarness();
-    const outsideTarget = join(destinationHarness.root, "outside-target.jsonl");
-    fixture(outsideTarget, "outside-must-not-be-ingested");
-    const destinationLink = join(
-      destinationHarness.home,
-      "recallnest",
-      "data",
-      "desktop-import",
-      "desktop-one.jsonl",
-    );
-    mkdirSync(dirname(destinationLink), { recursive: true });
-    symlinkSync(outsideTarget, destinationLink);
-
-    const destinationResult = syncOnly(destinationHarness);
-
-    expect(destinationResult.status).not.toBe(0);
-    expect(readFileSync(destinationHarness.report, "utf8")).toContain(
-      "unsafe-destination-symlink",
-    );
-    expect(readFileSync(outsideTarget, "utf8")).toBe("outside-must-not-be-ingested");
-  }, TEST_TIMEOUT_MS);
-
-  it("surfaces a Desktop copy failure and does not ingest", () => {
-    const harness = makeHarness();
-    mkdirSync(
-      join(harness.home, "recallnest", "data", "desktop-import", "desktop-one.jsonl"),
-      { recursive: true },
-    );
-
-    const result = syncOnly(harness);
-
-    expect(result.status).not.toBe(0);
-    expect(readFileSync(harness.report, "utf8")).toContain("copy-failed:IsADirectoryError");
-    expect(existsSync(harness.ingestMarker)).toBe(false);
-  }, TEST_TIMEOUT_MS);
-
-  it("does not derive from a failed or partial source sync", () => {
-    const desktopHarness = makeHarness();
-    const desktopImport = join(
-      desktopHarness.home,
-      "recallnest",
-      "data",
-      "desktop-import",
-      "desktop-one.jsonl",
-    );
-    fixture(desktopImport, "known-good-desktop");
-
-    const desktopResult = run(
-      desktopHarness,
-      ["--sync-only", "--mapping-report", desktopHarness.report],
-      { FAKE_RSYNC_FAIL_SOURCE: "local-agent-mode-sessions" },
-    );
-
-    expect(desktopResult.status).not.toBe(0);
-    expect(readFileSync(desktopImport, "utf8")).toBe("known-good-desktop");
-    expect(readFileSync(desktopHarness.report, "utf8")).toContain(
-      "derived-skipped:source-sync-failed",
-    );
-
-    const indexHarness = makeHarness();
-    const kimiIndex = join(indexHarness.home, ".kimi-code", "session_index.jsonl");
-    fixture(kimiIndex, "{\"sessionId\":\"mini-only\"}\n");
-
-    const indexResult = run(
-      indexHarness,
-      ["--sync-only", "--mapping-report", indexHarness.report],
-      { FAKE_RSYNC_FAIL_SOURCE: ".kimi-code/session_index.jsonl" },
-    );
-
-    expect(indexResult.status).not.toBe(0);
-    expect(readFileSync(kimiIndex, "utf8")).toContain("mini-only");
-    expect(readFileSync(kimiIndex, "utf8")).not.toContain("mac-kimi");
-    expect(readFileSync(indexHarness.report, "utf8")).toContain(
-      "kimi-index-merge\t" + join(indexHarness.home, ".kimi-code", "session_index.macbook.jsonl"),
-    );
-    expect(readFileSync(indexHarness.report, "utf8")).toContain(
-      "derived-skipped:source-sync-failed",
-    );
-  }, TEST_TIMEOUT_MS);
-
-  it("distinguishes absent probes from partial, transport, and wrong-type failures", () => {
-    const legacyHarness = makeHarness();
-    const legacyResult = run(
-      legacyHarness,
-      ["--sync-only", "--mapping-report", legacyHarness.report],
-      { FAKE_RSYNC_FAIL_SOURCE: "antigravity-rescue/conversations" },
-    );
-    const legacyMapping = readFileSync(legacyHarness.report, "utf8");
-    expect(legacyResult.status).not.toBe(0);
-    expect(legacyMapping).toContain("agy-legacy-pb\t");
-    expect(legacyMapping).toContain("sync-failed:23");
-    expect(legacyMapping).not.toContain(
-      "agy-legacy-pb\tmac:~/Downloads/antigravity-rescue/conversations/\t"
-      + join(legacyHarness.home, "machine-data", "macbook-agy", "legacy-pb")
-      + "/\t"
-      + join(legacyHarness.home, "machine-data", "macbook-agy", "legacy-pb")
-      + "/\tsource-absent",
-    );
-
-    const probeHarness = makeHarness();
-    const probeResult = run(
-      probeHarness,
-      ["--sync-only", "--mapping-report", probeHarness.report],
-      { FAKE_SSH_FAIL_PROBE: "$HOME/.codex" },
-    );
-    expect(probeResult.status).not.toBe(0);
-    expect(readFileSync(probeHarness.report, "utf8")).toContain("probe-failed:255");
-    expect(
-      rsyncCalls(probeHarness).some((call) =>
-        call.sourceArg === "mac:~/.codex/session_index.jsonl"
-      ),
-    ).toBe(false);
-
-    const wrongTypeHarness = makeHarness();
-    const wrongTypeIndex = join(
-      wrongTypeHarness.remoteHome,
-      ".codex",
-      "session_index.jsonl",
-    );
-    renameSync(wrongTypeIndex, wrongTypeIndex + ".saved");
-    mkdirSync(wrongTypeIndex);
-    const wrongTypeResult = syncOnly(wrongTypeHarness);
-    const wrongTypeMapping = readFileSync(wrongTypeHarness.report, "utf8");
-    expect(wrongTypeResult.status).not.toBe(0);
-    expect(wrongTypeMapping).toContain("probe-failed:3");
-    expect(wrongTypeMapping).not.toContain(
-      "codex-session-index\tmac:~/.codex/session_index.jsonl\t"
-      + join(wrongTypeHarness.home, ".codex", "session_index.macbook.jsonl")
-      + "\t"
-      + join(wrongTypeHarness.home, ".codex", "session_index.jsonl")
-      + "\tsource-absent",
-    );
-
-    const absentHarness = makeHarness();
-    const absentIndex = join(absentHarness.remoteHome, ".codex", "session_index.jsonl");
-    renameSync(absentIndex, absentIndex + ".saved");
-    const absentResult = syncOnly(absentHarness);
-    expect(absentResult.status).toBe(0);
-    expect(readFileSync(absentHarness.report, "utf8")).toContain(
-      "codex-session-index\tmac:~/.codex/session_index.jsonl\t"
-      + join(absentHarness.home, ".codex", "session_index.macbook.jsonl")
-      + "\t"
-      + join(absentHarness.home, ".codex", "session_index.jsonl")
-      + "\tsource-absent",
-    );
-  }, TEST_TIMEOUT_MS);
-
-  it("surfaces mapping append failures without installing a report or ingesting", () => {
-    const harness = makeHarness();
-    const result = run(
-      harness,
-      ["--sync-only", "--mapping-report", harness.report],
-      { FAKE_BREAK_MAPPING_TMP: harness.report },
-    );
-
-    expect(result.status).not.toBe(0);
-    expect(result.stdout + result.stderr).toContain("sync-only 映射报告追加失败");
-    expect(existsSync(harness.report)).toBe(false);
-    expect(existsSync(harness.ingestMarker)).toBe(false);
-  }, TEST_TIMEOUT_MS);
-
-  it("marks files pending when a live source changes after inventory", () => {
-    const liveSourceHarness = makeHarness();
-    const liveSourceResult = run(
-      liveSourceHarness,
-      ["--sync-only", "--mapping-report", liveSourceHarness.report],
-      { FAKE_RSYNC_MUTATE_ON_VERIFY_SOURCE: ".claude/projects/" },
-    );
-    const liveSourceRows = readFileSync(liveSourceHarness.report, "utf8")
-      .trim()
-      .split("\n")
-      .slice(1)
-      .map((line) => line.split("\t"))
-      .filter(([sourceKind]) => sourceKind === "claude-code");
-    expect(liveSourceResult.status).not.toBe(0);
-    expect(liveSourceRows.some((fields) => fields[4] === "pending:1")).toBe(true);
-    expect(liveSourceRows.some((fields) => fields[4] === "verified")).toBe(false);
-  }, TEST_TIMEOUT_MS);
-});