b17dadb · f875eea · 4000444 · 3d46397 · 532a334
@@ -184,8 +184,8 @@
there is landing it upstream.
the API.
A fork across forges (#1085): a spawned forge's `<org>/forge` follows its
parent's forge code in the mode the spawner chose, `tell-me` (default) or
`take-updates`; `/:owner/forge/following` shows the chain to the root and
parent's forge code in the mode the spawner chose, `take-updates` (default) or
`tell-me`; `/:owner/forge/following` shows the chain to the root and
the owner's **Sever**, which cuts the link and deletes nothing (the page
and the parent's `/family` say "follows nothing since …"). `docs/SPAWN.md`
has the shape. A **conflict** on **Take updates** is a tell for the crew:
@@ -256,8 +256,8 @@
the default branch is pushed to `child/<name>/<branch>-<tip>` at the parent,
and the pull opens there, titled by the change that landed last and naming it
(`org/forge#7`). Asking again for the same tip returns the pull already made.
The repository's admin changes how the forge follows its parent (`tell-me` or
`take-updates`) from the radio form on the same page, with `PATCH
The repository's admin changes how the forge follows its parent (`take-updates` or
`tell-me`) from the radio form on the same page, with `PATCH
/api/v1/forge/following {"mode"}`, with the MCP `follow_mode` tool, or by pressing `m` on the chain screen in the terminal. The
record in `parent.json` is rewritten atomically and a `forge.follow_mode` event
is appended. A non-admin is refused (403), a value outside the two modes is
@@ -197,7 +197,7 @@
bytes in `tools/list`. After changing a tool run `bun scripts/mcp-table.ts`;
| `signup` | — | Sign-ups: open (default); invite lets in only a person with an open invite link; closed refuses every new account | 291 |
| `sizes` | — | A child forge's sizes: small, medium and large, each with CPU, memory and disk | 196 |
| `snapshot_now` | — | Take a snapshot now, as Backups does (admin) | 133 |
| `spawn` | — | Spawn a child forge | 910 |
| `spawn` | — | Spawn a child forge | 908 |
| `spend` | — | Report what your session spent outside forge runs: who, model, tokens or dollars, issue | 470 |
| `ssh_keys` | `list`, `add`, `remove` | Your SSH keys; add: key, remove: id | 250 |
| `steer` | — | Say a word to one crew run by its id | 224 |
@@ -95,8 +95,8 @@
reads child → parent → … → root.
`parent.json` keeps `forgeCode`: `repo`, `upstream`, `mode`, `tip` (the
upstream's tip at birth) and `chain` (the ancestors' hops, copied from the
parent's own `parent.json`, so a grandchild reads the whole chain offline).
The spawner chooses `followMode` in the spawn input: `tell-me` (default) or
`take-updates`; it is part of the plan. `/:owner/forge/following` on the
The spawner chooses `followMode` in the spawn input: `take-updates` (default) or
`tell-me`; it is part of the plan. A plain fork (not a spawned forge) defaults to `tell-me`. `/:owner/forge/following` on the
child shows the chain, root first, one line per hop with its mode and how
many commits of its own it had when the next hop was born (the last hop is
counted now). What the modes do is in
@@ -125,7 +125,7 @@
learned (the parent's tip, how far behind the child is) is kept in
The owner's `followMode` decides what happens when the parent has new commits:
- `tell-me` sends one inbox card per new tip, listing its commits.
- `take-updates` opens one pull from the branch `forge/take-updates`
- `take-updates` (the default) fast-forwards main when the fork has no commits of its own; otherwise it opens one pull from the branch `forge/take-updates`
  (`TAKE_BRANCH`) holding the parent's code, and updates that same pull when
  the parent moves again. The pull carries the check like any other.
@@ -142,7 +142,7 @@
leaves. The page and the parent's tree then say it follows nothing since
the date.
A spawned forge's own code is a fork of its parent's (`<org>/forge`, chosen
`followMode` `tell-me` or `take-updates`; in `take-updates` the hourly check puts what the parent gained in a pull.
`followMode` `take-updates` (default) or `tell-me`; in `take-updates` the hourly check fast-forwards a fork with no commits of its own, and puts what the parent gained in a pull when the fork has its own.
 Once an hour, and
on demand, a forge that follows and has not severed fetches its parent's code into
`refs/upstream/*` of its own `<org>/forge` (no branch of the fork moves) and keeps
@@ -150,10 +150,10 @@
on demand, a forge that follows and has not severed fetches its parent's code in
the count shows on the chain page, in the terminal's **Chain** (`c` checks now), and as
`upstream` in the API and MCP payloads. `POST /:owner/forge/following/check` (a writer,
same-origin) checks on demand; a fetch is cut at 60 s and a failure is recorded, not
thrown. In `take-updates` the check then puts `refs/upstream/HEAD` (a fast-forward, or a clean merge commit) on the
thrown. In `take-updates` the check first fast-forwards main itself when the fork has no commits of its own (compare-and-swap, so a push in between wins). Otherwise it puts `refs/upstream/HEAD` (a fast-forward, or a clean merge commit) on the
fork's `forge/take-updates` branch and opens one pull, "Take updates from <parent>", into main, or updates
that pull when it is open (`spawn/take.ts`); the fork's check runs on it like on any pull and a person merges it.
Main is never moved, so nothing deploys by itself. It is recorded as `taken` in `upstream.json` (the chain line
Main is moved only by that untouched-fork fast-forward; a fork with its own commits gets the pull and a person merges it. It is recorded as `taken` in `upstream.json` (the chain line
reads "N commits from your parent are in pull #P") and as a `forge.updates_taken` event; a pull closed unmerged
is not reopened until the parent moves again. `forge/take-updates` belongs to the check: a commit a person pushes there is overwritten by the next check that finds something different to put on it (open a branch of your own to build on it). On a conflict nothing changes and one open issue,
"Take updates from <parent>", names the files. In `tell-me`, a new parent tip makes one inbox card for the owner (an issue on the fork assigned to them, "Your parent forge has N new commits", linking the chain page); `toldTip` in `upstream.json` keeps it to one per tip, and `take-updates` or a severed link makes none. Its chain
@@ -3,7 +3,7 @@
A fork follows its upstream in one of three modes, said in one line on its page:
- **Follows ann/yard automatically** (`take-updates`): new code is merged as it lands; a conflict goes to the crew.
- **Proposes updates from ann/yard** (`tell-me`, the default): a fork with nothing of its own still moves along; one with work of its own is told, and takes updates when its owner chooses.
- **Takes updates from ann/yard** (`take-updates`, the default for a new forge): a fork with no commits of its own fast-forwards by itself; one with commits of its own gets a pull to merge. A plain fork defaults to `tell-me`: its owner is told and chooses.
- **Does not follow ann/yard** (`dont-follow`, #608): nothing is fast-forwarded, merged or announced, and the crew is never asked to converge. The fork can still offer its changes up.
The line shows only on a fork, to anyone who can see the page.
@@ -1,7 +1,7 @@
/** How a plain fork follows its parent: one row per fork that chose; none means the default. */
import type { Database } from "bun:sqlite";
import { DEFAULT_MODE, FOLLOW_MODES } from "../spawn/chain.ts";
import { FOLLOW_MODES, type FollowMode } from "../spawn/chain.ts";
/**
 * A plain fork's modes: the chain's two, and `dont-follow` (#608), which a
@@ -13,9 +13,12 @@
export type ForkFollowMode = (typeof FORK_FOLLOW_MODES)[number];
export const isForkFollowMode = (v: unknown): v is ForkFollowMode =>
  typeof v === "string" && (FORK_FOLLOW_MODES as readonly string[]).includes(v);
/** A plain fork still proposes by default; only a spawned forge takes updates. */
export const FORK_DEFAULT_MODE: FollowMode = "tell-me";
export function forkFollowMode(db: Database, repoId: string): ForkFollowMode {
  const row = db.query<{ mode: ForkFollowMode }, [string]>("SELECT mode FROM fork_follow WHERE repo_id = ?1").get(repoId);
  return row?.mode ?? DEFAULT_MODE;
  return row?.mode ?? FORK_DEFAULT_MODE;
}
export function setForkFollowMode(db: Database, repoId: string, mode: ForkFollowMode): void {
@@ -24,7 +27,7 @@
export function setForkFollowMode(db: Database, repoId: string, mode: ForkFollow
  ).run(repoId, mode);
}
/** The stored modes of these repos in one query; a repo with none stored is absent (it follows `DEFAULT_MODE`). */
/** The stored modes of these repos in one query; a repo with none stored is absent (it follows `FORK_DEFAULT_MODE`). */
export function forkFollowModes(db: Database, repoIds: readonly string[]): Map<string, ForkFollowMode> {
  if (repoIds.length === 0) return new Map();
  const rows = db
@@ -20,7 +20,8 @@
import { err, ok, type Result } from "../kernel/result.ts";
export const FOLLOW_MODES = ["tell-me", "take-updates"] as const;
export type FollowMode = (typeof FOLLOW_MODES)[number];
export const DEFAULT_MODE: FollowMode = "tell-me";
/** What a new forge follows with; a link on disk with no mode is read as `tell-me`, as it always was. */
export const DEFAULT_MODE: FollowMode = "take-updates";
/** One forge in the chain, as recorded when the hop below it was made. */
export interface Hop {
@@ -98,7 +99,7 @@
export async function forgeLinkOf(app: App): Promise<ForgeLink | undefined> {
  return {
    repo: l["repo"],
    upstream: l["upstream"],
    mode: isMode(l["mode"]) ? l["mode"] : DEFAULT_MODE,
    mode: isMode(l["mode"]) ? l["mode"] : "tell-me",
    tip: typeof l["tip"] === "string" && TIP.test(l["tip"]) ? l["tip"] : "",
    chain,
    ...(severedAt === undefined ? {} : { severedAt }),
@@ -2,8 +2,9 @@
 * Follow words (#7199): what each follow mode does, in one plain line, so
 * `/forges/new`, the terminal's new-forge screen and MCP `spawn` say the
 * same thing. They describe `src/spawn/upstream.ts`: `tell-me` sends the
 * owner an inbox card when this forge's code moves; `take-updates` opens the
 * one `forge/take-updates` pull (`src/spawn/take.ts`), which a person merges.
 * owner an inbox card when this forge's code moves; `take-updates` (the
 * default) fast-forwards a forge the owner has not changed, and otherwise
 * opens the one `forge/take-updates` pull (`src/spawn/take.ts`), which a person merges.
 */
import type { FollowMode } from "./chain.ts";
@@ -15,12 +16,12 @@
export const FOLLOW_LABELS: Readonly<Record<FollowMode, string>> = {
export const FOLLOW_WORDS: Readonly<Record<FollowMode, string>> = {
  "tell-me": "tells the owner in their inbox when this forge's code moves.",
  "take-updates": "opens a pull with the new code, and a person merges it.",
  "take-updates": "takes new code in by itself; opens a pull once the repository has commits of its own.",
};
/** One line naming both modes, for the terminal's hint. */
export const FOLLOW_LINE =
  `tell-me (default) ${FOLLOW_WORDS["tell-me"]} take-updates ${FOLLOW_WORDS["take-updates"]}`;
  `take-updates (default) ${FOLLOW_WORDS["take-updates"]} tell-me ${FOLLOW_WORDS["tell-me"]}`;
/** The same, short enough for an MCP field (60 bytes); docs/MCP.md has the long words. */
export const FOLLOW_SHORT = "tell-me: an inbox card; take-updates: a pull a person merges";
export const FOLLOW_SHORT = "take-updates: merges itself or a pull; tell-me: inbox card";
@@ -70,7 +70,7 @@
export interface SpawnInput {
  readonly budgetUsd?: unknown;
  /** One line describing a fresh app to start in the child, beside the forked ones; optional. */
  readonly fresh?: unknown;
  /** How the child follows the forge's code: `tell-me` (default) or `take-updates`. */
  /** How the child follows the forge's code: `take-updates` (default) or `tell-me`. */
  readonly followMode?: unknown;
  /** How big the child is: `small`, `medium` or `large`; optional. */
  readonly size?: unknown;
@@ -116,7 +116,7 @@
export interface SpawnPlan {
  readonly forWhom?: string;
  /** A fresh app, present only when asked for. */
  readonly fresh?: PlannedFresh;
  /** How the child follows its parent's forge code; absent means `tell-me`. */
  /** How the child follows its parent's forge code; absent means `take-updates`. */
  readonly followMode?: FollowMode;
  /** The child's size, present only when chosen. */
  readonly size?: Size;
@@ -1,11 +1,12 @@
/**
 * Taking the parent's code, for a forge that follows in `take-updates`
 * mode. Once the hourly fetch has put the parent's tip at
 * `refs/upstream/HEAD`, this puts a fast-forward, or a merge commit when git
 * merges the two without conflict, on one branch, `forge/take-updates`, and
 * `refs/upstream/HEAD`, a fork the owner has not changed (its default branch
 * is an ancestor of the parent's) is fast-forwarded in place. Otherwise this
 * puts a merge commit, when git merges the two without conflict, on one branch, `forge/take-updates`, and
 * opens one pull from it into the default branch (or updates the one already
 * open). The fork's check runs on it like on any pull; a person merges it.
 * It never moves the default branch, and production follows that branch.
 * open). The fork's check runs on it like on any pull.
 * That pull never moves the default branch; a person merges it.
 * A conflict changes nothing; it opens (or finds) one issue naming the files.
 */
@@ -26,6 +27,7 @@
import type { ForgeLink } from "./chain.ts";
/** What the last check did with the parent's new commits; absent when it did nothing. */
export type Taken =
  | { readonly kind: "pull"; readonly number: number; readonly commits: number }
  | { readonly kind: "forwarded"; readonly commits: number }
  | { readonly kind: "conflict"; readonly files: readonly string[]; readonly issue: number | null };
export const takeTitle = (upstream: string): string => `Take updates from ${upstream}`;
@@ -120,6 +122,27 @@
export async function takeFromParent(app: App, link: ForgeLink): Promise<Taken |
  const count = await runGit(["rev-list", "--count", `${head}..${up}`], { cwd: dir });
  const commits = count.ok ? Number(count.value.trim()) || 0 : 0;
  // A forge that takes updates and whose owner has not changed the repository:
  // the parent's code is a pure fast-forward, with nothing of theirs to review it against.
  // A forge that only tells (and is pressed to take) still gets the pull.
  if (base === head && link.mode === "take-updates") {
    const ref = `refs/heads/${branch}`;
    // Compare-and-swap: a push to the branch since `head` was read wins, and the next check looks again.
    if (!(await runGit(["update-ref", ref, up, head], { cwd: dir })).ok) return undefined;
    app.bus.append({
      kind: "push",
      repoId: repo.id,
      actorId: owner.id,
      payload: { updates: [{ ref, oldOid: head, newOid: up }], followed: link.upstream },
    });
    app.bus.append({
      kind: "forge.updates_taken",
      repoId: repo.id,
      payload: { repo: link.repo, upstream: link.upstream, from: head, to: up, commits, pull: null },
    });
    return { kind: "forwarded", commits };
  }
  const had = await resolveOid(dir, `refs/heads/${TAKE_BRANCH}`);
  let to = up;
  if (base !== head) {
@@ -68,6 +68,8 @@
export async function upstreamState(app: App): Promise<UpstreamState | undefined
function readTaken(v: unknown): { taken?: Taken } {
  if (typeof v !== "object" || v === null) return {};
  const t = v as Record<string, unknown>;
  if (t["kind"] === "forwarded" && typeof t["commits"] === "number")
    return { taken: { kind: "forwarded", commits: t["commits"] } };
  if (t["kind"] === "pull" && typeof t["number"] === "number" && typeof t["commits"] === "number")
    return { taken: { kind: "pull", number: t["number"], commits: t["commits"] } };
  if (t["kind"] === "conflict" && Array.isArray(t["files"]))
@@ -221,6 +223,8 @@
export function upstreamWords(s: UpstreamState | undefined, now = Date.now()): s
  const mins = Math.max(0, Math.floor((now - s.checkedAt) / 60_000));
  const when = mins < 1 ? "just now" : mins < 60 ? `${mins} min ago` : `${Math.floor(mins / 60)} h ago`;
  if (s.error !== "") return `could not check your parent: ${s.error} (${when})`;
  if (s.taken?.kind === "forwarded")
    return `${s.taken.commits} commit${s.taken.commits === 1 ? "" : "s"} from your parent ${s.taken.commits === 1 ? "was" : "were"} taken in (checked ${when})`;
  if (s.taken?.kind === "pull")
    return `${s.taken.commits} commit${s.taken.commits === 1 ? "" : "s"} from your parent ${s.taken.commits === 1 ? "is" : "are"} in pull #${s.taken.number} (checked ${when})`;
  if (s.taken?.kind === "conflict")
@@ -82,7 +82,7 @@
export function newForgeScreen(f: Session, ctx: Ctx, initial: Record<string, str
      name: val("name"),
      apps,
      ...(val("fresh") === "" ? {} : { fresh: val("fresh") }),
      followMode: val("followMode") === "" ? "tell-me" : val("followMode"),
      followMode: val("followMode") === "" ? "take-updates" : val("followMode"),
      ...(val("for") === "" ? {} : { for: val("for") }),
      ...(val("direction") === "" ? {} : { direction: val("direction") }),
      ...(val("modelKey") === "" ? {} : { modelKey: val("modelKey") }),
@@ -136,7 +136,7 @@
export function newForgeScreen(f: Session, ctx: Ctx, initial: Record<string, str
          const budget = (body["plan"] as { budgetUsd?: number | null } | undefined)?.budgetUsd ?? null;
          const size = (body["plan"] as { size?: string } | undefined)?.size;
          const template = (body["plan"] as { template?: string } | undefined)?.template;
          const mode = val("followMode") === "" ? "tell-me" : val("followMode");
          const mode = val("followMode") === "" ? "take-updates" : val("followMode");
          plan = [
            `A forge at ${childUrlOf(f.app, val("name"))}.`,
            `It follows this forge's code as ${mode}${isFollowMode(mode) ? `: it ${FOLLOW_WORDS[mode]}` : "."}`,
@@ -59,7 +59,7 @@
const EMPTY: Values = {
  apps: [],
  crew: [],
  fresh: "",
  followMode: "tell-me",
  followMode: "take-updates",
  keepAccess: false,
  budgetUsd: "",
  modelEndpoint: "",
@@ -248,22 +248,22 @@
function formView(
            <input
              type="radio"
              name="followMode"
              value="tell-me"
              ${values.followMode !== "take-updates" ? html`checked` : null}
              value="take-updates"
              ${values.followMode !== "tell-me" ? html`checked` : null}
            />
            <span
              >${FOLLOW_LABELS["tell-me"]} <span class="muted small">${FOLLOW_WORDS["tell-me"]}</span></span
              >${FOLLOW_LABELS["take-updates"]} <span class="muted small">${FOLLOW_WORDS["take-updates"]}</span></span
            >
          </label>
          <label class="check">
            <input
              type="radio"
              name="followMode"
              value="take-updates"
              ${values.followMode === "take-updates" ? html`checked` : null}
              value="tell-me"
              ${values.followMode === "tell-me" ? html`checked` : null}
            />
            <span
              >${FOLLOW_LABELS["take-updates"]} <span class="muted small">${FOLLOW_WORDS["take-updates"]}</span></span
              >${FOLLOW_LABELS["tell-me"]} <span class="muted small">${FOLLOW_WORDS["tell-me"]}</span></span
            >
          </label>
          ${errors["followMode"]
@@ -485,7 +485,7 @@
export async function newForgeSubmit(ctx: Ctx): Promise<Response> {
    apps: all(form, "apps"),
    crew: all(form, "crew"),
    fresh: field(form, "fresh").trim(),
    followMode: field(form, "followMode").trim() || "tell-me",
    followMode: field(form, "followMode").trim() || "take-updates",
    keepAccess: asBool(form, "keepAccess"),
    budgetUsd: field(form, "budgetUsd").trim(),
    modelEndpoint: field(form, "modelEndpoint").trim(),
@@ -87,8 +87,6 @@
describe("following across forges, end to end", () => {
  });
  test("the whole path", async () => {
    const start = await main();
    // 1-2. Two parent commits: behind 2, one card listing both.
    await theirs("p1.txt", "1\n", "parent one");
    await theirs("p2.txt", "2\n", "parent two");
@@ -101,7 +99,10 @@
describe("following across forges, end to end", () => {
    expect(cards[0]!.body).toContain("parent two");
    expect(takes()).toHaveLength(0);
    // 3. take-updates: the next check opens one pull listing both; main stays.
    // 3. take-updates, the fork having a commit of its own: the next check opens one pull listing both; main stays.
    const own = await commitToBranch(app, kid, repo, { message: "own", files: [{ path: "own.txt", content: "own\n" }] });
    expect(own.ok).toBe(true);
    const start = await main();
    expect((await setChainMode(app, "take-updates")).ok).toBe(true);
    const took = await checkUpstream(app, { remote: parent });
    expect(took?.taken).toMatchObject({ kind: "pull", commits: 2 });
@@ -296,15 +296,15 @@
describe("+ New forge", () => {
    expect(await again.text()).not.toMatch(/claim#[A-Za-z0-9_-]{43}/);
  });
  test("the form offers how the child follows the forge's code, tell-me by default, and take-updates is recorded", async () => {
  test("the form offers how the child follows the forge's code, take-updates by default, and tell-me is recorded", async () => {
    const html = (await (await get(admin, "/forges/new")).text()).replace(/\s+/g, " ");
    expect(html).toMatch(/name="followMode" value="tell-me" checked/);
    expect(html).toContain('value="take-updates"');
    expect(html).toMatch(/name="followMode" value="take-updates" checked/);
    expect(html).toContain('value="tell-me"');
    (app.config as { forgeRepo?: string }).forgeRepo = "alice/bakery";
    try {
      const res = await post(admin, [
        ["name", "follower"],
        ["followMode", "take-updates"],
        ["followMode", "tell-me"],
        ["do", "spawn"],
      ]);
      expect(res.status).toBe(201);
@@ -314,7 +314,7 @@
describe("+ New forge", () => {
        ),
      );
      const mine = docs.find((d) => d?.name === "follower");
      expect(mine?.forgeCode?.mode).toBe("take-updates");
      expect(mine?.forgeCode?.mode).toBe("tell-me");
      const bad = await post(admin, [
        ["name", "wrongmode"],
        ["followMode", "yolo"],
@@ -330,7 +330,7 @@
describe("+ New forge", () => {
  test("the page promises no update that does not happen", async () => {
    const html = (await (await get(admin, "/forges/new")).text()).replace(/\s+/g, " ");
    expect(html).toContain("Tell me <span class=\"muted small\">tells the owner in their inbox when this forge&#39;s code moves.</span>");
    expect(html).toContain("Take updates <span class=\"muted small\">opens a pull with the new code, and a person merges it.</span>");
    expect(html).toContain("Take updates <span class=\"muted small\">takes new code in by itself; opens a pull once the repository has commits of its own.</span>");
    expect(html).toContain("<legend>How it follows this forge's code</legend>");
    expect(html).not.toMatch(/recorded for now|nothing acts on it yet/i);
    expect(html).not.toContain("when this forge changes");
@@ -339,7 +339,7 @@
describe("+ New forge", () => {
  test("MCP spawn says what each follow mode does, as the page does", () => {
    const followMode = (spawnTool.inputSchema.properties as Record<string, { description?: string }>)["followMode"];
    expect(followMode?.description).toBe("tell-me: an inbox card; take-updates: a pull a person merges");
    expect(followMode?.description).toBe("take-updates: merges itself or a pull; tell-me: inbox card");
  });
  test("a forge at its depth limit shows no door, and its page says why", async () => {
@@ -163,7 +163,7 @@
describe("anonymous spawn", () => {
        join(childDirOf(app, body.bodyId), "parent.json"),
      ).json()) as any;
      expect(parent.forgeCode).toEqual(
        expect.objectContaining({ repo: "kid/forge", upstream: "alice/forge-code", mode: "tell-me" }),
        expect.objectContaining({ repo: "kid/forge", upstream: "alice/forge-code", mode: "take-updates" }),
      );
    } finally {
      child.close();
@@ -126,20 +126,20 @@
describe("choosing how a forge follows its parent", () => {
  });
  test("the owner changes it from the page, the API and MCP; the page shows it", async () => {
    expect((await forgeLinkOf(child))?.mode).toBe("tell-me");
    expect((await forgeLinkOf(child))?.mode).toBe("take-updates");
    const page = async () => (await (await fetch(`${servers.url}/kid/forge/following`, { headers: { cookie } })).text()).replace(/\s+/g, " ");
    const html = await page();
    expect(html).toContain('action="/kid/forge/following/mode"');
    expect(html).toMatch(/value="tell-me" checked/);
    expect(html).toMatch(/value="take-updates" checked/);
    expect(html).not.toContain("<script>");
    // Rows and headings, not boxes.
    expect(html).not.toContain('class="card');
    expect(html).toContain('<ul class="list" aria-label="Forges, root first">');
    expect(html).toContain("<h2");
    expect((await form(cookie, "take-updates")).status).toBe(303);
    expect((await forgeLinkOf(child))?.mode).toBe("take-updates");
    expect(await page()).toMatch(/value="take-updates" checked/);
    expect((await form(cookie, "tell-me")).status).toBe(303);
    expect((await forgeLinkOf(child))?.mode).toBe("tell-me");
    expect(await page()).toMatch(/value="tell-me" checked/);
    const res = await patch(ownerTok, { mode: "tell-me" });
    expect(res.status).toBe(200);
@@ -71,7 +71,7 @@
describe("the chain of forges", () => {
    });
    if (!c.ok) throw new Error("commit");
    const a = await spawn(root, alice.value, "kid", "root.test", "take-updates");
    const a = await spawn(root, alice.value, "kid", "root.test");
    if (!a.ok) throw new Error(JSON.stringify(a.error));
    child = createApp({ dataDir: childDirOf(root, a.value.bodyId), url: "https://kid.test", port: 0 });
    // The child's owner changes their forge all they want.
@@ -84,7 +84,7 @@
describe("the chain of forges", () => {
    if (!own.ok) throw new Error("own commit");
    const founder = getUserByName(child.db, "alice")!;
    const b = await spawn(child, founder, "tot", "kid.test");
    const b = await spawn(child, founder, "tot", "kid.test", "tell-me");
    if (!b.ok) throw new Error(JSON.stringify(b.error));
    grand = createApp({ dataDir: childDirOf(child, b.value.bodyId), port: 0 });
    servers = await serve(grand);
@@ -100,13 +100,15 @@
describe("the chain of forges", () => {
    await rm(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
  });
  test("followMode is validated and defaults to tell-me", () => {
  test("followMode is validated and defaults to take-updates", () => {
    const base = { name: "x", org: "x", apps: [], carryBriefs: false, carrySubscriptions: false };
    expect(planSpawn(base, source).ok).toBe(true);
    const bad = planSpawn({ ...base, followMode: "yolo" }, source);
    expect(bad.ok).toBe(false);
    const grandLink = planSpawn({ ...base, followMode: "tell-me" }, source);
    expect(grandLink.ok && grandLink.value.followMode).toBeUndefined();
    const taking = planSpawn({ ...base, followMode: "take-updates" }, source);
    expect(taking.ok && taking.value.followMode).toBeUndefined();
    const telling = planSpawn({ ...base, followMode: "tell-me" }, source);
    expect(telling.ok && telling.value.followMode).toBe("tell-me");
  });
  test("the child carries a fork of the parent's forge code in the chosen mode", async () => {
@@ -118,7 +120,7 @@
describe("the chain of forges", () => {
    expect(getRepo(child.db, "kid", "forge")).toBeDefined();
  });
  test("the grandchild's fork names the child's forge, mode tell-me by default", async () => {
  test("the grandchild's fork names the child's forge, mode as chosen", async () => {
    const link = await forgeLinkOf(grand);
    expect(link?.upstream).toBe("kid/forge");
    expect(link?.mode).toBe("tell-me");
@@ -59,6 +59,9 @@
describe("the take pull's description", () => {
    work = join(dir, "work");
    await git(dir, "clone", "-q", "--bare", repoDir(app.reposRoot, "kid", "forge"), parent);
    await git(dir, "clone", "-q", parent, work);
    // The fork has a commit of its own, so updates arrive as a pull.
    const own = await commitToBranch(app, u.value, repo, { message: "own", files: [{ path: "own.txt", content: "own\n" }] });
    if (!own.ok) throw new Error(JSON.stringify(own.error));
    await Bun.write(
      join(app.config.dataDir, "parent.json"),
      JSON.stringify({
@@ -98,7 +101,7 @@
describe("the take pull's description", () => {
    await theirs("c6", "subject 6");
    await take();
    expect(body()).toBe("My own words.");
    expect(open()[0]!.headOid).toBe(await git(parent, "rev-parse", "refs/heads/main"));
    expect((await git(repoDir(app.reposRoot, "kid", "forge"), "rev-list", "--parents", "-n1", open()[0]!.headOid)).split(" ")).toContain(await git(parent, "rev-parse", "refs/heads/main"));
  });
  test("hostile subjects stay inert in a fresh pull's body", async () => {
@@ -101,7 +101,23 @@
describe("taking the parent's code", () => {
  const pulls = () => listPulls(app.db, repo.id, { state: "open" }).filter((p) => p.headBranch === "forge/take-updates");
  test("a fast-forward opens one pull and leaves main alone", async () => {
  test("an untouched fork fast-forwards main within one check, and opens no pull", async () => {
    const s = await checkUpstream(app, { remote: parent });
    const tip = await git(parent, "rev-parse", "refs/heads/main");
    expect(s?.taken).toEqual({ kind: "forwarded", commits: 1 });
    expect(await main()).toBe(tip);
    expect(pulls()).toHaveLength(0);
    expect(s?.behind).toBe(0);
    expect(taken()).toHaveLength(1);
    expect(listEvents(app.db, { repoId: repo.id, kind: "push" }).some((e) => JSON.stringify(e.payload).includes(tip))).toBe(true);
    expect(upstreamWords(s, s!.checkedAt)).toContain("1 commit from your parent was taken in");
    await checkUpstream(app, { remote: parent });
    expect(taken()).toHaveLength(1); // nothing new: nothing said again
  });
  test("a fork with commits of its own gets a pull, never an automatic merge", async () => {
    await mine("own.txt", "own\n");
    await theirs("p1.txt", "1\n");
    const before = await main();
    const s = await checkUpstream(app, { remote: parent });
    expect(pulls()).toHaveLength(1);
@@ -110,27 +126,23 @@
describe("taking the parent's code", () => {
    expect(p.authorId).toBe(kid.id);
    expect(s?.taken).toEqual({ kind: "pull", number: p.number, commits: 1 });
    expect(await main()).toBe(before);
    expect(await git(child, "rev-parse", "refs/heads/forge/take-updates")).toBe(await git(parent, "rev-parse", "refs/heads/main"));
    expect(taken()).toHaveLength(1);
    expect(taken()).toHaveLength(2);
    expect(upstreamWords(s, s!.checkedAt)).toContain(`1 commit from your parent is in pull #${p.number}`);
  });
  test("a second fetch with one more commit updates the same pull", async () => {
    const before = await main();
    const first = pulls()[0]!;
    await theirs("p1.txt", "1\n");
    await theirs("p1b.txt", "1b\n");
    const s = await checkUpstream(app, { remote: parent });
    expect(pulls()).toHaveLength(1);
    expect(pulls()[0]!.number).toBe(first.number);
    expect(pulls()[0]!.headOid).toBe(await git(parent, "rev-parse", "refs/heads/main"));
    expect(s?.taken).toEqual({ kind: "pull", number: first.number, commits: 2 });
    expect(await main()).toBe(before);
    expect(taken()).toHaveLength(2);
    expect(taken()).toHaveLength(3);
    const pushed = listEvents(app.db, { repoId: repo.id, kind: "pull.pushed" });
    expect(pushed).toHaveLength(1);
    expect(JSON.stringify(pushed[0]!.payload)).toContain(first.number.toString());
    await checkUpstream(app, { remote: parent });
    expect(taken()).toHaveLength(2); // nothing new: nothing said again
  });
  test("a clean merge goes on the branch, not on main", async () => {
@@ -198,6 +210,21 @@
describe("taking the parent's code", () => {
    const issues = listIssues(app.db, repo.id, { sealed: true }).filter((i) => i.title === "Take updates from root/forge");
    expect(issues).toHaveLength(1);
    expect(issues[0]!.body).toContain("a.txt");
    expect(taken()).toHaveLength(4);
    expect(taken()).toHaveLength(5);
  });
  test("a severed fork gets nothing", async () => {
    await Bun.write(
      join(app.config.dataDir, "parent.json"),
      JSON.stringify({
        upstream: "https://parent.test",
        forgeCode: { repo: "kid/forge", upstream: "root/forge", mode: "take-updates", tip: "a".repeat(40), chain: [], severedAt: new Date().toISOString() },
      }),
    );
    await theirs("p9.txt", "9\n");
    const before = await main();
    expect(await checkUpstream(app, { remote: parent })).toBeUndefined();
    expect(await main()).toBe(before);
    expect(taken()).toHaveLength(5);
  });
});
@@ -87,11 +87,11 @@
describe("the new forge screen", () => {
  test("the screen and its plan promise no update that does not happen", () =>
    withScreen(admin, async ({ tui, terminal }) => {
      const form = tui.screen.toText();
      expect(form).toContain("tell-me (default) tells the owner in their inbox");
      expect(form).toContain("take-updates (default) takes new code in by itself");
      terminal.feed("kai\x10");
      await settleApp(tui);
      const text = form + tui.screen.toText();
      expect(tui.screen.toText()).toContain("It follows this forge's code as tell-me: it tells the owner in their inbox");
      expect(tui.screen.toText()).toContain("It follows this forge's code as take-updates: it takes new code in by itself");
      expect(text).not.toMatch(/recorded for now/i);
      expect(text).not.toMatch(/keeps? (itself )?up to date|updates itself|automatically/i);
    }));
@@ -173,13 +173,13 @@
describe("the new forge screen", () => {
      expect(tui.screen.toText()).toMatch(/https:\/\/zed--forge\.test\/claim#/);
    }));
  test("the follow mode is a field: take-updates reaches parent.json", () =>
  test("the follow mode is a field: tell-me reaches parent.json", () =>
    withScreen(admin, async ({ tui, terminal }) => {
      (app.config as { forgeRepo?: string }).forgeRepo = "alice/bakery";
      try {
        terminal.feed("tuifollow" + "\t".repeat(8) + "take-updates\x10");
        terminal.feed("tuifollow" + "\t".repeat(8) + "tell-me\x10");
        await settleApp(tui);
        expect(tui.screen.toText()).toContain("take-updates");
        expect(tui.screen.toText()).toContain("tell-me");
        terminal.feed("\r");
        await settleApp(tui);
        const docs = await Promise.all(
@@ -187,7 +187,7 @@
describe("the new forge screen", () => {
            Bun.file(join(dir, "children", d, "parent.json")).json().catch(() => undefined),
          ),
        );
        expect(docs.find((d) => d?.name === "tuifollow")?.forgeCode?.mode).toBe("take-updates");
        expect(docs.find((d) => d?.name === "tuifollow")?.forgeCode?.mode).toBe("tell-me");
      } finally {
        delete (app.config as { forgeRepo?: string }).forgeRepo;
      }
		@@ -184,8 +184,8 @@ there is landing it upstream.
184	184	the API.
185	185
186	186	A fork across forges (#1085): a spawned forge's `<org>/forge` follows its
187		parent's forge code in the mode the spawner chose, `tell-me` (default) or
188		`take-updates`; `/:owner/forge/following` shows the chain to the root and
	187	parent's forge code in the mode the spawner chose, `take-updates` (default) or
	188	`tell-me`; `/:owner/forge/following` shows the chain to the root and
189	189	the owner's Sever, which cuts the link and deletes nothing (the page
190	190	and the parent's `/family` say "follows nothing since …"). `docs/SPAWN.md`
191	191	has the shape. A conflict on Take updates is a tell for the crew:
		@@ -256,8 +256,8 @@ the default branch is pushed to `child/<name>/<branch>-<tip>` at the parent,
256	256	and the pull opens there, titled by the change that landed last and naming it
257	257	(`org/forge#7`). Asking again for the same tip returns the pull already made.
258	258
259		The repository's admin changes how the forge follows its parent (`tell-me` or
260		`take-updates`) from the radio form on the same page, with `PATCH
	259	The repository's admin changes how the forge follows its parent (`take-updates` or
	260	`tell-me`) from the radio form on the same page, with `PATCH
261	261	/api/v1/forge/following {"mode"}`, with the MCP `follow_mode` tool, or by pressing `m` on the chain screen in the terminal. The
262	262	record in `parent.json` is rewritten atomically and a `forge.follow_mode` event
263	263	is appended. A non-admin is refused (403), a value outside the two modes is
		@@ -197,7 +197,7 @@ bytes in `tools/list`. After changing a tool run `bun scripts/mcp-table.ts`;
197	197	\| `signup` \| — \| Sign-ups: open (default); invite lets in only a person with an open invite link; closed refuses every new account \| 291 \|
198	198	\| `sizes` \| — \| A child forge's sizes: small, medium and large, each with CPU, memory and disk \| 196 \|
199	199	\| `snapshot_now` \| — \| Take a snapshot now, as Backups does (admin) \| 133 \|
200		\| `spawn` \| — \| Spawn a child forge \| 910 \|
	200	\| `spawn` \| — \| Spawn a child forge \| 908 \|
201	201	\| `spend` \| — \| Report what your session spent outside forge runs: who, model, tokens or dollars, issue \| 470 \|
202	202	\| `ssh_keys` \| `list`, `add`, `remove` \| Your SSH keys; add: key, remove: id \| 250 \|
203	203	\| `steer` \| — \| Say a word to one crew run by its id \| 224 \|
		@@ -95,8 +95,8 @@ reads child → parent → … → root.
95	95	`parent.json` keeps `forgeCode`: `repo`, `upstream`, `mode`, `tip` (the
96	96	upstream's tip at birth) and `chain` (the ancestors' hops, copied from the
97	97	parent's own `parent.json`, so a grandchild reads the whole chain offline).
98		The spawner chooses `followMode` in the spawn input: `tell-me` (default) or
99		`take-updates`; it is part of the plan. `/:owner/forge/following` on the
	98	The spawner chooses `followMode` in the spawn input: `take-updates` (default) or
	99	`tell-me`; it is part of the plan. A plain fork (not a spawned forge) defaults to `tell-me`. `/:owner/forge/following` on the
100	100	child shows the chain, root first, one line per hop with its mode and how
101	101	many commits of its own it had when the next hop was born (the last hop is
102	102	counted now). What the modes do is in
		@@ -125,7 +125,7 @@ learned (the parent's tip, how far behind the child is) is kept in
125	125	The owner's `followMode` decides what happens when the parent has new commits:
126	126
127	127	- `tell-me` sends one inbox card per new tip, listing its commits.
128		- `take-updates` opens one pull from the branch `forge/take-updates`
	128	- `take-updates` (the default) fast-forwards main when the fork has no commits of its own; otherwise it opens one pull from the branch `forge/take-updates`
129	129	(`TAKE_BRANCH`) holding the parent's code, and updates that same pull when
130	130	the parent moves again. The pull carries the check like any other.
131	131
		@@ -142,7 +142,7 @@ leaves. The page and the parent's tree then say it follows nothing since
142	142	the date.
143	143
144	144	A spawned forge's own code is a fork of its parent's (`<org>/forge`, chosen
145		`followMode` `tell-me` or `take-updates`; in `take-updates` the hourly check puts what the parent gained in a pull.
	145	`followMode` `take-updates` (default) or `tell-me`; in `take-updates` the hourly check fast-forwards a fork with no commits of its own, and puts what the parent gained in a pull when the fork has its own.
146	146	Once an hour, and
147	147	on demand, a forge that follows and has not severed fetches its parent's code into
148	148	`refs/upstream/*` of its own `<org>/forge` (no branch of the fork moves) and keeps
		@@ -150,10 +150,10 @@ on demand, a forge that follows and has not severed fetches its parent's code in
150	150	the count shows on the chain page, in the terminal's Chain (`c` checks now), and as
151	151	`upstream` in the API and MCP payloads. `POST /:owner/forge/following/check` (a writer,
152	152	same-origin) checks on demand; a fetch is cut at 60 s and a failure is recorded, not
153		thrown. In `take-updates` the check then puts `refs/upstream/HEAD` (a fast-forward, or a clean merge commit) on the
	153	thrown. In `take-updates` the check first fast-forwards main itself when the fork has no commits of its own (compare-and-swap, so a push in between wins). Otherwise it puts `refs/upstream/HEAD` (a fast-forward, or a clean merge commit) on the
154	154	fork's `forge/take-updates` branch and opens one pull, "Take updates from <parent>", into main, or updates
155	155	that pull when it is open (`spawn/take.ts`); the fork's check runs on it like on any pull and a person merges it.
156		Main is never moved, so nothing deploys by itself. It is recorded as `taken` in `upstream.json` (the chain line
	156	Main is moved only by that untouched-fork fast-forward; a fork with its own commits gets the pull and a person merges it. It is recorded as `taken` in `upstream.json` (the chain line
157	157	reads "N commits from your parent are in pull #P") and as a `forge.updates_taken` event; a pull closed unmerged
158	158	is not reopened until the parent moves again. `forge/take-updates` belongs to the check: a commit a person pushes there is overwritten by the next check that finds something different to put on it (open a branch of your own to build on it). On a conflict nothing changes and one open issue,
159	159	"Take updates from <parent>", names the files. In `tell-me`, a new parent tip makes one inbox card for the owner (an issue on the fork assigned to them, "Your parent forge has N new commits", linking the chain page); `toldTip` in `upstream.json` keeps it to one per tip, and `take-updates` or a severed link makes none. Its chain
		@@ -3,7 +3,7 @@
3	3	A fork follows its upstream in one of three modes, said in one line on its page:
4	4
5	5	- Follows ann/yard automatically (`take-updates`): new code is merged as it lands; a conflict goes to the crew.
6		- Proposes updates from ann/yard (`tell-me`, the default): a fork with nothing of its own still moves along; one with work of its own is told, and takes updates when its owner chooses.
	6	- Takes updates from ann/yard (`take-updates`, the default for a new forge): a fork with no commits of its own fast-forwards by itself; one with commits of its own gets a pull to merge. A plain fork defaults to `tell-me`: its owner is told and chooses.
7	7	- Does not follow ann/yard (`dont-follow`, #608): nothing is fast-forwarded, merged or announced, and the crew is never asked to converge. The fork can still offer its changes up.
8	8
9	9	The line shows only on a fork, to anyone who can see the page.
		@@ -1,7 +1,7 @@
1	1	/** How a plain fork follows its parent: one row per fork that chose; none means the default. */
2	2
3	3	import type { Database } from "bun:sqlite";
4		import { DEFAULT_MODE, FOLLOW_MODES } from "../spawn/chain.ts";
	4	import { FOLLOW_MODES, type FollowMode } from "../spawn/chain.ts";
5	5
6	6	/**
7	7	* A plain fork's modes: the chain's two, and `dont-follow` (#608), which a
		@@ -13,9 +13,12 @@ export type ForkFollowMode = (typeof FORK_FOLLOW_MODES)[number];
13	13	export const isForkFollowMode = (v: unknown): v is ForkFollowMode =>
14	14	typeof v === "string" && (FORK_FOLLOW_MODES as readonly string[]).includes(v);
15	15
	16	/** A plain fork still proposes by default; only a spawned forge takes updates. */
	17	export const FORK_DEFAULT_MODE: FollowMode = "tell-me";
	18
16	19	export function forkFollowMode(db: Database, repoId: string): ForkFollowMode {
17	20	const row = db.query<{ mode: ForkFollowMode }, [string]>("SELECT mode FROM fork_follow WHERE repo_id = ?1").get(repoId);
18		return row?.mode ?? DEFAULT_MODE;
	21	return row?.mode ?? FORK_DEFAULT_MODE;
19	22	}
20	23
21	24	export function setForkFollowMode(db: Database, repoId: string, mode: ForkFollowMode): void {
		@@ -24,7 +27,7 @@ export function setForkFollowMode(db: Database, repoId: string, mode: ForkFollow
24	27	).run(repoId, mode);
25	28	}
26	29
27		/** The stored modes of these repos in one query; a repo with none stored is absent (it follows `DEFAULT_MODE`). */
	30	/** The stored modes of these repos in one query; a repo with none stored is absent (it follows `FORK_DEFAULT_MODE`). */
28	31	export function forkFollowModes(db: Database, repoIds: readonly string[]): Map<string, ForkFollowMode> {
29	32	if (repoIds.length === 0) return new Map();
30	33	const rows = db
		@@ -20,7 +20,8 @@ import { err, ok, type Result } from "../kernel/result.ts";
20	20
21	21	export const FOLLOW_MODES = ["tell-me", "take-updates"] as const;
22	22	export type FollowMode = (typeof FOLLOW_MODES)[number];
23		export const DEFAULT_MODE: FollowMode = "tell-me";
	23	/** What a new forge follows with; a link on disk with no mode is read as `tell-me`, as it always was. */
	24	export const DEFAULT_MODE: FollowMode = "take-updates";
24	25
25	26	/** One forge in the chain, as recorded when the hop below it was made. */
26	27	export interface Hop {
		@@ -98,7 +99,7 @@ export async function forgeLinkOf(app: App): Promise<ForgeLink \| undefined> {
98	99	return {
99	100	repo: l["repo"],
100	101	upstream: l["upstream"],
101		mode: isMode(l["mode"]) ? l["mode"] : DEFAULT_MODE,
	102	mode: isMode(l["mode"]) ? l["mode"] : "tell-me",
102	103	tip: typeof l["tip"] === "string" && TIP.test(l["tip"]) ? l["tip"] : "",
103	104	chain,
104	105	...(severedAt === undefined ? {} : { severedAt }),
		@@ -2,8 +2,9 @@
2	2	* Follow words (#7199): what each follow mode does, in one plain line, so
3	3	* `/forges/new`, the terminal's new-forge screen and MCP `spawn` say the
4	4	* same thing. They describe `src/spawn/upstream.ts`: `tell-me` sends the
5		* owner an inbox card when this forge's code moves; `take-updates` opens the
6		* one `forge/take-updates` pull (`src/spawn/take.ts`), which a person merges.
	5	* owner an inbox card when this forge's code moves; `take-updates` (the
	6	* default) fast-forwards a forge the owner has not changed, and otherwise
	7	* opens the one `forge/take-updates` pull (`src/spawn/take.ts`), which a person merges.
7	8	*/
8	9
9	10	import type { FollowMode } from "./chain.ts";
		@@ -15,12 +16,12 @@ export const FOLLOW_LABELS: Readonly<Record<FollowMode, string>> = {
15	16
16	17	export const FOLLOW_WORDS: Readonly<Record<FollowMode, string>> = {
17	18	"tell-me": "tells the owner in their inbox when this forge's code moves.",
18		"take-updates": "opens a pull with the new code, and a person merges it.",
	19	"take-updates": "takes new code in by itself; opens a pull once the repository has commits of its own.",
19	20	};
20	21
21	22	/** One line naming both modes, for the terminal's hint. */
22	23	export const FOLLOW_LINE =
23		`tell-me (default) ${FOLLOW_WORDS["tell-me"]} take-updates ${FOLLOW_WORDS["take-updates"]}`;
	24	`take-updates (default) ${FOLLOW_WORDS["take-updates"]} tell-me ${FOLLOW_WORDS["tell-me"]}`;
24	25
25	26	/** The same, short enough for an MCP field (60 bytes); docs/MCP.md has the long words. */
26		export const FOLLOW_SHORT = "tell-me: an inbox card; take-updates: a pull a person merges";
	27	export const FOLLOW_SHORT = "take-updates: merges itself or a pull; tell-me: inbox card";
		@@ -70,7 +70,7 @@ export interface SpawnInput {
70	70	readonly budgetUsd?: unknown;
71	71	/** One line describing a fresh app to start in the child, beside the forked ones; optional. */
72	72	readonly fresh?: unknown;
73		/** How the child follows the forge's code: `tell-me` (default) or `take-updates`. */
	73	/** How the child follows the forge's code: `take-updates` (default) or `tell-me`. */
74	74	readonly followMode?: unknown;
75	75	/** How big the child is: `small`, `medium` or `large`; optional. */
76	76	readonly size?: unknown;
		@@ -116,7 +116,7 @@ export interface SpawnPlan {
116	116	readonly forWhom?: string;
117	117	/** A fresh app, present only when asked for. */
118	118	readonly fresh?: PlannedFresh;
119		/** How the child follows its parent's forge code; absent means `tell-me`. */
	119	/** How the child follows its parent's forge code; absent means `take-updates`. */
120	120	readonly followMode?: FollowMode;
121	121	/** The child's size, present only when chosen. */
122	122	readonly size?: Size;
		@@ -1,11 +1,12 @@
1	1	/**
2	2	* Taking the parent's code, for a forge that follows in `take-updates`
3	3	* mode. Once the hourly fetch has put the parent's tip at
4		* `refs/upstream/HEAD`, this puts a fast-forward, or a merge commit when git
5		* merges the two without conflict, on one branch, `forge/take-updates`, and
	4	* `refs/upstream/HEAD`, a fork the owner has not changed (its default branch
	5	* is an ancestor of the parent's) is fast-forwarded in place. Otherwise this
	6	* puts a merge commit, when git merges the two without conflict, on one branch, `forge/take-updates`, and
6	7	* opens one pull from it into the default branch (or updates the one already
7		* open). The fork's check runs on it like on any pull; a person merges it.
8		* It never moves the default branch, and production follows that branch.
	8	* open). The fork's check runs on it like on any pull.
	9	* That pull never moves the default branch; a person merges it.
9	10	* A conflict changes nothing; it opens (or finds) one issue naming the files.
10	11	*/
11	12
		@@ -26,6 +27,7 @@ import type { ForgeLink } from "./chain.ts";
26	27	/** What the last check did with the parent's new commits; absent when it did nothing. */
27	28	export type Taken =
28	29	\| { readonly kind: "pull"; readonly number: number; readonly commits: number }
	30	\| { readonly kind: "forwarded"; readonly commits: number }
29	31	\| { readonly kind: "conflict"; readonly files: readonly string[]; readonly issue: number \| null };
30	32
31	33	export const takeTitle = (upstream: string): string => `Take updates from ${upstream}`;
		@@ -120,6 +122,27 @@ export async function takeFromParent(app: App, link: ForgeLink): Promise<Taken \|
120	122	const count = await runGit(["rev-list", "--count", `${head}..${up}`], { cwd: dir });
121	123	const commits = count.ok ? Number(count.value.trim()) \|\| 0 : 0;
122	124
	125	// A forge that takes updates and whose owner has not changed the repository:
	126	// the parent's code is a pure fast-forward, with nothing of theirs to review it against.
	127	// A forge that only tells (and is pressed to take) still gets the pull.
	128	if (base === head && link.mode === "take-updates") {
	129	const ref = `refs/heads/${branch}`;
	130	// Compare-and-swap: a push to the branch since `head` was read wins, and the next check looks again.
	131	if (!(await runGit(["update-ref", ref, up, head], { cwd: dir })).ok) return undefined;
	132	app.bus.append({
	133	kind: "push",
	134	repoId: repo.id,
	135	actorId: owner.id,
	136	payload: { updates: [{ ref, oldOid: head, newOid: up }], followed: link.upstream },
	137	});
	138	app.bus.append({
	139	kind: "forge.updates_taken",
	140	repoId: repo.id,
	141	payload: { repo: link.repo, upstream: link.upstream, from: head, to: up, commits, pull: null },
	142	});
	143	return { kind: "forwarded", commits };
	144	}
	145
123	146	const had = await resolveOid(dir, `refs/heads/${TAKE_BRANCH}`);
124	147	let to = up;
125	148	if (base !== head) {
		@@ -68,6 +68,8 @@ export async function upstreamState(app: App): Promise<UpstreamState \| undefined
68	68	function readTaken(v: unknown): { taken?: Taken } {
69	69	if (typeof v !== "object" \|\| v === null) return {};
70	70	const t = v as Record<string, unknown>;
	71	if (t["kind"] === "forwarded" && typeof t["commits"] === "number")
	72	return { taken: { kind: "forwarded", commits: t["commits"] } };
71	73	if (t["kind"] === "pull" && typeof t["number"] === "number" && typeof t["commits"] === "number")
72	74	return { taken: { kind: "pull", number: t["number"], commits: t["commits"] } };
73	75	if (t["kind"] === "conflict" && Array.isArray(t["files"]))
		@@ -221,6 +223,8 @@ export function upstreamWords(s: UpstreamState \| undefined, now = Date.now()): s
221	223	const mins = Math.max(0, Math.floor((now - s.checkedAt) / 60_000));
222	224	const when = mins < 1 ? "just now" : mins < 60 ? `${mins} min ago` : `${Math.floor(mins / 60)} h ago`;
223	225	if (s.error !== "") return `could not check your parent: ${s.error} (${when})`;
	226	if (s.taken?.kind === "forwarded")
	227	return `${s.taken.commits} commit${s.taken.commits === 1 ? "" : "s"} from your parent ${s.taken.commits === 1 ? "was" : "were"} taken in (checked ${when})`;
224	228	if (s.taken?.kind === "pull")
225	229	return `${s.taken.commits} commit${s.taken.commits === 1 ? "" : "s"} from your parent ${s.taken.commits === 1 ? "is" : "are"} in pull #${s.taken.number} (checked ${when})`;
226	230	if (s.taken?.kind === "conflict")