d22791f
@@ -0,0 +1,390 @@
/**
 * An issue found already done is the asker's to close, not a park: a builder
 * that names a commit on the base records the outcome, shows it, strikes
 * nothing, and leaves the planner's list. Split from
 * `test/crew-parks.test.ts`, whose `engine` it shares.
 */
import { afterAll, beforeAll, describe, expect, test } from "bun:test";
import {
  addComment,
  openIssue,
  setIssueState,
} from "../src/actions/issues.ts";
import { commitToBranch } from "../src/actions/repos.ts";
import { getIssueById, listComments, type Issue } from "../src/core/issues.ts";
import { createUser } from "../src/core/users.ts";
import { parkedCount, settleAgentRun } from "../src/crew/autonomy.ts";
import {
  alreadyDoneOids,
  alreadyDoneSummary,
  namedCommits,
  onBase,
} from "../src/crew/already.ts";
import { repoDir } from "../src/git/repos.ts";
import { alreadyDone } from "../src/core/done_on_main.ts";
import { askedIn, askedJson } from "../src/core/asked.ts";
import { parkedTwice, struckOut } from "../src/crew/parks.ts";
import { engine, tick, type Engine } from "./helpers/parks-engine.ts";
describe("an issue found already done is the asker's to close, not a park", () => {
  let e: Engine;
  let oid: string;
  const settle = (on: Issue, state: "ok" | "failed", summary: string) =>
    settleAgentRun(e.app, e.fresh(), {
      issueId: on.id,
      state,
      summary,
      reason: "assigned",
      actorId: e.mason.id,
    });
  beforeAll(async () => {
    e = await engine("forge-already-");
    const seeded = await commitToBranch(e.app, e.alice, e.repo, {
      message: "Start",
      files: [{ path: "README.md", content: "# engine\n" }],
    });
    if (!seeded.ok) throw new Error(JSON.stringify(seeded.error));
    oid = seeded.value.commitOid;
  });
  afterAll(() => e.close());
  test("only a named commit that is on the base counts", async () => {
    const dir = repoDir(e.app.reposRoot, e.repo.ownerName, e.repo.name);
    expect(namedCommits("already done on main in " + oid.slice(0, 9))).toEqual([
      oid.slice(0, 9),
    ]);
    expect(namedCommits("already done on main")).toEqual([]);
    expect(namedCommits("out of scope, see " + oid.slice(0, 9))).toEqual([]);
    expect(await onBase(dir, "main", [oid.slice(0, 9)])).toEqual([oid]);
    expect(await onBase(dir, "main", ["deadbeef"])).toEqual([]);
    expect(await onBase(dir, "nope", [oid.slice(0, 9)])).toEqual([]);
  });
  test("an already-done outcome is recorded, shown, and no strike", async () => {
    const work = e.issue("Already built");
    const summary = alreadyDoneSummary([oid]);
    expect(alreadyDoneOids(summary)).toEqual([oid]);
    for (let n = 0; n < 3; n++) {
      expect(settle(work, "ok", summary)).toBe(true);
      await tick();
    }
    const parks = listComments(e.app.db, work.id).filter((c) =>
      c.body.startsWith("Parked by the crew"),
    );
    expect(parks).toEqual([]);
    expect(parkedCount(e.app, e.fresh(), work.id)).toBe(0);
    expect(struckOut(e.app.db, e.fresh(), [work.id]).has(work.id)).toBe(false);
    expect(alreadyDone(e.app.db, [work.id]).get(work.id)).toEqual([oid]);
    expect(getIssueById(e.app.db, work.id)!.state).toBe("open");
    const signin = await fetch(`${e.servers.url}/signin`, {
      method: "POST",
      body: new URLSearchParams({
        username: "alice",
        password: "a-good-passphrase",
      }),
      redirect: "manual",
    });
    const cookie = (signin.headers.get("set-cookie") ?? "").split(";")[0]!;
    const page = await (
      await fetch(`${e.servers.url}/alice/engine/issues/${work.number}`, {
        headers: { cookie },
      })
    ).text();
    expect(page).toContain("waiting for you to close it");
    expect(page).toContain(`/commit/${oid}`);
    const closed = await fetch(
      `${e.servers.url}/alice/engine/issues/${work.number}/state`,
      {
        method: "POST",
        headers: { cookie, origin: e.servers.url },
        body: new URLSearchParams({ state: "closed", reason: "done" }),
        redirect: "manual",
      },
    );
    expect(closed.status).toBeLessThan(400);
    expect(getIssueById(e.app.db, work.id)!.state).toBe("closed");
    expect(
      listComments(e.app.db, work.id).some((c) =>
        c.body.startsWith(`Closed: already done on main in [\`${oid.slice(0, 7)}\``),
      ),
    ).toBe(true);
  });
  test("the asked JSON carries the commits; closing through any door writes the note", async () => {
    const work = e.issue("Asked and already built");
    expect(settle(work, "ok", alreadyDoneSummary([oid]))).toBe(true);
    const row = askedIn(e.app.db, [e.fresh()], { show: "all" }).find(
      (a) => a.issue.id === work.id,
    )!;
    expect(askedJson(row).doneBy).toEqual([oid]);
    // Not the web form: the same close the terminal makes.
    expect(setIssueState(e.app, e.alice, e.fresh(), work, "closed").ok).toBe(true);
    const comments = listComments(e.app.db, work.id).filter((c) =>
      c.body.startsWith("Closed: already done on main in "),
    );
    expect(comments).toHaveLength(1);
    expect(comments[0]!.body).toContain(oid.slice(0, 7));
    // An issue with no note closes without one.
    const plain = e.issue("Closed plainly");
    expect(setIssueState(e.app, e.alice, e.fresh(), plain, "closed").ok).toBe(true);
    expect(
      listComments(e.app.db, plain.id).some((c) => c.body.startsWith("Closed:")),
    ).toBe(false);
  });
  test("the asked page says done on main, with the commits", async () => {
    const work = e.issue("Asked page");
    expect(settle(work, "ok", alreadyDoneSummary([oid]))).toBe(true);
    const signin = await fetch(`${e.servers.url}/signin`, {
      method: "POST",
      body: new URLSearchParams({
        username: "alice",
        password: "a-good-passphrase",
      }),
      redirect: "manual",
    });
    const cookie = (signin.headers.get("set-cookie") ?? "").split(";")[0]!;
    const page = await (
      await fetch(`${e.servers.url}/asked`, { headers: { cookie } })
    ).text();
    expect(page).toContain("Done on main");
    expect(page).toContain(`on main in ${oid.slice(0, 7)}, waiting for you to close it`);
  });
  test("an issue parked twice and then found done leaves the planner's list", () => {
    const work = e.issue("Parked, then built");
    e.ended(work, "no changes pushed: DECLINED: out of scope");
    e.ended(work, "no changes pushed: DECLINED: out of scope");
    const listed = () =>
      parkedTwice(e.app.db, [e.fresh()]).some((p) => p.issueId === work.id);
    expect(listed()).toBe(true);
    expect(settle(work, "ok", alreadyDoneSummary([oid]))).toBe(true);
    expect(alreadyDone(e.app.db, [work.id]).get(work.id)).toEqual([oid]);
    expect(listed()).toBe(false);
  });
  test("writes in one millisecond are read in the order they were written", () => {
    // What a fast machine does by chance, every time: one timestamp for all.
    const at = new Date().toISOString();
    const stamp = (...on: Issue[]) => {
      for (const one of on) {
        e.app.db.query("UPDATE issue SET created_at = ?1 WHERE id = ?2").run(at, one.id);
        e.app.db.query("UPDATE comment SET created_at = ?1 WHERE issue_id = ?2").run(at, one.id);
      }
    };
    const now = (on: Issue): Issue => {
      const found = getIssueById(e.app.db, on.id);
      if (found === undefined) throw new Error(`no issue ${on.id}`);
      return found;
    };
    const declined = "no changes pushed: DECLINED: out of scope";
    const split = (on: Issue, into: Issue) => {
      const closed = setIssueState(e.app, e.atlas, e.fresh(), now(on), "closed", {
        reason: "split",
        into: [into.number],
      });
      return closed.ok ? "closed" : closed.error;
    };
    // Parked twice, then found done: the note is the newest word.
    const built = e.issue("Parked, then built");
    e.ended(built, declined);
    e.ended(built, declined);
    expect(settle(built, "ok", alreadyDoneSummary([oid]))).toBe(true);
    stamp(built);
    expect(parkedTwice(e.app.db, [e.fresh()]).some((p) => p.issueId === built.id)).toBe(false);
    expect(alreadyDone(e.app.db, [built.id]).get(built.id)).toEqual([oid]);
    // Found done, then parked: the park is.
    const undone = e.issue("Built, then parked");
    expect(settle(undone, "ok", alreadyDoneSummary([oid]))).toBe(true);
    e.ended(undone, declined);
    stamp(undone);
    expect(alreadyDone(e.app.db, [undone.id]).has(undone.id)).toBe(false);
    // A person's word, then two parks: both count.
    const told = e.issue("Told, then parked");
    expect(addComment(e.app, e.alice, e.fresh(), now(told), "Try it smaller.").ok).toBe(true);
    e.ended(told, declined);
    e.ended(told, declined);
    stamp(told);
    expect(parkedCount(e.app, e.fresh(), told.id)).toBe(2);
    // Handed over, then split into an issue opened after the hand-over.
    const half = e.issue("Told, then parked: the first half");
    stamp(told, half);
    expect(split(told, half)).toBe("closed");
    // Re-planned on its own pass: into the issue opened after it, not before.
    const older = e.issue("Opened first");
    const newer = e.issue("Opened second");
    stamp(older, newer);
    expect(split(newer, older)).toBe("forbidden");
    expect(split(older, newer)).toBe("closed");
  });
  test("the planner re-planning on its own pass: splits, drops what the crew wrote, closes what is done, and no more", async () => {
    const { atlas, mason } = e;
    const state = (on: Issue) => getIssueById(e.app.db, on.id)!;
    const close = (
      on: Issue,
      how?: { reason: "done" | "dropped" | "split"; into?: number[] },
    ) => {
      const closed = setIssueState(e.app, atlas, e.fresh(), state(on), "closed", how);
      return closed.ok ? "closed" : closed.error;
    };
    // Nobody handed any of these over: a person's ask, never parked.
    const asked = e.issue("Re-plan me");
    const stale = e.issue("Opened before the ask");
    const part = e.issue("Re-plan me, the first half");
    // Split, into an issue opened since.
    expect(close(asked, { reason: "split", into: [part.number] })).toBe("closed");
    expect(state(asked).closeReason).toBe("split");
    // Refused: into an issue older than the issue, or a closed one.
    const again = e.issue("Re-plan me too");
    expect(close(again, { reason: "split", into: [stale.number] })).toBe("forbidden");
    expect(close(again, { reason: "split", into: [asked.number] })).toBe("forbidden");
    // Refused: dropping a person's ask.
    expect(close(again, { reason: "dropped" })).toBe("forbidden");
    // Refused: done with no done note, said or not.
    expect(close(again)).toBe("forbidden");
    expect(close(again, { reason: "done" })).toBe("forbidden");
    expect(state(again).state).toBe("open");
    // Dropped: an issue the crew wrote.
    const made = openIssue(e.app, mason, e.fresh(), { title: "Crew's own chore" });
    if (!made.ok) throw new Error(String(made.error));
    expect(close(made.value, { reason: "dropped" })).toBe("closed");
    expect(state(made.value).closeReason).toBe("dropped");
    // Done: when commits on main are named for it.
    const built = e.issue("Already built, found by the planner");
    expect(
      settleAgentRun(e.app, e.fresh(), {
        issueId: built.id,
        state: "ok",
        summary: alreadyDoneSummary([oid]),
        reason: "assigned",
        actorId: mason.id,
      }),
    ).toBe(true);
    expect(close(built, { reason: "done" })).toBe("closed");
    expect(state(built).closeReason).toBe("done");
    // Never a reopen.
    const reopened = setIssueState(e.app, atlas, e.fresh(), state(made.value), "open");
    expect(reopened.ok ? "open" : reopened.error).toBe("forbidden");
    // A builder has none of it.
    const other = e.issue("Not for builders");
    const own = setIssueState(e.app, mason, e.fresh(), other, "closed", { reason: "split", into: [part.number] });
    expect(own.ok ? "closed" : own.error).toBe("forbidden");
  });
  test("the planner closes an umbrella as split into issues that all closed as done since, and no other", async () => {
    const { atlas } = e;
    const state = (on: Issue) => getIssueById(e.app.db, on.id)!;
    const close = (on: Issue, into: number[]) => {
      const closed = setIssueState(e.app, atlas, e.fresh(), state(on), "closed", {
        reason: "split",
        into,
      });
      return closed.ok ? "closed" : closed.error;
    };
    const finish = (on: Issue, reason: "done" | "dropped") => {
      const r = setIssueState(e.app, e.alice, e.fresh(), state(on), "closed", { reason });
      if (!r.ok) throw new Error(String(r.error));
    };
    // Old, unrelated work that closed as done before the umbrella existed.
    const old = e.issue("Old unrelated work");
    finish(old, "done");
    await Bun.sleep(5);
    const umbrella = e.issue("Umbrella");
    await Bun.sleep(5);
    const a = e.issue("Piece A");
    const b = e.issue("Piece B");
    const dropped = e.issue("Piece dropped");
    const open = e.issue("Piece still open, older than nothing");
    finish(a, "done");
    finish(dropped, "dropped");
    // Refused: an old done issue is no piece of it, alone or beside a real one.
    expect(close(umbrella, [old.number])).toBe("forbidden");
    finish(b, "done");
    expect(close(umbrella, [a.number, old.number])).toBe("forbidden");
    // Refused: itself, a dropped piece, an open one, a done beside a fresh open.
    expect(close(umbrella, [a.number, umbrella.number])).toBe("forbidden");
    expect(close(umbrella, [a.number, dropped.number])).toBe("forbidden");
    expect(close(umbrella, [a.number, open.number])).toBe("forbidden");
    await Bun.sleep(5);
    const fresh = e.issue("Fresh piece, open");
    expect(close(umbrella, [a.number, fresh.number])).toBe("forbidden");
    // Refused: a number that is no issue here (another repository's is none of this one's).
    expect(close(umbrella, [a.number, 99999])).toBe("forbidden");
    expect(state(umbrella).state).toBe("open");
    // Allowed: every piece closed as done since.
    expect(close(umbrella, [a.number, b.number])).toBe("closed");
    expect(state(umbrella).closeReason).toBe("split");
  });
  test("another person's comment that reads like the note is that person's word", async () => {
    const carol = await createUser(e.app.db, {
      origin: "seed",
      trusted: true,
      username: "carol",
      email: "[email protected]",
      password: "a-good-passphrase",
    });
    if (!carol.ok) throw new Error(carol.error);
    // Anyone who can read may direct the crew here, for this test only.
    e.app.db.run("UPDATE repo SET visibility = 'public', crew_outsiders = 1 WHERE id = ?1", [e.repo.id]);
    try {
      const work = e.issue("Words");
      e.ended(work, "no changes pushed: DECLINED: out of scope");
      expect(parkedCount(e.app, e.fresh(), work.id)).toBe(1);
      await tick();
      addComment(
        e.app,
        carol.value,
        e.fresh(),
        work,
        "Done on main already, waiting for you to close it: try again anyway",
      );
      expect(parkedCount(e.app, e.fresh(), work.id)).toBe(0);
      expect(alreadyDone(e.app.db, [work.id]).has(work.id)).toBe(false);
    } finally {
      e.app.db.run("UPDATE repo SET visibility = 'private', crew_outsiders = 0 WHERE id = ?1", [e.repo.id]);
    }
  });
  test("an ordinary decline, or a claim with no commit, still parks", () => {
    const work = e.issue("Out of scope");
    expect(settle(work, "ok", "no changes pushed: DECLINED: out of scope")).toBe(true);
    expect(parkedCount(e.app, e.fresh(), work.id)).toBe(1);
    expect(alreadyDone(e.app.db, [work.id]).has(work.id)).toBe(false);
    expect(alreadyDoneOids("no changes pushed: already done: " + oid)).toEqual([]);
  });
  test("an issue parked twice whose newest crew note is the done note is not handed to the planner", () => {
    const park = (on: Issue) => {
      for (let n = 0; n < 2; n++)
        addComment(e.app, e.mason, e.fresh(), on, "Parked by the crew: " + nothingNew);
    };
    const nothingNew = "the run ended without a pull: nothing to propose";
    const finished = e.issue("Parked, then found done");
    const open = e.issue("Parked, still open");
    park(finished);
    park(open);
    const numbers = () => parkedTwice(e.app.db, [e.fresh()]).map((i) => i.number);
    expect(numbers()).toEqual([finished.number, open.number]);
    addComment(
      e.app,
      e.mason,
      e.fresh(),
      finished,
      "Done on main already, waiting for you to close it: " + oid,
    );
    // Written in the same instant as the park: the clock cannot order them.
    e.app.db.run(
      `UPDATE comment SET created_at = (SELECT MAX(p.created_at) FROM comment p
         WHERE p.issue_id = ?1 AND p.body LIKE 'Parked by the crew%')
       WHERE issue_id = ?1 AND body LIKE 'Done on main already%'`,
      [finished.id],
    );
    expect(alreadyDone(e.app.db, [finished.id]).get(finished.id)).toEqual([oid]);
    expect(numbers()).toEqual([open.number]);
  });
});
@@ -9,14 +9,14 @@
 * once, even with a full map, even after it declined the direction — while
 * the board, the map's data and the MCP's `map` show it until it is split,
 * replaced or deferred.
 *
 * An issue found already done is not a park: `test/crew-parks-done.test.ts`.
 */
import { afterAll, beforeAll, describe, expect, test } from "bun:test";
import { Database } from "bun:sqlite";
import { chmodSync, existsSync, readFileSync, writeFileSync } from "node:fs";
import { mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { createApp, type App } from "../src/app.ts";
import { type App } from "../src/app.ts";
import { addToCrew, createAgent } from "../src/actions/crew.ts";
import { linkIssue } from "../src/actions/dependencies.ts";
import {
@@ -25,15 +25,11 @@
import {
  setIssueState,
} from "../src/actions/issues.ts";
import { openPull } from "../src/actions/pulls.ts";
import {
  commitToBranch,
  createRepo,
  updateRepoSettings,
} from "../src/actions/repos.ts";
import { commitToBranch, createRepo } from "../src/actions/repos.ts";
import { getAgentByName, setCrewRole } from "../src/core/agents.ts";
import { createApp as insertApp } from "../src/core/apps.ts";
import { getIssueById, listComments, type Issue } from "../src/core/issues.ts";
import { getRepoById, type Repo } from "../src/core/repos.ts";
import { type Repo } from "../src/core/repos.ts";
import {
  claimRun,
  createRun,
@@ -44,7 +40,7 @@
import { migrations } from "../src/core/schema.ts";
import { submitReview } from "../src/core/reviews.ts";
import { createToken } from "../src/core/tokens.ts";
import { createUser, getUserByName, type User } from "../src/core/users.ts";
import { serve, type Servers } from "../src/http/server.ts";
import { type Servers } from "../src/http/server.ts";
import { handedOverPulls } from "../src/crew/guard.ts";
import { driveRepo, parkedCount, settleAgentRun } from "../src/crew/autonomy.ts";
import { taskPrompt } from "../src/crew/brief.ts";
@@ -55,107 +51,15 @@
import {
  interruptionOf,
} from "../src/crew/interrupted.ts";
import { laterGate } from "../src/crew/later.ts";
import {
  alreadyDoneOids,
  alreadyDoneSummary,
  namedCommits,
  onBase,
} from "../src/crew/already.ts";
import { repoDir } from "../src/git/repos.ts";
import { alreadyDone } from "../src/core/done_on_main.ts";
import { askedIn, askedJson } from "../src/core/asked.ts";
import {
  handedOver,
  parkedTwice,
  parkReason,
  struckOut,
} from "../src/crew/parks.ts";
import { engine, tick, type Engine } from "./helpers/parks-engine.ts";
import { promote } from "./helpers/members.ts";
/**
 * One forge with alice's `engine` on its own: atlas plans, mason builds.
 * `ended` is a builder's run on an issue that ends without a pull, settled
 * as the crew would settle it.
 */
async function engine(
  prefix: string,
  visibility: "public" | "private" = "private",
) {
  const dataDir = await mkdtemp(join(tmpdir(), prefix));
  const app = createApp({ dataDir, port: 0 });
  const servers = await serve(app);
  const a = await createUser(app.db, {
    origin: "seed",
    trusted: true,
    username: "alice",
    email: "[email protected]",
    password: "a-good-passphrase",
    adminIfFirst: true,
  });
  if (!a.ok) throw new Error(a.error);
  const alice = a.value;
  const made = await createRepo(app, alice, { name: "engine", visibility });
  if (!made.ok) throw new Error(String(made.error));
  const repo = made.value;
  for (const name of ["atlas", "mason"]) {
    const agent = await createAgent(app, alice, { username: name });
    if (!agent.ok) throw new Error(String(agent.error));
    expect(addToCrew(app, alice, repo, name).ok).toBe(true);
  }
  const atlas = getUserByName(app.db, "atlas")!;
  const mason = getUserByName(app.db, "mason")!;
  setCrewRole(app.db, repo.id, atlas.id, "planner");
  const set = await updateRepoSettings(app, alice, repo, {
    autonomy: "autonomous",
    autonomyDirection: "Keep the engine small.",
    autonomyCeilingUsd: 100,
    autonomyBy: alice.id,
  });
  if (!set.ok) throw new Error(JSON.stringify(set.error));
  const fresh = () => getRepoById(app.db, repo.id)!;
  return {
    dataDir,
    app,
    servers,
    alice,
    atlas,
    mason,
    repo,
    fresh,
    issue(title: string): Issue {
      const opened = openIssue(app, alice, fresh(), { title });
      if (!opened.ok) throw new Error(String(opened.error));
      return opened.value;
    },
    ended(on: Issue, summary: string): boolean {
      const run = createRun(app.db, {
        repoId: repo.id,
        kind: "agent",
        issueId: on.id,
        actorId: mason.id,
        reason: "assigned",
      });
      claimRun(app.db, run.id);
      const recorded = interruptedSummary(summary);
      finishRun(app.db, run.id, { state: "failed", summary: recorded });
      return settleAgentRun(app, fresh(), {
        issueId: on.id,
        state: "failed",
        summary: recorded,
        reason: "assigned",
        actorId: mason.id,
      });
    },
    async close(): Promise<void> {
      servers.stop();
      app.close();
      await rm(dataDir, { recursive: true, force: true });
    },
  };
}
type Engine = Awaited<ReturnType<typeof engine>>;
const tick = () => Bun.sleep(5);
describe("which runs were interrupted", () => {
  test("the provider, the network and a restart; never the work itself", () => {
    expect(
@@ -1283,366 +1187,3 @@
describe("migration 43", () => {
    expect(after[4]).toBe(bodies[4]!);
  });
});
describe("an issue found already done is the asker's to close, not a park", () => {
  let e: Engine;
  let oid: string;
  const settle = (on: Issue, state: "ok" | "failed", summary: string) =>
    settleAgentRun(e.app, e.fresh(), {
      issueId: on.id,
      state,
      summary,
      reason: "assigned",
      actorId: e.mason.id,
    });
  beforeAll(async () => {
    e = await engine("forge-already-");
    const seeded = await commitToBranch(e.app, e.alice, e.repo, {
      message: "Start",
      files: [{ path: "README.md", content: "# engine\n" }],
    });
    if (!seeded.ok) throw new Error(JSON.stringify(seeded.error));
    oid = seeded.value.commitOid;
  });
  afterAll(() => e.close());
  test("only a named commit that is on the base counts", async () => {
    const dir = repoDir(e.app.reposRoot, e.repo.ownerName, e.repo.name);
    expect(namedCommits("already done on main in " + oid.slice(0, 9))).toEqual([
      oid.slice(0, 9),
    ]);
    expect(namedCommits("already done on main")).toEqual([]);
    expect(namedCommits("out of scope, see " + oid.slice(0, 9))).toEqual([]);
    expect(await onBase(dir, "main", [oid.slice(0, 9)])).toEqual([oid]);
    expect(await onBase(dir, "main", ["deadbeef"])).toEqual([]);
    expect(await onBase(dir, "nope", [oid.slice(0, 9)])).toEqual([]);
  });
  test("an already-done outcome is recorded, shown, and no strike", async () => {
    const work = e.issue("Already built");
    const summary = alreadyDoneSummary([oid]);
    expect(alreadyDoneOids(summary)).toEqual([oid]);
    for (let n = 0; n < 3; n++) {
      expect(settle(work, "ok", summary)).toBe(true);
      await tick();
    }
    const parks = listComments(e.app.db, work.id).filter((c) =>
      c.body.startsWith("Parked by the crew"),
    );
    expect(parks).toEqual([]);
    expect(parkedCount(e.app, e.fresh(), work.id)).toBe(0);
    expect(struckOut(e.app.db, e.fresh(), [work.id]).has(work.id)).toBe(false);
    expect(alreadyDone(e.app.db, [work.id]).get(work.id)).toEqual([oid]);
    expect(getIssueById(e.app.db, work.id)!.state).toBe("open");
    const signin = await fetch(`${e.servers.url}/signin`, {
      method: "POST",
      body: new URLSearchParams({
        username: "alice",
        password: "a-good-passphrase",
      }),
      redirect: "manual",
    });
    const cookie = (signin.headers.get("set-cookie") ?? "").split(";")[0]!;
    const page = await (
      await fetch(`${e.servers.url}/alice/engine/issues/${work.number}`, {
        headers: { cookie },
      })
    ).text();
    expect(page).toContain("waiting for you to close it");
    expect(page).toContain(`/commit/${oid}`);
    const closed = await fetch(
      `${e.servers.url}/alice/engine/issues/${work.number}/state`,
      {
        method: "POST",
        headers: { cookie, origin: e.servers.url },
        body: new URLSearchParams({ state: "closed", reason: "done" }),
        redirect: "manual",
      },
    );
    expect(closed.status).toBeLessThan(400);
    expect(getIssueById(e.app.db, work.id)!.state).toBe("closed");
    expect(
      listComments(e.app.db, work.id).some((c) =>
        c.body.startsWith(`Closed: already done on main in [\`${oid.slice(0, 7)}\``),
      ),
    ).toBe(true);
  });
  test("the asked JSON carries the commits; closing through any door writes the note", async () => {
    const work = e.issue("Asked and already built");
    expect(settle(work, "ok", alreadyDoneSummary([oid]))).toBe(true);
    const row = askedIn(e.app.db, [e.fresh()], { show: "all" }).find(
      (a) => a.issue.id === work.id,
    )!;
    expect(askedJson(row).doneBy).toEqual([oid]);
    // Not the web form: the same close the terminal makes.
    expect(setIssueState(e.app, e.alice, e.fresh(), work, "closed").ok).toBe(true);
    const comments = listComments(e.app.db, work.id).filter((c) =>
      c.body.startsWith("Closed: already done on main in "),
    );
    expect(comments).toHaveLength(1);
    expect(comments[0]!.body).toContain(oid.slice(0, 7));
    // An issue with no note closes without one.
    const plain = e.issue("Closed plainly");
    expect(setIssueState(e.app, e.alice, e.fresh(), plain, "closed").ok).toBe(true);
    expect(
      listComments(e.app.db, plain.id).some((c) => c.body.startsWith("Closed:")),
    ).toBe(false);
  });
  test("the asked page says done on main, with the commits", async () => {
    const work = e.issue("Asked page");
    expect(settle(work, "ok", alreadyDoneSummary([oid]))).toBe(true);
    const signin = await fetch(`${e.servers.url}/signin`, {
      method: "POST",
      body: new URLSearchParams({
        username: "alice",
        password: "a-good-passphrase",
      }),
      redirect: "manual",
    });
    const cookie = (signin.headers.get("set-cookie") ?? "").split(";")[0]!;
    const page = await (
      await fetch(`${e.servers.url}/asked`, { headers: { cookie } })
    ).text();
    expect(page).toContain("Done on main");
    expect(page).toContain(`on main in ${oid.slice(0, 7)}, waiting for you to close it`);
  });
  test("an issue parked twice and then found done leaves the planner's list", () => {
    const work = e.issue("Parked, then built");
    e.ended(work, "no changes pushed: DECLINED: out of scope");
    e.ended(work, "no changes pushed: DECLINED: out of scope");
    const listed = () =>
      parkedTwice(e.app.db, [e.fresh()]).some((p) => p.issueId === work.id);
    expect(listed()).toBe(true);
    expect(settle(work, "ok", alreadyDoneSummary([oid]))).toBe(true);
    expect(alreadyDone(e.app.db, [work.id]).get(work.id)).toEqual([oid]);
    expect(listed()).toBe(false);
  });
  test("writes in one millisecond are read in the order they were written", () => {
    // What a fast machine does by chance, every time: one timestamp for all.
    const at = new Date().toISOString();
    const stamp = (...on: Issue[]) => {
      for (const one of on) {
        e.app.db.query("UPDATE issue SET created_at = ?1 WHERE id = ?2").run(at, one.id);
        e.app.db.query("UPDATE comment SET created_at = ?1 WHERE issue_id = ?2").run(at, one.id);
      }
    };
    const now = (on: Issue): Issue => {
      const found = getIssueById(e.app.db, on.id);
      if (found === undefined) throw new Error(`no issue ${on.id}`);
      return found;
    };
    const declined = "no changes pushed: DECLINED: out of scope";
    const split = (on: Issue, into: Issue) => {
      const closed = setIssueState(e.app, e.atlas, e.fresh(), now(on), "closed", {
        reason: "split",
        into: [into.number],
      });
      return closed.ok ? "closed" : closed.error;
    };
    // Parked twice, then found done: the note is the newest word.
    const built = e.issue("Parked, then built");
    e.ended(built, declined);
    e.ended(built, declined);
    expect(settle(built, "ok", alreadyDoneSummary([oid]))).toBe(true);
    stamp(built);
    expect(parkedTwice(e.app.db, [e.fresh()]).some((p) => p.issueId === built.id)).toBe(false);
    expect(alreadyDone(e.app.db, [built.id]).get(built.id)).toEqual([oid]);
    // Found done, then parked: the park is.
    const undone = e.issue("Built, then parked");
    expect(settle(undone, "ok", alreadyDoneSummary([oid]))).toBe(true);
    e.ended(undone, declined);
    stamp(undone);
    expect(alreadyDone(e.app.db, [undone.id]).has(undone.id)).toBe(false);
    // A person's word, then two parks: both count.
    const told = e.issue("Told, then parked");
    expect(addComment(e.app, e.alice, e.fresh(), now(told), "Try it smaller.").ok).toBe(true);
    e.ended(told, declined);
    e.ended(told, declined);
    stamp(told);
    expect(parkedCount(e.app, e.fresh(), told.id)).toBe(2);
    // Handed over, then split into an issue opened after the hand-over.
    const half = e.issue("Told, then parked: the first half");
    stamp(told, half);
    expect(split(told, half)).toBe("closed");
    // Re-planned on its own pass: into the issue opened after it, not before.
    const older = e.issue("Opened first");
    const newer = e.issue("Opened second");
    stamp(older, newer);
    expect(split(newer, older)).toBe("forbidden");
    expect(split(older, newer)).toBe("closed");
  });
  test("the planner re-planning on its own pass: splits, drops what the crew wrote, closes what is done, and no more", async () => {
    const { atlas, mason } = e;
    const state = (on: Issue) => getIssueById(e.app.db, on.id)!;
    const close = (
      on: Issue,
      how?: { reason: "done" | "dropped" | "split"; into?: number[] },
    ) => {
      const closed = setIssueState(e.app, atlas, e.fresh(), state(on), "closed", how);
      return closed.ok ? "closed" : closed.error;
    };
    // Nobody handed any of these over: a person's ask, never parked.
    const asked = e.issue("Re-plan me");
    const stale = e.issue("Opened before the ask");
    const part = e.issue("Re-plan me, the first half");
    // Split, into an issue opened since.
    expect(close(asked, { reason: "split", into: [part.number] })).toBe("closed");
    expect(state(asked).closeReason).toBe("split");
    // Refused: into an issue older than the issue, or a closed one.
    const again = e.issue("Re-plan me too");
    expect(close(again, { reason: "split", into: [stale.number] })).toBe("forbidden");
    expect(close(again, { reason: "split", into: [asked.number] })).toBe("forbidden");
    // Refused: dropping a person's ask.
    expect(close(again, { reason: "dropped" })).toBe("forbidden");
    // Refused: done with no done note, said or not.
    expect(close(again)).toBe("forbidden");
    expect(close(again, { reason: "done" })).toBe("forbidden");
    expect(state(again).state).toBe("open");
    // Dropped: an issue the crew wrote.
    const made = openIssue(e.app, mason, e.fresh(), { title: "Crew's own chore" });
    if (!made.ok) throw new Error(String(made.error));
    expect(close(made.value, { reason: "dropped" })).toBe("closed");
    expect(state(made.value).closeReason).toBe("dropped");
    // Done: when commits on main are named for it.
    const built = e.issue("Already built, found by the planner");
    expect(
      settleAgentRun(e.app, e.fresh(), {
        issueId: built.id,
        state: "ok",
        summary: alreadyDoneSummary([oid]),
        reason: "assigned",
        actorId: mason.id,
      }),
    ).toBe(true);
    expect(close(built, { reason: "done" })).toBe("closed");
    expect(state(built).closeReason).toBe("done");
    // Never a reopen.
    const reopened = setIssueState(e.app, atlas, e.fresh(), state(made.value), "open");
    expect(reopened.ok ? "open" : reopened.error).toBe("forbidden");
    // A builder has none of it.
    const other = e.issue("Not for builders");
    const own = setIssueState(e.app, mason, e.fresh(), other, "closed", { reason: "split", into: [part.number] });
    expect(own.ok ? "closed" : own.error).toBe("forbidden");
  });
  test("the planner closes an umbrella as split into issues that all closed as done since, and no other", async () => {
    const { atlas } = e;
    const state = (on: Issue) => getIssueById(e.app.db, on.id)!;
    const close = (on: Issue, into: number[]) => {
      const closed = setIssueState(e.app, atlas, e.fresh(), state(on), "closed", {
        reason: "split",
        into,
      });
      return closed.ok ? "closed" : closed.error;
    };
    const finish = (on: Issue, reason: "done" | "dropped") => {
      const r = setIssueState(e.app, e.alice, e.fresh(), state(on), "closed", { reason });
      if (!r.ok) throw new Error(String(r.error));
    };
    // Old, unrelated work that closed as done before the umbrella existed.
    const old = e.issue("Old unrelated work");
    finish(old, "done");
    await Bun.sleep(5);
    const umbrella = e.issue("Umbrella");
    await Bun.sleep(5);
    const a = e.issue("Piece A");
    const b = e.issue("Piece B");
    const dropped = e.issue("Piece dropped");
    const open = e.issue("Piece still open, older than nothing");
    finish(a, "done");
    finish(dropped, "dropped");
    // Refused: an old done issue is no piece of it, alone or beside a real one.
    expect(close(umbrella, [old.number])).toBe("forbidden");
    finish(b, "done");
    expect(close(umbrella, [a.number, old.number])).toBe("forbidden");
    // Refused: itself, a dropped piece, an open one, a done beside a fresh open.
    expect(close(umbrella, [a.number, umbrella.number])).toBe("forbidden");
    expect(close(umbrella, [a.number, dropped.number])).toBe("forbidden");
    expect(close(umbrella, [a.number, open.number])).toBe("forbidden");
    await Bun.sleep(5);
    const fresh = e.issue("Fresh piece, open");
    expect(close(umbrella, [a.number, fresh.number])).toBe("forbidden");
    // Refused: a number that is no issue here (another repository's is none of this one's).
    expect(close(umbrella, [a.number, 99999])).toBe("forbidden");
    expect(state(umbrella).state).toBe("open");
    // Allowed: every piece closed as done since.
    expect(close(umbrella, [a.number, b.number])).toBe("closed");
    expect(state(umbrella).closeReason).toBe("split");
  });
  test("another person's comment that reads like the note is that person's word", async () => {
    const carol = await createUser(e.app.db, {
      origin: "seed",
      trusted: true,
      username: "carol",
      email: "[email protected]",
      password: "a-good-passphrase",
    });
    if (!carol.ok) throw new Error(carol.error);
    // Anyone who can read may direct the crew here, for this test only.
    e.app.db.run("UPDATE repo SET visibility = 'public', crew_outsiders = 1 WHERE id = ?1", [e.repo.id]);
    try {
      const work = e.issue("Words");
      e.ended(work, "no changes pushed: DECLINED: out of scope");
      expect(parkedCount(e.app, e.fresh(), work.id)).toBe(1);
      await tick();
      addComment(
        e.app,
        carol.value,
        e.fresh(),
        work,
        "Done on main already, waiting for you to close it: try again anyway",
      );
      expect(parkedCount(e.app, e.fresh(), work.id)).toBe(0);
      expect(alreadyDone(e.app.db, [work.id]).has(work.id)).toBe(false);
    } finally {
      e.app.db.run("UPDATE repo SET visibility = 'private', crew_outsiders = 0 WHERE id = ?1", [e.repo.id]);
    }
  });
  test("an ordinary decline, or a claim with no commit, still parks", () => {
    const work = e.issue("Out of scope");
    expect(settle(work, "ok", "no changes pushed: DECLINED: out of scope")).toBe(true);
    expect(parkedCount(e.app, e.fresh(), work.id)).toBe(1);
    expect(alreadyDone(e.app.db, [work.id]).has(work.id)).toBe(false);
    expect(alreadyDoneOids("no changes pushed: already done: " + oid)).toEqual([]);
  });
  test("an issue parked twice whose newest crew note is the done note is not handed to the planner", () => {
    const park = (on: Issue) => {
      for (let n = 0; n < 2; n++)
        addComment(e.app, e.mason, e.fresh(), on, "Parked by the crew: " + nothingNew);
    };
    const nothingNew = "the run ended without a pull: nothing to propose";
    const finished = e.issue("Parked, then found done");
    const open = e.issue("Parked, still open");
    park(finished);
    park(open);
    const numbers = () => parkedTwice(e.app.db, [e.fresh()]).map((i) => i.number);
    expect(numbers()).toEqual([finished.number, open.number]);
    addComment(
      e.app,
      e.mason,
      e.fresh(),
      finished,
      "Done on main already, waiting for you to close it: " + oid,
    );
    // Written in the same instant as the park: the clock cannot order them.
    e.app.db.run(
      `UPDATE comment SET created_at = (SELECT MAX(p.created_at) FROM comment p
         WHERE p.issue_id = ?1 AND p.body LIKE 'Parked by the crew%')
       WHERE issue_id = ?1 AND body LIKE 'Done on main already%'`,
      [finished.id],
    );
    expect(alreadyDone(e.app.db, [finished.id]).get(finished.id)).toEqual([oid]);
    expect(numbers()).toEqual([open.number]);
  });
});
@@ -0,0 +1,101 @@
import { expect } from "bun:test";
import { mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { createApp } from "../../src/app.ts";
import { addToCrew, createAgent } from "../../src/actions/crew.ts";
import { openIssue } from "../../src/actions/issues.ts";
import { createRepo, updateRepoSettings } from "../../src/actions/repos.ts";
import { setCrewRole } from "../../src/core/agents.ts";
import type { Issue } from "../../src/core/issues.ts";
import { getRepoById } from "../../src/core/repos.ts";
import { claimRun, createRun, finishRun } from "../../src/core/runs.ts";
import { createUser, getUserByName } from "../../src/core/users.ts";
import { serve } from "../../src/http/server.ts";
import { settleAgentRun } from "../../src/crew/autonomy.ts";
import { interruptedSummary } from "../../src/crew/interrupted.ts";
/**
 * One forge with alice's `engine` on its own: atlas plans, mason builds.
 * `ended` is a builder's run on an issue that ends without a pull, settled
 * as the crew would settle it. Shared by `test/crew-parks.test.ts` and
 * `test/crew-parks-done.test.ts`.
 */
export async function engine(
  prefix: string,
  visibility: "public" | "private" = "private",
) {
  const dataDir = await mkdtemp(join(tmpdir(), prefix));
  const app = createApp({ dataDir, port: 0 });
  const servers = await serve(app);
  const a = await createUser(app.db, {
    origin: "seed",
    trusted: true,
    username: "alice",
    email: "[email protected]",
    password: "a-good-passphrase",
    adminIfFirst: true,
  });
  if (!a.ok) throw new Error(a.error);
  const alice = a.value;
  const made = await createRepo(app, alice, { name: "engine", visibility });
  if (!made.ok) throw new Error(String(made.error));
  const repo = made.value;
  for (const name of ["atlas", "mason"]) {
    const agent = await createAgent(app, alice, { username: name });
    if (!agent.ok) throw new Error(String(agent.error));
    expect(addToCrew(app, alice, repo, name).ok).toBe(true);
  }
  const atlas = getUserByName(app.db, "atlas")!;
  const mason = getUserByName(app.db, "mason")!;
  setCrewRole(app.db, repo.id, atlas.id, "planner");
  const set = await updateRepoSettings(app, alice, repo, {
    autonomy: "autonomous",
    autonomyDirection: "Keep the engine small.",
    autonomyCeilingUsd: 100,
    autonomyBy: alice.id,
  });
  if (!set.ok) throw new Error(JSON.stringify(set.error));
  const fresh = () => getRepoById(app.db, repo.id)!;
  return {
    dataDir,
    app,
    servers,
    alice,
    atlas,
    mason,
    repo,
    fresh,
    issue(title: string): Issue {
      const opened = openIssue(app, alice, fresh(), { title });
      if (!opened.ok) throw new Error(String(opened.error));
      return opened.value;
    },
    ended(on: Issue, summary: string): boolean {
      const run = createRun(app.db, {
        repoId: repo.id,
        kind: "agent",
        issueId: on.id,
        actorId: mason.id,
        reason: "assigned",
      });
      claimRun(app.db, run.id);
      const recorded = interruptedSummary(summary);
      finishRun(app.db, run.id, { state: "failed", summary: recorded });
      return settleAgentRun(app, fresh(), {
        issueId: on.id,
        state: "failed",
        summary: recorded,
        reason: "assigned",
        actorId: mason.id,
      });
    },
    async close(): Promise<void> {
      servers.stop();
      app.close();
      await rm(dataDir, { recursive: true, force: true });
    },
  };
}
export type Engine = Awaited<ReturnType<typeof engine>>;
export const tick = () => Bun.sleep(5);
		@@ -0,0 +1,390 @@
	1	/**
	2	* An issue found already done is the asker's to close, not a park: a builder
	3	* that names a commit on the base records the outcome, shows it, strikes
	4	* nothing, and leaves the planner's list. Split from
	5	* `test/crew-parks.test.ts`, whose `engine` it shares.
	6	*/
	7	import { afterAll, beforeAll, describe, expect, test } from "bun:test";
	8	import {
	9	addComment,
	10	openIssue,
	11	setIssueState,
	12	} from "../src/actions/issues.ts";
	13	import { commitToBranch } from "../src/actions/repos.ts";
	14	import { getIssueById, listComments, type Issue } from "../src/core/issues.ts";
	15	import { createUser } from "../src/core/users.ts";
	16	import { parkedCount, settleAgentRun } from "../src/crew/autonomy.ts";
	17	import {
	18	alreadyDoneOids,
	19	alreadyDoneSummary,
	20	namedCommits,
	21	onBase,
	22	} from "../src/crew/already.ts";
	23	import { repoDir } from "../src/git/repos.ts";
	24	import { alreadyDone } from "../src/core/done_on_main.ts";
	25	import { askedIn, askedJson } from "../src/core/asked.ts";
	26	import { parkedTwice, struckOut } from "../src/crew/parks.ts";
	27	import { engine, tick, type Engine } from "./helpers/parks-engine.ts";
	28
	29	describe("an issue found already done is the asker's to close, not a park", () => {
	30	let e: Engine;
	31	let oid: string;
	32	const settle = (on: Issue, state: "ok" \| "failed", summary: string) =>
	33	settleAgentRun(e.app, e.fresh(), {
	34	issueId: on.id,
	35	state,
	36	summary,
	37	reason: "assigned",
	38	actorId: e.mason.id,
	39	});
	40
	41	beforeAll(async () => {
	42	e = await engine("forge-already-");
	43	const seeded = await commitToBranch(e.app, e.alice, e.repo, {
	44	message: "Start",
	45	files: [{ path: "README.md", content: "# engine\n" }],
	46	});
	47	if (!seeded.ok) throw new Error(JSON.stringify(seeded.error));
	48	oid = seeded.value.commitOid;
	49	});
	50	afterAll(() => e.close());
	51
	52	test("only a named commit that is on the base counts", async () => {
	53	const dir = repoDir(e.app.reposRoot, e.repo.ownerName, e.repo.name);
	54	expect(namedCommits("already done on main in " + oid.slice(0, 9))).toEqual([
	55	oid.slice(0, 9),
	56	]);
	57	expect(namedCommits("already done on main")).toEqual([]);
	58	expect(namedCommits("out of scope, see " + oid.slice(0, 9))).toEqual([]);
	59	expect(await onBase(dir, "main", [oid.slice(0, 9)])).toEqual([oid]);
	60	expect(await onBase(dir, "main", ["deadbeef"])).toEqual([]);
	61	expect(await onBase(dir, "nope", [oid.slice(0, 9)])).toEqual([]);
	62	});
	63
	64	test("an already-done outcome is recorded, shown, and no strike", async () => {
	65	const work = e.issue("Already built");
	66	const summary = alreadyDoneSummary([oid]);
	67	expect(alreadyDoneOids(summary)).toEqual([oid]);
	68	for (let n = 0; n < 3; n++) {
	69	expect(settle(work, "ok", summary)).toBe(true);
	70	await tick();
	71	}
	72	const parks = listComments(e.app.db, work.id).filter((c) =>
	73	c.body.startsWith("Parked by the crew"),
	74	);
	75	expect(parks).toEqual([]);
	76	expect(parkedCount(e.app, e.fresh(), work.id)).toBe(0);
	77	expect(struckOut(e.app.db, e.fresh(), [work.id]).has(work.id)).toBe(false);
	78	expect(alreadyDone(e.app.db, [work.id]).get(work.id)).toEqual([oid]);
	79	expect(getIssueById(e.app.db, work.id)!.state).toBe("open");
	80
	81	const signin = await fetch(`${e.servers.url}/signin`, {
	82	method: "POST",
	83	body: new URLSearchParams({
	84	username: "alice",
	85	password: "a-good-passphrase",
	86	}),
	87	redirect: "manual",
	88	});
	89	const cookie = (signin.headers.get("set-cookie") ?? "").split(";")[0]!;
	90	const page = await (
	91	await fetch(`${e.servers.url}/alice/engine/issues/${work.number}`, {
	92	headers: { cookie },
	93	})
	94	).text();
	95	expect(page).toContain("waiting for you to close it");
	96	expect(page).toContain(`/commit/${oid}`);
	97
	98	const closed = await fetch(
	99	`${e.servers.url}/alice/engine/issues/${work.number}/state`,
	100	{
	101	method: "POST",
	102	headers: { cookie, origin: e.servers.url },
	103	body: new URLSearchParams({ state: "closed", reason: "done" }),
	104	redirect: "manual",
	105	},
	106	);
	107	expect(closed.status).toBeLessThan(400);
	108	expect(getIssueById(e.app.db, work.id)!.state).toBe("closed");
	109	expect(
	110	listComments(e.app.db, work.id).some((c) =>
	111	c.body.startsWith(`Closed: already done on main in [\`${oid.slice(0, 7)}\``),
	112	),
	113	).toBe(true);
	114	});
	115
	116	test("the asked JSON carries the commits; closing through any door writes the note", async () => {
	117	const work = e.issue("Asked and already built");
	118	expect(settle(work, "ok", alreadyDoneSummary([oid]))).toBe(true);
	119	const row = askedIn(e.app.db, [e.fresh()], { show: "all" }).find(
	120	(a) => a.issue.id === work.id,
	121	)!;
	122	expect(askedJson(row).doneBy).toEqual([oid]);
	123	// Not the web form: the same close the terminal makes.
	124	expect(setIssueState(e.app, e.alice, e.fresh(), work, "closed").ok).toBe(true);
	125	const comments = listComments(e.app.db, work.id).filter((c) =>
	126	c.body.startsWith("Closed: already done on main in "),
	127	);
	128	expect(comments).toHaveLength(1);
	129	expect(comments[0]!.body).toContain(oid.slice(0, 7));
	130	// An issue with no note closes without one.
	131	const plain = e.issue("Closed plainly");
	132	expect(setIssueState(e.app, e.alice, e.fresh(), plain, "closed").ok).toBe(true);
	133	expect(
	134	listComments(e.app.db, plain.id).some((c) => c.body.startsWith("Closed:")),
	135	).toBe(false);
	136	});
	137
	138	test("the asked page says done on main, with the commits", async () => {
	139	const work = e.issue("Asked page");
	140	expect(settle(work, "ok", alreadyDoneSummary([oid]))).toBe(true);
	141	const signin = await fetch(`${e.servers.url}/signin`, {
	142	method: "POST",
	143	body: new URLSearchParams({
	144	username: "alice",
	145	password: "a-good-passphrase",
	146	}),
	147	redirect: "manual",
	148	});
	149	const cookie = (signin.headers.get("set-cookie") ?? "").split(";")[0]!;
	150	const page = await (
	151	await fetch(`${e.servers.url}/asked`, { headers: { cookie } })
	152	).text();
	153	expect(page).toContain("Done on main");
	154	expect(page).toContain(`on main in ${oid.slice(0, 7)}, waiting for you to close it`);
	155	});
	156
	157	test("an issue parked twice and then found done leaves the planner's list", () => {
	158	const work = e.issue("Parked, then built");
	159	e.ended(work, "no changes pushed: DECLINED: out of scope");
	160	e.ended(work, "no changes pushed: DECLINED: out of scope");
	161	const listed = () =>
	162	parkedTwice(e.app.db, [e.fresh()]).some((p) => p.issueId === work.id);
	163	expect(listed()).toBe(true);
	164	expect(settle(work, "ok", alreadyDoneSummary([oid]))).toBe(true);
	165	expect(alreadyDone(e.app.db, [work.id]).get(work.id)).toEqual([oid]);
	166	expect(listed()).toBe(false);
	167	});
	168
	169	test("writes in one millisecond are read in the order they were written", () => {
	170	// What a fast machine does by chance, every time: one timestamp for all.
	171	const at = new Date().toISOString();
	172	const stamp = (...on: Issue[]) => {
	173	for (const one of on) {
	174	e.app.db.query("UPDATE issue SET created_at = ?1 WHERE id = ?2").run(at, one.id);
	175	e.app.db.query("UPDATE comment SET created_at = ?1 WHERE issue_id = ?2").run(at, one.id);
	176	}
	177	};
	178	const now = (on: Issue): Issue => {
	179	const found = getIssueById(e.app.db, on.id);
	180	if (found === undefined) throw new Error(`no issue ${on.id}`);
	181	return found;
	182	};
	183	const declined = "no changes pushed: DECLINED: out of scope";
	184	const split = (on: Issue, into: Issue) => {
	185	const closed = setIssueState(e.app, e.atlas, e.fresh(), now(on), "closed", {
	186	reason: "split",
	187	into: [into.number],
	188	});
	189	return closed.ok ? "closed" : closed.error;
	190	};
	191	// Parked twice, then found done: the note is the newest word.
	192	const built = e.issue("Parked, then built");
	193	e.ended(built, declined);
	194	e.ended(built, declined);
	195	expect(settle(built, "ok", alreadyDoneSummary([oid]))).toBe(true);
	196	stamp(built);
	197	expect(parkedTwice(e.app.db, [e.fresh()]).some((p) => p.issueId === built.id)).toBe(false);
	198	expect(alreadyDone(e.app.db, [built.id]).get(built.id)).toEqual([oid]);
	199	// Found done, then parked: the park is.
	200	const undone = e.issue("Built, then parked");
	201	expect(settle(undone, "ok", alreadyDoneSummary([oid]))).toBe(true);
	202	e.ended(undone, declined);
	203	stamp(undone);
	204	expect(alreadyDone(e.app.db, [undone.id]).has(undone.id)).toBe(false);
	205	// A person's word, then two parks: both count.
	206	const told = e.issue("Told, then parked");
	207	expect(addComment(e.app, e.alice, e.fresh(), now(told), "Try it smaller.").ok).toBe(true);
	208	e.ended(told, declined);
	209	e.ended(told, declined);
	210	stamp(told);
	211	expect(parkedCount(e.app, e.fresh(), told.id)).toBe(2);
	212	// Handed over, then split into an issue opened after the hand-over.
	213	const half = e.issue("Told, then parked: the first half");
	214	stamp(told, half);
	215	expect(split(told, half)).toBe("closed");
	216	// Re-planned on its own pass: into the issue opened after it, not before.
	217	const older = e.issue("Opened first");
	218	const newer = e.issue("Opened second");
	219	stamp(older, newer);
	220	expect(split(newer, older)).toBe("forbidden");
	221	expect(split(older, newer)).toBe("closed");
	222	});
	223
	224	test("the planner re-planning on its own pass: splits, drops what the crew wrote, closes what is done, and no more", async () => {
	225	const { atlas, mason } = e;
	226	const state = (on: Issue) => getIssueById(e.app.db, on.id)!;
	227	const close = (
	228	on: Issue,
	229	how?: { reason: "done" \| "dropped" \| "split"; into?: number[] },
	230	) => {
	231	const closed = setIssueState(e.app, atlas, e.fresh(), state(on), "closed", how);
	232	return closed.ok ? "closed" : closed.error;
	233	};
	234	// Nobody handed any of these over: a person's ask, never parked.
	235	const asked = e.issue("Re-plan me");
	236	const stale = e.issue("Opened before the ask");
	237	const part = e.issue("Re-plan me, the first half");
	238	// Split, into an issue opened since.
	239	expect(close(asked, { reason: "split", into: [part.number] })).toBe("closed");
	240	expect(state(asked).closeReason).toBe("split");
	241	// Refused: into an issue older than the issue, or a closed one.
	242	const again = e.issue("Re-plan me too");
	243	expect(close(again, { reason: "split", into: [stale.number] })).toBe("forbidden");
	244	expect(close(again, { reason: "split", into: [asked.number] })).toBe("forbidden");
	245	// Refused: dropping a person's ask.
	246	expect(close(again, { reason: "dropped" })).toBe("forbidden");
	247	// Refused: done with no done note, said or not.
	248	expect(close(again)).toBe("forbidden");
	249	expect(close(again, { reason: "done" })).toBe("forbidden");
	250	expect(state(again).state).toBe("open");
	251	// Dropped: an issue the crew wrote.
	252	const made = openIssue(e.app, mason, e.fresh(), { title: "Crew's own chore" });
	253	if (!made.ok) throw new Error(String(made.error));
	254	expect(close(made.value, { reason: "dropped" })).toBe("closed");
	255	expect(state(made.value).closeReason).toBe("dropped");
	256	// Done: when commits on main are named for it.
	257	const built = e.issue("Already built, found by the planner");
	258	expect(
	259	settleAgentRun(e.app, e.fresh(), {
	260	issueId: built.id,
	261	state: "ok",
	262	summary: alreadyDoneSummary([oid]),
	263	reason: "assigned",
	264	actorId: mason.id,
	265	}),
	266	).toBe(true);
	267	expect(close(built, { reason: "done" })).toBe("closed");
	268	expect(state(built).closeReason).toBe("done");
	269	// Never a reopen.
	270	const reopened = setIssueState(e.app, atlas, e.fresh(), state(made.value), "open");
	271	expect(reopened.ok ? "open" : reopened.error).toBe("forbidden");
	272	// A builder has none of it.
	273	const other = e.issue("Not for builders");
	274	const own = setIssueState(e.app, mason, e.fresh(), other, "closed", { reason: "split", into: [part.number] });
	275	expect(own.ok ? "closed" : own.error).toBe("forbidden");
	276	});
	277
	278	test("the planner closes an umbrella as split into issues that all closed as done since, and no other", async () => {
	279	const { atlas } = e;
	280	const state = (on: Issue) => getIssueById(e.app.db, on.id)!;
	281	const close = (on: Issue, into: number[]) => {
	282	const closed = setIssueState(e.app, atlas, e.fresh(), state(on), "closed", {
	283	reason: "split",
	284	into,
	285	});
	286	return closed.ok ? "closed" : closed.error;
	287	};
	288	const finish = (on: Issue, reason: "done" \| "dropped") => {
	289	const r = setIssueState(e.app, e.alice, e.fresh(), state(on), "closed", { reason });
	290	if (!r.ok) throw new Error(String(r.error));
	291	};
	292	// Old, unrelated work that closed as done before the umbrella existed.
	293	const old = e.issue("Old unrelated work");
	294	finish(old, "done");
	295	await Bun.sleep(5);
	296	const umbrella = e.issue("Umbrella");
	297	await Bun.sleep(5);
	298	const a = e.issue("Piece A");
	299	const b = e.issue("Piece B");
	300	const dropped = e.issue("Piece dropped");
	301	const open = e.issue("Piece still open, older than nothing");
	302	finish(a, "done");
	303	finish(dropped, "dropped");
	304	// Refused: an old done issue is no piece of it, alone or beside a real one.
	305	expect(close(umbrella, [old.number])).toBe("forbidden");
	306	finish(b, "done");
	307	expect(close(umbrella, [a.number, old.number])).toBe("forbidden");
	308	// Refused: itself, a dropped piece, an open one, a done beside a fresh open.
	309	expect(close(umbrella, [a.number, umbrella.number])).toBe("forbidden");
	310	expect(close(umbrella, [a.number, dropped.number])).toBe("forbidden");
	311	expect(close(umbrella, [a.number, open.number])).toBe("forbidden");
	312	await Bun.sleep(5);
	313	const fresh = e.issue("Fresh piece, open");
	314	expect(close(umbrella, [a.number, fresh.number])).toBe("forbidden");
	315	// Refused: a number that is no issue here (another repository's is none of this one's).
	316	expect(close(umbrella, [a.number, 99999])).toBe("forbidden");
	317	expect(state(umbrella).state).toBe("open");
	318	// Allowed: every piece closed as done since.
	319	expect(close(umbrella, [a.number, b.number])).toBe("closed");
	320	expect(state(umbrella).closeReason).toBe("split");
	321	});
	322
	323	test("another person's comment that reads like the note is that person's word", async () => {
	324	const carol = await createUser(e.app.db, {
	325	origin: "seed",
	326	trusted: true,
	327	username: "carol",
	328	email: "[email protected]",
	329	password: "a-good-passphrase",
	330	});
	331	if (!carol.ok) throw new Error(carol.error);
	332	// Anyone who can read may direct the crew here, for this test only.
	333	e.app.db.run("UPDATE repo SET visibility = 'public', crew_outsiders = 1 WHERE id = ?1", [e.repo.id]);
	334	try {
	335	const work = e.issue("Words");
	336	e.ended(work, "no changes pushed: DECLINED: out of scope");
	337	expect(parkedCount(e.app, e.fresh(), work.id)).toBe(1);
	338	await tick();
	339	addComment(
	340	e.app,
	341	carol.value,
	342	e.fresh(),
	343	work,
	344	"Done on main already, waiting for you to close it: try again anyway",
	345	);
	346	expect(parkedCount(e.app, e.fresh(), work.id)).toBe(0);
	347	expect(alreadyDone(e.app.db, [work.id]).has(work.id)).toBe(false);
	348	} finally {
	349	e.app.db.run("UPDATE repo SET visibility = 'private', crew_outsiders = 0 WHERE id = ?1", [e.repo.id]);
	350	}
	351	});
	352
	353	test("an ordinary decline, or a claim with no commit, still parks", () => {
	354	const work = e.issue("Out of scope");
	355	expect(settle(work, "ok", "no changes pushed: DECLINED: out of scope")).toBe(true);
	356	expect(parkedCount(e.app, e.fresh(), work.id)).toBe(1);
	357	expect(alreadyDone(e.app.db, [work.id]).has(work.id)).toBe(false);
	358	expect(alreadyDoneOids("no changes pushed: already done: " + oid)).toEqual([]);
	359	});
	360
	361	test("an issue parked twice whose newest crew note is the done note is not handed to the planner", () => {
	362	const park = (on: Issue) => {
	363	for (let n = 0; n < 2; n++)
	364	addComment(e.app, e.mason, e.fresh(), on, "Parked by the crew: " + nothingNew);
	365	};
	366	const nothingNew = "the run ended without a pull: nothing to propose";
	367	const finished = e.issue("Parked, then found done");
	368	const open = e.issue("Parked, still open");
	369	park(finished);
	370	park(open);
	371	const numbers = () => parkedTwice(e.app.db, [e.fresh()]).map((i) => i.number);
	372	expect(numbers()).toEqual([finished.number, open.number]);
	373	addComment(
	374	e.app,
	375	e.mason,
	376	e.fresh(),
	377	finished,
	378	"Done on main already, waiting for you to close it: " + oid,
	379	);
	380	// Written in the same instant as the park: the clock cannot order them.
	381	e.app.db.run(
	382	`UPDATE comment SET created_at = (SELECT MAX(p.created_at) FROM comment p
	383	WHERE p.issue_id = ?1 AND p.body LIKE 'Parked by the crew%')
	384	WHERE issue_id = ?1 AND body LIKE 'Done on main already%'`,
	385	[finished.id],
	386	);
	387	expect(alreadyDone(e.app.db, [finished.id]).get(finished.id)).toEqual([oid]);
	388	expect(numbers()).toEqual([open.number]);
	389	});
	390	});
		@@ -0,0 +1,101 @@
	1	import { expect } from "bun:test";
	2	import { mkdtemp, rm } from "node:fs/promises";
	3	import { tmpdir } from "node:os";
	4	import { join } from "node:path";
	5	import { createApp } from "../../src/app.ts";
	6	import { addToCrew, createAgent } from "../../src/actions/crew.ts";
	7	import { openIssue } from "../../src/actions/issues.ts";
	8	import { createRepo, updateRepoSettings } from "../../src/actions/repos.ts";
	9	import { setCrewRole } from "../../src/core/agents.ts";
	10	import type { Issue } from "../../src/core/issues.ts";
	11	import { getRepoById } from "../../src/core/repos.ts";
	12	import { claimRun, createRun, finishRun } from "../../src/core/runs.ts";
	13	import { createUser, getUserByName } from "../../src/core/users.ts";
	14	import { serve } from "../../src/http/server.ts";
	15	import { settleAgentRun } from "../../src/crew/autonomy.ts";
	16	import { interruptedSummary } from "../../src/crew/interrupted.ts";
	17
	18	/**
	19	* One forge with alice's `engine` on its own: atlas plans, mason builds.
	20	* `ended` is a builder's run on an issue that ends without a pull, settled
	21	* as the crew would settle it. Shared by `test/crew-parks.test.ts` and
	22	* `test/crew-parks-done.test.ts`.
	23	*/
	24	export async function engine(
	25	prefix: string,
	26	visibility: "public" \| "private" = "private",
	27	) {
	28	const dataDir = await mkdtemp(join(tmpdir(), prefix));
	29	const app = createApp({ dataDir, port: 0 });
	30	const servers = await serve(app);
	31	const a = await createUser(app.db, {
	32	origin: "seed",
	33	trusted: true,
	34	username: "alice",
	35	email: "[email protected]",
	36	password: "a-good-passphrase",
	37	adminIfFirst: true,
	38	});
	39	if (!a.ok) throw new Error(a.error);
	40	const alice = a.value;
	41	const made = await createRepo(app, alice, { name: "engine", visibility });
	42	if (!made.ok) throw new Error(String(made.error));
	43	const repo = made.value;
	44	for (const name of ["atlas", "mason"]) {
	45	const agent = await createAgent(app, alice, { username: name });
	46	if (!agent.ok) throw new Error(String(agent.error));
	47	expect(addToCrew(app, alice, repo, name).ok).toBe(true);
	48	}
	49	const atlas = getUserByName(app.db, "atlas")!;
	50	const mason = getUserByName(app.db, "mason")!;
	51	setCrewRole(app.db, repo.id, atlas.id, "planner");
	52	const set = await updateRepoSettings(app, alice, repo, {
	53	autonomy: "autonomous",
	54	autonomyDirection: "Keep the engine small.",
	55	autonomyCeilingUsd: 100,
	56	autonomyBy: alice.id,
	57	});
	58	if (!set.ok) throw new Error(JSON.stringify(set.error));
	59	const fresh = () => getRepoById(app.db, repo.id)!;
	60	return {
	61	dataDir,
	62	app,
	63	servers,
	64	alice,
	65	atlas,
	66	mason,
	67	repo,
	68	fresh,
	69	issue(title: string): Issue {
	70	const opened = openIssue(app, alice, fresh(), { title });
	71	if (!opened.ok) throw new Error(String(opened.error));
	72	return opened.value;
	73	},
	74	ended(on: Issue, summary: string): boolean {
	75	const run = createRun(app.db, {
	76	repoId: repo.id,
	77	kind: "agent",
	78	issueId: on.id,
	79	actorId: mason.id,
	80	reason: "assigned",
	81	});
	82	claimRun(app.db, run.id);
	83	const recorded = interruptedSummary(summary);
	84	finishRun(app.db, run.id, { state: "failed", summary: recorded });
	85	return settleAgentRun(app, fresh(), {
	86	issueId: on.id,
	87	state: "failed",
	88	summary: recorded,
	89	reason: "assigned",
	90	actorId: mason.id,
	91	});
	92	},
	93	async close(): Promise<void> {
	94	servers.stop();
	95	app.close();
	96	await rm(dataDir, { recursive: true, force: true });
	97	},
	98	};
	99	}
	100	export type Engine = Awaited<ReturnType<typeof engine>>;
	101	export const tick = () => Bun.sleep(5);