@fungi.computer/shed 0.0.0-stage → 0.0.1

package/backend/test/runs.node.test.ts

@@ -0,0 +1,1770 @@
+import { spawn } from "node:child_process";
+import { readFile, writeFile, rm, mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import type { HostActor } from "@fungi.computer/puffball/app-method-runtime";
+import assert from "node:assert/strict";
+import * as z from "zod";
+import { it, type TestContext } from "node:test";
+import { DatabaseSync } from "node:sqlite";
+import {
+  mintComputerProcessId,
+  type ComputerProcess,
+} from "@fungi.computer/computer/operations";
+import { appBackend } from "../methods.js";
+import {
+  createShedRuns,
+  type ShedRunInput,
+  type ShedStartInput,
+} from "../runs.js";
+import {
+  buildAppApi,
+  buildAppDeclaration,
+} from "@fungi.computer/agar/backend-declaration";
+import { appBackend as shedBackend } from "../methods.js";
+import shedMetadata from "../../package.json" with { type: "json" };
+const appApi = buildAppApi(shedBackend);
+const appDeclaration = buildAppDeclaration(shedBackend, shedMetadata.fungi.app);
+/** A `run` App method reply that completed with a definite exit code. */
+const completedRun = z.object({ exitCode: z.number(), logPath: z.string() });
+
+void it("reuses one process across repeated and restored calls, then returns its exit and log", async (t) => {
+  const database = new DatabaseSync(":memory:");
+  t.after(() => {
+    database.close();
+  });
+  const sql = {
+    exec(query: string, ...values: (string | number | null)[]) {
+      const rows = database.prepare(query).all(...values);
+      return { toArray: () => rows };
+    },
+  };
+  let starts = 0;
+  let process: ComputerProcess = {
+    id: mintComputerProcessId(),
+    port: null,
+    command: "sleep 120",
+    cwd: "/workspace",
+    state: "running",
+    exitCode: null,
+    sync: "synced",
+    startedAt: 1,
+    endedAt: null,
+  };
+  const computer = {
+    processStart: (input: { command: string; cwd?: string }) => {
+      starts++;
+      assert.match(input.command, /tee/);
+      assert.match(input.command, /out\.log/);
+      assert.equal(input.cwd, "/workspace");
+      return Promise.resolve(process);
+    },
+    processes: () => Promise.resolve({ processes: [process] }),
+  };
+  const caller = {
+    actor: { kind: "member", memberId: "member-one" },
+    computerId: "computer-one",
+    idempotencyKey: "run-one:node-one:0",
+  } satisfies Parameters<typeof appBackend.call>[3];
+  const input = { command: "sleep 120", cwd: "/workspace" };
+  const context = { runs: createShedRuns(sql), env: { COMPUTER: computer } };
+  assert.deepEqual(await appBackend.call("run", input, context, caller), {
+    kind: "pending",
+    retryAfterMs: 5000,
+  });
+  assert.deepEqual(await appBackend.call("run", input, context, caller), {
+    kind: "pending",
+    retryAfterMs: 5000,
+  });
+  const restored = { runs: createShedRuns(sql), env: { COMPUTER: computer } };
+  assert.deepEqual(await appBackend.call("run", input, restored, caller), {
+    kind: "pending",
+    retryAfterMs: 5000,
+  });
+  process = { ...process, state: "exited", exitCode: 0, endedAt: 2 };
+  const result = await appBackend.call("run", input, restored, caller);
+  assert.deepEqual(result, {
+    exitCode: 0,
+    logPath:
+      "/workspace/.fungi/runs/call-65a2ca4d35e831fc10077ccde277c7b1e87568b118b8a81bb8f9f9a13c9a15db/out.log",
+  });
+  assert.equal(starts, 1);
+});
+
+void it("tails only the recorded run log on its pinned Computer within the byte bound", async (t) => {
+  const database = new DatabaseSync(":memory:");
+  t.after(() => {
+    database.close();
+  });
+  const runs = createShedRuns({
+    exec(query, ...values) {
+      const rows = database.prepare(query).all(...values);
+      return { toArray: () => rows };
+    },
+  });
+  const process: ComputerProcess = {
+    id: mintComputerProcessId(),
+    port: null,
+    command: "printf hello",
+    cwd: null,
+    state: "running",
+    exitCode: null,
+    sync: "synced",
+    startedAt: 1,
+    endedAt: null,
+  };
+  const reads: unknown[] = [];
+  const context = {
+    runs,
+    env: {
+      COMPUTER: {
+        processStart: () => Promise.resolve(process),
+        processes: () => Promise.resolve({ processes: [process] }),
+        read: (input: {
+          path: string;
+          byteOffset: number;
+          byteLength: number;
+        }) => {
+          reads.push(input);
+          return Promise.resolve({
+            path: input.path,
+            byteOffset: input.byteOffset,
+            content: "aGVsbG8=",
+            encoding: "base64",
+            truncated: true,
+          });
+        },
+      },
+    },
+  };
+  const caller = {
+    actor: { kind: "member", memberId: "member-one" },
+    computerId: "computer-one",
+    idempotencyKey: "log-run",
+  } satisfies Parameters<typeof appBackend.call>[3];
+  await appBackend.call("run", { command: "printf hello" }, context, caller);
+  const result = await appBackend.call(
+    "logs",
+    { run: "log-run", offset: 3, length: 8 },
+    context,
+    caller,
+  );
+  assert.deepEqual(result, {
+    run: "log-run",
+    path: "/workspace/.fungi/runs/call-d60b717068a52378cd93c7967b4dea8b3ca36f28f75c60b920023b34fbbc1bd7/out.log",
+    byteOffset: 3,
+    content: "aGVsbG8=",
+    encoding: "base64",
+    truncated: true,
+  });
+  assert.deepEqual(reads, [
+    {
+      path: "/workspace/.fungi/runs/call-d60b717068a52378cd93c7967b4dea8b3ca36f28f75c60b920023b34fbbc1bd7/out.log",
+      byteOffset: 3,
+      byteLength: 8,
+    },
+  ]);
+  await assert.rejects(
+    appBackend.call(
+      "logs",
+      { run: "log-run", offset: 0, length: 131073 },
+      context,
+      caller,
+    ),
+  );
+  assert.deepEqual(
+    await appBackend.call(
+      "logs",
+      { run: "log-run", offset: 0, length: 8 },
+      context,
+      {
+        ...caller,
+        computerId: "computer-other",
+      },
+    ),
+    { error: "not_found" },
+  );
+  assert.deepEqual(
+    await appBackend.call(
+      "logs",
+      { run: "../../secret", offset: 0, length: 8 },
+      context,
+      caller,
+    ),
+    { error: "not_found" },
+  );
+  assert.equal(reads.length, 1);
+});
+
+void it("returns only an admitted preview and refuses an unexposed port", async (t) => {
+  const database = new DatabaseSync(":memory:");
+  t.after(() => {
+    database.close();
+  });
+  const requests: number[] = [];
+  const context = {
+    runs: createShedRuns({
+      exec(query, ...values) {
+        const rows = database.prepare(query).all(...values);
+        return { toArray: () => rows };
+      },
+    }),
+    env: {
+      COMPUTER: {
+        processStart: () =>
+          Promise.reject(new Error("unexpected process start")),
+        processes: () => Promise.reject(new Error("unexpected process read")),
+        preview: (input: { port: number }): Promise<z.core.util.JSONType> => {
+          requests.push(input.port);
+          if (input.port === 3000)
+            return Promise.resolve({
+              port: input.port,
+              previewUrl: "https://fixture.preview.example/",
+              expiresAt: 5000,
+              openMode: "external-only",
+            });
+          return Promise.resolve({ error: "not_granted" });
+        },
+      },
+    },
+  };
+  const caller = {
+    actor: { kind: "member", memberId: "member-one" },
+    computerId: "computer-one",
+  } satisfies Parameters<typeof appBackend.call>[3];
+  assert.deepEqual(
+    await appBackend.call("expose", { port: 3000 }, context, caller),
+    { previewUrl: "https://fixture.preview.example/", expiresAt: 5000 },
+  );
+  await assert.rejects(
+    appBackend.call("expose", { port: 3001 }, context, caller),
+  );
+  await assert.rejects(appBackend.call("expose", { port: 0 }, context, caller));
+  await assert.rejects(
+    appBackend.call("expose", { port: 3000 }, context, {
+      ...caller,
+      computerId: null,
+    }),
+  );
+  assert.deepEqual(requests, [3000, 3001]);
+});
+
+void it("tees both real shell streams, returns a nonzero exit as a normal result, and never repeats a concurrent or restored call", async (t) => {
+  const database = new DatabaseSync(":memory:");
+  t.after(() => {
+    database.close();
+  });
+  const sql = {
+    exec(query: string, ...values: (string | number | null)[]) {
+      const rows = database.prepare(query).all(...values);
+      return { toArray: () => rows };
+    },
+  };
+  const key = `shell-test-${randomUUID()}`;
+  const root = await mkdtemp(join(tmpdir(), "shed-shell-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  let starts = 0;
+  const computer = {
+    processStart: (input: { command: string; cwd?: string }) =>
+      new Promise<ComputerProcess>((resolve, reject) => {
+        starts++;
+        // Map the fixture Computer workspace onto an isolated local directory.
+        const process = spawn(
+          "bash",
+          ["-c", input.command.replaceAll("/workspace", root)],
+          {
+            cwd: input.cwd,
+            stdio: "ignore",
+          },
+        );
+        process.once("error", reject);
+        process.once("close", (exitCode) => {
+          resolve({
+            id: mintComputerProcessId(),
+            port: null,
+            command: input.command,
+            cwd: input.cwd ?? null,
+            state: "exited",
+            exitCode,
+            sync: "unknown",
+            startedAt: 1,
+            endedAt: 2,
+          });
+        });
+      }),
+    processes: () =>
+      Promise.reject(new Error("completed exit must be remembered")),
+  };
+  const caller = {
+    actor: { kind: "member", memberId: "member-one" },
+    computerId: "computer-one",
+    idempotencyKey: key,
+  } satisfies Parameters<typeof appBackend.call>[3];
+  const context = { runs: createShedRuns(sql), env: { COMPUTER: computer } };
+  const input = {
+    command: `printf '%s\\n' "out with quote: '"; printf 'err\\n' >&2; exit 7`,
+    cwd: root,
+  };
+  const first = appBackend.call("run", input, context, caller);
+  const completed = first.then((reply) => {
+    const result = completedRun.parse(reply);
+    assert.equal(result.exitCode, 7);
+    assert.match(result.logPath, /out\.log$/);
+  });
+  assert.deepEqual(await appBackend.call("run", input, context, caller), {
+    kind: "pending",
+    retryAfterMs: 5000,
+  });
+  await completed;
+  const log = context.runs.logPath(key, caller.computerId, caller.actor);
+  assert.ok("path" in log);
+  assert.match(
+    await readFile(log.path.replaceAll("/workspace", root), "utf8"),
+    /out with quote:.*\nerr\n/,
+  );
+  const restored = { runs: createShedRuns(sql), env: { COMPUTER: computer } };
+  const resumed = completedRun.parse(
+    await appBackend.call("run", input, restored, caller),
+  );
+  assert.equal(resumed.exitCode, 7);
+  assert.equal(starts, 1);
+});
+
+void it("rejects a command whose quoted wrapper exceeds the native bound before claiming a run", async (t) => {
+  const { processStartInputSchema } =
+    await import("@fungi.computer/computer/operations");
+  const database = new DatabaseSync(":memory:");
+  t.after(() => {
+    database.close();
+  });
+  let starts = 0;
+  const context = {
+    runs: createShedRuns({
+      exec(query, ...values) {
+        const rows = database.prepare(query).all(...values);
+        return { toArray: () => rows };
+      },
+    }),
+    env: {
+      COMPUTER: {
+        processStart: (input: { command: string; cwd?: string }) => {
+          starts++;
+          processStartInputSchema
+            .omit({ requestId: true, requestScope: true })
+            .parse(input);
+          return Promise.reject(new Error("unexpected dispatch"));
+        },
+        processes: () => Promise.reject(new Error("unexpected process read")),
+        read: () => Promise.reject(new Error("unexpected log read")),
+      },
+    },
+  };
+  const caller = {
+    actor: { kind: "member", memberId: "member-one" },
+    computerId: "computer-one",
+    idempotencyKey: "oversized-wrapper",
+  } satisfies Parameters<typeof appBackend.call>[3];
+  await assert.rejects(
+    appBackend.call("run", { command: "'".repeat(3000) }, context, caller),
+  );
+  assert.equal(starts, 0);
+  assert.deepEqual(
+    await appBackend.call(
+      "logs",
+      { run: "oversized-wrapper" },
+      context,
+      caller,
+    ),
+    { error: "not_found" },
+  );
+});
+
+void it("requires the host key and Computer, and refuses to restart after a lost start reply", async (t) => {
+  const database = new DatabaseSync(":memory:");
+  t.after(() => {
+    database.close();
+  });
+  const sql = {
+    exec(query: string, ...values: (string | number | null)[]) {
+      const rows = database.prepare(query).all(...values);
+      return { toArray: () => rows };
+    },
+  };
+  let starts = 0;
+  const computer = {
+    processStart: () => {
+      starts++;
+      return Promise.reject(new Error("Start reply lost"));
+    },
+    processes: () =>
+      Promise.reject(new Error("unidentified process must not be guessed")),
+  };
+  const caller = {
+    actor: { kind: "member", memberId: "member-one" },
+    computerId: "computer-one",
+  } satisfies Parameters<typeof appBackend.call>[3];
+  const context = { runs: createShedRuns(sql), env: { COMPUTER: computer } };
+  const input = { command: "printf once" };
+  await assert.rejects(
+    appBackend.call("run", input, context, caller),
+    /host idempotency key/,
+  );
+  await assert.rejects(
+    appBackend.call("run", input, context, {
+      ...caller,
+      computerId: null,
+      idempotencyKey: "lost-reply",
+    }),
+    /Computer access/,
+  );
+  assert.equal(starts, 0);
+  const identified = { ...caller, idempotencyKey: "lost-reply" };
+  await assert.rejects(
+    appBackend.call("run", input, context, identified),
+    /Start reply lost/,
+  );
+  const restored = { runs: createShedRuns(sql), env: { COMPUTER: computer } };
+  await assert.rejects(
+    appBackend.call("run", input, restored, identified),
+    /Process start outcome is unavailable\. Log: .*out\.log/,
+  );
+  await assert.rejects(
+    appBackend.call("run", { command: "different" }, restored, identified),
+    /Run identity conflicts/,
+  );
+  await assert.rejects(
+    appBackend.call("run", input, restored, {
+      ...identified,
+      computerId: "computer-other",
+    }),
+    /Run identity conflicts/,
+  );
+  assert.equal(starts, 1);
+});
+
+void it("publishes run as Pending-capable with its required Computer authority", () => {
+  const { run, logs, expose } = appApi.methods;
+  assert.ok(run);
+  assert.ok(logs);
+  assert.ok(expose);
+  assert.equal(run.pending, true);
+  assert.equal(run.effect, "write");
+  assert.deepEqual(run.requires, ["computer.execute", "computer.writeFile"]);
+  assert.deepEqual(logs.requires, ["computer.readFile"]);
+  assert.equal(logs.effect, "read");
+  assert.equal(expose.effect, "write");
+  assert.deepEqual(expose.requires, ["computer.execute"]);
+  assert.deepEqual(appDeclaration.api, appApi);
+  assert.deepEqual(appDeclaration.backend?.bindings, [
+    {
+      name: "COMPUTER",
+      operations: [
+        "ports",
+        "processes",
+        "exec",
+        "processStart",
+        "processKill",
+        "write",
+        "read",
+        "preview",
+        "workflowGitPass",
+      ],
+    },
+  ]);
+});
+
+void it("renews one Workflow selector while retaining the original process across polls and reopen", async (t) => {
+  const database = new DatabaseSync(":memory:");
+  t.after(() => {
+    database.close();
+  });
+  const sql = {
+    exec(query: string, ...values: (string | number | null)[]) {
+      const rows = database.prepare(query).all(...values);
+      return { toArray: () => rows };
+    },
+  };
+  let clock = 1000;
+  const remote =
+    "https://git.team.internal/workflow/pass_workflow/app_source.git";
+  const gitAccess = {
+    repository: {
+      kind: "installation" as const,
+      installationId: "installation_one",
+      repository: "app_source",
+    },
+    branches: ["refs/heads/main"],
+  };
+  const calls: string[] = [];
+  let starts = 0;
+  let renewals = 0;
+  const process: ComputerProcess = {
+    id: mintComputerProcessId(),
+    port: null,
+    command: "git push",
+    cwd: "/workspace",
+    state: "running",
+    exitCode: null,
+    sync: "synced",
+    startedAt: 1000,
+    endedAt: null,
+  };
+  const computer = {
+    write: (input: { path: string; content: string }) =>
+      Promise.resolve({
+        path: input.path,
+        bytes: new TextEncoder().encode(input.content).byteLength,
+      }),
+    workflowGitPass: () => {
+      renewals++;
+      return Promise.resolve({
+        passId: "pass_workflow",
+        remote,
+        expiresAt: clock + 60000,
+      });
+    },
+    processStart: (input: { command: string; cwd?: string }) => {
+      starts++;
+      calls.push(input.command);
+      return Promise.resolve(process);
+    },
+    processes: () => Promise.resolve({ processes: [process] }),
+  };
+  const caller = {
+    actor: { kind: "member" as const, memberId: "member_one" },
+    computerId: "computer_one",
+    idempotencyKey: "opaque_call_key",
+  };
+  const input = {
+    command: 'git push "$FUNGI_GIT_REMOTE" HEAD:refs/heads/main',
+    cwd: "/workspace",
+    gitAccess,
+  };
+  await appBackend.call(
+    "run",
+    input,
+    { runs: createShedRuns(sql, () => clock), env: { COMPUTER: computer } },
+    caller,
+  );
+  clock = 6000;
+  await appBackend.call(
+    "run",
+    input,
+    { runs: createShedRuns(sql, () => clock), env: { COMPUTER: computer } },
+    caller,
+  );
+  assert.equal(starts, 1);
+  assert.equal(renewals, 2);
+  assert.ok(calls[0]?.includes("FUNGI_GIT_REMOTE"));
+  clock = 61001;
+  await appBackend.call(
+    "run",
+    input,
+    { runs: createShedRuns(sql, () => clock), env: { COMPUTER: computer } },
+    caller,
+  );
+  assert.equal(starts, 1);
+  assert.equal(renewals, 3);
+});
+
+function workflowRunFixture(t: TestContext) {
+  const database = new DatabaseSync(":memory:");
+  t.after(() => {
+    database.close();
+  });
+  const sql = {
+    exec(query: string, ...values: (string | number | null)[]) {
+      const rows = database.prepare(query).all(...values);
+      return { toArray: () => rows };
+    },
+  };
+  let clock = 1000;
+  let starts = 0;
+  let mints = 0;
+  const remote =
+    "https://git.team.internal/workflow/pass_workflow/app_source.git";
+  let pass: z.core.util.JSONType = {
+    passId: "pass_workflow",
+    remote,
+    expiresAt: 61000,
+  };
+  const process: ComputerProcess = {
+    id: mintComputerProcessId(),
+    port: null,
+    command: "git push",
+    cwd: null,
+    state: "running",
+    exitCode: null,
+    sync: "synced",
+    startedAt: 1000,
+    endedAt: null,
+  };
+  const delivered = new Map<string, string>();
+  const computer = {
+    write: (input: { path: string; content: string }) => {
+      delivered.set(input.path, input.content);
+      return Promise.resolve({
+        path: input.path,
+        bytes: new TextEncoder().encode(input.content).byteLength,
+      });
+    },
+    processStart: (input: { command: string; cwd?: string }) => {
+      assert.equal(input.command.includes(remote), false);
+      assert.ok([...delivered.values()].includes(`${remote}\n`));
+      starts++;
+      return Promise.resolve(process);
+    },
+    processes: () => Promise.resolve({ processes: [process] }),
+    workflowGitPass: () => {
+      mints++;
+      return Promise.resolve(pass);
+    },
+  };
+  const context = {
+    runs: createShedRuns(sql, () => clock),
+    env: { COMPUTER: computer },
+  };
+  const caller = {
+    actor: { kind: "member" as const, memberId: "member_one" },
+    computerId: "computer_one",
+    idempotencyKey: "opaque_call_key",
+  };
+  const input: ShedRunInput = {
+    command: "git push",
+    gitAccess: {
+      repository: {
+        kind: "installation",
+        installationId: "installation_one",
+        repository: "app_source",
+      },
+      branches: ["refs/heads/main"],
+    },
+  };
+  return {
+    sql,
+    context,
+    caller,
+    input,
+    computer,
+    process,
+    remote,
+    starts: () => starts,
+    written: () => [...delivered.values()],
+    mints: () => mints,
+    setClock: (value: number) => {
+      clock = value;
+    },
+    setPass: (value: z.core.util.JSONType) => {
+      pass = value;
+    },
+  };
+}
+
+void it("refuses expired or changed selectors without replacing the original process", async (t) => {
+  const f = workflowRunFixture(t);
+  await appBackend.call("run", f.input, f.context, f.caller);
+  f.setClock(61000);
+  await assert.rejects(
+    appBackend.call("run", f.input, f.context, f.caller),
+    /Workflow Git pass expired/,
+  );
+  assert.equal(f.mints(), 1);
+  assert.equal(f.starts(), 1);
+  f.setClock(6000);
+  f.setPass({
+    passId: "pass_other",
+    remote: "https://git.team.internal/workflow/pass_other/app_source.git",
+    expiresAt: 66000,
+  });
+  await assert.rejects(
+    appBackend.call("run", f.input, f.context, f.caller),
+    /changed or expired/,
+  );
+  f.setPass({ error: "revoked" });
+  await assert.rejects(appBackend.call("run", f.input, f.context, f.caller));
+  assert.equal(f.starts(), 1);
+  await assert.rejects(
+    appBackend.call(
+      "run",
+      {
+        ...f.input,
+        gitAccess: {
+          repository: {
+            kind: "installation",
+            installationId: "installation_one",
+            repository: "app_source",
+          },
+          branches: ["refs/heads/other"],
+        },
+      },
+      f.context,
+      f.caller,
+    ),
+    /Run identity conflicts/,
+  );
+});
+
+// Regression coverage for the Storyboard Save defect: a Workflow step's
+// `git push` through Shed `run` exiting non-zero must surface as a normal
+// result the Workflow can read, never as an opaque dispatch failure. Exit 0
+// and a real dispatch failure are the two cases a non-zero exit must stay
+// distinguishable from.
+void it("returns exit 0 as a normal run result", async (t) => {
+  const f = workflowRunFixture(t);
+  assert.deepEqual(await appBackend.call("run", f.input, f.context, f.caller), {
+    kind: "pending",
+    retryAfterMs: 5000,
+  });
+  f.process.state = "exited";
+  f.process.exitCode = 0;
+  f.process.endedAt = 2000;
+  const result = completedRun.parse(
+    await appBackend.call("run", f.input, f.context, f.caller),
+  );
+  assert.equal(result.exitCode, 0);
+});
+
+void it("returns a non-zero git push exit as a normal run result, never dispatch_failed", async (t) => {
+  const f = workflowRunFixture(t);
+  assert.deepEqual(await appBackend.call("run", f.input, f.context, f.caller), {
+    kind: "pending",
+    retryAfterMs: 5000,
+  });
+  f.process.state = "exited";
+  f.process.exitCode = 1;
+  f.process.endedAt = 2000;
+  // The fix is exactly this: the call resolves with the failed exit, it
+  // does not reject. A caller that told dispatch failure from command
+  // failure by catching a throw would mistake this `git push` for a
+  // platform failure.
+  const result = completedRun.parse(
+    await appBackend.call("run", f.input, f.context, f.caller),
+  );
+  assert.equal(result.exitCode, 1);
+  // Resuming an already-exited claim returns the same result, not a throw.
+  const resumed = completedRun.parse(
+    await appBackend.call("run", f.input, f.context, f.caller),
+  );
+  assert.deepEqual(resumed, result);
+});
+
+void it("still throws on a real dispatch failure, distinct from a non-zero exit", async (t) => {
+  const f = workflowRunFixture(t);
+  f.computer.processStart = () =>
+    Promise.reject(new Error("the Computer could not be reached"));
+  await assert.rejects(
+    appBackend.call("run", f.input, f.context, f.caller),
+    /the Computer could not be reached/,
+  );
+});
+
+void it("claims no process when the Workflow binding is missing or refuses", async (t) => {
+  const f = workflowRunFixture(t);
+  const { workflowGitPass: omitted, ...withoutPass } = f.computer;
+  assert.ok(omitted);
+  await assert.rejects(
+    appBackend.call(
+      "run",
+      f.input,
+      { ...f.context, env: { COMPUTER: withoutPass } },
+      f.caller,
+    ),
+    /binding is unavailable/,
+  );
+  f.setPass({ error: "not_granted" });
+  await assert.rejects(appBackend.call("run", f.input, f.context, f.caller));
+  assert.equal(f.starts(), 0);
+  f.setPass({ passId: "pass_workflow", remote: f.remote, expiresAt: 61000 });
+  await appBackend.call(
+    "run",
+    { ...f.input, command: "printf fixed" },
+    f.context,
+    f.caller,
+  );
+  assert.equal(f.starts(), 1);
+});
+
+void it("uses the canonical resolved scope grammar before minting", async (t) => {
+  const f = workflowRunFixture(t);
+  for (const gitAccess of [
+    { repository: "$trigger.repository", branches: ["refs/heads/main"] },
+    {
+      repository: {
+        kind: "installation",
+        installationId: "installation_one",
+        repository: "app_source",
+      },
+      branches: ["refs/heads/*"],
+    },
+    {
+      repository: {
+        kind: "installation",
+        installationId: "installation_one",
+        repository: "app_source",
+      },
+      branches: ["refs/heads/main"],
+      memberId: "untrusted",
+    },
+  ])
+    await assert.rejects(
+      appBackend.call(
+        "run",
+        z.json().parse({ ...f.input, gitAccess }),
+        f.context,
+        f.caller,
+      ),
+    );
+  assert.equal(f.starts(), 0);
+  assert.equal(f.mints(), 0);
+});
+
+void it("passes the complete Workflow URL only through the command-local shell environment", async (t) => {
+  const root = await mkdtemp(join(tmpdir(), "shed-workflow-remote-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const f = workflowRunFixture(t);
+  let credentialPath = "";
+  f.computer.write = (input: { path: string; content: string }) => {
+    credentialPath = input.path.replaceAll("/workspace", root);
+    return writeFile(
+      input.path.replaceAll("/workspace", root),
+      input.content,
+    ).then(() => ({
+      path: input.path,
+      bytes: new TextEncoder().encode(input.content).byteLength,
+    }));
+  };
+  f.computer.processStart = (input: { command: string; cwd?: string }) =>
+    new Promise((resolve, reject) => {
+      const child = spawn(
+        "bash",
+        ["-c", input.command.replaceAll("/workspace", root)],
+        { cwd: root, stdio: "ignore" },
+      );
+      child.once("error", reject);
+      child.once("exit", (code) => {
+        resolve({
+          ...f.process,
+          state: "exited",
+          exitCode: code,
+          endedAt: 1001,
+        });
+      });
+    });
+  const input = {
+    ...f.input,
+    command:
+      'test "$FUNGI_GIT_REMOTE" = "https://git.team.internal/workflow/pass_workflow/app_source.git" && ! test -e .fungi-git-58fc43972eaef9e869f7a384f4da68f65c6b660f84e3d7fa4332f89ac6ceb7e3.remote && printf remote-matched',
+  };
+  const result = await appBackend.call("run", input, f.context, f.caller);
+  assert.deepEqual(result, {
+    exitCode: 0,
+    logPath:
+      "/workspace/.fungi/runs/call-58fc43972eaef9e869f7a384f4da68f65c6b660f84e3d7fa4332f89ac6ceb7e3/out.log",
+  });
+  assert.equal(
+    await readFile(
+      join(
+        root,
+        ".fungi/runs/call-58fc43972eaef9e869f7a384f4da68f65c6b660f84e3d7fa4332f89ac6ceb7e3/out.log",
+      ),
+      "utf8",
+    ),
+    "remote-matched",
+  );
+  await assert.rejects(readFile(credentialPath), { code: "ENOENT" });
+});
+
+void it("gives a bearer pass to git only as command-local extraHeader config", async (t) => {
+  const root = await mkdtemp(join(tmpdir(), "shed-workflow-bearer-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const f = workflowRunFixture(t);
+  const remote = "https://oyster.test/git/bonsai/pond.git";
+  const bearer = `wgp.workflows.${"b".repeat(64)}`;
+  f.setPass({ passId: "pass_workflow", remote, bearer, expiresAt: 61000 });
+  await writeFile(
+    join(root, "expected-header"),
+    `Authorization: Bearer ${bearer}`,
+  );
+  await writeFile(join(root, "expected-secret"), "b".repeat(64));
+  let credentialPath = "";
+  let started = "";
+  f.computer.write = (input: { path: string; content: string }) => {
+    credentialPath = input.path.replaceAll("/workspace", root);
+    return writeFile(credentialPath, input.content).then(() => ({
+      path: input.path,
+      bytes: new TextEncoder().encode(input.content).byteLength,
+    }));
+  };
+  f.computer.processStart = (input: { command: string; cwd?: string }) => {
+    started = input.command;
+    return new Promise((resolve, reject) => {
+      const child = spawn(
+        "bash",
+        ["-c", input.command.replaceAll("/workspace", root)],
+        { cwd: root, stdio: "ignore", env: { PATH: process.env.PATH } },
+      );
+      child.once("error", reject);
+      child.once("exit", (code) => {
+        resolve({
+          ...f.process,
+          state: "exited",
+          exitCode: code,
+          endedAt: 1001,
+        });
+      });
+    });
+  };
+  const input = {
+    ...f.input,
+    command: [
+      "git init -q repo",
+      'test "$FUNGI_GIT_REMOTE" = "https://oyster.test/git/bonsai/pond.git"',
+      // The expected header comes from a file, so the command never names it.
+      'test "$(git -C repo config --get-urlmatch http.extraHeader "$FUNGI_GIT_REMOTE")" = "$(cat expected-header)"',
+      'test -z "$(git -C repo config --get-urlmatch http.extraHeader https://elsewhere.test/x.git)"',
+      '! grep -qF "$(cat expected-secret)" repo/.git/config',
+      "printf header-scoped",
+    ].join(" && "),
+  };
+  const result = await appBackend.call("run", input, f.context, f.caller);
+  assert.equal(z.object({ exitCode: z.number() }).parse(result).exitCode, 0);
+  assert.equal(started.includes("b".repeat(64)), false);
+  await assert.rejects(readFile(credentialPath), { code: "ENOENT" });
+});
+
+void it("returns a running process at start and reuses its durable claim after reopening", async (t) => {
+  const database = new DatabaseSync(":memory:");
+  t.after(() => {
+    database.close();
+  });
+  const sql = {
+    exec(query: string, ...values: (string | number | null)[]) {
+      const rows = database.prepare(query).all(...values);
+      return { toArray: () => rows };
+    },
+  };
+  const process: ComputerProcess = {
+    id: mintComputerProcessId(),
+    port: null,
+    command: "sleep 120",
+    cwd: "/workspace",
+    state: "running",
+    exitCode: null,
+    sync: "synced",
+    startedAt: 1,
+    endedAt: null,
+  };
+  let starts = 0;
+  const computer = {
+    processStart: (input: { command: string; cwd?: string }) => {
+      starts++;
+      assert.match(input.command, /tee/);
+      assert.equal(input.cwd, "/workspace");
+      return Promise.resolve(process);
+    },
+    processes: () => Promise.resolve({ processes: [process] }),
+  };
+  const caller = {
+    actor: { kind: "member", memberId: "member-one" },
+    computerId: "computer-one",
+    idempotencyKey: "server-one",
+  } satisfies Parameters<typeof appBackend.call>[3];
+  const input = { command: "sleep 120", cwd: "/workspace" };
+  const context = { runs: createShedRuns(sql), env: { COMPUTER: computer } };
+  const expected = {
+    process,
+    logPath:
+      "/workspace/.fungi/runs/call-0f0f9a06650856cadfd8d3abfa0af4470f4640be6edaecd068a39e221522acb6/out.log",
+  };
+  assert.deepEqual(
+    await appBackend.call("start", input, context, caller),
+    expected,
+  );
+  const restored = { runs: createShedRuns(sql), env: { COMPUTER: computer } };
+  assert.deepEqual(
+    await appBackend.call("start", input, restored, caller),
+    expected,
+  );
+  assert.equal(starts, 1);
+  await assert.rejects(
+    appBackend.call("start", { command: "different" }, restored, caller),
+    /identity conflicts/,
+  );
+  assert.equal(starts, 1);
+});
+
+void it("recovers a lost start reply with the same native input instead of starting another process", async (t) => {
+  const database = new DatabaseSync(":memory:");
+  t.after(() => {
+    database.close();
+  });
+  const sql = {
+    exec(query: string, ...values: (string | number | null)[]) {
+      const rows = database.prepare(query).all(...values);
+      return { toArray: () => rows };
+    },
+  };
+  const process: ComputerProcess = {
+    id: mintComputerProcessId(),
+    port: null,
+    command: "sleep 120",
+    cwd: null,
+    state: "running",
+    exitCode: null,
+    sync: "synced",
+    startedAt: 1,
+    endedAt: null,
+  };
+  const requests: unknown[] = [];
+  const computer = {
+    // The native Computer owns replay identity; the binding retains the host call key.
+    processStart: (input: { command: string; cwd?: string }) => {
+      requests.push(input);
+      if (requests.length === 1)
+        return Promise.reject(new Error("Start reply lost"));
+      return Promise.resolve(process);
+    },
+    processes: () => Promise.resolve({ processes: [process] }),
+  };
+  const caller = {
+    actor: { kind: "member", memberId: "member-one" },
+    computerId: "computer-one",
+    idempotencyKey: "lost-server-start",
+  } satisfies Parameters<typeof appBackend.call>[3];
+  const input = { command: "sleep 120" };
+  await assert.rejects(
+    appBackend.call(
+      "start",
+      input,
+      { runs: createShedRuns(sql), env: { COMPUTER: computer } },
+      caller,
+    ),
+    /Start reply lost/,
+  );
+  const reply = await appBackend.call(
+    "start",
+    input,
+    { runs: createShedRuns(sql), env: { COMPUTER: computer } },
+    caller,
+  );
+  assert.deepEqual(reply, {
+    process,
+    logPath:
+      "/workspace/.fungi/runs/call-e0f1dcd3d2ff59ec53abdaaf0e9686d4b6d0ccb461cd8f8de397fb59cc5719bc/out.log",
+  });
+  assert.equal(requests.length, 2);
+  assert.deepEqual(requests[1], requests[0]);
+});
+
+void it("starts a declared port and binds retry identity to the native process port", async (t) => {
+  const database = new DatabaseSync(":memory:");
+  t.after(() => {
+    database.close();
+  });
+  const sql = {
+    exec(query: string, ...values: (string | number | null)[]) {
+      const rows = database.prepare(query).all(...values);
+      return { toArray: () => rows };
+    },
+  };
+  const process = {
+    id: mintComputerProcessId(),
+    command: "node server.js",
+    cwd: null,
+    port: 3000,
+    state: "running",
+    exitCode: null,
+    sync: "unknown",
+    startedAt: 1,
+    endedAt: null,
+  };
+  const requests: unknown[] = [];
+  const computer = {
+    processStart: (input: { command: string; cwd?: string; port?: number }) => {
+      requests.push(input);
+      assert.equal(input.port, 3000);
+      assert.equal("requestId" in input, false);
+      assert.equal("requestScope" in input, false);
+      return Promise.resolve(process);
+    },
+    processes: () => Promise.resolve({ processes: [process] }),
+  };
+  const caller = {
+    actor: { kind: "member", memberId: "member-one" },
+    computerId: "computer-one",
+    idempotencyKey: "port-server",
+  } satisfies Parameters<typeof appBackend.call>[3];
+  const input: ShedStartInput = { command: "node server.js", port: 3000 };
+  const result = await appBackend.call(
+    "start",
+    input,
+    { runs: createShedRuns(sql), env: { COMPUTER: computer } },
+    caller,
+  );
+  assert.deepEqual(result, {
+    process,
+    logPath:
+      "/workspace/.fungi/runs/call-2cdee24467fcd4a5ee2327b807f614582c9e2cc2d42f90f577fe001d5a0ca118/out.log",
+    port: 3000,
+  });
+  const restored = { runs: createShedRuns(sql), env: { COMPUTER: computer } };
+  assert.deepEqual(
+    await appBackend.call("start", input, restored, caller),
+    result,
+  );
+  await assert.rejects(
+    appBackend.call("start", { ...input, port: 3001 }, restored, caller),
+    /identity conflicts/,
+  );
+  for (const selector of [
+    { requestId: "guest-selected" },
+    { requestScope: "installation:other" },
+    { computerId: "computer-other" },
+    { method: "guest-selected" },
+  ]) {
+    await assert.rejects(
+      appBackend.call(
+        "start",
+        z.json().parse({ ...input, ...selector }),
+        restored,
+        caller,
+      ),
+      /Unrecognized key/,
+    );
+  }
+  await assert.rejects(
+    appBackend.call("run", input, restored, caller),
+    /Unrecognized key/,
+  );
+  assert.equal(requests.length, 1);
+});
+
+void it("replays an already started process without renewing its expired Workflow Git pass", async (t) => {
+  const fixture = workflowRunFixture(t);
+  const expected = {
+    process: fixture.process,
+    logPath:
+      "/workspace/.fungi/runs/call-9a64fff978ad485e46f9452873bb5507312585c79c4265d164886c2e7cdc347c/out.log",
+  };
+  assert.deepEqual(
+    await appBackend.call(
+      "start",
+      fixture.input,
+      fixture.context,
+      fixture.caller,
+    ),
+    expected,
+  );
+  fixture.setClock(61000);
+  assert.deepEqual(
+    await appBackend.call(
+      "start",
+      fixture.input,
+      fixture.context,
+      fixture.caller,
+    ),
+    expected,
+  );
+  assert.equal(fixture.starts(), 1);
+  assert.equal(fixture.mints(), 1);
+});
+
+void it("starts a separate native process and Git pass for another member with the same raw key", async (t) => {
+  const f = workflowRunFixture(t);
+  const commands: string[] = [];
+  const processes: ComputerProcess[] = [];
+  f.computer.processes = () => Promise.resolve({ processes });
+  f.computer.processStart = (input: { command: string; cwd?: string }) => {
+    commands.push(input.command);
+    const process = { ...f.process, id: mintComputerProcessId() };
+    processes.push(process);
+    return Promise.resolve(process);
+  };
+  const first = await appBackend.call("start", f.input, f.context, f.caller);
+  const secondRemote = "https://git.fixture/member-b.git";
+  f.setPass({
+    passId: "pass_member_b",
+    remote: secondRemote,
+    expiresAt: 60000,
+  });
+  const secondCaller = {
+    ...f.caller,
+    actor: { kind: "member", memberId: "member_b" },
+  } satisfies Parameters<typeof appBackend.call>[3];
+  const second = await appBackend.call(
+    "start",
+    f.input,
+    f.context,
+    secondCaller,
+  );
+  assert.equal(commands.length, 2, "member-b must reach its own native start");
+  assert.equal(f.mints(), 2);
+  assert.equal(f.written().length, 2);
+  assert.equal(f.written()[0], `${f.remote}\n`);
+  assert.equal(f.written()[1], `${secondRemote}\n`);
+  assert.equal(commands[0]?.includes(f.remote), false);
+  assert.equal(commands[1]?.includes(secondRemote), false);
+  assert.notEqual(commands[0], commands[1]);
+  assert.equal(commands[1].includes(f.remote), false);
+  assert.notDeepEqual(second, first);
+});
+
+void it("does not read another member's raw-key log or dispatch a file read", async (t) => {
+  const f = workflowRunFixture(t);
+  await appBackend.call("start", f.input, f.context, f.caller);
+  let reads = 0;
+  const context = {
+    ...f.context,
+    env: {
+      COMPUTER: {
+        ...f.computer,
+        read: (input: {
+          path: string;
+          byteOffset: number;
+          byteLength: number;
+        }) => {
+          reads++;
+          return Promise.resolve({
+            path: input.path,
+            byteOffset: input.byteOffset,
+            content: "",
+            encoding: "base64",
+            truncated: false,
+          });
+        },
+      },
+    },
+  };
+  const caller = {
+    ...f.caller,
+    actor: { kind: "member", memberId: "member_b" },
+  } satisfies Parameters<typeof appBackend.call>[3];
+  assert.deepEqual(
+    await appBackend.call(
+      "logs",
+      { run: f.caller.idempotencyKey },
+      context,
+      caller,
+    ),
+    { error: "not_found" },
+  );
+  assert.equal(reads, 0);
+});
+
+void it("separates start and run claims, refusing an ambiguous member raw-key log without reading", async (t) => {
+  const f = workflowRunFixture(t);
+  await appBackend.call("start", f.input, f.context, f.caller);
+  await appBackend.call("run", f.input, f.context, f.caller);
+  assert.equal(f.starts(), 2);
+  let reads = 0;
+  const context = {
+    ...f.context,
+    env: {
+      COMPUTER: {
+        ...f.computer,
+        read: (input: {
+          path: string;
+          byteOffset: number;
+          byteLength: number;
+        }) => {
+          reads++;
+          return Promise.resolve({
+            path: input.path,
+            byteOffset: input.byteOffset,
+            content: "",
+            encoding: "base64",
+            truncated: false,
+          });
+        },
+      },
+    },
+  };
+  assert.deepEqual(
+    await appBackend.call(
+      "logs",
+      { run: f.caller.idempotencyKey },
+      context,
+      f.caller,
+    ),
+    { error: "ambiguous" },
+  );
+  assert.equal(reads, 0);
+});
+
+void it("does not read an old unscoped claim whose raw key resembles a scoped identity", async (t) => {
+  const f = workflowRunFixture(t);
+  const scopedKey = JSON.stringify([
+    f.caller.actor,
+    "run",
+    f.caller.idempotencyKey,
+  ]);
+  // Seed the previous shipped unscoped ledger, including an arbitrary raw key.
+  const database = new DatabaseSync(":memory:");
+  t.after(() => {
+    database.close();
+  });
+  database.exec(
+    "CREATE TABLE shed_runs (requestKey TEXT PRIMARY KEY, computerId TEXT NOT NULL, command TEXT NOT NULL, cwd TEXT, processId TEXT, phase TEXT NOT NULL, exitCode INTEGER, logPath TEXT NOT NULL, gitAccess TEXT, passId TEXT, remote TEXT, expiresAt INTEGER)",
+  );
+  database
+    .prepare(
+      "INSERT INTO shed_runs (requestKey, computerId, command, phase, exitCode, logPath) VALUES (?, ?, ?, 'exited', 0, ?)",
+    )
+    .run(
+      scopedKey,
+      f.caller.computerId,
+      "printf fresh",
+      "/workspace/.fungi/runs/old-owner/out.log",
+    );
+  const runs = createShedRuns({
+    exec(query, ...values) {
+      const rows = database.prepare(query).all(...values);
+      return { toArray: () => rows };
+    },
+  });
+  let starts = 0;
+  const context = {
+    runs,
+    env: {
+      COMPUTER: {
+        ...f.computer,
+        processStart: () => {
+          starts++;
+          return Promise.resolve(f.process);
+        },
+      },
+    },
+  };
+  assert.deepEqual(
+    await appBackend.call(
+      "run",
+      { command: "printf fresh" },
+      context,
+      f.caller,
+    ),
+    { kind: "pending", retryAfterMs: 5000 },
+  );
+  assert.equal(starts, 1);
+});
+
+void it("recovers run after a parsed pre-dispatch refusal without starting twice", async (t) => {
+  const f = workflowRunFixture(t);
+  let requests = 0;
+  let starts = 0;
+  const context = {
+    ...f.context,
+    env: {
+      COMPUTER: {
+        ...f.computer,
+        processStart: () => {
+          requests++;
+          if (requests === 1) return Promise.resolve({ error: "unavailable" });
+          starts++;
+          return Promise.resolve(f.process);
+        },
+      },
+    },
+  };
+  const input = { command: "sleep 120" };
+  assert.deepEqual(await appBackend.call("run", input, context, f.caller), {
+    error: "unavailable",
+  });
+  assert.deepEqual(await appBackend.call("run", input, context, f.caller), {
+    kind: "pending",
+    retryAfterMs: 5000,
+  });
+  assert.equal(starts, 1);
+});
+
+void it("returns not_found without reading a log after start is refused", async (t) => {
+  const f = workflowRunFixture(t);
+  let reads = 0;
+  const context = {
+    ...f.context,
+    env: {
+      COMPUTER: {
+        ...f.computer,
+        processStart: () => Promise.resolve({ error: "revoked" }),
+        read: () => {
+          reads++;
+          return Promise.reject(new Error("No log was written"));
+        },
+      },
+    },
+  };
+  assert.deepEqual(
+    await appBackend.call("start", { command: "sleep 120" }, context, f.caller),
+    { error: "revoked" },
+  );
+  assert.deepEqual(
+    await appBackend.call(
+      "logs",
+      { run: f.caller.idempotencyKey },
+      context,
+      f.caller,
+    ),
+    { error: "not_found" },
+  );
+  assert.equal(reads, 0);
+});
+
+void it("refuses the same member raw-key log on a different Computer with zero reads", async (t) => {
+  const f = workflowRunFixture(t);
+  await appBackend.call("start", f.input, f.context, f.caller);
+  let reads = 0;
+  const context = {
+    ...f.context,
+    env: {
+      COMPUTER: {
+        ...f.computer,
+        read: () => {
+          reads++;
+          return Promise.reject(new Error("Wrong Computer read"));
+        },
+      },
+    },
+  };
+  assert.deepEqual(
+    await appBackend.call("logs", { run: f.caller.idempotencyKey }, context, {
+      ...f.caller,
+      computerId: "computer_other",
+    }),
+    { error: "not_found" },
+  );
+  assert.equal(reads, 0);
+});
+
+const refusedActors: HostActor[] = [
+  { kind: "agent", agentId: "agent_other" },
+  { kind: "team-key", keyId: "key_other" },
+];
+for (const actor of refusedActors)
+  for (const method of ["start", "run"]) {
+    void it(`refuses ${actor.kind} ${method} before a native start or dangling claim`, async (t) => {
+      const f = workflowRunFixture(t);
+      let starts = 0;
+      const context = {
+        ...f.context,
+        env: {
+          COMPUTER: {
+            ...f.computer,
+            processStart: () => {
+              starts++;
+              return Promise.resolve(f.process);
+            },
+          },
+        },
+      };
+      assert.deepEqual(
+        await appBackend.call(method, { command: "sleep 120" }, context, {
+          ...f.caller,
+          actor,
+        }),
+        { error: "not_granted" },
+      );
+      assert.equal(starts, 0);
+      assert.equal(
+        f.sql.exec("SELECT * FROM shed_process_claims").toArray().length,
+        0,
+      );
+    });
+  }
+
+void it("stops only a process claimed by this actor on this Computer", async (t) => {
+  const f = workflowRunFixture(t);
+  await appBackend.call("start", f.input, f.context, f.caller);
+  let kills = 0;
+  const reply = { process: f.process, signalled: true };
+  const context = {
+    ...f.context,
+    env: {
+      COMPUTER: {
+        ...f.computer,
+        processKill: () => {
+          kills++;
+          return Promise.resolve(reply);
+        },
+      },
+    },
+  };
+  assert.deepEqual(
+    await appBackend.call("stop", { id: f.process.id }, context, {
+      ...f.caller,
+      actor: { kind: "member", memberId: "member_other" },
+    }),
+    { error: "not_found" },
+  );
+  assert.deepEqual(
+    await appBackend.call(
+      "stop",
+      { id: mintComputerProcessId() },
+      context,
+      f.caller,
+    ),
+    { error: "not_found" },
+  );
+  assert.deepEqual(
+    await appBackend.call("stop", { id: f.process.id }, context, {
+      ...f.caller,
+      computerId: "computer_other",
+    }),
+    { error: "not_found" },
+  );
+  assert.equal(kills, 0);
+  assert.deepEqual(
+    await appBackend.call("stop", { id: f.process.id }, context, f.caller),
+    reply,
+  );
+  assert.equal(kills, 1);
+});
+
+void it("keeps the bearer Git remote out of native stored command metadata", async (t) => {
+  const f = workflowRunFixture(t);
+  let storedCommand = "";
+  let delivered = "";
+  const context = {
+    ...f.context,
+    env: {
+      COMPUTER: {
+        ...f.computer,
+        write: (input: { path: string; content: string }) => {
+          delivered = input.content;
+          return Promise.resolve({
+            path: input.path,
+            bytes: new TextEncoder().encode(input.content).byteLength,
+          });
+        },
+        processStart: (input: { command: string; cwd?: string }) => {
+          storedCommand = input.command;
+          return Promise.resolve({ ...f.process, command: storedCommand });
+        },
+      },
+    },
+  };
+  await appBackend.call("start", f.input, context, f.caller);
+  assert.equal(storedCommand.includes(f.remote), false);
+  assert.equal(delivered, `${f.remote}\n`);
+});
+
+void it("does not reuse an expired Git remote while redispatching an uncertain start", async (t) => {
+  const f = workflowRunFixture(t);
+  let starts = 0;
+  let writes = 0;
+  const write = f.computer.write;
+  f.computer.write = (input) => {
+    writes++;
+    return write(input);
+  };
+  f.computer.processStart = () => {
+    starts++;
+    return Promise.reject(new Error("Reply lost"));
+  };
+  await assert.rejects(
+    appBackend.call("start", f.input, f.context, f.caller),
+    /Reply lost/,
+  );
+  const writesBeforeExpiry = writes;
+  f.setClock(61000);
+  await assert.rejects(
+    appBackend.call("start", f.input, f.context, f.caller),
+    /expired/,
+  );
+  assert.equal(starts, 1);
+  assert.equal(writes, writesBeforeExpiry);
+});
+
+void it("retires full claims with the native window and never starts a second process for a pruned uncertain key", async (t) => {
+  const f = workflowRunFixture(t);
+  const retained = new Map<string, ComputerProcess>();
+  let starts = 0;
+  const computer = {
+    processStart(input: { command: string; cwd?: string }) {
+      let process = retained.get(input.command);
+      if (!process) {
+        starts++;
+        process = {
+          ...f.process,
+          id: mintComputerProcessId(),
+          command: input.command,
+          state: "exited",
+          exitCode: 0,
+          startedAt: starts,
+          endedAt: starts,
+        };
+        retained.set(input.command, process);
+        while (retained.size > 64) {
+          const oldest = retained.keys().next().value;
+          assert.notEqual(oldest, undefined);
+          if (oldest !== undefined) retained.delete(oldest);
+        }
+        if (starts === 1) return Promise.reject(new Error("Reply lost"));
+      }
+      return Promise.resolve(process);
+    },
+    processes: () => Promise.resolve({ processes: [...retained.values()] }),
+  };
+  const context = { ...f.context, env: { COMPUTER: computer } };
+  const input = { command: "printf done" };
+  await assert.rejects(
+    appBackend.call("start", input, context, f.caller),
+    /Reply lost/,
+  );
+  for (let index = 0; index < 64; index++)
+    await appBackend.call("start", input, context, {
+      ...f.caller,
+      idempotencyKey: `fresh-${String(index)}`,
+    });
+  assert.deepEqual(await appBackend.call("start", input, context, f.caller), {
+    error: "not_found",
+  });
+  assert.equal(starts, 65);
+  assert.equal(
+    f.sql.exec("SELECT * FROM shed_process_claims").toArray().length,
+    64,
+  );
+});
+
+for (const mode of ["start", "run"] as const)
+  void it(`preserves a running ${mode} claim omitted from the global newest-64 listing`, async (t) => {
+    const f = workflowRunFixture(t);
+    const owned = new Map<string, ComputerProcess>();
+    const foreign = Array.from({ length: 64 }, (_, index) => ({
+      ...f.process,
+      id: mintComputerProcessId(),
+      startedAt: 1000 + index,
+      state: "exited" as const,
+      exitCode: 0,
+      endedAt: 2000,
+    }));
+    let truncated = false;
+    const computer = {
+      processStart: (input: { command: string }) => {
+        const process: ComputerProcess = {
+          ...f.process,
+          id: mintComputerProcessId(),
+          command: input.command,
+          state: owned.size === 0 ? "running" : "exited",
+          exitCode: owned.size === 0 ? null : 0,
+          endedAt: owned.size === 0 ? null : 2000,
+        };
+        owned.set(input.command, process);
+        return Promise.resolve(process);
+      },
+      processes: () =>
+        Promise.resolve({
+          processes: truncated ? foreign : [...owned.values()].slice(0, 64),
+        }),
+      processKill: () =>
+        Promise.resolve({ process: f.process, signalled: true }),
+    };
+    const context = { ...f.context, env: { COMPUTER: computer } };
+    const input = { command: "sleep 120" };
+    const first = await appBackend.call(mode, input, context, f.caller);
+    const firstProcess = [...owned.values()][0];
+    assert.ok(firstProcess);
+    // Simulate a scope at capacity; other scopes displace its oldest live record.
+    for (let index = 0; index < 63; index++) {
+      await appBackend.call(mode, input, context, {
+        ...f.caller,
+        idempotencyKey: `owned-${String(index)}`,
+      });
+    }
+    truncated = true;
+    await appBackend.call(mode, input, context, {
+      ...f.caller,
+      idempotencyKey: "next-call",
+    });
+    assert.equal(
+      f.context.runs.owns(firstProcess.id, f.caller.computerId, f.caller.actor),
+      true,
+    );
+    assert.ok(
+      "path" in
+        f.context.runs.logPath(
+          f.caller.idempotencyKey,
+          f.caller.computerId,
+          f.caller.actor,
+        ),
+    );
+    assert.deepEqual(
+      await appBackend.call("stop", { id: firstProcess.id }, context, f.caller),
+      { process: f.process, signalled: true },
+    );
+    truncated = false;
+    assert.deepEqual(
+      await appBackend.call(mode, input, context, f.caller),
+      first,
+    );
+  });
+
+void it("bounds retired markers per member and method to the latest 64 retired calls", async (t) => {
+  const f = workflowRunFixture(t);
+  let starts = 0;
+  const computer = {
+    processStart: (input: { command: string }) => {
+      starts++;
+      return Promise.resolve({
+        ...f.process,
+        id: mintComputerProcessId(),
+        command: input.command,
+        state: "exited",
+        exitCode: 0,
+        startedAt: starts,
+        endedAt: starts,
+      });
+    },
+    processes: () => Promise.resolve({ processes: [] }),
+  };
+  const context = { ...f.context, env: { COMPUTER: computer } };
+  for (let index = 0; index < 260; index++) {
+    await appBackend.call("start", { command: "true" }, context, {
+      ...f.caller,
+      idempotencyKey: `bounded-${String(index)}`,
+    });
+  }
+  assert.equal(
+    f.sql.exec("SELECT * FROM shed_retired_claim_keys").toArray().length,
+    64,
+  );
+  assert.deepEqual(
+    await appBackend.call("start", { command: "true" }, context, {
+      ...f.caller,
+      idempotencyKey: "bounded-195",
+    }),
+    { error: "not_found" },
+  );
+  assert.equal(starts, 260);
+});
+
+void it("keeps the native command identity stable across a Git refusal and re-mint", async (t) => {
+  const f = workflowRunFixture(t);
+  const accepted = new Map<string, ComputerProcess>();
+  let calls = 0;
+  const processStart = (input: { command: string }) => {
+    calls++;
+    let process = accepted.get(input.command);
+    if (!process) {
+      process = { ...f.process, command: input.command };
+      accepted.set(input.command, process);
+    }
+    // Simulate a refusal after acceptance; the native key/command pair must replay.
+    return Promise.resolve(calls === 1 ? { error: "unavailable" } : process);
+  };
+  const context = {
+    ...f.context,
+    env: { COMPUTER: { ...f.computer, processStart } },
+  };
+  assert.deepEqual(await appBackend.call("start", f.input, context, f.caller), {
+    error: "unavailable",
+  });
+  f.setPass({
+    passId: "pass_reminted",
+    remote: "https://git.team.internal/workflow/pass_reminted/app_source.git",
+    expiresAt: 61000,
+  });
+  await appBackend.call("start", f.input, context, f.caller);
+  assert.equal(f.mints(), 2);
+  assert.equal(accepted.size, 1);
+  assert.equal(calls, 2);
+});