@fungi.computer/bonsai 0.0.0-stage → 0.0.1

package/test/changes.test.ts

@@ -0,0 +1,1063 @@
+import { bindingOf } from "./git-binding.fixture.js";
+import { execFileSync, spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { commitFiles } from "@fungi.computer/agar/git-commit";
+import { DatabaseSync } from "node:sqlite";
+import { fromNodeSqlite } from "@fungi.computer/watchdog/node-sqlite";
+import { describe, expect, it, vi } from "vitest";
+import * as z from "zod";
+import {
+  appGitPushFactSchema,
+  type AppGitPushFact,
+} from "@fungi.computer/agar/git";
+import {
+  parseAppMethodCallContext,
+  type AppMethodCallContext,
+} from "@fungi.computer/puffball/app-method-runtime";
+import { checkRequestResult, checkReportResult } from "../shared/contract.js";
+import type { Commit } from "@fungi.computer/agar/roles/files";
+import { hookEvent, type HookEvent } from "../shared/hooks.js";
+import { ensureBonsaiTables, BonsaiState } from "../backend/state.js";
+import type { GitStore } from "../backend/git.js";
+import { observePush } from "../backend/service.js";
+import { change } from "../backend/changes.js";
+import { refreshChangeCopy } from "../backend/change-copy.js";
+import { appBackend } from "../backend/methods.js";
+
+const base = "a".repeat(40);
+const first = "b".repeat(40);
+const next = "c".repeat(40);
+const zero = "0".repeat(40);
+const recorded = z.literal(true);
+function commit(hash: string, parents: string[], message: string): Commit {
+  return {
+    hash,
+    parents,
+    message,
+    treeHash: "e".repeat(40),
+    author: { name: "Morel", email: "morel@test.invalid" },
+    committer: { name: "Morel", email: "morel@test.invalid" },
+    authoredAt: 1,
+    committedAt: 1,
+  };
+}
+
+function fixture() {
+  const database = new DatabaseSync(":memory:");
+  const owner = fromNodeSqlite(database);
+  ensureBonsaiTables(owner.sql);
+  const state = new BonsaiState(owner.sql, owner.transactionSync);
+  state.registerRepo({
+    name: "pond",
+    description: null,
+    parent: null,
+    owner: null,
+  });
+  state.registerRepo({
+    name: "pond--morel",
+    description: null,
+    parent: "pond",
+    owner: "morel",
+  });
+  const commits = new Map(
+    [
+      commit(base, [], "Start"),
+      commit(first, [base], "Add fish"),
+      commit(next, [first], "Add waves"),
+    ].map((item) => [item.hash, item]),
+  );
+  const branches = new Map([
+    ["pond", new Map([["main", base]])],
+    ["pond--morel", new Map([["main", first]])],
+  ]);
+  const unused = () => Promise.reject(new Error("Unexpected Git write"));
+  const store: GitStore = {
+    get binding() {
+      return bindingOf(this);
+    },
+    cloneUrl: (name) => Promise.resolve(`https://git.test/${name}.git`),
+    create: unused,
+    fork: unused,
+    info: (name) =>
+      Promise.resolve({
+        name,
+        defaultBranch: "main",
+        lastPushAt: null,
+        source: null,
+      }),
+    log: (_name, ref, limit) => {
+      let current = commits.get(branches.get(_name)?.get(ref) ?? ref);
+      const history: Commit[] = [];
+      while (current !== undefined && history.length < limit) {
+        history.push(current);
+        current = commits.get(current.parents[0] ?? "");
+      }
+      return Promise.resolve(history);
+    },
+    commit: (_name, hash) => Promise.resolve(commits.get(hash) ?? null),
+    tree: () => Promise.resolve([]),
+    blob: unused,
+    exchange: unused,
+    refs: (name) =>
+      Promise.resolve(
+        [...(branches.get(name)?.entries() ?? [])].map(([name, hash]) => ({
+          name: `refs/heads/${name}`,
+          hash,
+        })),
+      ),
+  };
+  const delivered: HookEvent[] = [];
+  const bonsai = {
+    state,
+    store,
+    events: {
+      emit: (_type: string, payload: unknown) => {
+        delivered.push(hookEvent.parse(payload));
+        return Promise.resolve();
+      },
+    },
+  };
+  const push = (
+    eventId: string,
+    repository: string,
+    before: string,
+    after: string,
+    ref = "refs/heads/main",
+    writer: AppGitPushFact["writer"] = {
+      kind: "actor",
+      actor: { kind: "agent", agentId: "morel" },
+    },
+  ) =>
+    observePush(
+      bonsai,
+      appGitPushFactSchema.parse({
+        eventId,
+        repository,
+        writer,
+        updates: [{ ref, before, after }],
+      }),
+    );
+  return { database, state, bonsai, commits, branches, delivered, push };
+}
+
+describe("Stored Change lifecycle from accepted host pushes", () => {
+  it("lists three prepared koi fork Changes without reading Git objects", async () => {
+    const f = fixture();
+    try {
+      f.state.registerRepo({
+        name: "pond--chanterelle",
+        description: null,
+        parent: "pond",
+        owner: "chanterelle",
+      });
+      f.state.registerRepo({
+        name: "pond--enoki",
+        description: null,
+        parent: "pond",
+        owner: "enoki",
+      });
+      for (const [index, agent] of [
+        "morel",
+        "chanterelle",
+        "enoki",
+      ].entries()) {
+        let parent = base;
+        for (let n = 1; n <= 3; n += 1) {
+          const hash = (index * 3 + n).toString(16).repeat(40);
+          f.commits.set(hash, {
+            ...commit(hash, [parent], `Koi ${agent} ${String(n)}`),
+            treeHash: hash,
+          });
+          parent = hash;
+        }
+        f.branches.set(`pond--${agent}`, new Map([["main", parent]]));
+        f.state.insertChange({
+          repo: "pond",
+          sourceRepo: `pond--${agent}`,
+          sourceRef: "main",
+          targetRef: "main",
+          title: `Koi ${agent}`,
+          body: "",
+          openedBy: agent,
+          openedKind: "agent",
+          createdAt: index + 1,
+          updatedAt: index + 1,
+          state: "open",
+          head: parent,
+          target: base,
+          conflict:
+            index === 2
+              ? { head: parent, target: base, paths: ["src/pond.ts"] }
+              : null,
+          lease: null,
+          mergedCommit: null,
+          mergedBy: null,
+          closedBy: null,
+        });
+      }
+      for (const row of f.state.changes("pond"))
+        await refreshChangeCopy(f.bonsai, row);
+      const noDiff = () =>
+        Promise.reject(
+          new Error("Changes listing must not load file diff objects"),
+        );
+      const reads: string[] = [];
+      let active = 0;
+      let peak = 0;
+      const log = async (repo: string, ref: string, limit: number) => {
+        reads.push(`${repo}:${ref}`);
+        active += 1;
+        peak = Math.max(peak, active);
+        await Promise.resolve();
+        const result = await f.bonsai.store.log(repo, ref, limit);
+        active -= 1;
+        return result;
+      };
+      const result = await appBackend.call(
+        "changes.list",
+        { repo: "pond" },
+        {
+          bonsai: {
+            ...f.bonsai,
+            store: {
+              ...f.bonsai.store,
+              log,
+              commit: noDiff,
+              tree: noDiff,
+              blob: noDiff,
+            },
+          },
+        },
+        { computerId: null, actor: { kind: "member", memberId: "Levi" } },
+      );
+      expect(reads).toHaveLength(0);
+      expect(peak).toBe(0);
+      expect(result).toMatchObject({
+        changes: [
+          { number: 3, ahead: 3, behind: 0, status: "conflict" },
+          { number: 2, ahead: 3, behind: 0, status: "ready" },
+          { number: 1, ahead: 3, behind: 0, status: "ready" },
+        ],
+      });
+    } finally {
+      f.database.close();
+    }
+  });
+
+  it("attributes accepted installation pushes to their host-held caller", async () => {
+    const f = fixture();
+    try {
+      await f.push(
+        "installation-agent",
+        "pond--morel",
+        base,
+        first,
+        "refs/heads/main",
+        {
+          kind: "installation",
+          installationId: "bonsai",
+          onBehalfOf: { kind: "agent", agentId: "morel" },
+        },
+      );
+      expect(f.state.changes("pond")[0]).toMatchObject({
+        openedBy: "morel",
+        openedKind: "agent",
+      });
+      expect(
+        f.state.events(null, 20).find((event) => event.type === "push")?.actor,
+      ).toBe("morel");
+    } finally {
+      f.database.close();
+    }
+  });
+
+  it("attributes accepted member pushes to the stable member ID", async () => {
+    const f = fixture();
+    try {
+      await f.push(
+        "installation-member",
+        "pond--morel",
+        base,
+        first,
+        "refs/heads/main",
+        {
+          kind: "installation",
+          installationId: "bonsai",
+          onBehalfOf: { kind: "member", memberId: "Levi" },
+        },
+      );
+      expect(f.state.changes("pond")[0]).toMatchObject({
+        openedBy: "Levi",
+        openedKind: "human",
+      });
+    } finally {
+      f.database.close();
+    }
+  });
+
+  it("opens numbered work, pins review to the head and closes a deleted source", async () => {
+    const f = fixture();
+    try {
+      await f.push("push-one", "pond--morel", base, first);
+      const opened = f.state.changes("pond")[0];
+      expect(opened).toMatchObject({
+        repo: "pond",
+        number: 1,
+        sourceRepo: "pond--morel",
+        sourceRef: "main",
+        targetRef: "main",
+        head: first,
+        target: base,
+        title: "Add fish",
+        openedBy: "morel",
+        state: "open",
+      });
+      f.state.transition("approval", "at-first", recorded, () => {
+        f.state.approve("pond", 1, {
+          actor: "Ada",
+          kind: "human",
+          head: first,
+          at: 2,
+        });
+        f.state.reportCheck("pond", 1, {
+          head: first,
+          name: "tests",
+          status: "passed",
+          reporter: "Ada",
+          attemptId: "event-one",
+          runUrl: null,
+          summary: null,
+          updatedAt: 2,
+        });
+        return { result: true, events: [] };
+      });
+      expect(
+        (await change(f.bonsai, { name: "morel", kind: "human" }, "pond", 1))
+          .change.mergeable,
+      ).toEqual({ allowed: true });
+      f.branches.get("pond--morel")?.set("main", next);
+      await f.push("push-two", "pond--morel", first, next);
+      const updated = await change(
+        f.bonsai,
+        { name: "morel", kind: "human" },
+        "pond",
+        1,
+      );
+      expect(updated.change).toMatchObject({
+        head: next,
+        revision: 1,
+        mergeable: { allowed: false, reason: "needs-approval" },
+      });
+      expect(updated.review.approvals).toEqual([
+        { actor: "Ada", kind: "human", head: first, at: 2 },
+      ]);
+      expect(updated.review.checks[0]?.head).toBe(first);
+      const event = f.delivered.find(
+        (event) => event.type === "change.updated",
+      );
+      expect(event?.data.repository.cloneUrl).toBe(
+        "https://git.test/pond--morel.git",
+      );
+      expect(event?.data.activity.data).toMatchObject({
+        before: first,
+        after: next,
+      });
+      await f.push("delete-source", "pond--morel", next, zero);
+      expect(f.state.change("pond", 1)).toMatchObject({
+        state: "closed",
+        closedBy: "morel",
+        head: next,
+      });
+      const count = f.state.events(null, 100).length;
+      await f.push("delete-source", "pond--morel", next, zero);
+      expect(f.state.events(null, 100)).toHaveLength(count);
+    } finally {
+      f.database.close();
+    }
+  });
+
+  it("settles a proposal when the accepted target contains its proposed head", async () => {
+    const f = fixture();
+    try {
+      await f.push("push-one", "pond--morel", base, first);
+      f.branches.get("pond")?.set("main", next);
+      await f.push("target-move", "pond", base, next);
+      expect(f.state.change("pond", 1)).toMatchObject({
+        state: "merged",
+        head: first,
+        target: next,
+        mergedCommit: next,
+        mergedBy: "morel",
+      });
+      expect(
+        f.delivered.filter((event) => event.type === "change.merged"),
+      ).toHaveLength(1);
+    } finally {
+      f.database.close();
+    }
+  });
+
+  it("atomically opens every proposal from a push larger than one drain page", async () => {
+    const f = fixture();
+    try {
+      await observePush(
+        f.bonsai,
+        appGitPushFactSchema.parse({
+          eventId: "many",
+          repository: "pond--morel",
+          writer: { kind: "actor", actor: { kind: "agent", agentId: "morel" } },
+          updates: Array.from({ length: 65 }, (_, i) => ({
+            ref: `refs/heads/topic-${String(i)}`,
+            before: base,
+            after: first,
+          })),
+        }),
+      );
+      expect(f.state.changes("pond")).toHaveLength(65);
+      expect(f.delivered).toHaveLength(32);
+      const layout = {
+        repo: "pond",
+        tiles: { view: "overview", placements: [] },
+      };
+      await appBackend.call(
+        "insights.layout.save",
+        layout,
+        { bonsai: f.bonsai },
+        caller("drain-next"),
+      );
+      expect(f.delivered).toHaveLength(64);
+      await appBackend.call(
+        "insights.layout.save",
+        layout,
+        { bonsai: f.bonsai },
+        caller("drain-last"),
+      );
+      expect(f.delivered).toHaveLength(66);
+      expect(
+        f.delivered.filter((event) => event.type === "change.opened"),
+      ).toHaveLength(65);
+      expect(new Set(f.delivered.map((event) => event.data.eventId)).size).toBe(
+        66,
+      );
+    } finally {
+      f.database.close();
+    }
+  });
+});
+
+it("refuses an Agent merge before Git transport or a lease", async () => {
+  const f = fixture();
+  try {
+    await f.push("open-work", "pond--morel", base, first);
+    const result = await appBackend.call(
+      "changes.merge",
+      { repo: "pond", number: 1, head: first },
+      { bonsai: f.bonsai },
+      {
+        computerId: null,
+        actor: { kind: "agent", agentId: "morel" },
+        idempotencyKey: "agent-merge",
+      },
+    );
+    expect(result).toEqual({ kind: "refused", reason: "agents-cannot-merge" });
+    expect(f.state.change("pond", 1)).toMatchObject({
+      state: "open",
+      lease: null,
+    });
+  } finally {
+    f.database.close();
+  }
+});
+
+function caller(key: string): AppMethodCallContext {
+  return {
+    computerId: null,
+    actor: { kind: "member", memberId: "Levi" },
+    idempotencyKey: key,
+  };
+}
+
+it("uses real event identities for same-head check reruns, refuses late terminal reports and survives reopen", async () => {
+  const f = fixture();
+  try {
+    await f.push("open-work", "pond--morel", base, first);
+    const identity = { repo: "pond", number: 1, head: first };
+    const requested = checkRequestResult.parse(
+      await appBackend.call(
+        "checks.request",
+        { ...identity, names: ["tests"] },
+        { bonsai: f.bonsai },
+        caller("request-one"),
+      ),
+    );
+    if (requested.kind !== "requested")
+      throw new Error("Expected a check request");
+    expect(
+      f.delivered.some(
+        (event) =>
+          event.type === "change.checks_requested" &&
+          event.data.eventId === requested.attemptId,
+      ),
+    ).toBe(true);
+    const report = {
+      ...identity,
+      name: "tests",
+      attemptId: requested.attemptId,
+    };
+    expect(
+      await appBackend.call(
+        "checks.report",
+        { ...report, status: "running" },
+        { bonsai: f.bonsai },
+        caller("running-one"),
+      ),
+    ).toEqual({ kind: "recorded" });
+    expect(
+      await appBackend.call(
+        "checks.report",
+        { ...report, status: "failed" },
+        { bonsai: f.bonsai },
+        caller("failed-one"),
+      ),
+    ).toEqual({ kind: "recorded" });
+    expect(
+      await appBackend.call(
+        "checks.report",
+        { ...report, status: "passed" },
+        { bonsai: f.bonsai },
+        caller("conflicting-terminal"),
+      ),
+    ).toEqual({ kind: "settled" });
+    const rerun = checkRequestResult.parse(
+      await appBackend.call(
+        "checks.request",
+        { ...identity, names: ["tests"] },
+        { bonsai: f.bonsai },
+        caller("request-two"),
+      ),
+    );
+    if (rerun.kind !== "requested") throw new Error("Expected a rerun");
+    expect(rerun.attemptId).not.toBe(requested.attemptId);
+    expect(
+      await appBackend.call(
+        "checks.report",
+        { ...report, status: "failed" },
+        { bonsai: f.bonsai },
+        caller("late-old-attempt"),
+      ),
+    ).toEqual({ kind: "settled" });
+    const newer = { ...report, attemptId: rerun.attemptId, status: "passed" };
+    expect(
+      checkReportResult.parse(
+        await appBackend.call(
+          "checks.report",
+          newer,
+          { bonsai: f.bonsai },
+          caller("passed-two"),
+        ),
+      ),
+    ).toEqual({ kind: "recorded" });
+    const owner = fromNodeSqlite(f.database);
+    const reopened = {
+      ...f.bonsai,
+      state: new BonsaiState(owner.sql, owner.transactionSync),
+    };
+    const count = f.delivered.length;
+    expect(
+      await appBackend.call(
+        "checks.report",
+        newer,
+        { bonsai: reopened },
+        caller("passed-two"),
+      ),
+    ).toEqual({ kind: "recorded" });
+    expect(f.delivered).toHaveLength(count);
+    expect(reopened.state.checks("pond", 1)[0]).toMatchObject({
+      attemptId: rerun.attemptId,
+      status: "passed",
+      runUrl: null,
+    });
+    await expect(
+      appBackend.call(
+        "checks.report",
+        { ...newer, status: "failed" },
+        { bonsai: reopened },
+        caller("passed-two"),
+      ),
+    ).rejects.toThrow("different");
+    await expect(
+      appBackend.call(
+        "checks.report",
+        { ...newer, workflow: "forged-workflow" },
+        { bonsai: reopened },
+        caller("forged-attribution"),
+      ),
+    ).rejects.toThrow();
+    await expect(
+      appBackend.call(
+        "checks.report",
+        { ...newer, attemptId: "invented" },
+        { bonsai: reopened },
+        caller("invented-attempt"),
+      ),
+    ).rejects.toThrow("actual Change trigger");
+  } finally {
+    f.database.close();
+  }
+});
+
+it("refuses concurrent merges and retries while the first Git exchange is pending", async () => {
+  const f = fixture();
+  let failExchange: ((reason: Error) => void) | undefined;
+  let exchangeStarted: (() => void) | undefined;
+  const started = new Promise<void>((resolve) => {
+    exchangeStarted = resolve;
+  });
+  const transport = new Promise<never>((_resolve, reject) => {
+    failExchange = reject;
+  });
+  const bonsai = {
+    ...f.bonsai,
+    store: {
+      ...f.bonsai.store,
+      exchange: () => {
+        exchangeStarted?.();
+        return transport;
+      },
+    },
+  };
+  try {
+    await f.push("open-work", "pond--morel", base, first);
+    const input = { repo: "pond", number: 1, head: first };
+    const merging = appBackend.call(
+      "changes.merge",
+      input,
+      { bonsai },
+      caller("first-merge"),
+    );
+    const outcome = merging.catch((error: unknown) => error);
+    await started;
+    expect(
+      await appBackend.call(
+        "changes.merge",
+        input,
+        { bonsai },
+        caller("second-merge"),
+      ),
+    ).toEqual({ kind: "refused", reason: "merging" });
+    expect(
+      await appBackend.call(
+        "changes.merge",
+        input,
+        { bonsai },
+        caller("first-merge"),
+      ),
+    ).toEqual({ kind: "refused", reason: "merging" });
+    failExchange?.(new Error("Git transport unavailable"));
+    expect(await outcome).toBeInstanceOf(Error);
+    expect(
+      f.delivered.filter((event) => event.type === "change.merged"),
+    ).toEqual([]);
+  } finally {
+    failExchange?.(new Error("Test finished"));
+    f.database.close();
+  }
+});
+
+it("recovers an expired failed-transport lease on the next approval call", async () => {
+  const f = fixture();
+  const time = vi.spyOn(Date, "now");
+  try {
+    await f.push("open-work", "pond--morel", base, first);
+    await expect(
+      appBackend.call(
+        "changes.merge",
+        { repo: "pond", number: 1, head: first },
+        { bonsai: f.bonsai },
+        caller("failed-merge"),
+      ),
+    ).rejects.toThrow("Unexpected Git write");
+    const lease = f.state.requireChange("pond", 1).lease;
+    if (lease === null) throw new Error("Expected durable interrupted lease");
+    time.mockReturnValue(lease.at + 120_001);
+    expect(
+      await appBackend.call(
+        "changes.approve",
+        { repo: "pond", number: 1, head: first },
+        { bonsai: f.bonsai },
+        caller("after-timeout"),
+      ),
+    ).toEqual({ kind: "approved" });
+    expect(f.state.requireChange("pond", 1)).toMatchObject({
+      state: "open",
+      lease: null,
+    });
+  } finally {
+    time.mockRestore();
+    f.database.close();
+  }
+});
+
+it("merges the reviewed head through native Git and replays the committed receipt without a second write", async () => {
+  const f = fixture();
+  const root = mkdtempSync(join(tmpdir(), "bonsai-merge-"));
+  const run = (...args: string[]) =>
+    execFileSync("git", args, { cwd: root, encoding: "utf8" }).trim();
+  let beforeReceive: (() => Promise<void>) | null = null;
+  const store: GitStore = {
+    get binding() {
+      return bindingOf(this);
+    },
+    ...f.bonsai.store,
+    exchange: async (name, request) => {
+      if (
+        name === "pond" &&
+        request.service === "receive-pack" &&
+        request.phase === "exchange"
+      ) {
+        const hook = beforeReceive;
+        beforeReceive = null;
+        await hook?.();
+      }
+      const advertise = request.phase === "advertise";
+      const result = spawnSync("git", ["http-backend"], {
+        input: request.body ?? new Uint8Array(),
+        env: {
+          ...process.env,
+          GIT_PROJECT_ROOT: root,
+          GIT_HTTP_EXPORT_ALL: "1",
+          PATH_INFO: advertise
+            ? `/${name}.git/info/refs`
+            : `/${name}.git/git-${request.service}`,
+          REQUEST_METHOD: advertise ? "GET" : "POST",
+          QUERY_STRING: advertise ? `service=git-${request.service}` : "",
+          CONTENT_TYPE: request.headers["content-type"] ?? "",
+        },
+      });
+      const output = new Uint8Array(result.stdout);
+      const split = new TextDecoder().decode(output).indexOf("\r\n\r\n");
+      if (result.status !== 0 || split < 0)
+        return Promise.reject(new Error("Native Git fixture failed"));
+      return Promise.resolve({
+        status: 200,
+        headers: {
+          "content-type": `application/x-git-${request.service}-${advertise ? "advertisement" : "result"}`,
+        },
+        body: new Uint8Array(output.subarray(split + 4)),
+      });
+    },
+  };
+  const bonsai = { ...f.bonsai, store };
+  try {
+    run("init", "--bare", "-q", "-b", "main", "pond.git");
+    run("--git-dir=pond.git", "config", "http.receivepack", "true");
+    const author = { name: "Morel", email: "morel@test.invalid" };
+    const initial = await commitFiles(store, {
+      repository: "pond",
+      branch: "main",
+      expectedHead: null,
+      message: "Start",
+      author,
+      changes: [
+        { path: "food.txt", content: new TextEncoder().encode("food\n") },
+      ],
+    });
+    if (initial.kind !== "committed")
+      throw new Error("Expected initial native commit");
+    run("clone", "--bare", "-q", "pond.git", "pond--morel.git");
+    run("--git-dir=pond--morel.git", "config", "http.receivepack", "true");
+    const proposed = await commitFiles(store, {
+      repository: "pond--morel",
+      branch: "main",
+      expectedHead: initial.commit,
+      message: "Add fish",
+      author,
+      changes: [
+        { path: "fish.txt", content: new TextEncoder().encode("fish\n") },
+      ],
+    });
+    if (proposed.kind !== "committed")
+      throw new Error("Expected proposed native commit");
+    f.commits.set(initial.commit, commit(initial.commit, [], "Start"));
+    f.commits.set(
+      proposed.commit,
+      commit(proposed.commit, [initial.commit], "Add fish"),
+    );
+    f.branches.set("pond", new Map([["main", initial.commit]]));
+    f.branches.set("pond--morel", new Map([["main", proposed.commit]]));
+    await f.push("native-open", "pond--morel", initial.commit, proposed.commit);
+    let newHead = "";
+    beforeReceive = async () => {
+      const changed = await commitFiles(store, {
+        repository: "pond--morel",
+        branch: "main",
+        expectedHead: proposed.commit,
+        message: "Add waves",
+        author,
+        changes: [
+          { path: "waves.txt", content: new TextEncoder().encode("waves\n") },
+        ],
+      });
+      if (changed.kind !== "committed")
+        throw new Error("Expected concurrent source write");
+      newHead = changed.commit;
+      f.commits.set(
+        changed.commit,
+        commit(changed.commit, [proposed.commit], "Add waves"),
+      );
+      f.branches.set("pond--morel", new Map([["main", changed.commit]]));
+      await f.push(
+        "native-source-moved",
+        "pond--morel",
+        proposed.commit,
+        changed.commit,
+      );
+    };
+    const input = { repo: "pond", number: 1, head: proposed.commit };
+    const result = await appBackend.call(
+      "changes.merge",
+      input,
+      { bonsai },
+      caller("native-merge"),
+    );
+    const accepted = run("--git-dir=pond.git", "rev-parse", "main");
+    expect(result).toEqual({
+      kind: "merged",
+      before: initial.commit,
+      after: accepted,
+    });
+    expect(
+      run("--git-dir=pond.git", "show", "-s", "--format=%P", accepted),
+    ).toBe(`${initial.commit} ${proposed.commit}`);
+    expect(run("--git-dir=pond.git", "show", "main:fish.txt")).toBe("fish");
+    expect(
+      run("--git-dir=pond.git", "ls-tree", "-r", "--name-only", accepted),
+    ).toBe("fish.txt\nfood.txt");
+    const owner = fromNodeSqlite(f.database);
+    const restarted = {
+      ...bonsai,
+      state: new BonsaiState(owner.sql, owner.transactionSync),
+    };
+    expect(
+      await appBackend.call(
+        "changes.merge",
+        input,
+        { bonsai: restarted },
+        caller("native-merge"),
+      ),
+    ).toEqual(result);
+    expect(run("--git-dir=pond.git", "rev-parse", "main")).toBe(accepted);
+    expect(
+      f.delivered.filter((event) => event.type === "change.merged"),
+    ).toHaveLength(1);
+    expect(
+      f.delivered.find((event) => event.type === "change.merged")?.data,
+    ).toMatchObject({ change: { head: proposed.commit } });
+    await expect(
+      appBackend.call(
+        "changes.merge",
+        { ...input, head: newHead },
+        { bonsai: restarted },
+        caller("native-merge"),
+      ),
+    ).rejects.toThrow("Receipt key reused with different contents");
+    expect(f.state.requireChange("pond", 1)).toMatchObject({
+      state: "open",
+      head: newHead,
+      target: accepted,
+      lease: null,
+    });
+  } finally {
+    f.database.close();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+it("reads viewer approve and close decisions from host identity and the current Change", async () => {
+  const f = fixture();
+  try {
+    await f.push("viewer-actions-open", "pond--morel", base, first);
+    const input = { repo: "pond", number: 1 };
+    const cases = [
+      {
+        actor: { kind: "member", memberId: "Levi" },
+        actions: { approve: { allowed: true }, close: { allowed: true } },
+      },
+      {
+        actor: { kind: "member", memberId: "morel" },
+        actions: {
+          approve: { allowed: false, reason: "self-approval" },
+          close: { allowed: true },
+        },
+      },
+      {
+        actor: { kind: "agent", agentId: "morel" },
+        actions: {
+          approve: { allowed: false, reason: "agents-cannot-approve" },
+          close: { allowed: true },
+        },
+      },
+      {
+        actor: { kind: "agent", agentId: "another-agent" },
+        actions: {
+          approve: { allowed: false, reason: "agents-cannot-approve" },
+          close: { allowed: false, reason: "not-authorized" },
+        },
+      },
+    ];
+    for (const candidate of cases) {
+      const context = parseAppMethodCallContext({
+        ...caller("viewer-actions-read"),
+        actor: candidate.actor,
+      });
+      expect(
+        await appBackend.call(
+          "changes.get",
+          input,
+          { bonsai: f.bonsai },
+          context,
+        ),
+      ).toMatchObject({ actions: candidate.actions });
+    }
+    expect(
+      await appBackend.call(
+        "changes.close",
+        input,
+        { bonsai: f.bonsai },
+        caller("viewer-actions-close"),
+      ),
+    ).toEqual({ allowed: true });
+    expect(
+      await appBackend.call(
+        "changes.get",
+        input,
+        { bonsai: f.bonsai },
+        caller("viewer-actions-after-close"),
+      ),
+    ).toMatchObject({
+      actions: {
+        approve: { allowed: false, reason: "not-open" },
+        close: { allowed: false, reason: "not-open" },
+      },
+    });
+  } finally {
+    f.database.close();
+  }
+});
+
+describe("Sole Team member review", () => {
+  const ownPush = (f: ReturnType<typeof fixture>) =>
+    f.push("own-work", "pond--morel", base, first, "refs/heads/main", {
+      kind: "actor",
+      actor: { kind: "member", memberId: "Levi" },
+    });
+  const input = { repo: "pond", number: 1, head: first };
+  const sole = (key: string) =>
+    parseAppMethodCallContext({ ...caller(key), soleMember: true });
+
+  it("keeps another reviewer required when the host does not attest a sole member", async () => {
+    const f = fixture();
+    try {
+      await ownPush(f);
+      expect(
+        await appBackend.call(
+          "changes.approve",
+          input,
+          { bonsai: f.bonsai },
+          caller("multi-approve"),
+        ),
+      ).toEqual({ kind: "refused", reason: "self-approval" });
+      expect(
+        await appBackend.call(
+          "changes.merge",
+          input,
+          { bonsai: f.bonsai },
+          caller("multi-merge"),
+        ),
+      ).toEqual({ kind: "refused", reason: "needs-approval" });
+      expect(f.state.approvals("pond", 1)).toEqual([]);
+    } finally {
+      f.database.close();
+    }
+  });
+
+  it("lets the attested sole member approve and merge their own Change as a recorded self-approval", async () => {
+    const f = fixture();
+    try {
+      await ownPush(f);
+      expect(
+        await appBackend.call(
+          "changes.approve",
+          input,
+          { bonsai: f.bonsai },
+          sole("sole-approve"),
+        ),
+      ).toEqual({ kind: "approved" });
+      expect(f.state.approvals("pond", 1)).toMatchObject([
+        { actor: "Levi", kind: "self", head: first },
+      ]);
+      expect(
+        await appBackend.call(
+          "changes.get",
+          { repo: "pond", number: 1 },
+          { bonsai: f.bonsai },
+          sole("sole-read"),
+        ),
+      ).toMatchObject({
+        change: { status: "ready", mergeable: { allowed: true } },
+      });
+      // Admission passed: the merge reaches the fixture's refused Git write.
+      await expect(
+        appBackend.call(
+          "changes.merge",
+          input,
+          { bonsai: f.bonsai },
+          sole("sole-merge"),
+        ),
+      ).rejects.toThrow("Unexpected Git write");
+      expect(f.state.requireChange("pond", 1).lease?.by).toBe("Levi");
+    } finally {
+      f.database.close();
+    }
+  });
+
+  it("records the sole member's approval of an Agent's Change as independent, and Agents cannot claim sole membership", async () => {
+    const f = fixture();
+    try {
+      await f.push("agent-work", "pond--morel", base, first);
+      expect(
+        await appBackend.call(
+          "changes.approve",
+          input,
+          { bonsai: f.bonsai },
+          parseAppMethodCallContext({
+            ...caller("agent-approve"),
+            actor: { kind: "agent", agentId: "morel" },
+          }),
+        ),
+      ).toEqual({ kind: "refused", reason: "agents-cannot-approve" });
+      expect(() =>
+        parseAppMethodCallContext({
+          ...caller("agent-sole"),
+          actor: { kind: "agent", agentId: "morel" },
+          soleMember: true,
+        }),
+      ).toThrow("sole member");
+      expect(
+        await appBackend.call(
+          "changes.approve",
+          input,
+          { bonsai: f.bonsai },
+          sole("owner-approves-agent"),
+        ),
+      ).toEqual({ kind: "approved" });
+      expect(f.state.approvals("pond", 1)).toMatchObject([
+        { actor: "Levi", kind: "human", head: first },
+      ]);
+    } finally {
+      f.database.close();
+    }
+  });
+});