"note": "Heuristic false-green LEADS, not findings. A finding requires a demonstrated reproduction (surviving mutation via mutation-runner). Do not treat a candidate as a confirmed false green. Coverage-theater leads may include tests that delegate their assertion to a custom helper the classifier does not recognise; verify before acting.",

  "sourceDigest": "sha256:dd810dd48c5bdbc9becd7fcc01dd41a4ca2abf0b2d6f6a545907247f6e3e8361",

  "summary": {

    "filesScanned": 2467,

    "filesScanned": 2468,

    "candidateCount": 16,

    "byMode": {

      "false_green_coverage_theater": 15,

{

  "schemaVersion": "1",

  "repository": "OpenAgentsInc/openagents",

  "sourceDigest": "sha256:f11a893e45986831504d003dfa23967abb728700567e6ec3469c41b7dae7aa0f",

  "sourceDigest": "sha256:359b6533e42f95b7605e98f21e6ed7a4f837f917a73ad1723aab8cee17ec0752",

  "surfaces": [

    {

      "id": "app:@openagentsinc/acceptance-runner",

      "oracles": [

        {

          "type": "test",

          "ref": "packages/openagents-cli (63 tracked test files)"

          "ref": "packages/openagents-cli (64 tracked test files)"

        },

        {

          "type": "behavior-contract",

import { delegateTool, openagentsTool, shellTool, skillTool } from "./coder-tools.js";

import {

  describeLoad,

  invokePlugin,

  isRefusal,

  loadPluginFromManifest,

  pluginIdentity,

  pluginTool,

  type LoadedPlugin,

} from "./coder-plugins.js";

import { runForeignResume } from "./coder-foreign-resume.js";

import { existsSync } from "node:fs";

import { spawnSync } from "node:child_process";

import { resolve as resolvePath } from "node:path";

import { dirname, join, resolve as resolvePath } from "node:path";

import { fileURLToPath } from "node:url";

import { rebuild, RELOAD_EXIT_CODE, sourceCheckout } from "./coder-reload.js";

import { loadSkillSelection, standingContext } from "./coder-skills.js";

        return described;

      };

      const locateForeignSessionsManifest = (): string | undefined => {

        let here = dirname(fileURLToPath(import.meta.url));

        while (true) {

          const candidate = join(here, "plugins/foreign-sessions/manifest.json");

          if (existsSync(candidate)) {

            return candidate;

          }

          const parent = dirname(here);

          if (parent === here) {

            return undefined;

          }

          here = parent;

        }

      };

      const foreignSessionsManifest = locateForeignSessionsManifest();

      const runForeignSessionResume = async (

        selection: number | undefined,

      ): Promise<string> => {

        if (foreignSessionsManifest === undefined) {

          return (

            "The foreign session scanner is not available from this installation. " +

            "It lives at plugins/foreign-sessions/manifest.json in the repository."

          );

        }

        const loaded = loadPluginFromManifest(foreignSessionsManifest);

        if (isRefusal(loaded)) {

          return `Could not load the foreign session scanner (${loaded.code}): ${loaded.reason}`;

        }

        const invoke = async (input: Record<string, unknown>): Promise<unknown> => {

          const packet = new TextEncoder().encode(JSON.stringify(input));

          const outcome = await invokePlugin(loaded, packet);

          if (isRefusal(outcome)) {

            return { refusal: { code: outcome.code, reason: outcome.reason } };

          }

          try {

            return JSON.parse(new TextDecoder().decode(outcome));

          } catch (cause) {

            throw new Error(

              `the scanner output is not valid JSON: ${

                cause instanceof Error ? cause.message : String(cause)

              }`,

            );

          }

        };

        return runForeignResume(

          { now_ms: Date.now(), cwd: process.cwd(), selection },

          invoke,

        );

      };

      // Only when there is really no way to run a child. A refused child

      // thread is not that: `buildDelegation` prefers a free harness model over

      // the account's grant anyway, so the grant lane failing is the normal

                stdout: process.stdout,

                skills,

                onSkillsChanged: declareTools,

                resume: runForeignSessionResume,

                loadPlugin,

              })

            : await runCoderPlain(session, {

                stdout: process.stdout,

                prompt: oneShot,

                skills,

                resume: runForeignSessionResume,

                loadPlugin,

              });

        } finally {

/**

 * Foreign session resume picker for `openagents coder`.

 *

 * The scanner half of OpenAgentsInc/openagents.com#198 is a packet-v0 WASM

 * plugin under `plugins/foreign-sessions`. This module is the CLI picker

 * half: it builds the bounded, filtered scan request, interprets the

 * metadata-only result, renders a numbered list, and prints a resume command.

 *

 * It takes an `invoke` seam so tests can stand in a fake plugin and so the

 * real call loads the plugin and invokes it outside this module.

 */

const DAY_MS = 86_400_000;

const HOUR_MS = 3_600_000;

export const DEFAULT_MAX_AGE_DAYS = 30;

export const DEFAULT_PICKER_LIMIT = 10;

export interface ForeignSession {

  readonly source: "claude" | "codex";

  readonly session_id: string;

  readonly path: string;

  readonly cwd: string | undefined;

  readonly project_dir: string | undefined;

  readonly mtime_ms: number;

  readonly size_bytes: number;

  readonly record_count: number | undefined;

  readonly metadata_truncated: boolean;

}

export interface ForeignScanOutput {

  readonly sessions: ReadonlyArray<ForeignSession>;

  readonly scanned_dirs: number;

  readonly scanned_files: number;

  readonly skipped: {

    readonly malformed: number;

    readonly unreadable: number;

    readonly symlinked: number;

  };

  readonly oversized: number;

  readonly missing_sources: ReadonlyArray<string>;

  readonly scan_truncated: boolean;

  readonly read_budget_exhausted: boolean;

}

export interface ForeignScanRefusal {

  readonly code: string;

  readonly reason: string;

}

export interface ForeignResumeDeps {

  readonly now_ms: number;

  readonly cwd: string;

  readonly selection: number | undefined;

}

export type ForeignResumeInvoke = (

  input: Record<string, unknown>,

) => Promise<unknown>;

export interface ForeignResumeOptions {

  readonly max_age_days?: number | undefined;

  readonly limit?: number | undefined;

}

const asRecord = (value: unknown): Record<string, unknown> =>

  typeof value === "object" && value !== null && !Array.isArray(value)

    ? (value as Record<string, unknown>)

    : {};

const asString = (value: unknown): string =>

  typeof value === "string" ? value : "";

const asNumber = (value: unknown): number =>

  typeof value === "number" && Number.isFinite(value) ? value : 0;

const asBool = (value: unknown): boolean => value === true;

const asArray = (value: unknown): ReadonlyArray<unknown> =>

  Array.isArray(value) ? value : [];

function parseSession(value: unknown): ForeignSession | undefined {

  const record = asRecord(value);

  const source = record["source"];

  if (source !== "claude" && source !== "codex") return undefined;

  return {

    source,

    session_id: asString(record["session_id"]),

    path: asString(record["path"]),

    cwd: record["cwd"] === undefined ? undefined : asString(record["cwd"]),

    project_dir:

      record["project_dir"] === undefined

        ? undefined

        : asString(record["project_dir"]),

    mtime_ms: asNumber(record["mtime_ms"]),

    size_bytes: asNumber(record["size_bytes"]),

    record_count:

      record["record_count"] === undefined

        ? undefined

        : asNumber(record["record_count"]),

    metadata_truncated: asBool(record["metadata_truncated"]),

  };

}

function parseScanOutput(value: unknown): ForeignScanOutput {

  const record = asRecord(value);

  const rawSessions = asArray(record["sessions"]);

  const sessions = rawSessions

    .map(parseSession)

    .filter((s): s is ForeignSession => s !== undefined);

  const rawSkipped = asRecord(record["skipped"]);

  const rawMissing = asArray(record["missing_sources"]);

  return {

    sessions,

    scanned_dirs: asNumber(record["scanned_dirs"]),

    scanned_files: asNumber(record["scanned_files"]),

    skipped: {

      malformed: asNumber(rawSkipped["malformed"]),

      unreadable: asNumber(rawSkipped["unreadable"]),

      symlinked: asNumber(rawSkipped["symlinked"]),

    },

    oversized: asNumber(record["oversized"]),

    missing_sources: rawMissing.filter((m): m is string => typeof m === "string"),

    scan_truncated: asBool(record["scan_truncated"]),

    read_budget_exhausted: asBool(record["read_budget_exhausted"]),

  };

}

type ScanResult =

  | { readonly kind: "ok"; readonly output: ForeignScanOutput }

  | { readonly kind: "refusal"; readonly refusal: ForeignScanRefusal }

  | { readonly kind: "error"; readonly message: string };

function normalizeScanResult(value: unknown): ScanResult {

  const record = asRecord(value);

  if (record["refusal"] !== undefined) {

    const refusal = asRecord(record["refusal"]);

    const code = asString(refusal["code"]);

    const reason = asString(refusal["reason"]);

    if (code.length > 0 && reason.length > 0) {

      return { kind: "refusal", refusal: { code, reason } };

    }

    return { kind: "error", message: "The scanner returned a malformed refusal." };

  }

  if (record["ok"] !== undefined) {

    return { kind: "ok", output: parseScanOutput(record["ok"]) };

  }

  return { kind: "error", message: "The scanner returned an unrecognised packet." };

}

function buildPacket(

  deps: ForeignResumeDeps,

  options: ForeignResumeOptions,

): Record<string, unknown> {

  return {

    now_ms: deps.now_ms,

    cwd_filter: deps.cwd,

    max_age_days: options.max_age_days ?? DEFAULT_MAX_AGE_DAYS,

    limit: options.limit ?? DEFAULT_PICKER_LIMIT,

  };

}

export function formatAge(mtime_ms: number, now_ms: number): string {

  const diff = Math.max(0, now_ms - mtime_ms);

  const days = Math.floor(diff / DAY_MS);

  if (days >= 1) {

    return `${String(days)} day${days === 1 ? "" : "s"} ago`;

  }

  const hours = Math.floor(diff / HOUR_MS);

  if (hours >= 1) {

    return `${String(hours)} hour${hours === 1 ? "" : "s"} ago`;

  }

  return "just now";

}

function resumeCommand(session: ForeignSession): string {

  const id = session.session_id;

  if (session.source === "claude") {

    if (session.cwd !== undefined && session.cwd.length > 0) {

      return `cd "${session.cwd}" && claude --resume ${id}`;

    }

    return `claude --resume ${id}`;

  }

  if (session.cwd !== undefined && session.cwd.length > 0) {

    return `cd "${session.cwd}" && codex resume ${id}`;

  }

  return `codex resume ${id}`;

}

function describeSession(session: ForeignSession, now_ms: number): string {

  const age = formatAge(session.mtime_ms, now_ms);

  const records =

    session.record_count === undefined ? "metadata only" : `${String(session.record_count)} records`;

  const truncated = session.metadata_truncated ? " · truncated" : "";

  const cwd = session.cwd ?? "(cwd unknown)";

  return `${session.source.padEnd(6)}  ${session.session_id}  ${cwd}  ${age}  ${records}${truncated}`;

}

function describeList(

  output: ForeignScanOutput,

  now_ms: number,

  cwd: string,

): string {

  const sessions = output.sessions;

  const header = `Recent foreign sessions for this directory (${cwd}):`;

  if (sessions.length === 0) {

    const reasons: string[] = [];

    if (output.missing_sources.length > 0) {

      reasons.push(

        `the scanner could not read the ${output.missing_sources.join(" or ")} state store`,

      );

    }

    if (output.scan_truncated) {

      reasons.push("the scan was truncated");

    }

    if (output.read_budget_exhausted) {

      reasons.push("the file-read budget was exhausted");

    }

    const reason = reasons.length > 0 ? ` (${reasons.join("; ")})` : "";

    return `${header}\n\nNo recent foreign sessions were found${reason}.`;

  }

  const lines = sessions

    .map((session, index) => `  ${String(index + 1).padStart(2)}. ${describeSession(session, now_ms)}`)

    .join("\n");

  const notes: string[] = [];

  if (output.scan_truncated) {

    notes.push("The scan hit a bound and may be partial.");

  }

  if (output.read_budget_exhausted) {

    notes.push("The file-read budget was exhausted; some sessions may be metadata-only.");

  }

  const note = notes.length > 0 ? `\n\n${notes.join(" ")}` : "";

  return `${header}\n\n${lines}\n\nRun /resume <number> to see the resume command for that session.${note}`;

}

function describeSelection(session: ForeignSession, now_ms: number): string {

  const age = formatAge(session.mtime_ms, now_ms);

  return [

    "Resume context:",

    `  source:      ${session.source}`,

    `  session id:  ${session.session_id}`,

    `  cwd:         ${session.cwd ?? "(unknown)"}`,

    `  age:         ${age}`,

    `  records:     ${session.record_count === undefined ? "(unknown)" : String(session.record_count)}`,

    session.metadata_truncated ? "  metadata:    truncated" : undefined,

    "",

    "Run this to resume in the foreign tool:",

    `  ${resumeCommand(session)}`,

  ]

    .filter((line): line is string => line !== undefined)

    .join("\n");

}

/**

 * Run one `/resume` turn: ask the scanner, then either list sessions or

 * describe the selected one. Returns a single notice string.

 *

 * The `invoke` seam is given the packet the real plugin expects:

 * `now_ms`, `cwd_filter`, `max_age_days`, `limit`. Sources default to both.

 */

export async function runForeignResume(

  deps: ForeignResumeDeps,

  invoke: ForeignResumeInvoke,

  options?: ForeignResumeOptions,

): Promise<string> {

  const packet = buildPacket(deps, options ?? {});

  let raw: unknown;

  try {

    raw = await invoke(packet);

  } catch (cause) {

    return `The scanner could not run: ${cause instanceof Error ? cause.message : String(cause)}`;

  }

  const result = normalizeScanResult(raw);

  if (result.kind === "error") {

    return result.message;

  }

  if (result.kind === "refusal") {

    return `The scanner refused (${result.refusal.code}): ${result.refusal.reason}`;

  }

  const output = result.output;

  const sessions = output.sessions;

  if (deps.selection !== undefined) {

    if (deps.selection < 1 || deps.selection > sessions.length) {

      return `There is no session at ${String(deps.selection)}.${

        sessions.length === 0

          ? ""

          : ` Choose a number from 1 to ${String(sessions.length)}.`

      }\n\n${describeList(output, deps.now_ms, deps.cwd)}`;

    }

    return describeSelection(sessions[deps.selection - 1]!, deps.now_ms);

  }

  return describeList(output, deps.now_ms, deps.cwd);

}

  readonly prompt?: string | undefined;

  /** The workspace's skills, so `/skills` can report them. */

  readonly skills?: SkillSelection | undefined;

  /**

   * Pick and describe a foreign coding-agent session to resume.

   *

   * For `/resume` and `/resume <number>`. The caller loads the foreign-sessions

   * plugin and invokes it; this mode only asks for the result and writes it.

   */

  readonly resume?: ((selection: number | undefined) => Promise<string>) | undefined;

  /**

   * Load a WASM plugin from a manifest path and say what happened.

   *

      return;

    }

    const resumeMatch = /^\/resume(?:\s+(\d+))?\s*$/.exec(line.trim());

    if (resumeMatch !== null) {

      const selection = resumeMatch[1] === undefined ? undefined : Number(resumeMatch[1]);

      const text =

        options.resume === undefined

          ? "This session cannot resume foreign sessions."

          : await options.resume(selection).catch(() => "The foreign session scan failed unexpectedly.");

      stdout.write(`\n${text}\n`);

      return;

    }

    written = 0;

    stdout.write(`\ncoder> `);

    await session.submit(line);

          "  /system                     what the model is told: tools, skills, and its",

          "                              standing context",

          "  /skills                     choose which skills the model is offered",

          "  /resume [<n>]               list or select a recent foreign coding session",

          "  /export                     write this conversation as an ATIF trajectory",

          "  /reload                     rebuild and restart on the current source",

          "  /delegate [<n>x] <prompt>   run child agents on a prompt",

          "  /help     this list",

          "  /system   what the model is told, including tools and skills",

          "  /skills   choose which skills the model is offered",

          "  /resume   list or select a recent foreign coding session",

          "  /export   write this conversation as an ATIF trajectory",

          "  /reload   rebuild and restart on the current source",

          "  /delegate [<n>x] <prompt>   run child agents on a prompt",

  readonly skills?: SkillSelection | undefined;

  /** Re-declare the tools after a skill is switched. */

  readonly onSkillsChanged?: (() => void) | undefined;

  /**

   * Pick and describe a foreign coding-agent session to resume.

   *

   * For `/resume` and `/resume <number>`. The caller loads the foreign-sessions

   * plugin and invokes it; this interface only asks for the result and shows it

   * as a notice.

   */

  readonly resume?: ((selection: number | undefined) => Promise<string>) | undefined;

  /**

   * Load a WASM plugin from a manifest path and say what happened.

   *

        return;

      }

      // `/resume` lists recent foreign coding-agent sessions or describes one.

      const resumeMatch = /^\/resume(?:\s+(\d+))?\s*$/.exec(prompt.trim());

      if (resumeMatch !== null) {

        const selection = resumeMatch[1] === undefined ? undefined : Number(resumeMatch[1]);

        if (options.resume === undefined) {

          session.notice("This session cannot resume foreign sessions.");

        } else {

          void options

            .resume(selection)

            .then((text) => {

              session.notice(text);

              render();

            })

            .catch(() => {

              session.notice("The foreign session scan failed unexpectedly.");

              render();

            });

        }

        render();

        return;

      }

      if (prompt.trimStart().startsWith("/delegate")) {

        void session.submit(prompt);

        render();

import { describe, expect, it } from "vitest";

import {

  DEFAULT_MAX_AGE_DAYS,

  DEFAULT_PICKER_LIMIT,

  formatAge,

  runForeignResume,

  type ForeignResumeInvoke,

  type ForeignSession,

} from "../src/coder-foreign-resume.js";

const DAY_MS = 86_400_000;

const HOUR_MS = 3_600_000;

const NOW_MS = 1_000_000_000_000;

const session = (overrides: Partial<ForeignSession>): ForeignSession => ({

  source: "claude",

  session_id: "abc-123",

  path: "projects/abc.jsonl",

  cwd: undefined,

  project_dir: undefined,

  mtime_ms: NOW_MS,

  size_bytes: 100,

  record_count: 1,

  metadata_truncated: false,

  ...overrides,

});

const makeInvoke =

  (output: unknown): ForeignResumeInvoke =>

  async (input) => {

    void input;

    return output;

  };

const lastInput = async (output: unknown): Promise<{ input: Record<string, unknown>; result: string }> => {

  let captured: Record<string, unknown> = {};

  const invoke: ForeignResumeInvoke = async (input) => {

    captured = input;

    return output;

  };

  const result = await runForeignResume(

    { now_ms: NOW_MS, cwd: "/test/cwd", selection: undefined },

    invoke,

  );

  return { input: captured, result };

};

describe("runForeignResume packet", () => {

  it("sends the cwd filter, now, sensible age and limit bounds", async () => {

    const { input } = await lastInput({ ok: { sessions: [] } });

    expect(input["cwd_filter"]).toBe("/test/cwd");

    expect(input["now_ms"]).toBe(NOW_MS);

    expect(input["max_age_days"]).toBe(DEFAULT_MAX_AGE_DAYS);

    expect(input["limit"]).toBe(DEFAULT_PICKER_LIMIT);

    expect(input["sources"]).toBeUndefined();

  });

});

describe("runForeignResume listing", () => {

  it("renders a numbered, newest-first list and the /resume instruction", async () => {

    const result = await runForeignResume(

      { now_ms: NOW_MS, cwd: "/test/cwd", selection: undefined },

      makeInvoke({

        ok: {

          sessions: [

            session({

              source: "codex",

              session_id: "codex-newest",

              cwd: "/Users/ada/gamma",

              mtime_ms: NOW_MS - DAY_MS,

              record_count: 3,

            }),

            session({

              source: "claude",

              session_id: "claude-older",

              cwd: "/Users/ada/alpha",

              mtime_ms: NOW_MS - 3 * DAY_MS,

              record_count: 7,

            }),

          ],

        },

      }),

    );

    expect(result).toContain("Recent foreign sessions for this directory (/test/cwd):");

    expect(result).toContain("1.");

    expect(result).toContain("2.");

    // Newest first.

    expect(result.indexOf("codex-newest")).toBeLessThan(result.indexOf("claude-older"));

    expect(result).toContain("/Users/ada/gamma");

    expect(result).toContain("/Users/ada/alpha");

    expect(result).toContain("Run /resume <number>");

  });

  it("reports an empty list with missing sources", async () => {

    const result = await runForeignResume(

      { now_ms: NOW_MS, cwd: "/test/cwd", selection: undefined },

      makeInvoke({

        ok: { sessions: [], missing_sources: ["claude", "codex"], scan_truncated: false },

      }),

    );

    expect(result).toContain("No recent foreign sessions were found");

    expect(result).toContain("claude or codex state store");

  });

  it("notes a truncated scan", async () => {

    const result = await runForeignResume(

      { now_ms: NOW_MS, cwd: "/test/cwd", selection: undefined },

      makeInvoke({

        ok: {

          sessions: [session({ session_id: "one" })],

          scan_truncated: true,

          read_budget_exhausted: false,

        },

      }),

    );

    expect(result).toContain("The scan hit a bound and may be partial");

  });

  it("flags metadata-only sessions", async () => {

    const result = await runForeignResume(

      { now_ms: NOW_MS, cwd: "/test/cwd", selection: undefined },

      makeInvoke({

        ok: {

          sessions: [

            session({

              session_id: "huge",

              record_count: undefined,

              metadata_truncated: true,

            }),

          ],

        },

      }),

    );

    expect(result).toContain("huge");

    expect(result).toContain("metadata only");

    expect(result).toContain("truncated");

  });

});

describe("runForeignResume selection", () => {

  const sessions = [

    session({

      source: "claude",

      session_id: "claude-1",

      cwd: "/Users/ada/alpha",

      mtime_ms: NOW_MS - 2 * DAY_MS,

      record_count: 5,

    }),

    session({

      source: "codex",

      session_id: "codex-2",

      cwd: "/Users/ada/gamma",

      mtime_ms: NOW_MS - DAY_MS,

      record_count: 3,

    }),

  ];

  it("prints the resume context and exact command for a Claude session", async () => {

    const result = await runForeignResume(

      { now_ms: NOW_MS, cwd: "/test/cwd", selection: 1 },

      makeInvoke({ ok: { sessions } }),

    );

    expect(result).toContain("source:      claude");

    expect(result).toContain("session id:  claude-1");

    expect(result).toContain("cwd:         /Users/ada/alpha");

    expect(result).toContain('cd "/Users/ada/alpha" && claude --resume claude-1');

  });

  it("prints the resume command for a Codex session", async () => {

    const result = await runForeignResume(

      { now_ms: NOW_MS, cwd: "/test/cwd", selection: 2 },

      makeInvoke({ ok: { sessions } }),

    );

    expect(result).toContain("source:      codex");

    expect(result).toContain("session id:  codex-2");

    expect(result).toContain('cd "/Users/ada/gamma" && codex resume codex-2');

  });

  it("rejects an out-of-range selection and re-lists", async () => {

    const result = await runForeignResume(

      { now_ms: NOW_MS, cwd: "/test/cwd", selection: 9 },

      makeInvoke({ ok: { sessions } }),

    );

    expect(result).toContain("There is no session at 9");

    expect(result).toContain("1 to 2");

    expect(result).toContain("Recent foreign sessions");

  });

  it("works when the session cwd is unknown", async () => {

    const result = await runForeignResume(

      { now_ms: NOW_MS, cwd: "/test/cwd", selection: 1 },

      makeInvoke({

        ok: {

          sessions: [session({ session_id: "unknown-cwd", cwd: undefined, record_count: undefined })],

        },

      }),

    );

    expect(result).toContain("cwd:         (unknown)");

    expect(result).toContain("claude --resume unknown-cwd");

    expect(result).not.toContain("cd ");

  });

});

describe("runForeignResume soft failures", () => {

  it("handles a typed plugin refusal", async () => {

    const result = await runForeignResume(

      { now_ms: NOW_MS, cwd: "/test/cwd", selection: undefined },

      makeInvoke({ refusal: { code: "unsupported", reason: "unknown source" } }),

    );

    expect(result).toContain("The scanner refused (unsupported)");

    expect(result).toContain("unknown source");

  });

  it("handles malformed scanner output", async () => {

    const result = await runForeignResume(

      { now_ms: NOW_MS, cwd: "/test/cwd", selection: undefined },

      makeInvoke({ unexpected: true }),

    );

    expect(result).toContain("unrecognised packet");

  });

  it("handles an invoke error without crashing", async () => {

    const result = await runForeignResume(

      { now_ms: NOW_MS, cwd: "/test/cwd", selection: undefined },

      async () => {

        throw new Error("worker trap");

      },

    );

    expect(result).toContain("The scanner could not run");

    expect(result).toContain("worker trap");

  });

  it("handles a malformed refusal", async () => {

    const result = await runForeignResume(

      { now_ms: NOW_MS, cwd: "/test/cwd", selection: undefined },

      makeInvoke({ refusal: { code: 123 } }),

    );

    expect(result).toContain("malformed refusal");

  });

});

describe("formatAge", () => {

  it("uses days for old sessions", () => {

    expect(formatAge(NOW_MS - 5 * DAY_MS, NOW_MS)).toBe("5 days ago");

  });

  it("uses hours for same-day sessions", () => {

    expect(formatAge(NOW_MS - 3 * HOUR_MS, NOW_MS)).toBe("3 hours ago");

  });

  it("uses one day singular", () => {

    expect(formatAge(NOW_MS - DAY_MS, NOW_MS)).toBe("1 day ago");

  });

  it("uses just now for very recent sessions", () => {

    expect(formatAge(NOW_MS - 1000, NOW_MS)).toBe("just now");

  });

});