965e1d6 · 170d9df · ce30540 · 1eab5cd · ebd32c1 · 60d4ea0
@@ -471,6 +471,15 @@
or `x` on the issue in the terminal); the close writes "Closed: already done
on main in …" on the thread. A claim with no commit, or with one that is not
on the base, is an ordinary decline and is parked as one.
**A red pull.** The decider stops a red check only when it is at least 70%
sure; below that the pull gets another feedback run. A stop parks the pull: it
closes as *parked*, not done, with a comment that says why. The pull page's
badge reads "Parked" instead of "Closed", the terminal's merge box says "Parked
by the crew, not merged", and the lists note it as stopped. Reopening it clears
the mark. Only the crew parks: the API and the page refuse `reason: "parked"`.
In the database the pull's `close_reason` stays NULL (its CHECK predates the
word) and `issue.parked = 1` carries it, so raw SQL never reads it as done.
An autonomous app's planner is **held** while nothing is landing or the plate
is full: no pull has merged in 48 h while one was closed unmerged, or more than
`slots × 3` ready, unassigned issues are waiting. The tick log says which
@@ -121,6 +121,7 @@
export const GATE: readonly string[] = [
  "test/checks.test.ts",
  "test/dependencies.test.ts",
  "test/map-closing.test.ts",
  "test/parked-close.test.ts",
  "test/autonomy.test.ts",
  "test/studio.test.ts",
  "test/studio-words.test.ts",
@@ -411,7 +411,11 @@
export function setIssueState(
  const children: Issue[] = [];
  if (closing.reason !== undefined || closing.into !== undefined) {
    // A reason is how an issue closes; a pull or a reopen has none.
    if (state !== "closed" || issue.kind !== "issue")
    if (
      state !== "closed" ||
      issue.kind !== (reason === "parked" ? "pull" : "issue") ||
      (reason === "parked" && closing.into !== undefined)
    )
      return err("invalid_reason");
    if (reason === "split") {
      for (const number of closing.into ?? []) {
@@ -451,7 +455,9 @@
export function setIssueState(
    actorId: user.value.id,
    payload: {
      number: issue.number,
      ...(issue.kind === "issue" && reason !== undefined ? { reason } : {}),
      ...(reason !== undefined && (issue.kind === "issue" || reason === "parked")
        ? { reason }
        : {}),
      ...(children.length > 0 ? { into: children.map((c) => c.number) } : {}),
    },
  });
@@ -188,7 +188,7 @@
export function dependenciesOf(
export interface Held {
  readonly issueId: string;
  readonly blockedById: string;
  readonly reason: Exclude<CloseReason, "done">;
  readonly reason: Exclude<CloseReason, "done" | "parked">;
}
export interface Graph {
@@ -12,8 +12,12 @@
import { repoVisible } from "./visibility.ts";
export type IssueKind = "issue" | "pull";
export type IssueState = "open" | "closed";
/** Why an issue closed: done frees what waited on it; the others hold it. */
export type CloseReason = "done" | "dropped" | "split";
/**
 * Why an issue closed: done frees what waited on it; the others hold it.
 * `parked` is the crew's own, on a pull it stopped for a person; it is never
 * one a request may name, so it is not in `CLOSE_REASONS`.
 */
export type CloseReason = "done" | "dropped" | "split" | "parked";
export const CLOSE_REASONS: readonly CloseReason[] = [
  "done",
  "dropped",
@@ -78,6 +82,7 @@
interface IssueRow {
  updated_at: string;
  closed_at: string | null;
  close_reason: CloseReason | null;
  parked: number;
  origin_author: string | null;
  origin_html_url: string | null;
  assignee_id: string | null;
@@ -107,7 +112,7 @@
function toIssue(row: IssueRow): Issue {
    createdAt: row.created_at,
    updatedAt: row.updated_at,
    closedAt: row.closed_at,
    closeReason: row.close_reason,
    closeReason: row.parked === 1 ? "parked" : row.close_reason,
    originAuthor: row.origin_author,
    originUrl: row.origin_html_url,
    assigneeId: row.assignee_id,
@@ -469,12 +474,15 @@
export function setIssueState(
): Issue | undefined {
  const now = new Date().toISOString();
  const closedAt = state === "closed" ? now : null;
  const why = state === "closed" ? reason : null;
  const why = state === "closed" && reason !== "parked" ? reason : null;
  const parked = state === "closed" && reason === "parked" ? 1 : 0;
  const changed = db
    .query(
      "UPDATE issue SET state = ?1, closed_at = ?2, updated_at = ?3, close_reason = ?5 WHERE id = ?4 AND state != ?1",
      `UPDATE issue SET state = ?1, closed_at = ?2, updated_at = ?3,
         close_reason = ?5, parked = ?6
       WHERE id = ?4 AND state != ?1`,
    )
    .run(state, closedAt, now, issueId, why).changes;
    .run(state, closedAt, now, issueId, why, parked).changes;
  return changed > 0 ? getIssueById(db, issueId) : undefined;
}
@@ -1787,6 +1787,13 @@
export const migrations: readonly string[] = [
    PRIMARY KEY (step, at, target)
  ) WITHOUT ROWID;
  `,
  // 89 — a pull the crew parked (#1624) closes as parked, not done. The
  // column carries it, and `close_reason` stays NULL: its CHECK cannot be
  // widened in place, and NULL is never read as done by raw SQL.
  // `closeReason` reads 'parked' from it.
  `
  ALTER TABLE issue ADD COLUMN parked INTEGER NOT NULL DEFAULT 0;
  `,
];
/**
@@ -957,7 +957,9 @@
export function parkPull(
  const issue = getIssueById(app.db, pull.id);
  if (!issue || issue.state !== "open") return false;
  addComment(app, by, repo, issue, `${PARK_NOTE}${why}`);
  const closed = setIssueState(app, by, repo, issue, "closed");
  const closed = setIssueState(app, by, repo, issue, "closed", {
    reason: "parked",
  });
  if (!closed.ok) return false;
  for (const number of closesFromBody(pull.body)) {
    const about = getIssue(app.db, repo.id, number);
@@ -858,7 +858,12 @@
export async function judgeFailedCheck(
      cause: certain(CAUSE_OPTIONS, "change"),
    }),
  );
  const retry = decided.answers.retry.choice === "stop" ? "stop" : "again";
  // A stop is a pull closed on a person's behalf: it takes the same
  // confidence as a cause. Below it the builder gets its one more try.
  const retry =
    decided.answers.retry.choice === "stop" && decided.answers.retry.p >= 0.7
      ? "stop"
      : "again";
  // The change is what a half-sure answer means: an environment called
  // that way on a hunch is how a broken change escapes a rework.
  const cause =
@@ -3018,6 +3018,9 @@
export function apiRoutes(router: Router<Handler>): void {
      const wanted = input.state === undefined ? undefined : str(input.state);
      if (wanted !== undefined && wanted !== "open" && wanted !== "closed")
        return json({ error: "invalid_state" }, 422);
      // A pull has no reason to give: "parked" is the crew's word alone.
      if (input.reason !== undefined || input.into !== undefined)
        return json({ error: "invalid_reason" }, 422);
      if (
        wanted === undefined &&
        text.title === undefined &&
@@ -1241,7 +1241,9 @@
function drawMergeBox(
    state === "merged"
      ? `Merged ${relTime(pull?.mergedAt ?? "")} into ${pull?.baseBranch ?? ""}`
      : state === "closed"
        ? "Closed without merging"
        ? issue.parked === true
          ? "Parked by the crew, not merged"
      
        sentinelcrew
        29d ago
        
      
      The terminal door has no test. Render the merge box for a parked pull and assert this text. Also, issue is not optional in drawMergeBox, so issue?.parked can be issue.parked.
    
          : "Closed without merging"
        : state === "mirrored"
          ? `Merge on the origin${issue.originUrl === null ? "" : ` — ${issue.originUrl}`}`
          : state === "conflicts"
@@ -96,6 +96,7 @@
export function localSource(
    createdAt: string;
    updatedAt: string;
    closedAt: string | null;
    closeReason?: string | null;
    id: string;
  }
@@ -119,6 +120,7 @@
export function localSource(
    createdAt: issue.createdAt,
    updatedAt: issue.updatedAt,
    closedAt: issue.closedAt,
    ...(issue.closeReason === "parked" ? { parked: true } : {}),
    labels,
    commentCount,
  });
@@ -137,6 +137,8 @@
export interface IssueSummary {
  readonly createdAt: string;
  readonly updatedAt: string;
  readonly closedAt: string | null;
  /** A pull the crew stopped for a person: closed, but not as done. */
  readonly parked?: boolean;
  readonly labels: readonly Label[];
  readonly commentCount: number;
}
@@ -903,7 +903,9 @@
export function dependenciesCard(
            ${icon(i.state === "closed" ? "issueClosed" : "issue")}
            <a href="${tellHref(base, i.number)}">${i.title}</a>
            <span class="muted small">#${i.number}</span>
            ${i.closeReason === "dropped" || i.closeReason === "split"
            ${i.closeReason === "dropped" ||
            i.closeReason === "split" ||
            i.closeReason === "parked"
              ? html`<span class="muted small">${i.closeReason}</span>`
              : null}
            ${removable &&
@@ -9,6 +9,7 @@
 * bigger.
 */
import { getIssueById } from "../../core/issues.ts";
import { mayEditIssue } from "../../actions/issues.ts";
import { marksByName, type Mark } from "../../core/marks.ts";
import { mayView } from "../../core/sealed.ts";
@@ -185,7 +186,10 @@
export function changeHead(ctx: Ctx, repo: Repo, pull: Pull): Html {
  return html`<div class="issue-head">
    <h1>${pull.title} <span class="number">#${pull.number}</span></h1>
    <div class="issue-meta">
      ${stateBadge(pullState(pull))}
      ${stateBadge(
        pullState(pull),
        getIssueById(ctx.app.db, pull.id)?.closeReason === "parked",
      
        sentinelcrew
        29d ago
        
      
      No test fails if this line goes. Cover it with the page fetch suggested in the test file.
    
      )}
      <span
        >${pull.originAuthor
          ? originTag(pull.originAuthor, originGlyph(repo))
@@ -210,7 +210,13 @@
export async function pullWord(
    return mergedPullWord(production, commitOid);
  }
  if (pull.state === "closed")
    return { word: "stopped", note: "closed without shipping" };
    return {
      word: "stopped",
      note:
        getIssueById(ctx.db, pull.id)?.closeReason === "parked"
          ? "parked by the crew"
          : "closed without shipping",
    };
  const check = checkSummary(ctx.db, pull.id, pull.headOid);
  // A repository that is not an app never deploys a head, so it never gets
  // a look: an open change there waits on a person, and says so.
@@ -239,14 +239,17 @@
export function badge(
/** The one badge whose value is a state machine, so it renders identically
 * on issues, pulls and lists. */
export function stateBadge(state: "open" | "closed" | "merged"): Html {
export function stateBadge(
  state: "open" | "closed" | "merged",
  parked = false,
): Html {
  if (state === "merged")
    return html`<span class="badge" data-pr="merged"
      >${icon("merge")}Merged</span
    >`;
  if (state === "closed")
    return html`<span class="badge" data-state="closed"
      >${icon("issueClosed")}Closed</span
      >${icon("issueClosed")}${parked ? "Parked" : "Closed"}</span
    >`;
  return html`<span class="badge" data-state="open"
    >${icon("issue")}Open</span
@@ -37,7 +37,10 @@
import { startChecks } from "../src/checks/service.ts";
import { serve, type Servers } from "../src/http/server.ts";
/** A decider that answers from a script: question name → choice. */
function scripted(answers: Record<string, string>): Decider & {
function scripted(
  answers: Record<string, string>,
  sureness: Record<string, number> = {},
): Decider & {
  seen: unknown[];
} {
  const seen: unknown[] = [];
@@ -51,7 +54,7 @@
function scripted(answers: Record<string, string>): Decider & {
        const choice = answers[key] ?? q.options[0]!;
        const probabilities: Record<string, number> = {};
        for (const o of q.options) probabilities[o] = o === choice ? 0.8 : 0.2;
        out[key] = { choice, p: 0.8, probabilities };
        out[key] = { choice, p: sureness[key] ?? 0.8, probabilities };
      }
      return out as { [K in keyof Q]: Answer };
    },
@@ -66,7 +69,8 @@
describe("the decision ledger", () => {
  let scout: User;
  let repo: Repo;
  const script: Record<string, string> = {};
  const decider = scripted(script);
  const sure: Record<string, number> = {};
  const decider = scripted(script, sure);
  const fresh = () => getRepoById(app.db, repo.id)!;
  beforeAll(async () => {
@@ -422,6 +426,74 @@
describe("the decision ledger", () => {
    }
  });
  test("a stop the decider is not sure of (p < 0.7) is a feedback run; a sure one parks, and the pull closes as parked", async () => {
    const { getAgentByName } = await import("../src/core/agents.ts");
    const scoutAgent = getAgentByName(app.db, "scout")!;
    const redPull = async (name: string) => {
      const branch = await commitToBranch(app, alice, repo, {
        branch: `feature/${name}`,
        base: "main",
        message: name,
        files: [{ path: `${name}.ts`, content: "export const x = 1;\n" }],
      });
      if (!branch.ok) throw new Error(JSON.stringify(branch.error));
      const opened = await openPull(app, scout, repo, {
        title: name,
        baseBranch: "main",
        headBranch: `feature/${name}`,
      });
      if (!opened.ok) throw new Error(String(opened.error));
      const pull = opened.value;
      const run = createRun(app.db, {
        repoId: repo.id,
        kind: "check",
        issueId: pull.id,
        env: `pull-${pull.number}`,
        commitOid: pull.headOid,
        reason: "pull",
      });
      claimRun(app.db, run.id);
      finishRun(app.db, run.id, { state: "failed", summary: "test failed: 1 of 9" });
      return {
        pull,
        failure: {
          runId: run.id,
          kind: "check",
          commitOid: pull.headOid,
          env: `pull-${pull.number}`,
          since: pull.createdAt,
        },
      };
    };
    script["retry"] = "stop";
    script["cause"] = "change";
    try {
      sure["retry"] = 0.59;
      const unsure = await redPull("unsure");
      expect(
        await answerFailedCheck(app, fresh(), unsure.pull, scoutAgent, unsure.failure),
      ).toBe("reworked");
      expect(getPull(app.db, repo.id, unsure.pull.number)?.state).toBe("open");
      expect(
        listRuns(app.db, repo.id, { kind: "agent" }).some(
          (r) => r.issueId === unsure.pull.id && r.reason === "check_failed",
        ),
      ).toBe(true);
      sure["retry"] = 0.77;
      const certain = await redPull("certain");
      expect(
        await answerFailedCheck(app, fresh(), certain.pull, scoutAgent, certain.failure),
      ).toBe("parked");
      const closed = getIssueById(app.db, certain.pull.id)!;
      expect(closed.state).toBe("closed");
      expect(closed.closeReason).toBe("parked");
    } finally {
      delete script["cause"];
      delete sure["retry"];
    }
  });
  test("conflicts come first: a green pull that no longer merges gets a conflict run before anyone decides", async () => {
    const branch = await commitToBranch(app, alice, repo, {
      branch: "feature/readme",
@@ -0,0 +1,224 @@
/**
 * A pull the crew parked closes as parked, not done (#1624). Only the crew
 * may say so: the API and the thread page refuse the word, a parked pull
 * stores no close_reason a raw query could read as done, and a reopen
 * clears it. Both doors name it.
 */
import { afterAll, beforeAll, describe, expect, test } from "bun:test";
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 { openIssue, setIssueState } from "../src/actions/issues.ts";
import { openPull } from "../src/actions/pulls.ts";
import { commitToBranch, createRepo } from "../src/actions/repos.ts";
import { getIssueById, type Issue } from "../src/core/issues.ts";
import type { Repo } from "../src/core/repos.ts";
import { createToken } from "../src/core/tokens.ts";
import { createUser, type User } from "../src/core/users.ts";
import { createForgeApp } from "../src/tui/forge.ts";
import { pullScreen } from "../src/tui/screens/pull.ts";
import { local } from "../src/tui/screens/where.ts";
import { headlessTerminal } from "../src/tui/term/terminal.ts";
import { settleApp } from "./helpers/tui.ts";
import { serve, type Servers } from "../src/http/server.ts";
describe("a parked pull", () => {
  let dataDir: string;
  let app: App;
  let servers: Servers;
  let alice: User;
  let repo: Repo;
  let headers: Record<string, string>;
  let count = 0;
  beforeAll(async () => {
    dataDir = await mkdtemp(join(tmpdir(), "forge-parked-"));
    app = createApp({ dataDir, port: 0 });
    servers = await serve(app);
    const a = await createUser(app.db, {
      trusted: true,
      username: "alice",
      email: "[email protected]",
      password: "a-good-passphrase",
      adminIfFirst: true,
    });
    if (!a.ok) throw new Error(a.error);
    alice = a.value;
    const made = await createRepo(app, alice, {
      name: "shop",
      visibility: "private",
    });
    if (!made.ok) throw new Error(String(made.error));
    repo = made.value;
    const seeded = await commitToBranch(app, alice, repo, {
      message: "Start",
      files: [{ path: "README.md", content: "# shop\n" }],
    });
    if (!seeded.ok) throw new Error(JSON.stringify(seeded.error));
    headers = {
      authorization: `Bearer ${createToken(app.db, alice.id, "t", "rw").token}`,
      "content-type": "application/json",
    };
  });
  afterAll(async () => {
    servers.stop();
    app.close();
    await rm(dataDir, { recursive: true, force: true });
  });
  const makePull = async (): Promise<Issue> => {
    const name = `feature/p${++count}`;
    const branch = await commitToBranch(app, alice, repo, {
      branch: name,
      base: "main",
      message: name,
      files: [
        { path: `${name.slice(8)}.ts`, content: "export const x = 1;\n" },
      ],
    });
    if (!branch.ok) throw new Error(JSON.stringify(branch.error));
    const opened = await openPull(app, alice, repo, {
      title: `Pull ${count}`,
      baseBranch: "main",
      headBranch: name,
    });
    if (!opened.ok) throw new Error(String(opened.error));
    return getIssueById(app.db, opened.value.id)!;
  };
  const rawReason = (id: string) =>
    app.db
      .query<{ close_reason: string | null }, [string]>(
        "SELECT close_reason FROM issue WHERE id = ?1",
      )
      .get(id)!.close_reason;
  test("closes as parked and leaves no 'done' for raw SQL to find", async () => {
    const pull = await makePull();
    const closed = setIssueState(app, alice, repo, pull, "closed", {
      reason: "parked",
    });
    expect(closed.ok).toBe(true);
    expect(getIssueById(app.db, pull.id)!.closeReason).toBe("parked");
    expect(rawReason(pull.id)).toBeNull();
  });
  test("reopening clears it", async () => {
    const pull = await makePull();
    setIssueState(app, alice, repo, pull, "closed", { reason: "parked" });
    const reopened = setIssueState(
      app,
      alice,
      repo,
      getIssueById(app.db, pull.id)!,
      "open",
    );
    expect(reopened.ok).toBe(true);
    const after = getIssueById(app.db, pull.id)!;
    expect(after.state).toBe("open");
    expect(after.closeReason).toBeNull();
    const parked = app.db
      .query<{ parked: number }, [string]>(
        "SELECT parked FROM issue WHERE id = ?1",
      )
      .get(pull.id)!.parked;
    expect(parked).toBe(0);
  });
  test("an issue cannot be parked, and a parked pull takes no children", async () => {
    const made = openIssue(app, alice, repo, { title: "Plain", body: "" });
    if (!made.ok) throw new Error(String(made.error));
    const issue = made.value;
    const asIssue = setIssueState(app, alice, repo, issue, "closed", {
      reason: "parked",
    });
    expect(asIssue.ok).toBe(false);
    if (!asIssue.ok) expect(asIssue.error).toBe("invalid_reason");
    const pull = await makePull();
    const into = setIssueState(app, alice, repo, pull, "closed", {
      reason: "parked",
      into: [issue.number],
    });
    expect(into.ok).toBe(false);
    if (!into.ok) expect(into.error).toBe("invalid_reason");
    expect(getIssueById(app.db, pull.id)!.state).toBe("open");
  });
  test("the API and the thread page refuse the word", async () => {
    const pull = await makePull();
    const res = await fetch(
      `${servers.url}/api/v1/repos/alice/shop/pulls/${pull.number}`,
      {
        method: "PATCH",
        headers,
        body: JSON.stringify({ state: "closed", reason: "parked" }),
      },
    );
    expect(res.status).toBe(422);
    expect(getIssueById(app.db, pull.id)!.state).toBe("open");
    const { CLOSE_REASONS } = await import("../src/core/issues.ts");
    expect(CLOSE_REASONS).not.toContain("parked");
  });
      
        sentinelcrew
        29d ago
        outdated
      
      This tests stateBadge on its own, not the pull page. Without the change.ts wiring it still passes, and the makePull/setIssueState lines above do nothing. Fetch the pull's page for the parked pull and assert Parked is in the HTML.
    
  test("the pull page and the pulls list say parked, and an ordinary close still says closed", async () => {
    const signin = await fetch(`${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 get = async (path: string) =>
      (await fetch(`${servers.url}${path}`, { headers: { cookie } })).text();
    const parked = await makePull();
    setIssueState(app, alice, repo, parked, "closed", { reason: "parked" });
    const plain = await makePull();
    setIssueState(app, alice, repo, plain, "closed");
    const page = await get(`/alice/shop/pulls/${parked.number}`);
    expect(page).toMatch(/data-state="closed"[^>]*>[^<]*<svg[\s\S]*?<\/svg>Parked</);
    expect(page).not.toMatch(/<\/svg>Closed</);
    expect(await get(`/alice/shop/pulls/${plain.number}`)).toMatch(
      /<\/svg>Closed</,
    );
    const list = await get("/alice/shop/pulls?word=stopped");
    expect(list).toContain("parked by the crew");
    expect(list).toContain("closed without shipping");
  });
  test("the terminal's merge box says parked", async () => {
    const pull = await makePull();
    setIssueState(app, alice, repo, pull, "closed", { reason: "parked" });
    const terminal = headlessTerminal(140, 44);
    const { app: tui, session } = createForgeApp(
      app,
      {
        sshUsername: "alice",
        remoteAddress: "127.0.0.1",
        fingerprint: "SHA256:alice",
        user: alice,
      },
      { terminal, exitHooks: false },
    );
    tui.start();
    try {
      tui.ctx.push(
        pullScreen(session, tui.ctx, local(session, repo), pull.number),
      );
      const end = Date.now() + 20_000;
      while (!tui.screen.toText().includes("Parked by the crew, not merged")) {
        if (Date.now() > end) throw new Error(tui.screen.toText());
        await settleApp(tui);
        await Bun.sleep(20);
      }
      expect(tui.screen.toText()).not.toContain("Closed without merging");
    } finally {
      tui.stop();
    }
  }, 60_000);
});
		@@ -471,6 +471,15 @@ or `x` on the issue in the terminal); the close writes "Closed: already done
471	471	on main in …" on the thread. A claim with no commit, or with one that is not
472	472	on the base, is an ordinary decline and is parked as one.
473	473
	474	A red pull. The decider stops a red check only when it is at least 70%
	475	sure; below that the pull gets another feedback run. A stop parks the pull: it
	476	closes as parked, not done, with a comment that says why. The pull page's
	477	badge reads "Parked" instead of "Closed", the terminal's merge box says "Parked
	478	by the crew, not merged", and the lists note it as stopped. Reopening it clears
	479	the mark. Only the crew parks: the API and the page refuse `reason: "parked"`.
	480	In the database the pull's `close_reason` stays NULL (its CHECK predates the
	481	word) and `issue.parked = 1` carries it, so raw SQL never reads it as done.
	482
474	483	An autonomous app's planner is held while nothing is landing or the plate
475	484	is full: no pull has merged in 48 h while one was closed unmerged, or more than
476	485	`slots × 3` ready, unassigned issues are waiting. The tick log says which
		@@ -121,6 +121,7 @@ export const GATE: readonly string[] = [
121	121	"test/checks.test.ts",
122	122	"test/dependencies.test.ts",
123	123	"test/map-closing.test.ts",
	124	"test/parked-close.test.ts",
124	125	"test/autonomy.test.ts",
125	126	"test/studio.test.ts",
126	127	"test/studio-words.test.ts",
		@@ -411,7 +411,11 @@ export function setIssueState(
411	411	const children: Issue[] = [];
412	412	if (closing.reason !== undefined \|\| closing.into !== undefined) {
413	413	// A reason is how an issue closes; a pull or a reopen has none.
414		if (state !== "closed" \|\| issue.kind !== "issue")
	414	if (
	415	state !== "closed" \|\|
	416	issue.kind !== (reason === "parked" ? "pull" : "issue") \|\|
	417	(reason === "parked" && closing.into !== undefined)
	418	)
415	419	return err("invalid_reason");
416	420	if (reason === "split") {
417	421	for (const number of closing.into ?? []) {
		@@ -451,7 +455,9 @@ export function setIssueState(
451	455	actorId: user.value.id,
452	456	payload: {
453	457	number: issue.number,
454		...(issue.kind === "issue" && reason !== undefined ? { reason } : {}),
	458	...(reason !== undefined && (issue.kind === "issue" \|\| reason === "parked")
	459	? { reason }
	460	: {}),
455	461	...(children.length > 0 ? { into: children.map((c) => c.number) } : {}),
456	462	},
457	463	});
		@@ -188,7 +188,7 @@ export function dependenciesOf(
188	188	export interface Held {
189	189	readonly issueId: string;
190	190	readonly blockedById: string;
191		readonly reason: Exclude<CloseReason, "done">;
	191	readonly reason: Exclude<CloseReason, "done" \| "parked">;
192	192	}
193	193
194	194	export interface Graph {
		@@ -12,8 +12,12 @@ import { repoVisible } from "./visibility.ts";
12	12
13	13	export type IssueKind = "issue" \| "pull";
14	14	export type IssueState = "open" \| "closed";
15		/** Why an issue closed: done frees what waited on it; the others hold it. */
16		export type CloseReason = "done" \| "dropped" \| "split";
	15	/**
	16	* Why an issue closed: done frees what waited on it; the others hold it.
	17	* `parked` is the crew's own, on a pull it stopped for a person; it is never
	18	* one a request may name, so it is not in `CLOSE_REASONS`.
	19	*/
	20	export type CloseReason = "done" \| "dropped" \| "split" \| "parked";
17	21	export const CLOSE_REASONS: readonly CloseReason[] = [
18	22	"done",
19	23	"dropped",
		@@ -78,6 +82,7 @@ interface IssueRow {
78	82	updated_at: string;
79	83	closed_at: string \| null;
80	84	close_reason: CloseReason \| null;
	85	parked: number;
81	86	origin_author: string \| null;
82	87	origin_html_url: string \| null;
83	88	assignee_id: string \| null;
		@@ -107,7 +112,7 @@ function toIssue(row: IssueRow): Issue {
107	112	createdAt: row.created_at,
108	113	updatedAt: row.updated_at,
109	114	closedAt: row.closed_at,
110		closeReason: row.close_reason,
	115	closeReason: row.parked === 1 ? "parked" : row.close_reason,
111	116	originAuthor: row.origin_author,
112	117	originUrl: row.origin_html_url,
113	118	assigneeId: row.assignee_id,
		@@ -469,12 +474,15 @@ export function setIssueState(
469	474	): Issue \| undefined {
470	475	const now = new Date().toISOString();
471	476	const closedAt = state === "closed" ? now : null;
472		const why = state === "closed" ? reason : null;
	477	const why = state === "closed" && reason !== "parked" ? reason : null;
	478	const parked = state === "closed" && reason === "parked" ? 1 : 0;
473	479	const changed = db
474	480	.query(
475		"UPDATE issue SET state = ?1, closed_at = ?2, updated_at = ?3, close_reason = ?5 WHERE id = ?4 AND state != ?1",
	481	`UPDATE issue SET state = ?1, closed_at = ?2, updated_at = ?3,
	482	close_reason = ?5, parked = ?6
	483	WHERE id = ?4 AND state != ?1`,
476	484	)
477		.run(state, closedAt, now, issueId, why).changes;
	485	.run(state, closedAt, now, issueId, why, parked).changes;
478	486	return changed > 0 ? getIssueById(db, issueId) : undefined;
479	487	}
480	488
		@@ -1787,6 +1787,13 @@ export const migrations: readonly string[] = [
1787	1787	PRIMARY KEY (step, at, target)
1788	1788	) WITHOUT ROWID;
1789	1789	`,
	1790	// 89 — a pull the crew parked (#1624) closes as parked, not done. The
	1791	// column carries it, and `close_reason` stays NULL: its CHECK cannot be
	1792	// widened in place, and NULL is never read as done by raw SQL.
	1793	// `closeReason` reads 'parked' from it.
	1794	`
	1795	ALTER TABLE issue ADD COLUMN parked INTEGER NOT NULL DEFAULT 0;
	1796	`,
1790	1797	];
1791	1798
1792	1799	/**
		@@ -957,7 +957,9 @@ export function parkPull(
957	957	const issue = getIssueById(app.db, pull.id);
958	958	if (!issue \|\| issue.state !== "open") return false;
959	959	addComment(app, by, repo, issue, `${PARK_NOTE}${why}`);
960		const closed = setIssueState(app, by, repo, issue, "closed");
	960	const closed = setIssueState(app, by, repo, issue, "closed", {
	961	reason: "parked",
	962	});
961	963	if (!closed.ok) return false;
962	964	for (const number of closesFromBody(pull.body)) {
963	965	const about = getIssue(app.db, repo.id, number);
		@@ -858,7 +858,12 @@ export async function judgeFailedCheck(
858	858	cause: certain(CAUSE_OPTIONS, "change"),
859	859	}),
860	860	);
861		const retry = decided.answers.retry.choice === "stop" ? "stop" : "again";
	861	// A stop is a pull closed on a person's behalf: it takes the same
	862	// confidence as a cause. Below it the builder gets its one more try.
	863	const retry =
	864	decided.answers.retry.choice === "stop" && decided.answers.retry.p >= 0.7
	865	? "stop"
	866	: "again";
862	867	// The change is what a half-sure answer means: an environment called
863	868	// that way on a hunch is how a broken change escapes a rework.
864	869	const cause =
		@@ -3018,6 +3018,9 @@ export function apiRoutes(router: Router<Handler>): void {
3018	3018	const wanted = input.state === undefined ? undefined : str(input.state);
3019	3019	if (wanted !== undefined && wanted !== "open" && wanted !== "closed")
3020	3020	return json({ error: "invalid_state" }, 422);
	3021	// A pull has no reason to give: "parked" is the crew's word alone.
	3022	if (input.reason !== undefined \|\| input.into !== undefined)
	3023	return json({ error: "invalid_reason" }, 422);
3021	3024	if (
3022	3025	wanted === undefined &&
3023	3026	text.title === undefined &&
		@@ -1241,7 +1241,9 @@ function drawMergeBox(
1241	1241	state === "merged"
1242	1242	? `Merged ${relTime(pull?.mergedAt ?? "")} into ${pull?.baseBranch ?? ""}`
1243	1243	: state === "closed"
1244		? "Closed without merging"
	1244	? issue.parked === true
	1245	? "Parked by the crew, not merged"
		sentinelcrew 29d ago The terminal door has no test. Render the merge box for a parked pull and assert this text. Also, `issue` is not optional in `drawMergeBox`, so `issue?.parked` can be `issue.parked`.
	1246	: "Closed without merging"
1245	1247	: state === "mirrored"
1246	1248	? `Merge on the origin${issue.originUrl === null ? "" : ` — ${issue.originUrl}`}`
1247	1249	: state === "conflicts"