@fungi.computer/bonsai 0.0.0-stage → 0.1.0

package/test/file-edits.test.ts

@@ -0,0 +1,2714 @@
+import * as z from "zod";
+import { replayKey } from "@fungi.computer/cairn";
+import { DatabaseSync } from "node:sqlite";
+import { afterEach, expect, it } from "vitest";
+import { fromNodeSqlite } from "@fungi.computer/watchdog/node-sqlite";
+import { commitFiles } from "@fungi.computer/agar/git-commit";
+import { GitStepMaterialError } from "@fungi.computer/agar/git-steps";
+import { countingGit } from "@fungi.computer/agar/read-copy";
+import { realGit } from "@fungi.computer/agar/test-kit/git";
+import { gitStore } from "../backend/git.js";
+import { BonsaiState, ensureBonsaiTables } from "../backend/state.js";
+import { appBackend } from "../backend/methods.js";
+import { observePush } from "../backend/service.js";
+import { getRepoDetail } from "../backend/repository-copy.js";
+import { readFileCopy } from "../backend/files-copy.js";
+import { refuseBackground } from "../backend/background.js";
+import {
+  saveFileEdit,
+  executeQueuedFileEdit,
+  cleanupSettledFileEdit,
+  projectQueuedFileEdit,
+  fileEditJobSchema,
+} from "../backend/file-edits.js";
+import {
+  actorLane,
+  backgroundContext,
+  backgroundOriginKey,
+  sealBackgroundOrigin,
+  admitClaimedOrigin,
+} from "@fungi.computer/puffball/background-replay";
+import {
+  Watchdog,
+  type ConcurrentWatchdogRuntime,
+} from "@fungi.computer/watchdog";
+import type {
+  WatchdogQueuedJob,
+  WatchdogRunningJob,
+} from "@fungi.computer/watchdog";
+import type { AppMethodCallContext } from "@fungi.computer/puffball/app-method-runtime";
+import { jsonValue, type JsonValue } from "../shared/contract.js";
+import {
+  fileContent,
+  fileSaveInput,
+  fileSaveResult,
+} from "@fungi.computer/agar/roles/files";
+import * as Schema from "effect/Schema";
+import { appDeclarationSchema } from "@fungi.computer/puffball/app";
+import { buildAppDeclaration } from "@fungi.computer/agar/backend-declaration";
+import { appBackend as bonsaiBackend } from "../backend/methods.js";
+import bonsaiMetadata from "../package.json" with { type: "json" };
+const appDeclaration = buildAppDeclaration(
+  bonsaiBackend,
+  bonsaiMetadata.fungi.app,
+);
+
+const close: (() => void)[] = [];
+afterEach(() => {
+  for (const dispose of close.splice(0)) dispose();
+});
+const encode = (text: string) => new TextEncoder().encode(text);
+const member = {
+  actor: { kind: "member" as const, memberId: "owner" },
+  computerId: null,
+};
+async function sealedWrite(
+  caller: AppMethodCallContext,
+  method = "files.save",
+) {
+  const key = await backgroundOriginKey("file-sync-native-owner-test");
+  const origin = await sealBackgroundOrigin(key, {
+    instanceId: "bonsai-test",
+    lane: actorLane(caller.actor),
+    method,
+  });
+  return backgroundContext(
+    caller,
+    [],
+    { name: method, effect: "write" },
+    origin,
+  );
+}
+async function claimedAdmission(caller: AppMethodCallContext = member) {
+  const key = await backgroundOriginKey("file-sync-native-owner-test");
+  return {
+    admit: (origin: Parameters<typeof admitClaimedOrigin>[2]) =>
+      admitClaimedOrigin(
+        key,
+        {
+          instanceId: "bonsai-test",
+          lane: actorLane(caller.actor),
+          admitted: ["files.save"],
+        },
+        origin,
+      ),
+  };
+}
+async function fixture() {
+  const database = new DatabaseSync(":memory:");
+  const owner = fromNodeSqlite(database);
+  ensureBonsaiTables(owner.sql);
+  const state = new BonsaiState(owner.sql, owner.transactionSync);
+  const provider = realGit();
+  close.push(() => {
+    database.close();
+    provider.close();
+  });
+  await provider.git.create("pond");
+  state.registerRepo({
+    name: "pond",
+    description: null,
+    parent: null,
+    owner: null,
+  });
+  const initial = await commitFiles(provider.git, {
+    repository: "pond",
+    branch: "main",
+    expectedHead: null,
+    changes: [{ path: "README.md", content: encode("Pond\n") }],
+    message: "Plant pond",
+    author: { name: "seed", email: "seed@test.invalid" },
+  });
+  if (initial.kind !== "committed") throw new Error("Fixture did not commit");
+  const controller = new AbortController();
+  close.push(() => {
+    controller.abort();
+  });
+  const counted = countingGit(provider.git, {
+    limit: 10000,
+    signal: controller.signal,
+  });
+  const bonsai = {
+    state,
+    store: gitStore(counted.git),
+    events: { emit: () => Promise.resolve() },
+  };
+  await getRepoDetail(bonsai, "pond");
+  await readFileCopy(bonsai, { repo: "pond", ref: "main", path: "README.md" });
+  const call = (
+    name: string,
+    input: JsonValue,
+    caller: AppMethodCallContext = member,
+  ) =>
+    appBackend
+      .call(name, input, { bonsai }, caller)
+      .then((value) => jsonValue.parse(value));
+  return { provider, counted, bonsai, call, initial: initial.commit };
+}
+
+async function claimFileSync(
+  f: Awaited<ReturnType<typeof fixture>>,
+  signal: AbortSignal,
+) {
+  const background = await claimedAdmission();
+  const runtime: ConcurrentWatchdogRuntime = await Watchdog.make({
+    owner: f.bonsai.state.backgroundOwner,
+    concurrentLane: actorLane(member.actor),
+    project: (transition) => {
+      projectQueuedFileEdit(f.bonsai, transition);
+    },
+    isAlive: () => Promise.resolve(false),
+    wake: { recompute: () => Promise.resolve() },
+    execute: (job) =>
+      executeQueuedFileEdit(
+        f.bonsai,
+        member,
+        job,
+        runtime.transactional.enqueueAcceptedJob,
+        background,
+        signal,
+      ),
+  });
+  const tick = await runtime.tickConcurrent();
+  if (tick.status === "settled")
+    await cleanupSettledFileEdit(f.bonsai, tick.job);
+  return tick;
+}
+async function replayFileSync(f: Awaited<ReturnType<typeof fixture>>) {
+  for (let frame = 0; frame < 16; frame++) {
+    const controller = new AbortController();
+    const tick = await claimFileSync(f, controller.signal);
+    controller.abort();
+    if (tick.status === "no_ready") return;
+    if (tick.status !== "settled")
+      throw new Error("File replay did not settle");
+  }
+  throw new Error("File replay did not reach a terminal state");
+}
+it("files.read returns the exact commit and blob baseline from the ready copy", async () => {
+  const f = await fixture();
+  const before = f.counted.total();
+  const result = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  expect(result.blob).toMatch(/^[0-9a-f]{40}$/u);
+  expect(result).toMatchObject({
+    commit: f.initial,
+    text: "Pond\n",
+  });
+  expect(f.counted.total() - before).toBe(0);
+});
+
+it("an Agent reads committed typed absence without another member's new-file text or revision", async () => {
+  const f = await fixture();
+  const input = { repo: "pond", ref: "main", path: "new.txt" };
+  const baseline = fileContent.parse(await f.call("files.read", input));
+  expect(baseline).toMatchObject({
+    commit: f.initial,
+    blob: null,
+    text: null,
+    version: null,
+  });
+  await f.call(
+    "files.save",
+    {
+      repo: "pond",
+      branch: "main",
+      path: "new.txt",
+      baseCommit: baseline.commit,
+      baseBlob: null,
+      text: "Member-private new file",
+      revision: null,
+    },
+    await sealedWrite(member),
+  );
+  expect(await f.call("files.read", input)).toMatchObject({
+    version: 1,
+    pending: { text: "Member-private new file", revision: 1 },
+  });
+  const before = f.counted.total();
+  const absent = await f.call("files.read", input, {
+    actor: { kind: "agent", agentId: "luna" },
+    computerId: null,
+  });
+  expect(absent).toMatchObject({
+    commit: f.initial,
+    blob: null,
+    text: null,
+    version: null,
+  });
+  expect(absent).not.toHaveProperty("pending");
+  expect(f.counted.total() - before).toBe(0);
+});
+
+it("a member save persists pending text with zero Git calls and only that member can read it", async () => {
+  const f = await fixture();
+  const baseline = await f.provider.git.readCommit("pond", f.initial);
+  if (baseline === null) throw new Error("Missing seed commit");
+  const tree = await f.provider.git.readTree("pond", baseline.treeHash);
+  const blob = tree?.find((entry) => entry.name === "README.md")?.hash;
+  if (blob === undefined) throw new Error("Missing seed blob");
+  const before = f.counted.total();
+  expect(
+    await f.call(
+      "files.save",
+      {
+        repo: "pond",
+        branch: "main",
+        path: "README.md",
+        baseBlob: blob,
+        baseCommit: f.initial,
+        text: "Edited\n",
+        revision: null,
+      },
+      await sealedWrite(member),
+    ),
+  ).toMatchObject({ kind: "saved", revision: 1, state: "pending" });
+  expect(f.counted.total() - before).toBe(0);
+  expect(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  ).toMatchObject({
+    pending: { text: "Edited\n", revision: 1, state: "pending" },
+  });
+  expect(
+    await f.call(
+      "files.read",
+      { repo: "pond", ref: "main", path: "README.md" },
+      { ...member, actor: { kind: "member", memberId: "other" } },
+    ),
+  ).not.toHaveProperty("pending");
+});
+
+it("reopening a synced file returns the member row version without exposing it to another caller", async () => {
+  const f = await fixture();
+  const baseline = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  const saved = await f.call(
+    "files.save",
+    {
+      repo: "pond",
+      branch: "main",
+      path: "README.md",
+      baseBlob: baseline.blob,
+      baseCommit: baseline.commit,
+      text: "Synced first edit\n",
+      revision: null,
+    },
+    await sealedWrite(member),
+  );
+  expect(saved).toMatchObject({ kind: "saved", revision: 1, state: "pending" });
+  await replayFileSync(f);
+  expect(
+    await f.call("files.sync", {}, await sealedWrite(member, "files.sync")),
+  ).toMatchObject({
+    settled: [{ result: { kind: "synced", revision: 1 } }],
+    more: false,
+  });
+  const reopened = await f.call("files.read", {
+    repo: "pond",
+    ref: "main",
+    path: "README.md",
+  });
+  expect(reopened).toMatchObject({ text: "Synced first edit\n", version: 1 });
+  expect(reopened).not.toHaveProperty("pending");
+  expect(
+    await f.call(
+      "files.read",
+      { repo: "pond", ref: "main", path: "README.md" },
+      {
+        ...member,
+        actor: { kind: "member", memberId: "other" },
+      },
+    ),
+  ).toMatchObject({ text: "Synced first edit\n", version: null });
+  const next = fileContent.parse(reopened);
+  const before = f.counted.total();
+  expect(
+    await f.call(
+      "files.save",
+      {
+        repo: "pond",
+        branch: "main",
+        path: "README.md",
+        baseCommit: next.commit,
+        baseBlob: next.blob,
+        text: "Second edit\n",
+        revision: next.version,
+      },
+      await sealedWrite(member),
+    ),
+  ).toMatchObject({ kind: "saved", revision: 2, state: "pending" });
+  expect(f.counted.total() - before).toBe(0);
+});
+
+it.each(["deleted", "new"] as const)(
+  "reopens a member's %s pending file at the real branch baseline",
+  async (kind) => {
+    const f = await fixture();
+    const baseline = fileContent.parse(
+      await f.call("files.read", {
+        repo: "pond",
+        ref: "main",
+        path: "README.md",
+      }),
+    );
+    const path = kind === "new" ? "NEW.md" : "README.md";
+    const before = f.counted.total();
+    expect(
+      await f.call(
+        "files.save",
+        {
+          repo: "pond",
+          branch: "main",
+          path,
+          baseBlob: kind === "new" ? null : baseline.blob,
+          baseCommit: baseline.commit,
+          text: "Private saved text\n",
+          revision: null,
+        },
+        await sealedWrite(member),
+      ),
+    ).toMatchObject({ kind: "saved", revision: 1 });
+    expect(f.counted.total() - before).toBe(0);
+    let currentCommit = f.initial;
+    if (kind === "deleted") {
+      const deleted = await commitFiles(f.provider.git, {
+        repository: "pond",
+        branch: "main",
+        expectedHead: f.initial,
+        changes: [{ path, content: null }],
+        message: "Delete file",
+        author: { name: "luna", email: "luna@test.invalid" },
+      });
+      if (deleted.kind !== "committed")
+        throw new Error("Deletion fixture did not commit");
+      currentCommit = deleted.commit;
+      await observePush(f.bonsai, {
+        eventId: "delete-file",
+        repository: "pond",
+        writer: { kind: "actor", actor: { kind: "agent", agentId: "luna" } },
+        updates: [
+          { ref: "refs/heads/main", before: f.initial, after: deleted.commit },
+        ],
+      });
+    }
+    f.bonsai.state = new BonsaiState(
+      f.bonsai.state.backgroundOwner.sql,
+      f.bonsai.state.backgroundOwner.transactionSync,
+    );
+    const reopened = await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path,
+    });
+    expect(reopened).toMatchObject({
+      commit: currentCommit,
+      blob: null,
+      text: null,
+      size: 0,
+      binary: false,
+      version: 1,
+      pending: { text: "Private saved text\n", revision: 1, state: "pending" },
+    });
+    expect(
+      await f.call(
+        "files.read",
+        { repo: "pond", ref: "main", path },
+        {
+          ...member,
+          actor: { kind: "member", memberId: "other" },
+        },
+      ),
+    ).toMatchObject({
+      commit: currentCommit,
+      blob: null,
+      text: null,
+      version: null,
+    });
+    for (const caller of [
+      { actor: { kind: "agent" as const, agentId: "luna" }, computerId: null },
+      { actor: { kind: "team-key" as const, keyId: "key" }, computerId: null },
+      {
+        ...member,
+        workflow: {
+          workflowId: "flow",
+          runId: "run",
+          nodeId: "node",
+          armedBy: member.actor,
+        },
+      },
+    ]) {
+      const committed = await f.call(
+        "files.read",
+        { repo: "pond", ref: "main", path },
+        caller,
+      );
+      expect(committed).toMatchObject({
+        commit: currentCommit,
+        blob: null,
+        text: null,
+        version: null,
+      });
+      expect(committed).not.toHaveProperty("pending");
+    }
+  },
+);
+
+it("Workflow file writes cannot probe, replace, discard or flush the armer's private row", async () => {
+  const f = await fixture();
+  const baseline = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  const input = {
+    repo: "pond",
+    branch: "main",
+    path: "README.md",
+    baseBlob: baseline.blob,
+    baseCommit: baseline.commit,
+    text: "Private pending secret\n",
+    revision: null,
+  };
+  await f.call("files.save", input, await sealedWrite(member));
+  const before = f.counted.total();
+  const caller = {
+    ...member,
+    workflow: {
+      workflowId: "flow",
+      runId: "run",
+      nodeId: "node",
+      armedBy: member.actor,
+    },
+  };
+  await expect(f.call("files.sync", {}, caller)).rejects.toMatchObject({
+    code: "forbidden",
+  });
+  for (const revision of [null, 1]) {
+    await expect(
+      f.call(
+        "files.save",
+        { ...input, text: "Workflow text\n", revision },
+        caller,
+      ),
+    ).rejects.toMatchObject({ code: "forbidden" });
+  }
+  await expect(
+    f.call(
+      "files.discard",
+      { repo: "pond", branch: "main", path: "README.md", revision: 1 },
+      caller,
+    ),
+  ).rejects.toMatchObject({ code: "forbidden" });
+  expect(f.counted.total() - before).toBe(0);
+  expect(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  ).toMatchObject({
+    version: 1,
+    pending: {
+      text: "Private pending secret\n",
+      revision: 1,
+      state: "pending",
+    },
+  });
+  expect(
+    await f.provider.git.log("pond", { ref: "main", limit: 10 }),
+  ).toHaveLength(1);
+  // R1 replay is ordinary member attribution with no Workflow and no enqueue eligibility.
+  await replayFileSync(f);
+  expect(await f.call("files.sync", {}, member)).toMatchObject({
+    settled: [{ result: { kind: "synced", revision: 1 } }],
+    more: false,
+  });
+});
+
+it.each(["agent", "team-key"] as const)(
+  "%s cannot use any private file-write method",
+  async (kind) => {
+    const f = await fixture();
+    const baseline = fileContent.parse(
+      await f.call("files.read", {
+        repo: "pond",
+        ref: "main",
+        path: "README.md",
+      }),
+    );
+    const caller: AppMethodCallContext = {
+      computerId: null,
+      actor:
+        kind === "agent"
+          ? { kind: "agent", agentId: "luna" }
+          : { kind: "team-key", keyId: "key" },
+    };
+    const before = f.counted.total();
+    await expect(
+      f.call(
+        "files.save",
+        {
+          repo: "pond",
+          branch: "main",
+          path: "README.md",
+          baseBlob: baseline.blob,
+          baseCommit: baseline.commit,
+          text: "Foreign text\n",
+          revision: null,
+        },
+        caller,
+      ),
+    ).rejects.toMatchObject({ code: "forbidden" });
+    await expect(f.call("files.sync", {}, caller)).rejects.toMatchObject({
+      code: "forbidden",
+    });
+    await expect(
+      f.call(
+        "files.discard",
+        { repo: "pond", branch: "main", path: "README.md", revision: 1 },
+        caller,
+      ),
+    ).rejects.toMatchObject({ code: "forbidden" });
+    expect(f.counted.total() - before).toBe(0);
+  },
+);
+
+it.each([false, true])(
+  "a stranded lane recovers independently while another lane tick is held=%s",
+  async (held) => {
+    const f = await fixture();
+    const other = {
+      actor: { kind: "member" as const, memberId: "other" },
+      computerId: null,
+    };
+    const baseline = fileContent.parse(
+      await f.call("files.read", {
+        repo: "pond",
+        ref: "main",
+        path: "README.md",
+      }),
+    );
+    const key = { repo: "pond", branch: "main", path: "README.md" };
+    for (const caller of [member, other])
+      await f.call(
+        "files.save",
+        {
+          ...key,
+          baseCommit: baseline.commit,
+          baseBlob: baseline.blob,
+          text: `${caller.actor.memberId}\n`,
+          revision: null,
+        },
+        await sealedWrite(caller),
+      );
+    // A valid persisted claim survives the isolate that previously owned it.
+    f.bonsai.state.backgroundOwner.sql.exec(
+      "UPDATE watchdog_jobs SET state='running', claim_token='dead-isolate' WHERE lane=? AND state='queued'",
+      actorLane(other.actor),
+    );
+    expect(
+      f.bonsai.state.backgroundOwner.sql
+        .exec(
+          "SELECT state FROM watchdog_jobs WHERE lane=?",
+          actorLane(other.actor),
+        )
+        .toArray(),
+    ).toEqual([{ state: "running" }]);
+    const arrived = Promise.withResolvers<undefined>();
+    const release = Promise.withResolvers<undefined>();
+    const binding = f.counted.git;
+    let block = held;
+    f.bonsai.store = gitStore({
+      ...binding,
+      refs: async (repo) => {
+        if (block) {
+          block = false;
+          arrived.resolve(undefined);
+          await release.promise;
+        }
+        return binding.refs(repo);
+      },
+    });
+    const aAdmission = await claimedAdmission(member);
+    const bAdmission = await claimedAdmission(other);
+    let hangingTick: Promise<unknown> | undefined;
+    try {
+      if (held) {
+        hangingTick = appBackend.call(
+          "sync",
+          {},
+          {
+            bonsai: f.bonsai,
+            env: { BACKGROUND: aAdmission },
+          },
+          { ...member },
+        );
+        await arrived.promise;
+      }
+      for (let frame = 0; frame < 8; frame++) {
+        const before = f.counted.total();
+        await appBackend.call(
+          "sync",
+          {},
+          {
+            bonsai: f.bonsai,
+            env: { BACKGROUND: bAdmission },
+          },
+          { ...other },
+        );
+        expect(f.counted.total() - before).toBeLessThanOrEqual(1);
+      }
+      expect(
+        f.bonsai.state.fileEdits.read(actorLane(other.actor), key),
+      ).toMatchObject({ state: "synced" });
+      expect(
+        f.bonsai.state.fileEdits.read(actorLane(member.actor), key),
+      ).toMatchObject({ state: "pending" });
+      expect(
+        await f.provider.git.log("pond", { ref: "main", limit: 10 }),
+      ).toHaveLength(2);
+    } finally {
+      release.resolve(undefined);
+      await hangingTick;
+    }
+  },
+);
+
+it.each([
+  ["discard", "read"],
+  ["save", "read"],
+  ["discard", "fetch"],
+  ["save", "fetch"],
+] as const)(
+  "%s during sync %s never commits withdrawn private text",
+  async (action, stage) => {
+    const f = await fixture();
+    const baseline = fileContent.parse(
+      await f.call("files.read", {
+        repo: "pond",
+        ref: "main",
+        path: "README.md",
+      }),
+    );
+    const input = {
+      repo: "pond",
+      branch: "main",
+      path: "README.md",
+      baseBlob: baseline.blob,
+      baseCommit: baseline.commit,
+      text: "Withdrawn private text\n",
+      revision: null,
+    };
+    await f.call("files.save", input, await sealedWrite(member));
+    const arrived = Promise.withResolvers<undefined>();
+    const release = Promise.withResolvers<undefined>();
+    const binding = f.bonsai.store.binding;
+    let held = false;
+    f.bonsai.store = gitStore({
+      ...binding,
+      readBlob: async (repo, hash) => {
+        const bytes = await binding.readBlob(repo, hash);
+        if (!held && stage === "read") {
+          held = true;
+          arrived.resolve(undefined);
+          await release.promise;
+        }
+        return bytes;
+      },
+      exchange: async (repo, request) => {
+        const reply = await binding.exchange(repo, request);
+        if (
+          !held &&
+          stage === "fetch" &&
+          request.service === "upload-pack" &&
+          request.phase === "exchange"
+        ) {
+          held = true;
+          arrived.resolve(undefined);
+          await release.promise;
+        }
+        return reply;
+      },
+    });
+    for (let frame = 0; frame < (stage === "fetch" ? 5 : 3); frame++)
+      await claimFileSync(f, new AbortController().signal);
+    const syncing = claimFileSync(f, new AbortController().signal);
+    try {
+      await arrived.promise;
+      if (action === "discard") {
+        expect(
+          await f.call("files.discard", {
+            repo: "pond",
+            branch: "main",
+            path: "README.md",
+            revision: 1,
+          }),
+        ).toEqual({ kind: "discarded" });
+      } else {
+        expect(
+          await f.call(
+            "files.save",
+            { ...input, text: "Latest saved text\n", revision: 1 },
+            await sealedWrite(member),
+          ),
+        ).toMatchObject({ kind: "saved", revision: 2 });
+      }
+      release.resolve(undefined);
+      await syncing;
+      expect(
+        await f.provider.git.log("pond", { ref: "main", limit: 10 }),
+      ).toHaveLength(1);
+      if (action === "save") await replayFileSync(f);
+      const history = await f.provider.git.log("pond", {
+        ref: "main",
+        limit: 10,
+      });
+      expect(history).toHaveLength(action === "discard" ? 1 : 2);
+      for (const commit of history) {
+        const tree = await f.provider.git.readTree("pond", commit.treeHash);
+        const blob = tree?.find((entry) => entry.name === "README.md");
+        if (blob === undefined) throw new Error("Missing race fixture file");
+        const bytes = await f.provider.git.readBlob("pond", blob.hash);
+        expect(new TextDecoder().decode(bytes ?? undefined)).not.toBe(
+          "Withdrawn private text\n",
+        );
+      }
+    } finally {
+      release.resolve(undefined);
+      await syncing;
+    }
+  },
+);
+
+it("discard leaves only a receipt hash, not the saved file's private text", async () => {
+  const f = await fixture();
+  const baseline = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  const secret = "Sensitive private file content";
+  const caller = await sealedWrite({
+    ...member,
+    idempotencyKey: "private-file-request",
+  });
+  const input = {
+    repo: "pond",
+    branch: "main",
+    path: "README.md",
+    baseBlob: baseline.blob,
+    baseCommit: baseline.commit,
+    text: secret,
+    revision: null,
+  };
+  const saved = await f.call("files.save", input, caller);
+  expect(await f.call("files.save", input, caller)).toEqual(saved);
+  await f.call("files.discard", {
+    repo: "pond",
+    branch: "main",
+    path: "README.md",
+    revision: 1,
+  });
+  // Persisted receipts are the protected representation, not an inspection of a private helper.
+  const receipts = f.bonsai.state.backgroundOwner.sql
+    .exec("SELECT digest,result FROM receipts")
+    .toArray();
+  expect(receipts).toHaveLength(1);
+  expect(JSON.stringify(receipts)).not.toContain(secret);
+});
+
+it("a member's saved-row bound permits replacement and discard without borrowing another member's capacity", async () => {
+  const f = await fixture();
+  const input = {
+    repo: "pond",
+    branch: "main",
+    baseCommit: f.initial,
+    baseBlob: null,
+    text: "Private draft",
+    revision: null,
+  };
+  const caller = await sealedWrite(member);
+  const before = f.counted.total();
+  for (let index = 0; index < 128; index++)
+    await f.call(
+      "files.save",
+      { ...input, path: `draft-${String(index)}.txt` },
+      caller,
+    );
+  await expect(
+    f.call("files.save", { ...input, path: "overflow.txt" }, caller),
+  ).rejects.toMatchObject({ code: "invalid" });
+  expect(
+    await f.call(
+      "files.save",
+      { ...input, path: "draft-0.txt", revision: 1 },
+      caller,
+    ),
+  ).toMatchObject({ kind: "saved" });
+  expect(
+    await f.call("files.discard", {
+      repo: "pond",
+      branch: "main",
+      path: "draft-1.txt",
+      revision: 2,
+    }),
+  ).toEqual({ kind: "discarded" });
+  expect(
+    await f.call("files.save", { ...input, path: "overflow.txt" }, caller),
+  ).toMatchObject({ kind: "saved" });
+  expect(
+    await f.call(
+      "files.save",
+      { ...input, path: "other.txt" },
+      await sealedWrite({
+        ...member,
+        actor: { kind: "member", memberId: "other" },
+      }),
+    ),
+  ).toMatchObject({ kind: "saved" });
+  expect(f.counted.total() - before).toBe(0);
+});
+
+it("sync refuses a directory target rather than replacing it with private text", async () => {
+  const f = await fixture();
+  const written = await commitFiles(f.provider.git, {
+    repository: "pond",
+    branch: "main",
+    expectedHead: f.initial,
+    changes: [{ path: "folder/child.txt", content: encode("Child") }],
+    message: "Add folder",
+    author: { name: "seed", email: "seed@test.invalid" },
+  });
+  if (written.kind !== "committed")
+    throw new Error("Missing directory fixture");
+  const commit = await f.provider.git.readCommit("pond", written.commit);
+  if (commit === null) throw new Error("Missing directory commit");
+  const tree = await f.provider.git.readTree("pond", commit.treeHash);
+  const folder = tree?.find((entry) => entry.name === "folder");
+  if (folder === undefined) throw new Error("Missing directory entry");
+  await f.call(
+    "files.save",
+    {
+      repo: "pond",
+      branch: "main",
+      path: "folder",
+      baseCommit: written.commit,
+      baseBlob: folder.hash,
+      text: "Private directory replacement",
+      revision: null,
+    },
+    await sealedWrite(member),
+  );
+  await replayFileSync(f);
+  expect(
+    await f.provider.git.log("pond", { ref: "main", limit: 10 }),
+  ).toHaveLength(2);
+  expect(
+    f.bonsai.state.fileEdits.pending(actorLane(member.actor), {
+      repo: "pond",
+      branch: "main",
+      path: "folder",
+    }),
+  ).toMatchObject({ state: "failed", text: "Private directory replacement" });
+});
+
+it("failed sync retries reach newer rows and leave access-changed rows refused", async () => {
+  const f = await fixture();
+  const lane = actorLane(member.actor);
+  const origin = (await sealedWrite(member)).backgroundOrigin;
+  const paths = ["first.txt", "second.txt", "third.txt", "refused.txt"];
+  const keys = paths.map((path) => ({ repo: "pond", branch: "main", path }));
+  for (const key of keys) {
+    f.bonsai.state.fileEdits.save(
+      lane,
+      {
+        ...key,
+        baseCommit: f.initial,
+        baseBlob: null,
+        text: "Retained text",
+        revision: null,
+      },
+      () => undefined,
+      origin,
+    );
+    const edit = f.bonsai.state.fileEdits.read(lane, key);
+    if (edit === null) throw new Error("Missing retry row");
+    f.bonsai.state.fileEdits.settle(edit, {
+      kind: "failed",
+      revision: edit.revision,
+      reason: key.path === "refused.txt" ? "access_changed" : "branch_missing",
+    });
+  }
+  const before = f.counted.total();
+  await f.call("files.sync", {}, await sealedWrite(member, "files.sync"));
+  expect(
+    keys.map((key) => f.bonsai.state.fileEdits.read(lane, key)?.state),
+  ).toEqual(["pending", "pending", "failed", "failed"]);
+  for (const key of keys.slice(0, 2)) {
+    const edit = f.bonsai.state.fileEdits.read(lane, key);
+    if (edit === null) throw new Error("Missing retry row");
+    f.bonsai.state.fileEdits.settle(edit, {
+      kind: "failed",
+      revision: edit.revision,
+      reason: "branch_missing",
+    });
+  }
+  await f.call("files.sync", {}, await sealedWrite(member, "files.sync"));
+  expect(
+    f.bonsai.state.fileEdits.read(lane, {
+      repo: "pond",
+      branch: "main",
+      path: "third.txt",
+    })?.state,
+  ).toBe("pending");
+  expect(
+    f.bonsai.state.fileEdits.read(lane, {
+      repo: "pond",
+      branch: "main",
+      path: "refused.txt",
+    }),
+  ).toMatchObject({
+    state: "failed",
+    failure: "access_changed",
+    text: "Retained text",
+  });
+  expect(f.counted.total() - before).toBe(0);
+});
+
+it("sync does not re-arm an access-changed edit", async () => {
+  const f = await fixture();
+  const edit = await queuedEdit(f);
+  f.bonsai.state.backgroundOwner.sql.exec(
+    "DELETE FROM repos WHERE name=?",
+    "pond",
+  );
+  expect(await edit.execute()).toEqual({
+    kind: "failed",
+    reason: "access_changed",
+  });
+  const before = f.counted.total();
+  expect(
+    await f.call("files.sync", {}, await sealedWrite(member, "files.sync")),
+  ).toEqual({
+    settled: [
+      {
+        repo: "pond",
+        branch: "main",
+        path: "README.md",
+        result: {
+          kind: "failed",
+          revision: edit.saved.revision,
+          reason: "access_changed",
+        },
+      },
+    ],
+    more: false,
+  });
+  expect(f.counted.total() - before).toBe(0);
+  expect(
+    f.bonsai.state.fileEdits.read(edit.job.lane, edit.input),
+  ).toMatchObject({
+    state: "failed",
+    failure: "access_changed",
+    text: edit.input.text,
+  });
+});
+
+async function queuedEdit(
+  f: Awaited<ReturnType<typeof fixture>>,
+  text = "Edited\n",
+) {
+  const baseline = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  const input = fileSaveInput.parse({
+    repo: "pond",
+    branch: "main",
+    path: "README.md",
+    baseCommit: baseline.commit,
+    baseBlob: baseline.blob,
+    text,
+    revision: null,
+  });
+  const lane = actorLane(member.actor);
+  const caller = await sealedWrite(member);
+  const saved = f.bonsai.state.fileEdits.save(
+    lane,
+    input,
+    () => undefined,
+    caller.backgroundOrigin,
+  );
+  if (saved.kind !== "saved") throw new Error("Fixture edit did not save");
+  const job: WatchdogRunningJob = {
+    state: "running",
+    jobId: "file-test",
+    queue: "file-test",
+    lane,
+    priority: 0,
+    payload: {
+      kind: "file-edit",
+      repo: input.repo,
+      branch: input.branch,
+      path: input.path,
+      revision: saved.revision,
+      lane,
+      origin: caller.backgroundOrigin,
+      operationKey: replayKey(),
+      timestamp: Math.floor(Date.now() / 1000),
+    },
+  };
+  const successors: WatchdogQueuedJob[] = [];
+  return {
+    input,
+    job,
+    saved,
+    successors,
+    execute: async () => {
+      const runtime = await Watchdog.make({
+        owner: f.bonsai.state.backgroundOwner,
+        concurrentLane: lane,
+        isAlive: () => Promise.resolve(false),
+        wake: { recompute: () => Promise.resolve() },
+        execute: () =>
+          Promise.resolve({
+            kind: "failed" as const,
+            reason: "access_changed",
+          }),
+      });
+      runtime.transactional.enqueueAcceptedJob({ ...job, state: "queued" });
+      await replayFileSync(f);
+      const settled = await runtime.read(job.jobId);
+      if (settled.status !== "found" || settled.job.state !== "settled")
+        throw new Error("Fixture claim did not settle");
+      return settled.job.outcome === "failed"
+        ? { kind: "failed" as const, reason: settled.job.failureReason }
+        : { kind: "completed" as const };
+    },
+  };
+}
+
+it("public files.sync requeues a retry without a Git call or a foreground claim", async () => {
+  const f = await fixture();
+  const edit = await queuedEdit(f);
+  const stored = f.bonsai.state.fileEdits.read(edit.job.lane, edit.input);
+  if (stored === null) throw new Error("Missing edit");
+  f.bonsai.state.fileEdits.settle(stored, {
+    kind: "failed",
+    revision: edit.saved.revision,
+    reason: "sync_failed",
+  });
+  const before = f.counted.total();
+  const result = await f.call(
+    "files.sync",
+    {},
+    await sealedWrite(member, "files.sync"),
+  );
+  expect(f.counted.total() - before).toBe(0);
+  expect(result).toEqual({ settled: [], more: true });
+  expect(
+    f.bonsai.state.fileEdits.read(edit.job.lane, edit.input),
+  ).toMatchObject({
+    state: "pending",
+    revision: edit.saved.revision,
+    text: edit.input.text,
+  });
+  expect(
+    await f.provider.git.log("pond", { ref: "main", limit: 10 }),
+  ).toHaveLength(1);
+});
+
+it("sync authors a real commit as the member and replay pushes no second commit", async () => {
+  const f = await fixture();
+  const edit = await queuedEdit(f);
+  expect(await edit.execute()).toEqual({ kind: "completed" });
+  const log = await f.provider.git.log("pond", { ref: "main", limit: 10 });
+  expect(log).toHaveLength(2);
+  expect(log[0]?.author.name).toBe("owner");
+  const before = f.counted.total();
+  expect(await edit.execute()).toEqual({ kind: "completed" });
+  expect(f.counted.total() - before).toBe(0);
+});
+
+it.each([
+  ["other.txt", "synced"],
+  ["README.md", "conflict"],
+])(
+  "Agent push to %s underneath produces %s without overwriting",
+  async (path, state) => {
+    const f = await fixture();
+    const edit = await queuedEdit(f);
+    const pushed = await commitFiles(f.provider.git, {
+      repository: "pond",
+      branch: "main",
+      expectedHead: f.initial,
+      changes: [{ path, content: encode("Agent change\n") }],
+      message: "Agent work",
+      author: { name: "luna", email: "luna@test.invalid" },
+    });
+    if (pushed.kind !== "committed") throw new Error("Agent fixture failed");
+    await edit.execute();
+    const row = f.bonsai.state.fileEdits.read(edit.job.lane, edit.input);
+    expect(row?.state).toBe(state);
+    const log = await f.provider.git.log("pond", { ref: "main", limit: 10 });
+    expect(log).toHaveLength(state === "synced" ? 3 : 2);
+    if (state === "synced") expect(log[0]?.parents).toEqual([pushed.commit]);
+    else expect(row?.theirs?.commit).toBe(pushed.commit);
+  },
+);
+
+it("two tabs conflict on revision and a discarded job never writes after replacement", async () => {
+  const f = await fixture();
+  const edit = await queuedEdit(f);
+  const lane = edit.job.lane;
+  expect(
+    f.bonsai.state.fileEdits.save(lane, edit.input, () => undefined),
+  ).toEqual({
+    kind: "conflict",
+    revision: edit.saved.revision,
+  });
+  expect(
+    f.bonsai.state.fileEdits.discard(lane, {
+      ...edit.input,
+      revision: edit.saved.revision,
+    }),
+  ).toEqual({ kind: "discarded" });
+  const replacement = f.bonsai.state.fileEdits.save(
+    lane,
+    { ...edit.input, revision: edit.saved.revision },
+    () => undefined,
+  );
+  if (replacement.kind !== "saved") throw new Error("Replacement did not save");
+  expect(replacement.revision).toBeGreaterThan(edit.saved.revision);
+  const before = f.counted.total();
+  await edit.execute();
+  expect(f.counted.total() - before).toBe(0);
+  expect(f.bonsai.state.fileEdits.read(lane, edit.input)?.revision).toBe(
+    replacement.revision,
+  );
+});
+
+it("another member cannot execute or discard the owner's pending edit", async () => {
+  const f = await fixture();
+  const edit = await queuedEdit(f);
+  const before = f.counted.total();
+  expect(
+    await executeQueuedFileEdit(
+      f.bonsai,
+      { ...member, actor: { kind: "member", memberId: "other" } },
+      edit.job,
+      () => undefined,
+      await claimedAdmission(),
+      new AbortController().signal,
+    ),
+  ).toEqual({ kind: "failed", reason: "access_changed" });
+  expect(
+    f.bonsai.state.fileEdits.discard("member:other", {
+      ...edit.input,
+      revision: edit.saved.revision,
+    }),
+  ).toEqual({ kind: "not_found" });
+  expect(f.counted.total() - before).toBe(0);
+  expect(f.bonsai.state.fileEdits.read(edit.job.lane, edit.input)?.state).toBe(
+    "pending",
+  );
+});
+
+it("text already accepted after a crash settles synced without another push", async () => {
+  const f = await fixture();
+  const edit = await queuedEdit(f);
+  const pushed = await commitFiles(f.provider.git, {
+    repository: "pond",
+    branch: "main",
+    expectedHead: f.initial,
+    changes: [{ path: "README.md", content: encode(edit.input.text) }],
+    message: "Already accepted",
+    author: { name: "owner", email: "owner@bonsai.invalid" },
+  });
+  if (pushed.kind !== "committed")
+    throw new Error("Crash fixture did not commit");
+  expect(await edit.execute()).toEqual({ kind: "completed" });
+  expect(
+    await f.provider.git.log("pond", { ref: "main", limit: 10 }),
+  ).toHaveLength(2);
+  expect(f.bonsai.state.fileEdits.read(edit.job.lane, edit.input)?.state).toBe(
+    "synced",
+  );
+});
+
+it("a vanished file-sync frame is recovered through real Watchdog and pushes once", async () => {
+  const f = await fixture();
+  const baseline = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  const context = await sealedWrite(member);
+  const began = Promise.withResolvers<WatchdogRunningJob>();
+  const release = Promise.withResolvers<undefined>();
+  const old = await Watchdog.make({
+    owner: f.bonsai.state.backgroundOwner,
+    concurrentLane: actorLane(member.actor),
+    isAlive: () => Promise.resolve(true),
+    wake: { recompute: () => Promise.resolve() },
+    execute: async (job) => {
+      began.resolve(job);
+      await release.promise;
+      return { kind: "completed" };
+    },
+  });
+  await saveFileEdit(
+    f.bonsai,
+    context,
+    {
+      repo: "pond",
+      branch: "main",
+      path: "README.md",
+      baseBlob: baseline.blob,
+      baseCommit: baseline.commit,
+      text: "After crash\n",
+      revision: null,
+    },
+    old,
+  );
+  const oldTick = old.tickConcurrent();
+  const claimed = await began.promise;
+  const fresh: ConcurrentWatchdogRuntime = await Watchdog.make({
+    owner: f.bonsai.state.backgroundOwner,
+    concurrentLane: actorLane(member.actor),
+    isAlive: () => Promise.resolve(false),
+    wake: { recompute: () => Promise.resolve() },
+    execute: async (job) =>
+      executeQueuedFileEdit(
+        f.bonsai,
+        member,
+        job,
+        fresh.transactional.enqueueAcceptedJob,
+        await claimedAdmission(),
+        new AbortController().signal,
+      ),
+  });
+  try {
+    expect(await fresh.tickConcurrent()).toMatchObject({
+      status: "settled",
+      job: { outcome: "completed" },
+    });
+    await replayFileSync(f);
+    expect(await fresh.read(claimed.jobId)).toMatchObject({
+      status: "found",
+      job: { state: "settled", outcome: "completed" },
+    });
+    expect(
+      await f.provider.git.log("pond", { ref: "main", limit: 10 }),
+    ).toHaveLength(2);
+  } finally {
+    release.resolve(undefined);
+    await expect(oldTick).rejects.toMatchObject({
+      cause: "settlement_rejected",
+    });
+  }
+});
+
+it("public save/sync/discard keep lanes separate and more ignores another member's queued edit", async () => {
+  const f = await fixture();
+  const baseline = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  const input = {
+    repo: "pond",
+    branch: "main",
+    path: "README.md",
+    baseBlob: baseline.blob,
+    baseCommit: baseline.commit,
+    text: "Owner edit\n",
+    revision: null,
+  };
+  const saved = await f.call("files.save", input, await sealedWrite(member));
+  expect(saved).toMatchObject({ kind: "saved", state: "pending" });
+  const other = {
+    ...member,
+    actor: { kind: "member" as const, memberId: "other" },
+  };
+  await f.call(
+    "files.save",
+    { ...input, text: "Other edit\n" },
+    await sealedWrite(other),
+  );
+  expect(
+    await f.call(
+      "files.discard",
+      { repo: "pond", branch: "main", path: "README.md", revision: 1 },
+      other,
+    ),
+  ).toMatchObject({ kind: "conflict" });
+  await replayFileSync(f);
+  const synced = await f.call(
+    "files.sync",
+    {},
+    await sealedWrite(member, "files.sync"),
+  );
+  expect(synced).toMatchObject({
+    settled: [
+      {
+        repo: "pond",
+        branch: "main",
+        path: "README.md",
+        result: { kind: "synced" },
+      },
+    ],
+    more: false,
+  });
+  expect(
+    f.bonsai.state.fileEdits.pending(actorLane(other.actor), input)?.state,
+  ).toBe("pending");
+  expect(
+    await f.call(
+      "files.read",
+      { repo: "pond", ref: "main", path: "README.md" },
+      { actor: { kind: "agent", agentId: "luna" }, computerId: null },
+    ),
+  ).not.toHaveProperty("pending");
+});
+
+it("unsealed ordinary saves and Workflow calls cannot create private rows", async () => {
+  const f = await fixture();
+  const baseline = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  const input = {
+    repo: "pond",
+    branch: "main",
+    path: "README.md",
+    baseBlob: baseline.blob,
+    baseCommit: baseline.commit,
+    text: "Foreground\n",
+    revision: null,
+  };
+  const before = f.counted.total();
+  const result = await f.call("files.save", input);
+  expect(f.counted.total() - before).toBe(0);
+  expect(result).toEqual({ kind: "refused", reason: "background-unavailable" });
+  const caller = await sealedWrite({
+    ...member,
+    workflow: {
+      workflowId: "flow",
+      runId: "run",
+      nodeId: "node",
+      armedBy: member.actor,
+    },
+  });
+  const next = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  await expect(
+    f.call(
+      "files.save",
+      {
+        ...input,
+        baseBlob: next.blob,
+        baseCommit: next.commit,
+        text: "Workflow\n",
+        revision: 1,
+      },
+      caller,
+    ),
+  ).rejects.toMatchObject({ code: "forbidden" });
+  expect(f.bonsai.state.fileEdits.hasPending(actorLane(member.actor))).toBe(
+    false,
+  );
+});
+
+it("Agents cannot use private file saves even on their own fork", async () => {
+  const f = await fixture();
+  const baseline = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  const input = {
+    repo: "pond",
+    branch: "main",
+    path: "README.md",
+    baseBlob: baseline.blob,
+    baseCommit: baseline.commit,
+    text: "Agent edit\n",
+    revision: null,
+  };
+  const agent = {
+    actor: { kind: "agent" as const, agentId: "luna" },
+    computerId: null,
+  };
+  const before = f.counted.total();
+  await expect(f.call("files.save", input, agent)).rejects.toMatchObject({
+    code: "forbidden",
+  });
+  expect(f.counted.total() - before).toBe(0);
+  await f.provider.git.create("pond--luna");
+  const forkHead = await commitFiles(f.provider.git, {
+    repository: "pond--luna",
+    branch: "main",
+    expectedHead: null,
+    changes: [{ path: "README.md", content: encode("Pond\n") }],
+    message: "Seed registered fork",
+    author: { name: "seed", email: "seed@test.invalid" },
+  });
+  if (forkHead.kind !== "committed")
+    throw new Error("Fork fixture did not commit");
+  f.bonsai.state.registerRepo({
+    name: "pond--luna",
+    description: null,
+    parent: "pond",
+    owner: "luna",
+  });
+  await expect(
+    f.call(
+      "files.save",
+      { ...input, repo: "pond--luna", baseCommit: forkHead.commit },
+      agent,
+    ),
+  ).rejects.toMatchObject({ code: "forbidden" });
+  expect(
+    await f.provider.git.log("pond--luna", { ref: "main", limit: 1 }),
+  ).toMatchObject([{ author: { name: "seed" } }]);
+});
+
+it("save refuses binary text and UTF-8 payloads over the byte limit with zero provider calls", async () => {
+  const f = await fixture();
+  const baseline = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  const input = {
+    repo: "pond",
+    branch: "main",
+    path: "README.md",
+    baseBlob: baseline.blob,
+    baseCommit: baseline.commit,
+    revision: null,
+  };
+  const before = f.counted.total();
+  for (const text of ["binary\0text", "🐟".repeat(17000)])
+    await expect(
+      f.call("files.save", { ...input, text }, await sealedWrite(member)),
+    ).rejects.toMatchObject({ code: "invalid" });
+  expect(f.counted.total() - before).toBe(0);
+});
+
+it("settled file rows reopen with the revision only in its SQLite column", async () => {
+  const f = await fixture();
+  const edit = await queuedEdit(f);
+  await edit.execute();
+  const rebuilt = new BonsaiState(
+    f.bonsai.state.backgroundOwner.sql,
+    f.bonsai.state.backgroundOwner.transactionSync,
+  );
+  expect(rebuilt.fileEdits.read(edit.job.lane, edit.input)).toMatchObject({
+    revision: edit.saved.revision,
+    state: "synced",
+    text: edit.input.text,
+  });
+  const raw = f.bonsai.state.backgroundOwner.sql
+    .exec("SELECT body FROM file_edits WHERE revision=?", edit.saved.revision)
+    .toArray()[0];
+  const stored = z.strictObject({ body: z.string() }).parse(raw);
+  expect(JSON.parse(stored.body)).not.toHaveProperty("revision");
+});
+
+it("a missing branch fails sync without a push and retains the saved text", async () => {
+  const f = await fixture();
+  const edit = await queuedEdit(f);
+  const missing = {
+    ...f.bonsai,
+    store: { ...f.bonsai.store, refs: () => Promise.resolve([]) },
+  };
+  f.bonsai.store = missing.store;
+  const before = f.counted.total();
+  expect(await edit.execute()).toEqual({ kind: "completed" });
+  expect(f.counted.total() - before).toBe(0);
+  expect(
+    f.bonsai.state.fileEdits.pending(edit.job.lane, edit.input),
+  ).toMatchObject({
+    text: edit.input.text,
+    state: "failed",
+    failure: "branch_missing",
+  });
+});
+
+it("current repository access is rechecked before sync with zero Git on refusal", async () => {
+  const f = await fixture();
+  const edit = await queuedEdit(f);
+  f.bonsai.state.backgroundOwner.sql.exec(
+    "DELETE FROM repos WHERE name=?",
+    "pond",
+  );
+  const before = f.counted.total();
+  expect(await edit.execute()).toEqual({
+    kind: "failed",
+    reason: "access_changed",
+  });
+  expect(f.counted.total() - before).toBe(0);
+  expect(
+    f.bonsai.state.fileEdits.pending(edit.job.lane, edit.input),
+  ).toMatchObject({
+    text: edit.input.text,
+    state: "failed",
+    failure: "access_changed",
+  });
+});
+
+it("an explicit sync retry requeues a failed edit without losing the member's text", async () => {
+  const f = await fixture();
+  const edit = await queuedEdit(f);
+  const stored = f.bonsai.state.fileEdits.read(edit.job.lane, edit.input);
+  if (stored === null) throw new Error("Missing edit");
+  f.bonsai.state.fileEdits.settle(stored, {
+    kind: "failed",
+    revision: edit.saved.revision,
+    reason: "sync_failed",
+  });
+  expect(
+    await f.call("files.sync", {}, await sealedWrite(member, "files.sync")),
+  ).toMatchObject({ more: true });
+  await replayFileSync(f);
+  expect(
+    await f.call("files.sync", {}, await sealedWrite(member, "files.sync")),
+  ).toMatchObject({
+    settled: [{ result: { kind: "synced" } }],
+    more: false,
+  });
+  expect(f.bonsai.state.fileEdits.read(edit.job.lane, edit.input)?.text).toBe(
+    edit.input.text,
+  );
+});
+
+it("Workflow-attested member tools read committed Git without private pending text", async () => {
+  const f = await fixture();
+  const edit = await queuedEdit(f);
+  const caller = {
+    ...member,
+    workflow: {
+      workflowId: "flow",
+      runId: "run",
+      nodeId: "node",
+      armedBy: member.actor,
+    },
+  };
+  const read = await f.call(
+    "files.read",
+    { repo: "pond", ref: "main", path: "README.md" },
+    caller,
+  );
+  expect(read).toMatchObject({ text: "Pond\n" });
+  expect(read).not.toHaveProperty("pending");
+  expect(
+    f.bonsai.state.fileEdits.pending(edit.job.lane, edit.input)?.text,
+  ).toBe(edit.input.text);
+});
+
+it("a replayed member save queues one edit and sync writes one commit", async () => {
+  const f = await fixture();
+  const baseline = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  const input = {
+    repo: "pond",
+    branch: "main",
+    path: "README.md",
+    baseBlob: baseline.blob,
+    baseCommit: baseline.commit,
+    text: "Replay saved\n",
+    revision: null,
+  };
+  const caller = await sealedWrite({
+    ...member,
+    idempotencyKey: "save-request",
+  });
+  const before = f.counted.total();
+  const first = await f.call("files.save", input, caller);
+  expect(await f.call("files.save", input, caller)).toEqual(first);
+  expect(f.counted.total() - before).toBe(0);
+  await replayFileSync(f);
+  expect(
+    await f.call("files.sync", {}, await sealedWrite(member, "files.sync")),
+  ).toMatchObject({
+    settled: [{ result: { kind: "synced" } }],
+    more: false,
+  });
+  expect(
+    await f.provider.git.log("pond", { ref: "main", limit: 10 }),
+  ).toHaveLength(2);
+});
+
+it("a claimed file-sync frame checkpoints at most one Git exchange and does not report Synced early", async () => {
+  const f = await fixture();
+  const edit = await queuedEdit(f);
+  const lane = actorLane(member.actor);
+  const key = await backgroundOriginKey("file-sync-native-owner-test");
+  const origin = await sealBackgroundOrigin(key, {
+    instanceId: "bonsai-test",
+    lane,
+    method: "files.save",
+  });
+  const job = {
+    ...edit.job,
+    payload: { ...fileEditJobSchema.parse(edit.job.payload), origin },
+  };
+  let exchanges = 0;
+  const binding = f.bonsai.store.binding;
+  const bonsai = {
+    ...f.bonsai,
+    store: gitStore({
+      ...binding,
+      exchange: async (repo, request) => {
+        exchanges++;
+        return binding.exchange(repo, request);
+      },
+    }),
+  };
+  const controller = new AbortController();
+  const decision = await executeQueuedFileEdit(
+    bonsai,
+    member,
+    job,
+    (next) => {
+      edit.successors.push(next);
+    },
+    {
+      admit: (claimed) =>
+        admitClaimedOrigin(
+          key,
+          {
+            instanceId: "bonsai-test",
+            lane,
+            admitted: ["files.save"],
+          },
+          claimed,
+        ),
+    },
+    controller.signal,
+  );
+  expect(exchanges).toBeLessThanOrEqual(1);
+  expect(decision).toEqual({ kind: "completed" });
+  expect(f.bonsai.state.fileEdits.read(lane, edit.input)?.state).toBe(
+    "pending",
+  );
+  expect(edit.successors).toHaveLength(1);
+});
+
+it("fresh claimed file-sync frames confirm Git before projecting Synced", async () => {
+  const f = await fixture();
+  const lane = actorLane(member.actor);
+  const key = await backgroundOriginKey("file-sync-native-owner-test");
+  const background = {
+    admit: (origin: Parameters<typeof admitClaimedOrigin>[2]) =>
+      admitClaimedOrigin(
+        key,
+        { instanceId: "bonsai-test", lane, admitted: ["files.save"] },
+        origin,
+      ),
+  };
+  const binding = f.bonsai.store.binding;
+  let exchanges = 0;
+  const bonsai = {
+    ...f.bonsai,
+    store: gitStore({
+      ...binding,
+      exchange: (repo, request) => {
+        exchanges++;
+        return binding.exchange(repo, request);
+      },
+    }),
+  };
+  const baseline = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  const open = async (signal: AbortSignal) => {
+    const runtime: ConcurrentWatchdogRuntime = await Watchdog.make({
+      owner: bonsai.state.backgroundOwner,
+      concurrentLane: lane,
+      project: (transition) => {
+        projectQueuedFileEdit(bonsai, transition);
+      },
+      isAlive: () => Promise.resolve(false),
+      wake: { recompute: () => Promise.resolve() },
+      execute: (job) =>
+        executeQueuedFileEdit(
+          bonsai,
+          member,
+          job,
+          runtime.transactional.enqueueAcceptedJob,
+          background,
+          signal,
+        ),
+    });
+    return runtime;
+  };
+  const foreground = new AbortController();
+  const runtime = await open(foreground.signal);
+  const saved = await saveFileEdit(
+    bonsai,
+    await sealedWrite(member),
+    {
+      repo: "pond",
+      branch: "main",
+      path: "README.md",
+      baseCommit: baseline.commit,
+      baseBlob: baseline.blob,
+      text: "Fresh frame file\n",
+      revision: null,
+    },
+    runtime,
+  );
+  expect(saved).toMatchObject({ kind: "saved", state: "pending" });
+  foreground.abort();
+  const phases: string[] = [];
+  for (let turn = 0; turn < 8; turn++) {
+    const controller = new AbortController();
+    const replay = await open(controller.signal);
+    const before = exchanges;
+    const tick = await replay.tickConcurrent();
+    expect(exchanges - before).toBeLessThanOrEqual(1);
+    if (tick.status === "no_ready") break;
+    expect(tick.status).toBe("settled");
+    if (tick.status !== "settled") throw new Error("Replay did not settle");
+    const cargo = fileEditJobSchema.parse(tick.job.payload);
+    phases.push(cargo.step?.phase ?? cargo.probe?.phase ?? "refs");
+    const row = bonsai.state.fileEdits.read(lane, {
+      repo: "pond",
+      branch: "main",
+      path: "README.md",
+    });
+    if (cargo.step?.phase !== "confirm") expect(row?.state).toBe("pending");
+    await cleanupSettledFileEdit(bonsai, tick.job);
+    controller.abort();
+  }
+  expect(phases).toEqual([
+    "refs",
+    "commit",
+    "tree",
+    "blob",
+    "inspect-base",
+    "fetch-base",
+    "push",
+    "confirm",
+  ]);
+  expect(
+    bonsai.state.fileEdits.read(lane, {
+      repo: "pond",
+      branch: "main",
+      path: "README.md",
+    }),
+  ).toMatchObject({ state: "synced" });
+  expect(
+    await f.provider.git.log("pond", { ref: "main", limit: 10 }),
+  ).toHaveLength(2);
+});
+
+it.each(["missing", "refused", "closed"])(
+  "claimed file sync refuses %s admission with zero Git effects",
+  async (kind) => {
+    const f = await fixture();
+    const edit = await queuedEdit(f);
+    const controller = new AbortController();
+    if (kind === "closed") controller.abort();
+    const background =
+      kind === "missing"
+        ? undefined
+        : kind === "refused"
+          ? {
+              admit: () =>
+                Promise.resolve({
+                  kind: "refused" as const,
+                  code: "access_changed" as const,
+                }),
+            }
+          : await claimedAdmission();
+    const before = f.counted.total();
+    expect(
+      await executeQueuedFileEdit(
+        f.bonsai,
+        member,
+        edit.job,
+        () => undefined,
+        background,
+        controller.signal,
+      ),
+    ).toEqual({ kind: "failed", reason: "access_changed" });
+    expect(f.counted.total() - before).toBe(0);
+    expect(
+      f.bonsai.state.fileEdits.read(edit.job.lane, edit.input)?.state,
+    ).toBe("pending");
+  },
+);
+
+it("an access refusal drops the member's staged Git material and keeps the saved text", async () => {
+  const f = await fixture();
+  const baseline = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  await f.call(
+    "files.save",
+    {
+      repo: "pond",
+      branch: "main",
+      path: "README.md",
+      baseCommit: baseline.commit,
+      baseBlob: baseline.blob,
+      text: "Private bytes staged for Git\n",
+      revision: null,
+    },
+    await sealedWrite(member),
+  );
+  for (let frame = 0; frame < 4; frame++)
+    expect(await claimFileSync(f, new AbortController().signal)).toMatchObject({
+      status: "settled",
+      job: { outcome: "completed" },
+    });
+  const staged = () =>
+    f.bonsai.state.backgroundOwner.sql
+      .exec("SELECT 1 FROM git_step_material")
+      .toArray().length;
+  expect(staged()).toBeGreaterThan(0);
+  const before = f.counted.total();
+  await refuseBackground(f.bonsai, {
+    lane: actorLane(member.actor),
+    code: "access_changed",
+  });
+  expect(f.counted.total() - before).toBe(0);
+  expect(staged()).toBe(0);
+  expect(
+    f.bonsai.state.fileEdits.pending(actorLane(member.actor), {
+      repo: "pond",
+      branch: "main",
+      path: "README.md",
+    }),
+  ).toMatchObject({
+    text: "Private bytes staged for Git\n",
+    state: "failed",
+    failure: "access_changed",
+  });
+});
+
+it("missing durable Git material terminally fails the claimed file job without a retry", async () => {
+  const f = await fixture();
+  const baseline = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  await f.call(
+    "files.save",
+    {
+      repo: "pond",
+      branch: "main",
+      path: "README.md",
+      baseCommit: baseline.commit,
+      baseBlob: baseline.blob,
+      text: "Retained after material loss\n",
+      revision: null,
+    },
+    await sealedWrite(member),
+  );
+  for (let frame = 0; frame < 4; frame++)
+    expect(await claimFileSync(f, new AbortController().signal)).toMatchObject({
+      status: "settled",
+      job: { outcome: "completed" },
+    });
+  f.bonsai.state.backgroundOwner.sql.exec("DELETE FROM git_step_material");
+  const advertisement = await claimFileSync(f, new AbortController().signal);
+  expect(advertisement).toMatchObject({
+    status: "settled",
+    job: { outcome: "completed" },
+  });
+  const failed = await claimFileSync(f, new AbortController().signal);
+  expect(failed).toMatchObject({
+    status: "settled",
+    job: { outcome: "failed", failureReason: "sync_failed" },
+  });
+  expect(
+    f.bonsai.state.fileEdits.pending(actorLane(member.actor), {
+      repo: "pond",
+      branch: "main",
+      path: "README.md",
+    }),
+  ).toMatchObject({
+    text: "Retained after material loss\n",
+    state: "failed",
+    failure: "permanent_material",
+  });
+  const before = f.counted.total();
+  expect(await claimFileSync(f, new AbortController().signal)).toEqual({
+    status: "no_ready",
+  });
+  expect(f.counted.total() - before).toBe(0);
+  expect(
+    await f.call("files.sync", {}, await sealedWrite(member, "files.sync")),
+  ).toMatchObject({ more: false });
+  expect(await claimFileSync(f, new AbortController().signal)).toEqual({
+    status: "no_ready",
+  });
+  expect(f.counted.total() - before).toBe(0);
+  expect(
+    await f.provider.git.log("pond", { ref: "main", limit: 10 }),
+  ).toHaveLength(1);
+  const failedRead = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  expect(
+    await f.call(
+      "files.save",
+      {
+        repo: "pond",
+        branch: "main",
+        path: "README.md",
+        baseCommit: failedRead.commit,
+        baseBlob: failedRead.blob,
+        revision: failedRead.version,
+        text: "Retained after material loss\n",
+      },
+      await sealedWrite(member),
+    ),
+  ).toMatchObject({ kind: "saved", state: "pending" });
+  await replayFileSync(f);
+  expect(
+    f.bonsai.state.fileEdits.read(actorLane(member.actor), {
+      repo: "pond",
+      branch: "main",
+      path: "README.md",
+    }),
+  ).toMatchObject({ state: "synced" });
+  expect(
+    await f.provider.git.log("pond", { ref: "main", limit: 10 }),
+  ).toHaveLength(2);
+});
+
+it("same-tick public sync callers never recover or execute each other's live claim", async () => {
+  const f = await fixture();
+  const baseline = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  const key = { repo: "pond", branch: "main", path: "README.md" };
+  await f.call(
+    "files.save",
+    {
+      ...key,
+      baseCommit: baseline.commit,
+      baseBlob: baseline.blob,
+      text: "Same tick\n",
+      revision: null,
+    },
+    await sealedWrite(member),
+  );
+  const realAdmission = await claimedAdmission();
+  let admissions = 0;
+  const BACKGROUND = {
+    admit: (origin: Parameters<typeof realAdmission.admit>[0]) => {
+      admissions++;
+      return realAdmission.admit(origin);
+    },
+  };
+  for (let frame = 0; frame < 8; frame++) {
+    const before = f.counted.total();
+    const admittedBefore = admissions;
+    const outcomes = await Promise.allSettled([
+      appBackend.call(
+        "sync",
+        {},
+        { bonsai: f.bonsai, env: { BACKGROUND } },
+        { ...member },
+      ),
+      appBackend.call(
+        "sync",
+        {},
+        { bonsai: f.bonsai, env: { BACKGROUND } },
+        { ...member },
+      ),
+    ]);
+    expect(outcomes.map((outcome) => outcome.status)).toEqual([
+      "fulfilled",
+      "fulfilled",
+    ]);
+    expect(admissions - admittedBefore).toBeLessThanOrEqual(1);
+    expect(f.counted.total() - before).toBeLessThanOrEqual(1);
+  }
+  expect(admissions).toBe(8);
+  expect(
+    f.bonsai.state.fileEdits.read(actorLane(member.actor), key),
+  ).toMatchObject({ state: "synced" });
+  expect(
+    await f.provider.git.log("pond", { ref: "main", limit: 10 }),
+  ).toHaveLength(2);
+});
+
+it.each([
+  "conflict",
+  "digest_mismatch",
+  "atomic_unavailable",
+  "push_refused",
+] as const)(
+  "a dependency %s is publicly permanent and a fresh re-save can sync",
+  async (code) => {
+    const f = await fixture();
+    const baseline = fileContent.parse(
+      await f.call("files.read", {
+        repo: "pond",
+        ref: "main",
+        path: "README.md",
+      }),
+    );
+    const key = { repo: "pond", branch: "main", path: "README.md" };
+    const input = {
+      ...key,
+      baseCommit: baseline.commit,
+      baseBlob: baseline.blob,
+      text: "Resaved\n",
+      revision: null,
+    };
+    await f.call("files.save", input, await sealedWrite(member));
+    const previous = f.bonsai.store;
+    const binding = f.counted.git;
+    f.bonsai.store = gitStore({
+      ...binding,
+      exchange: () => Promise.reject(new GitStepMaterialError(code)),
+    });
+    const BACKGROUND = await claimedAdmission();
+    for (let frame = 0; frame < 8; frame++) {
+      await appBackend.call(
+        "sync",
+        {},
+        { bonsai: f.bonsai, env: { BACKGROUND } },
+        { ...member },
+      );
+      if (
+        f.bonsai.state.fileEdits.read(actorLane(member.actor), key)?.state ===
+        "failed"
+      )
+        break;
+    }
+    const failed = fileContent.parse(
+      await f.call("files.read", {
+        repo: "pond",
+        ref: "main",
+        path: "README.md",
+      }),
+    );
+    expect(failed.pending).toMatchObject({
+      state: "failed",
+      failure: "permanent_material",
+    });
+    const before = f.counted.total();
+    expect(
+      await f.call("files.sync", {}, await sealedWrite(member, "files.sync")),
+    ).toMatchObject({ more: false });
+    expect(f.counted.total() - before).toBe(0);
+    f.bonsai.store = previous;
+    expect(
+      await f.call(
+        "files.save",
+        { ...input, revision: failed.version },
+        await sealedWrite(member),
+      ),
+    ).toMatchObject({ kind: "saved", state: "pending" });
+    await replayFileSync(f);
+    expect(
+      f.bonsai.state.fileEdits.read(actorLane(member.actor), key),
+    ).toMatchObject({ state: "synced" });
+    expect(
+      await f.provider.git.log("pond", { ref: "main", limit: 10 }),
+    ).toHaveLength(2);
+  },
+);
+
+it("an unsealed save refuses without leaving a pending row or wake", async () => {
+  const f = await fixture();
+  const baseline = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  const before = f.counted.total();
+  expect(
+    await f.call("files.save", {
+      repo: "pond",
+      branch: "main",
+      path: "README.md",
+      baseCommit: baseline.commit,
+      baseBlob: baseline.blob,
+      text: "Unsealed member text",
+      revision: null,
+    }),
+  ).toEqual({ kind: "refused", reason: "background-unavailable" });
+  expect(await f.call("files.sync", {}, member)).toEqual({
+    settled: [],
+    more: false,
+  });
+  expect(
+    f.bonsai.state.fileEdits.read(actorLane(member.actor), {
+      repo: "pond",
+      branch: "main",
+      path: "README.md",
+    }),
+  ).toBeNull();
+  expect(f.counted.total() - before).toBe(0);
+});
+
+it("discard retains only the member revision and rejects a stale null save", async () => {
+  const f = await fixture();
+  const key = { repo: "pond", ref: "main", path: "README.md" };
+  const baseline = fileContent.parse(await f.call("files.read", key));
+  const caller = await sealedWrite(member);
+  const input = {
+    repo: "pond",
+    branch: "main",
+    path: "README.md",
+    baseCommit: baseline.commit,
+    baseBlob: baseline.blob,
+    text: "Discarded private text",
+    revision: null,
+  };
+  expect(await f.call("files.save", input, caller)).toMatchObject({
+    kind: "saved",
+    revision: 1,
+  });
+  expect(
+    await f.call("files.discard", {
+      repo: "pond",
+      branch: "main",
+      path: "README.md",
+      revision: 1,
+    }),
+  ).toEqual({ kind: "discarded" });
+  const floor = fileContent.parse(await f.call("files.read", key));
+  expect(floor).toMatchObject({ version: 1, text: "Pond\n" });
+  expect(floor).not.toHaveProperty("pending");
+  expect(
+    await f.call("files.save", { ...input, text: "Old tab text" }, caller),
+  ).toEqual({ kind: "conflict", revision: 1 });
+  expect(
+    await f.call(
+      "files.save",
+      { ...input, text: "New edit", revision: floor.version },
+      caller,
+    ),
+  ).toMatchObject({ kind: "saved", revision: 2 });
+});
+
+it.each(["refs", "confirm", "admit"])(
+  "production sync retries transient %s failures in fresh claims before reporting Synced",
+  async (phase) => {
+    const f = await fixture();
+    const baseline = fileContent.parse(
+      await f.call("files.read", {
+        repo: "pond",
+        ref: "main",
+        path: "README.md",
+      }),
+    );
+    await f.call(
+      "files.save",
+      {
+        repo: "pond",
+        branch: "main",
+        path: "README.md",
+        baseCommit: baseline.commit,
+        baseBlob: baseline.blob,
+        text: "Retry saved text\n",
+        revision: null,
+      },
+      await sealedWrite(member),
+    );
+    const binding = f.bonsai.store.binding;
+    let failures = 0;
+    let pushed = false;
+    f.bonsai.store = gitStore({
+      ...binding,
+      refs: (repo) => {
+        if (phase === "refs" && failures < 2) {
+          failures++;
+          return Promise.reject(new Error("Transient fixture read"));
+        }
+        return binding.refs(repo);
+      },
+      exchange: async (repo, request) => {
+        if (
+          phase === "confirm" &&
+          pushed &&
+          request.phase === "advertise" &&
+          failures < 2
+        ) {
+          failures++;
+          throw new Error("Transient fixture confirmation");
+        }
+        const result = await binding.exchange(repo, request);
+        if (request.service === "receive-pack" && request.phase === "exchange")
+          pushed = true;
+        return result;
+      },
+    });
+    const admitted = await claimedAdmission();
+    const BACKGROUND = {
+      admit: (origin: Parameters<typeof admitted.admit>[0]) => {
+        if (phase === "admit" && failures < 2) {
+          failures++;
+          return Promise.reject(new Error("Transient fixture admission"));
+        }
+        return admitted.admit(origin);
+      },
+    };
+    for (let frame = 0; frame < 16; frame++) {
+      const [settled] = await Promise.allSettled([
+        appBackend.call(
+          "sync",
+          {},
+          { bonsai: f.bonsai, env: { BACKGROUND } },
+          { ...member },
+        ),
+      ]);
+      if (settled.status === "rejected")
+        expect(settled.reason).toMatchObject({ retryable: true });
+      const edit = f.bonsai.state.fileEdits.read(actorLane(member.actor), {
+        repo: "pond",
+        branch: "main",
+        path: "README.md",
+      });
+      if (failures > 0 && failures < 2) expect(edit?.state).toBe("pending");
+      if (edit?.state === "synced") break;
+      expect(edit?.state).toBe("pending");
+    }
+    expect(failures).toBe(2);
+    expect(
+      f.bonsai.state.fileEdits.read(actorLane(member.actor), {
+        repo: "pond",
+        branch: "main",
+        path: "README.md",
+      })?.state,
+    ).toBe("synced");
+    expect(
+      await f.provider.git.log("pond", { ref: "main", limit: 10 }),
+    ).toHaveLength(2);
+  },
+);
+
+it("a replacement after the old push landed waits for confirmation without self-conflict", async () => {
+  const f = await fixture();
+  const baseline = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  const input = {
+    repo: "pond",
+    branch: "main",
+    path: "README.md",
+    baseCommit: baseline.commit,
+    baseBlob: baseline.blob,
+    text: "First saved edit\n",
+    revision: null,
+  };
+  await f.call("files.save", input, await sealedWrite(member));
+  const observation = { pushed: false };
+  const binding = f.bonsai.store.binding;
+  f.bonsai.store = gitStore({
+    ...binding,
+    exchange: async (repo, request) => {
+      const reply = await binding.exchange(repo, request);
+      if (request.service === "receive-pack" && request.phase === "exchange")
+        observation.pushed = true;
+      return reply;
+    },
+  });
+  const BACKGROUND = await claimedAdmission();
+  for (let frame = 0; frame < 12 && !observation.pushed; frame++)
+    await appBackend.call(
+      "sync",
+      {},
+      { bonsai: f.bonsai, env: { BACKGROUND } },
+      { ...member },
+    );
+  expect(observation.pushed).toBe(true);
+  expect(
+    await f.call(
+      "files.save",
+      { ...input, text: "Replacement edit\n", revision: 1 },
+      await sealedWrite(member),
+    ),
+  ).toEqual({ kind: "conflict", revision: 1 });
+  await replayFileSync(f);
+  const confirmed = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  expect(confirmed).toMatchObject({ version: 1, text: "First saved edit\n" });
+  expect(
+    await f.call(
+      "files.save",
+      {
+        ...input,
+        baseCommit: confirmed.commit,
+        baseBlob: confirmed.blob,
+        text: "Replacement edit\n",
+        revision: confirmed.version,
+      },
+      await sealedWrite(member),
+    ),
+  ).toMatchObject({ kind: "saved", revision: 2 });
+  await replayFileSync(f);
+  expect(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  ).toMatchObject({ text: "Replacement edit\n", version: 2 });
+});
+
+it("deep file preflight spends at most one Git RPC per production sync frame", async () => {
+  const f = await fixture();
+  const path = [
+    ...Array.from({ length: 40 }, (_, index) => `dir-${String(index)}`),
+    "file.txt",
+  ].join("/");
+  const planted = await commitFiles(f.provider.git, {
+    repository: "pond",
+    branch: "main",
+    expectedHead: f.initial,
+    changes: [{ path, content: encode("Deep baseline\n") }],
+    message: "Plant deep file",
+    author: { name: "seed", email: "seed@test.invalid" },
+  });
+  if (planted.kind !== "committed")
+    throw new Error("Deep fixture did not commit");
+  const commit = await f.provider.git.readCommit("pond", planted.commit);
+  if (commit === null) throw new Error("Missing deep fixture commit");
+  let treeHash = commit.treeHash;
+  let blob: string | undefined;
+  for (const part of path.split("/")) {
+    const entries = await f.provider.git.readTree("pond", treeHash);
+    const entry = entries?.find((value) => value.name === part);
+    if (entry === undefined) throw new Error("Missing deep fixture path");
+    if (entry.type === "tree") treeHash = entry.hash;
+    else blob = entry.hash;
+  }
+  if (blob === undefined) throw new Error("Missing deep fixture file");
+  await f.call(
+    "files.save",
+    {
+      repo: "pond",
+      branch: "main",
+      path,
+      baseCommit: planted.commit,
+      baseBlob: blob,
+      text: "Deep saved edit\n",
+      revision: null,
+    },
+    await sealedWrite(member),
+  );
+  const BACKGROUND = await claimedAdmission();
+  for (let frame = 0; frame < 64; frame++) {
+    const before = f.counted.total();
+    const [settled] = await Promise.allSettled([
+      appBackend.call(
+        "sync",
+        {},
+        { bonsai: f.bonsai, env: { BACKGROUND } },
+        { ...member },
+      ),
+    ]);
+    if (settled.status === "rejected")
+      expect(settled.reason).toMatchObject({ retryable: true });
+    expect(f.counted.total() - before).toBeLessThanOrEqual(1);
+    const edit = f.bonsai.state.fileEdits.read(actorLane(member.actor), {
+      repo: "pond",
+      branch: "main",
+      path,
+    });
+    if (edit?.state === "synced") break;
+    expect(edit?.state).toBe("pending");
+  }
+  expect(
+    f.bonsai.state.fileEdits.read(actorLane(member.actor), {
+      repo: "pond",
+      branch: "main",
+      path,
+    })?.state,
+  ).toBe("synced");
+});
+
+it("production sync ends a transient phase after exactly three attempts", async () => {
+  const f = await fixture();
+  const baseline = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  await f.call(
+    "files.save",
+    {
+      repo: "pond",
+      branch: "main",
+      path: "README.md",
+      baseCommit: baseline.commit,
+      baseBlob: baseline.blob,
+      text: "Retained after three failures",
+      revision: null,
+    },
+    await sealedWrite(member),
+  );
+  let calls = 0;
+  f.bonsai.store = gitStore({
+    ...f.bonsai.store.binding,
+    refs: () => {
+      calls++;
+      return Promise.reject(new Error("Transient fixture outage"));
+    },
+  });
+  const BACKGROUND = await claimedAdmission();
+  for (let attempt = 0; attempt < 2; attempt++) {
+    await expect(
+      appBackend.call(
+        "sync",
+        {},
+        { bonsai: f.bonsai, env: { BACKGROUND } },
+        { ...member },
+      ),
+    ).rejects.toMatchObject({ code: "HOST_FAILURE", retryable: true });
+    expect(
+      f.bonsai.state.fileEdits.read(actorLane(member.actor), {
+        repo: "pond",
+        branch: "main",
+        path: "README.md",
+      })?.state,
+    ).toBe("pending");
+  }
+  expect(
+    await appBackend.call(
+      "sync",
+      {},
+      { bonsai: f.bonsai, env: { BACKGROUND } },
+      { ...member },
+    ),
+  ).toEqual({ more: false });
+  expect(calls).toBe(3);
+  expect(
+    f.bonsai.state.fileEdits.pending(actorLane(member.actor), {
+      repo: "pond",
+      branch: "main",
+      path: "README.md",
+    }),
+  ).toMatchObject({
+    state: "failed",
+    failure: "sync_failed",
+    text: "Retained after three failures",
+  });
+  expect(
+    await appBackend.call(
+      "sync",
+      {},
+      { bonsai: f.bonsai, env: { BACKGROUND } },
+      { ...member },
+    ),
+  ).toEqual({ more: false });
+  expect(calls).toBe(3);
+});
+
+it("a lost confirmation reply projects the durable Synced receipt instead of failure", async () => {
+  const f = await fixture();
+  const baseline = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  await f.call(
+    "files.save",
+    {
+      repo: "pond",
+      branch: "main",
+      path: "README.md",
+      baseCommit: baseline.commit,
+      baseBlob: baseline.blob,
+      text: "Confirmed before reply loss\n",
+      revision: null,
+    },
+    await sealedWrite(member),
+  );
+  for (let frame = 0; frame < 7; frame++)
+    await claimFileSync(f, new AbortController().signal);
+  const background = await claimedAdmission();
+  const signal = new AbortController().signal;
+  const runtime: ConcurrentWatchdogRuntime = await Watchdog.make({
+    owner: f.bonsai.state.backgroundOwner,
+    concurrentLane: actorLane(member.actor),
+    project: (transition) => {
+      projectQueuedFileEdit(f.bonsai, transition);
+    },
+    isAlive: () => Promise.resolve(false),
+    wake: { recompute: () => Promise.resolve() },
+    execute: async (job) => {
+      expect(fileEditJobSchema.parse(job.payload).step?.phase).toBe("confirm");
+      expect(
+        await executeQueuedFileEdit(
+          f.bonsai,
+          member,
+          job,
+          runtime.transactional.enqueueAcceptedJob,
+          background,
+          signal,
+        ),
+      ).toEqual({ kind: "completed" });
+      throw new Error("Fixture reply lost after durable confirmation");
+    },
+  });
+  const tick = await runtime.tickConcurrent();
+  expect(tick).toMatchObject({ status: "settled", job: { outcome: "failed" } });
+  expect(
+    f.bonsai.state.fileEdits.read(actorLane(member.actor), {
+      repo: "pond",
+      branch: "main",
+      path: "README.md",
+    }),
+  ).toMatchObject({ state: "synced", text: "Confirmed before reply loss\n" });
+  if (tick.status !== "settled") throw new Error("Lost reply did not settle");
+  await cleanupSettledFileEdit(f.bonsai, tick.job);
+  expect(
+    await f.provider.git.log("pond", { ref: "main", limit: 10 }),
+  ).toHaveLength(2);
+});
+
+// E7: the declared backend.sync continuation is the host's replay entry for saved files.
+it("the declared backend.sync continuation replays a member's saves as one member-authored push", async () => {
+  const continuation = appDeclaration.backend?.sync?.method;
+  if (continuation === undefined) throw new Error("Bonsai declares no sync");
+  expect(continuation).toBe("sync");
+  expect(
+    Schema.decodeUnknownSync(appDeclarationSchema)(appDeclaration),
+  ).toEqual(appDeclaration);
+  const f = await fixture();
+  const baseline = fileContent.parse(
+    await f.call("files.read", {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    }),
+  );
+  const key = { repo: "pond", branch: "main", path: "README.md" };
+  const before = f.counted.total();
+  let revision: number | null = null;
+  for (let save = 1; save <= 5; save++) {
+    const saved = fileSaveResult.parse(
+      await f.call(
+        "files.save",
+        {
+          ...key,
+          baseCommit: baseline.commit,
+          baseBlob: baseline.blob,
+          text: `Edit ${String(save)}\n`,
+          revision,
+        },
+        await sealedWrite(member),
+      ),
+    );
+    if (saved.kind !== "saved") throw new Error("Member save did not queue");
+    revision = saved.revision;
+  }
+  expect(f.counted.total() - before).toBe(0);
+  const BACKGROUND = await claimedAdmission();
+  const deliver = async () =>
+    z
+      .strictObject({ more: z.boolean() })
+      .parse(
+        await appBackend.call(
+          continuation,
+          {},
+          { bonsai: f.bonsai, env: { BACKGROUND } },
+          { ...member },
+        ),
+      );
+  // Each admitted frame spends at most one Git exchange; the host re-posts while more.
+  let frames = 0;
+  while ((await deliver()).more)
+    if (++frames > 32) throw new Error("Continuation did not drain the lane");
+  expect(
+    f.bonsai.state.fileEdits.read(actorLane(member.actor), key),
+  ).toMatchObject({ state: "synced", text: "Edit 5\n" });
+  const log = await f.provider.git.log("pond", { ref: "main", limit: 10 });
+  expect(log).toHaveLength(2);
+  expect(log[0]?.author.name).toBe("owner");
+  // Carrier delivery is at-least-once: a redelivered wake pushes nothing new.
+  expect(await deliver()).toEqual({ more: false });
+  expect(
+    await f.provider.git.log("pond", { ref: "main", limit: 10 }),
+  ).toHaveLength(2);
+});