6d21ae9 · 37f854b · 9a5254d · 8e2125c · 5b33981
@@ -307,14 +307,26 @@
one undo.
- **Close as not doing** closes every open issue that is the limb's own,
  the limb included, as `dropped`, with the reason said on each. What other
  work outside the limb also waits for is not the limb's to close.
- **Raise** and **Lower** (#1064) move the limb one place among its
  siblings — the pillars and Later at the top, a milestone's limbs under
  it. The place is stored per group of siblings (`limb_place`), kept across
  a restart, and is the order the limbs are listed in; a limb never placed
  follows the placed ones, by number. The preview shows the new order and
  how the top of the ready list changes. Once a person has set an order in
  a repository, the crew's ready order follows it: an issue beneath a
  higher limb comes before one beneath a lower limb (beneath two limbs, the
  higher), after them come issues beneath no limb, and within a limb the
  order is the old one — what it frees, then age. Until then nothing about
  the ready order changes. It is one fleet row, the verb `place`; undo puts
  the place back. Through the API and the MCP `limb` tool (`action` raise or
  lower, `under` when the limb sits in several places), dry-run by default.
An umbrella or the gate is the plan's own and is not filed. A leaf beneath
a limb that is not deferred cannot be deferred alone: defer the limb. A
candidate to trim offers Defer first. Raising and lowering a limb against
its siblings is #760; handing one to the planner is #761.
candidate to trim offers Defer first. Handing one to the planner is #761.
The same is `POST /api/v1/repos/:owner/:name/milestones/:number/limb`
`{ "action": "defer" | "resume" | "close", "reason"?, "pillar"?, "dryRun"? }`
`{ "action": "defer" | "resume" | "close" | "raise" | "lower", "reason"?, "pillar"?, "under"?, "dryRun"? }`
and the MCP's `limb`, both a dry run unless `dryRun` is false. Applying and
undoing take an admin token of a person who administers the repository; an
agent may look and never apply.
@@ -178,6 +178,7 @@
export const GATE: readonly string[] = [
  "test/issues.test.ts",
  "test/kernel.test.ts",
  "test/keys.test.ts",
  "test/limb_order.test.ts",
  "test/limbs.test.ts",
  "test/live-pages.test.ts",
  "test/live.test.ts",
@@ -34,6 +34,7 @@
import {
} from "../core/issues.ts";
import { listCrewRoles } from "../core/agents.ts";
import { joinMany } from "../core/pulls.ts";
import { seating, type Seating } from "../core/limb_seats.ts";
import { pillarsOf, type Pillars } from "../core/pillars.ts";
import {
  canAdmin,
@@ -178,6 +179,16 @@
function loadTargets(
  const pillars = new Map<string, Pillars>();
  for (const [repoId, repo] of repos) pillars.set(repoId, pillarsOf(app.db, repo));
  const under = umbrellasOver(app, ids, [...pillars.values()]);
  // Read on the first ask, once for a repository: only `place` wants it.
  const seatings = new Map<string, Seating>();
  const seatingOf = (repo: Repo) => () => {
    let seats = seatings.get(repo.id);
    if (seats === undefined) {
      seats = seating(app.db, repo);
      seatings.set(repo.id, seats);
    }
    return seats;
  };
  const peers: ReadonlySet<string> = new Set(ids);
  const pull = (id: string) => {
    const p = pulls.get(id);
@@ -207,6 +218,7 @@
function loadTargets(
        planner: planners.get(repo.id) ?? null,
        pillars: pillars.get(repo.id)!,
        under: under.get(id) ?? [],
        seating: seatingOf(repo),
        peers,
        ...(viewer === undefined
          ? {}
@@ -16,6 +16,11 @@
 *   one reason said on each — and never what something outside the limb
 *   also waits for.
 *
 * - `raise` and `lower` move the limb one place among its siblings (#1064),
 *   and the crew takes ready work in that order. One row: the limb, holding
 *   its seat (`core/limb_seats.ts`). The preview shows the new order and how
 *   the top of the ready list changes.
 *
 * Who may is the fleet's rule, unchanged: a person who administers the
 * repository; an agent may preview and never apply.
 */
@@ -23,6 +28,9 @@
import type { App } from "../app.ts";
import type { FleetValue, Operation } from "../core/fleet_ops.ts";
import type { Issue } from "../core/issues.ts";
import { readyNow } from "../core/dependencies.ts";
import { limbRanks, withGroup } from "../core/limb_order.ts";
import { parseSeat, seating } from "../core/limb_seats.ts";
import { readPlan } from "../core/milestones.ts";
import { isStructural, pillarsOf } from "../core/pillars.ts";
import { canRead, type Repo } from "../core/repos.ts";
@@ -35,7 +43,7 @@
import {
  type Plan,
} from "./fleet.ts";
export const LIMB_ACTIONS = ["defer", "resume", "close"] as const;
export const LIMB_ACTIONS = ["defer", "resume", "close", "raise", "lower"] as const;
export type LimbAction = (typeof LIMB_ACTIONS)[number];
export const isLimbAction = (value: unknown): value is LimbAction =>
@@ -47,6 +55,8 @@
export interface LimbRequest {
  readonly reason?: string;
  /** For `resume`: the pillar to put it back under; absent leaves it under none. */
  readonly pillar?: string;
  /** For `raise` and `lower`: among whose limbs, `top` or a milestone's number; absent when the limb sits in one place. */
  readonly under?: string;
}
/** An issue an action touches or takes along, as a person reads it. */
@@ -62,8 +72,17 @@
export interface LimbReach {
  readonly taken: readonly LimbIssue[];
  /** For `defer` and `close`: what beneath it stays, because something outside the limb still waits for it. */
  readonly kept: readonly LimbIssue[];
  /** For `raise` and `lower`: the limbs of that group as they would stand, and the top of the ready list before and after. */
  readonly order?: readonly LimbIssue[];
  readonly ready?: {
    readonly before: readonly LimbIssue[];
    readonly after: readonly LimbIssue[];
  };
}
/** How many ready issues the preview shows: the top of the list. */
const TOP_READY = 5;
const brief = (issue: Issue): LimbIssue => ({
  number: issue.number,
  title: issue.title,
@@ -72,6 +91,66 @@
const brief = (issue: Issue): LimbIssue => ({
const fail = (code: FleetError["code"], message: string) =>
  err<FleetError>({ code, message });
/** One step up or down among the limb's siblings, with the order and the ready list it makes. */
function move(
  app: App,
  repo: Repo,
  limb: Issue,
  request: LimbRequest,
  where: string,
): Result<
  { query: string; action: { verb: string; value: FleetValue }; reach: LimbReach },
  FleetError
> {
  const seats = seating(app.db, repo);
  const held = seats.of(limb.id).flatMap((s) => parseSeat(s) ?? []);
  const under = request.under?.trim().toLowerCase();
  if (under !== undefined && under !== "top" && !/^[1-9][0-9]{0,8}$/.test(under))
    return fail("bad_action", "under is top, or the number of a milestone");
  const seat =
    under === undefined
      ? held.length === 1
        ? held[0]
        : undefined
      : held.find((s) => s.group === under);
  if (seat === undefined)
    return fail(
      "bad_action",
      held.length === 0 || under !== undefined
        ? "it is not one of the limbs of a milestone, so it has no place to move"
        : "it is a limb of several milestones: say which with under",
    );
  const to = seat.place + (request.action === "raise" ? -1 : 1);
  const size = seats.size(seat.group);
  if (to < 1) return fail("bad_action", "it is first already");
  if (to > size) return fail("bad_action", "it is last already");
  const ids = [...seats.order(seat.group)];
  ids.splice(seat.place - 1, 1);
  ids.splice(to - 1, 0, limb.id);
  const group = seats.parentId(seat.group)!;
  const after = readyNow({
    ...seats.graph,
    limbRank: limbRanks(seats.tree, withGroup(seats.places, group, ids)),
  });
  const byId = new Map(seats.graph.issues.map((i) => [i.id, i]));
  return ok({
    query: `${where} number:${limb.number}`,
    action: { verb: "place", value: `${seat.group}:${to}` },
    reach: {
      limb: brief(limb),
      taken: [],
      kept: [],
      order: ids.flatMap((id) => byId.get(id) ?? []).map(brief),
      ready: {
        before: readyNow(seats.graph)
          .slice(0, TOP_READY)
          .map((r) => brief(r.issue)),
        after: after.slice(0, TOP_READY).map((r) => brief(r.issue)),
      },
    },
  });
}
/** The fleet operation a limb action is, and what it reaches. */
function shape(
  app: App,
@@ -93,6 +172,8 @@
function shape(
    return fail("not_found", "no such milestone here");
  const limb = brief(rows.own[0]);
  const where = `issue repo:${repo.ownerName}/${repo.name}`;
  if (request.action === "raise" || request.action === "lower")
    return move(app, repo, rows.own[0], request, where);
  if (request.action === "close") {
    const reason = (request.reason ?? "").trim();
    if (reason === "")
@@ -14,6 +14,7 @@
import { getIssuesByIds, type CloseReason, type Issue } from "./issues.ts";
import { pillarsOf, structuralIds } from "./pillars.ts";
import { getRepoById } from "./repos.ts";
import { unadoptedAmong } from "../crew/direct.ts";
import { limbRanks, limbTree, readPlaces } from "./limb_order.ts";
export type DependencyError = "self" | "cross_repo" | "cycle" | "not_an_issue";
@@ -215,6 +216,12 @@
export interface Graph {
   * words, as every surface says it (`deferredWhy`).
   */
  readonly deferred: ReadonlyMap<string, string>;
  /**
   * Where each issue stands in the order of the limbs (#1064), the first
   * limb that holds it, lower first. Only when a person has set an order
   * here; absent, the ready order is the one that never knew limbs.
   */
  readonly limbRank?: ReadonlyMap<string, number>;
}
/**
@@ -318,7 +325,16 @@
export function repoGraph(
  );
  const repo = getRepoById(db, repoId);
  const set = repo === undefined ? undefined : pillarsOf(db, repo);
  const places = readPlaces(db, repoId);
  return {
    ...(set === undefined || places.size === 0
      
        sentinelcrew
        1mo ago
        
      
      This gate is what undo has to bring back. Today it only flips one way: once a group is stored, limbRank is on for the repository even after every move is undone.
    
      ? {}
      : {
          limbRank: limbRanks(
            limbTree({ issues, edges: kept }, set),
            places,
          ),
        }),
    issues,
    unadopted:
      repo === undefined ? new Set() : unadoptedAmong(db, repo, issues),
@@ -509,14 +525,22 @@
function clearNow(graph: Graph): Ranked[] {
 * reader's suggestion only once someone who writes here adopted it, and
 * never the plan's own furniture: an umbrella or the Later gate is not
 * work. What a free crew slot takes next.
 *
 * Where a person has ordered the limbs (`limb_order.ts`), an issue beneath
 * a higher limb comes before one beneath a lower limb, and one beneath no
 * limb after them all; within a limb the order is the one above.
 */
export function readyNow(graph: Graph): Ranked[] {
  return clearNow(graph).filter(
  const ready = clearNow(graph).filter(
    (r) =>
      !graph.unadopted.has(r.issue.id) &&
      !graph.structural.has(r.issue.id) &&
      !graph.deferred.has(r.issue.id),
  );
  const rank = graph.limbRank;
  if (rank === undefined) return ready;
  const of = (r: Ranked) => rank.get(r.issue.id) ?? Number.MAX_SAFE_INTEGER;
  return ready.sort((a, b) => of(a) - of(b));
}
/**
@@ -0,0 +1,213 @@
/**
 * The order of the limbs (#1064): which of a milestone's limbs comes first,
 * set by a person, and the crew's ready order that follows it.
 *
 * `limbTree` reads the shape once from a graph: what each issue waits for
 * with the plan's furniture left out, the top of the plan, and which
 * children are limbs (they bring a tree of their own) rather than leaves.
 * A person's places are stored per group of siblings — `TOP` for the top of
 * the plan, else the issue whose limbs they are — and a limb with no place
 * of its own follows the placed ones, by number. `limbRanks` walks the
 * ordered tree once: an issue's rank is the first limb that holds it, so one
 * beneath two limbs takes the higher. Nothing here queries per issue.
 */
import type { Database } from "bun:sqlite";
import type { Graph } from "./dependencies.ts";
import type { Issue } from "./issues.ts";
import { isStructural, type Pillars } from "./pillars.ts";
/** The group of siblings at the top of the plan. */
export const TOP = "";
/** Stored places: group → limb → place (1 is first). */
export type Places = ReadonlyMap<string, ReadonlyMap<string, number>>;
export interface LimbTree {
  /** Every issue that waits for something beyond the furniture, and what for. */
  readonly waitsFor: ReadonlyMap<string, readonly string[]>;
  readonly waitedBy: ReadonlyMap<string, readonly string[]>;
  /** Issues that wait for anything at all, the furniture included. */
  readonly waits: ReadonlySet<string>;
  /** The top-level limbs in their natural order: the pillars and Later, or the plan's roots. */
  readonly top: readonly Issue[];
  /** What an issue waits for directly, as its milestone shows it. */
  childrenOf(id: string): readonly string[];
  /** The children that bring a tree of their own, by number. */
  limbsOf(id: string): readonly string[];
  /** Every issue that has children. */
  parents(): readonly string[];
}
export function limbTree(
  graph: Pick<Graph, "issues" | "edges">,
  set: Pillars,
): LimbTree {
  const byId = new Map(graph.issues.map((i) => [i.id, i]));
  const waitsFor = new Map<string, string[]>();
  const waitedBy = new Map<string, string[]>();
  const waits = new Set<string>();
  for (const edge of graph.edges) {
    waits.add(edge.issueId);
    if (isStructural(set, edge.blockedById)) continue;
    waitsFor.set(edge.issueId, [
      ...(waitsFor.get(edge.issueId) ?? []),
      edge.blockedById,
    ]);
    waitedBy.set(edge.blockedById, [
      ...(waitedBy.get(edge.blockedById) ?? []),
      edge.issueId,
    ]);
  }
  // Work behind the gate is Later's whether or not the Later umbrella waits
  // for it: its milestone counts what the map's Later row counts.
  const behindGate =
    set.gate === undefined
      ? []
      : graph.edges
          .filter(
            (e) =>
              e.blockedById === set.gate!.id && !isStructural(set, e.issueId),
          )
          .map((e) => e.issueId);
  if (set.later !== undefined && behindGate.length > 0) waits.add(set.later.id);
  const childrenOf = (id: string): readonly string[] =>
    id === set.later?.id
      ? [...new Set([...(waitsFor.get(id) ?? []), ...behindGate])]
      : (waitsFor.get(id) ?? []);
  const top: Issue[] =
    set.pillars.length > 0
      ? [
          ...set.pillars.map((p) => p.umbrella),
          ...(set.later === undefined ? [] : [set.later]),
        ]
      : graph.issues.filter(
          (i) =>
            i.state === "open" &&
            childrenOf(i.id).length > 0 &&
            !(waitedBy.get(i.id) ?? []).some(
              (id) => byId.get(id)?.state === "open",
            ),
        );
  const parents = [
    ...new Set([
      ...waitsFor.keys(),
      ...(set.later !== undefined && behindGate.length > 0 ? [set.later.id] : []),
    ]),
  ];
  return {
    waitsFor,
    waitedBy,
    waits,
    top,
    childrenOf,
    parents: () => parents,
    limbsOf(id) {
      const children = childrenOf(id)
        .map((c) => byId.get(c))
        .filter((i): i is Issue => i !== undefined)
        .sort((a, b) => a.number - b.number);
      // A child is a limb when it brings a tree of its own; one that only
      // waits for its siblings is a leaf in an order.
      const siblings = new Set(children.map((c) => c.id));
      return children
        .filter((c) => (waitsFor.get(c.id) ?? []).some((w) => !siblings.has(w)))
        .map((c) => c.id);
    },
  };
}
/** Every stored place of one repository, in one read. */
export function readPlaces(db: Database, repoId: string): Places {
  const out = new Map<string, Map<string, number>>();
  for (const row of db
    .query<{ parent_id: string; issue_id: string; place: number }, [string]>(
      `SELECT parent_id, issue_id, place FROM limb_place WHERE repo_id = ?1`,
    )
    .all(repoId)) {
    const group = out.get(row.parent_id) ?? new Map<string, number>();
    group.set(row.issue_id, row.place);
    out.set(row.parent_id, group);
  }
  return out;
}
/** One group of siblings in order: the placed ones by place, then the rest as they came. */
export function seated(
  places: Places,
  group: string,
  ids: readonly string[],
): string[] {
  const mine = places.get(group);
  if (mine === undefined) return [...ids];
  const at = (id: string) => mine.get(id);
  const placed = ids
    .filter((id) => at(id) !== undefined)
    .sort((a, b) => at(a)! - at(b)!);
  return [...placed, ...ids.filter((id) => at(id) === undefined)];
}
/** Every group that has limbs, each in order. */
export function groupsOf(tree: LimbTree, places: Places): Map<string, string[]> {
  const out = new Map<string, string[]>();
  const top = tree.top.map((i) => i.id);
  if (top.length > 0) out.set(TOP, seated(places, TOP, top));
  for (const id of tree.parents()) {
    const limbs = tree.limbsOf(id);
    if (limbs.length > 0) out.set(id, seated(places, id, limbs));
  }
  return out;
}
/**
 * Each issue's rank: the first limb, in the order of the limbs, that holds
 * it. A lower rank is higher. Issues beneath no limb have none.
 */
export function limbRanks(tree: LimbTree, places: Places): Map<string, number> {
  const rank = new Map<string, number>();
  const seen = new Set<string>();
  let next = 0;
  const visit = (id: string): void => {
    if (seen.has(id)) return;
    seen.add(id);
    const n = next++;
    if (!rank.has(id)) rank.set(id, n);
    for (const child of tree.childrenOf(id)) if (!rank.has(child)) rank.set(child, n);
    for (const limb of seated(places, id, tree.limbsOf(id))) visit(limb);
  };
  for (const id of seated(places, TOP, tree.top.map((i) => i.id))) visit(id);
  return rank;
}
/** The places with one group set to this order, 1 for the first. */
export function withGroup(
  places: Places,
  group: string,
  ids: readonly string[],
): Places {
  const next = new Map(places);
  next.set(group, new Map(ids.map((id, n) => [id, n + 1])));
  return next;
}
/** Keep one group's order. */
export function savePlaces(
  db: Database,
      
        sentinelcrew
        1mo ago
        
      
      High: this always writes rows, so moving a limb back to where it started (undo, or a raise followed by a lower) leaves limb_place non-empty, and the ready order stays limb-ranked for good. When ids equals the group's natural order (seated(new Map(), group, natural)), delete the group's rows and insert nothing.
    
  repoId: string,
  group: string,
  ids: readonly string[],
): void {
  db.transaction(() => {
    db.query(`DELETE FROM limb_place WHERE repo_id = ?1 AND parent_id = ?2`).run(
      repoId,
      group,
    );
    ids.forEach((id, n) =>
      db
        .query(
          `INSERT INTO limb_place (repo_id, parent_id, issue_id, place) VALUES (?1, ?2, ?3, ?4)`,
        )
        .run(repoId, group, id, n + 1),
    );
  })();
}
@@ -0,0 +1,104 @@
/**
 * A limb's seat (#1064): its place among its siblings, as a fleet row holds
 * it. A seat is `<group>:<place>`, the group being `top` or the number of
 * the issue whose limbs these are, the place counted from 1. A limb that is
 * a limb of several issues holds one seat in each. Moving a limb rewrites
 * its group's order whole, so the fleet's undo — the seat from before — puts
 * the others back with it.
 */
import { repoGraph, type Graph } from "./dependencies.ts";
import type { Database } from "bun:sqlite";
import {
  groupsOf,
  limbTree,
  type LimbTree,
  readPlaces,
  savePlaces,
  TOP,
  type Places,
} from "./limb_order.ts";
import { pillarsOf } from "./pillars.ts";
import type { Repo } from "./repos.ts";
export interface Seating {
  /** The seats an issue holds, `top` first, then by the number of the group. */
  of(issueId: string): readonly string[];
  /** How many limbs sit in a group (`top` or an issue number). */
  size(group: string): number;
  /** A group's limbs, in order, as issue ids. */
  order(group: string): readonly string[];
  /** The id of the issue a group names. */
  parentId(group: string): string | undefined;
  readonly places: Places;
  /** What it was read from, for a caller that asks more of the same graph. */
  readonly graph: Graph;
  readonly tree: LimbTree;
}
const SEAT = /^(top|[1-9][0-9]{0,8}):([1-9][0-9]{0,5})$/;
/** A seat's group and place, or nothing when it is not one. */
export function parseSeat(
  value: unknown,
): { group: string; place: number } | undefined {
  const m = typeof value === "string" ? SEAT.exec(value) : null;
  return m === null ? undefined : { group: m[1]!, place: Number(m[2]) };
}
export function seating(
  db: Database,
  repo: Repo,
  read?: { graph: Graph; tree: LimbTree; places: Places },
): Seating {
  const graph = read?.graph ?? repoGraph(db, repo.id);
  const tree = read?.tree ?? limbTree(graph, pillarsOf(db, repo));
  const places = read?.places ?? readPlaces(db, repo.id);
  const groups = groupsOf(tree, places);
  const numberOf = new Map(graph.issues.map((i) => [i.id, i.number]));
  const idOf = new Map(graph.issues.map((i) => [String(i.number), i.id]));
  const name = (id: string): string =>
    id === TOP ? "top" : String(numberOf.get(id) ?? 0);
  const keys = [...groups.keys()].sort((a, b) =>
    a === TOP ? -1 : b === TOP ? 1 : (numberOf.get(a) ?? 0) - (numberOf.get(b) ?? 0),
  );
  const held = new Map<string, string[]>();
  for (const key of keys)
    groups.get(key)!.forEach((id, n) =>
      held.set(id, [...(held.get(id) ?? []), `${name(key)}:${n + 1}`]),
    );
  const keyOf = (group: string): string =>
    group === "top" ? TOP : (idOf.get(group) ?? "\0");
  return {
    of: (id) => held.get(id) ?? [],
    size: (group) => groups.get(keyOf(group))?.length ?? 0,
    order: (group) => groups.get(keyOf(group)) ?? [],
    parentId: (group) => (group === "top" ? TOP : idOf.get(group)),
    places,
    graph,
    tree,
  };
}
/** Seat a limb at a place in its group; undefined when it sits there, else why not. */
export function moveLimb(
  db: Database,
  repo: Repo,
  issueId: string,
  seat: { group: string; place: number },
): string | undefined {
  const seats = seating(db, repo);
  const ids = [...seats.order(seat.group)];
  const at = ids.indexOf(issueId);
  if (at < 0) return "it is not one of those limbs";
  if (seat.place > ids.length) return `there are only ${ids.length} limbs there`;
  ids.splice(at, 1);
  ids.splice(seat.place - 1, 0, issueId);
  const group = seats.parentId(seat.group)!;
  // Back where it began is no order at all: the rows go, and the crew's
  // ready order is the natural one again.
  const natural = group === TOP ? seats.tree.top.map((i) => i.id) : seats.tree.limbsOf(group);
  const same = ids.length === natural.length && ids.every((id, n) => id === natural[n]);
  savePlaces(db, repo.id, group, same ? [] : ids);
  return undefined;
}
@@ -15,6 +15,14 @@
import type { Database } from "bun:sqlite";
import { deferredIn, repoGraph, type Graph } from "./dependencies.ts";
import {
  limbTree,
  readPlaces,
  seated,
  TOP,
  type LimbTree,
  type Places,
} from "./limb_order.ts";
import type { Issue } from "./issues.ts";
import {
  isStructural,
@@ -106,6 +114,8 @@
export interface Milestone extends Limb {
}
export interface Plan {
  /** What the plan was read from, for a caller that asks more of the same graph. */
  readonly read: { readonly graph: Graph; readonly tree: LimbTree; readonly places: Places };
  /** The top-level limbs, in order: the pillars and Later, or the plan's roots. */
  readonly limbs: readonly Limb[];
  /**
@@ -165,39 +175,10 @@
export function readPlan(
  const byId = new Map(graph.issues.map((i) => [i.id, i]));
  const byNumber = new Map(graph.issues.map((i) => [i.number, i]));
  // What each issue waits for directly, furniture left out.
  const waitsFor = new Map<string, string[]>();
  const waitedBy = new Map<string, string[]>();
  const waits = new Set<string>();
  for (const edge of graph.edges) {
    waits.add(edge.issueId);
    if (isStructural(set, edge.blockedById)) continue;
    waitsFor.set(edge.issueId, [
      ...(waitsFor.get(edge.issueId) ?? []),
      edge.blockedById,
    ]);
    waitedBy.set(edge.blockedById, [
      ...(waitedBy.get(edge.blockedById) ?? []),
      edge.issueId,
    ]);
  }
  // Work behind the gate is Later's whether or not the Later umbrella waits
  // for it: its milestone counts what the map's Later row counts.
  const behindGate =
    set.gate === undefined
      ? []
      : graph.edges
          .filter(
            (e) =>
              e.blockedById === set.gate!.id && !isStructural(set, e.issueId),
          )
          .map((e) => e.issueId);
  if (set.later !== undefined && behindGate.length > 0) waits.add(set.later.id);
  /** What an issue waits for directly, as its milestone shows it. */
  const childrenOf = (id: string): string[] =>
    id === set.later?.id
      ? [...new Set([...(waitsFor.get(id) ?? []), ...behindGate])]
      : (waitsFor.get(id) ?? []);
  // What each issue waits for directly, furniture left out (`limb_order.ts`).
  const tree = limbTree(graph, set);
  const places = readPlaces(db, repo.id);
  const { waitsFor, waitedBy, waits, childrenOf } = tree;
  const memo = new Map<string, Set<string>>();
  const walking = new Set<string>();
  const beneath = (id: string): Set<string> => {
@@ -214,6 +195,11 @@
export function readPlan(
    memo.set(id, out);
    return out;
  };
  /** Sibling limbs as issues, in the order a person set. */
  const arranged = (group: string, ids: readonly string[]): Issue[] =>
    seated(places, group, ids)
      .map((id) => byId.get(id))
      .filter((i): i is Issue => i !== undefined);
  // Where the crew is: the issue a run is on, or the issue its pull closes.
  const proposed = openPullsClosing(db, repo.id);
@@ -354,24 +340,13 @@
export function readPlan(
    };
  };
  const isMilestone = (id: string): boolean => childrenOf(id).length > 0;
  const top: Issue[] =
    set.pillars.length > 0
      ? [
          ...set.pillars.map((p) => p.umbrella),
          ...(set.later === undefined ? [] : [set.later]),
        ]
      : graph.issues.filter(
          (i) =>
            i.state === "open" &&
            isMilestone(i.id) &&
            !(waitedBy.get(i.id) ?? []).some(
              (id) => byId.get(id)?.state === "open",
            ),
        );
  const top = arranged(
    TOP,
    tree.top.map((i) => i.id),
  );
  return {
    read: { graph, tree, places },
    limbs: top.map(limbOf),
    limb(number: number): { own: Issue[]; shared: Issue[] } | undefined {
      const issue = byNumber.get(number);
@@ -484,11 +459,7 @@
export function readPlan(
        .map((id) => byId.get(id))
        .filter((i): i is Issue => i !== undefined)
        .sort((a, b) => a.number - b.number);
      // A child is a limb when it brings a tree of its own; one that only
      // waits for its siblings is a leaf in an order.
      const siblings = new Set(children.map((c) => c.id));
      const isLimb = (child: Issue): boolean =>
        (waitsFor.get(child.id) ?? []).some((id) => !siblings.has(id));
      const limbIds = new Set(tree.limbsOf(issue.id));
      const closedThisWeek = under.filter(
        (i) =>
          i.state === "closed" && counted(i) && (i.closedAt ?? "") >= since,
@@ -534,9 +505,9 @@
export function readPlan(
          .filter((pull) => pull.closes.some((n) => numbers.has(n)))
          .map(({ number: n, title, at }) => ({ number: n, title, at })),
        estimate,
        limbs: children.filter(isLimb).map(limbOf),
        limbs: arranged(issue.id, [...limbIds]).map(limbOf),
        leaves: children
          .filter((c) => !isLimb(c))
          .filter((c) => !limbIds.has(c.id))
          .map((c) => {
            const state = stateOf(c);
            const why =
@@ -1584,6 +1584,17 @@
export const migrations: readonly string[] = [
  ALTER TABLE look ADD COLUMN attached_by TEXT;
  ALTER TABLE look ADD COLUMN note TEXT;
  `,
  // 75 — a limb's place among its siblings (#1064), set by a person. `parent_id`
  // is the issue whose limbs these are, or '' for the top of the plan.
  `
  CREATE TABLE limb_place (
    repo_id   TEXT NOT NULL REFERENCES repo(id) ON DELETE CASCADE,
    parent_id TEXT NOT NULL,
    issue_id  TEXT NOT NULL,
      
        sentinelcrew
        1mo ago
        
      
      Minor, not blocking. issue_id and parent_id have no foreign key to issue, so deleting or transferring an issue leaves its limb_place rows behind. readPlaces then returns a non-empty map, and repoGraph keeps setting limbRank (and re-sorting readyNow) even when no live group has a set order. seated drops ids that are not in the tree, so the order shown stays right. Suggested fix: add REFERENCES issue(id) ON DELETE CASCADE to issue_id in a later migration, or have moveLimb prune the rows whose ids are gone.
    
    place     INTEGER NOT NULL,
    PRIMARY KEY (repo_id, parent_id, issue_id)
  );
  `,
];
/**
@@ -23,6 +23,7 @@
import { cancelRepoRun, requeueRepoRun } from "../actions/runs.ts";
import { isCrew } from "../core/agents.ts";
import { mergePull } from "../actions/pulls.ts";
import { bringUpToDate } from "../crew/autonomy.ts";
import { moveLimb, parseSeat, type Seating } from "../core/limb_seats.ts";
import { getHold } from "../core/holds.ts";
import { recordInteraction, removeDismissals } from "../core/interactions.ts";
import { getPull } from "../core/pulls.ts";
@@ -69,6 +70,8 @@
export interface Target {
  readonly pillars?: Pillars;
  /** For an issue: the numbers of the umbrellas that wait for it directly, ascending. */
  readonly under?: readonly number[];
  /** For an issue: its repository's limbs in order, read on the first ask. */
  readonly seating?: () => Seating;
  /** For an issue: the ids of every row this operation is over, itself included. */
  readonly peers?: ReadonlySet<string>;
}
@@ -676,4 +679,50 @@
export const VERBS: Record<string, Verb> = {
      );
    },
  },
  /**
   * Seat a limb among its siblings: the value is a seat, `<group>:<place>`
   * (`top` or an issue number, then the place from 1), and the limb takes
   * that place with the others moving over. The row holds every seat the
   * limb has, so undo is the seats from before. The order is kept here and
   * is not the origin's, so a mirror is no reason to refuse.
   */
  place: {
    kind: "issue",
    reversible: true,
    parse: (_app, value) =>
      parseSeat(value) === undefined
        ? err("place takes a seat: top:2, or the number of the milestone and the place, 12:1")
        : ok(String(value)),
    read: (t) => [...(t.seating?.().of(t.id) ?? [])],
    next: replace,
    nextFor(_t, before, value) {
      const want = parseSeat(value);
      const held = Array.isArray(before) ? before.map(String) : [];
      return want === undefined
        ? held
        : held.map((seat) => (parseSeat(seat)?.group === want.group ? String(value) : seat));
    },
    refuse(_app, t, after) {
      const seats = t.seating?.();
      for (const seat of Array.isArray(after) ? after.map(String) : []) {
        const want = parseSeat(seat);
        if (want === undefined || seats === undefined) return "not a seat";
        if (want.place > seats.size(want.group))
          return `there are only ${seats.size(want.group)} limbs there`;
      }
      return undefined;
    },
    async write(app, _actor, t, after) {
      const have = t.seating?.().of(t.id) ?? [];
      for (const seat of Array.isArray(after) ? after.map(String) : []) {
        const want = parseSeat(seat);
        if (want === undefined) return "not a seat";
        if (have.includes(seat)) continue;
        const why = moveLimb(app.db, t.repo, t.id, want);
        if (why !== undefined) return why;
      }
      return undefined;
    },
  },
};
@@ -2510,7 +2510,7 @@
export function apiRoutes(router: Router<Handler>): void {
      },
    );
  // One action on a whole limb (#733): defer, resume, or close as not
  // doing. A fleet operation in every respect — a dry run by default with a
  // doing, or raise or lower it among its siblings (#1064). A fleet operation in every respect — a dry run by default with a
  // read credential, an admin token to apply, the receipt in
  // /api/v1/fleet/ops/:id and its undo at …/undo.
  router.add(
@@ -2525,11 +2525,14 @@
export function apiRoutes(router: Router<Handler>): void {
      const number = positiveInt(ctx.params.number);
      if (!repo || number === undefined) return notFound();
      if (!isLimbAction(input.action))
        return apiError("bad_action", 422, "action is defer, resume or close");
        return apiError("bad_action", 422, "action is defer, resume, close, raise or lower");
      const request = {
        action: input.action,
        ...(typeof input.reason === "string" ? { reason: input.reason } : {}),
        ...(typeof input.pillar === "string" ? { pillar: input.pillar } : {}),
        ...(typeof input.under === "string" || typeof input.under === "number"
          ? { under: String(input.under) }
          : {}),
      };
      if (dryRun) {
        const plan = previewLimb(ctx.app, ctx.auth.user, repo, number, request);
@@ -1249,7 +1249,7 @@
const TOOLS: readonly Tool[] = [
  {
    name: "limb",
    description:
      "One action on a whole limb of the plan — a milestone and everything beneath it that only it needs. `defer` moves the limb behind the Later gate, so the crew picks none of it; `resume` brings it back, under `pillar` when you name one; `close` closes every open issue of the limb as not doing, with `reason` said on each; `undo` reverses an `operation` by its id. A dry run unless `dryRun` is false: it answers with every row before and after, what the action takes along (`taken`) and what stays because something outside the limb still waits for it (`kept`), and changes nothing. Applying and undoing take an admin token of a person who administers the app, and answer with the receipt.",
      "One action on a whole limb of the plan — a milestone and everything beneath it that only it needs. `defer` moves the limb behind the Later gate, so the crew picks none of it; `resume` brings it back, under `pillar` when you name one; `close` closes every open issue of the limb as not doing, with `reason` said on each; `raise` and `lower` move it one place among its siblings — `under` says whose limbs when it is a limb of several, or `top` — and the crew takes ready work from the higher limb first; the dry run answers with the new `order` and the top of the ready list `before` and `after`. `undo` reverses an `operation` by its id. A dry run unless `dryRun` is false: it answers with every row before and after, what the action takes along (`taken`) and what stays because something outside the limb still waits for it (`kept`), and changes nothing. Applying and undoing take an admin token of a person who administers the app, and answer with the receipt.",
    inputSchema: {
      type: "object",
      properties: {
@@ -1259,7 +1259,7 @@
const TOOLS: readonly Tool[] = [
          minimum: 1,
          description: "The limb: the number of its issue.",
        },
        action: { type: "string", enum: ["defer", "resume", "close", "undo"] },
        action: { type: "string", enum: ["defer", "resume", "close", "raise", "lower", "undo"] },
        reason: {
          type: "string",
          description: "For close: why it is not being done, in one sentence.",
@@ -1269,6 +1269,11 @@
const TOOLS: readonly Tool[] = [
          description:
            "For resume: the pillar to put it back under, by name or short form; under none when absent.",
        },
        under: {
          type: "string",
          description:
            "For raise and lower: among whose limbs — `top`, or the number of the milestone; needed only when the limb sits in several places.",
        },
        operation: {
          type: "string",
          description: "For undo: the id of the operation to reverse.",
@@ -1303,11 +1308,14 @@
const TOOLS: readonly Tool[] = [
        !Number.isInteger(number) ||
        number < 1
      )
        return bad("invalid", "give the limb's issue number and an action: defer, resume, close or undo");
        return bad("invalid", "give the limb's issue number and an action: defer, resume, close, raise, lower or undo");
      const request = {
        action: args["action"],
        ...(typeof args["reason"] === "string" ? { reason: args["reason"] } : {}),
        ...(typeof args["pillar"] === "string" ? { pillar: args["pillar"] } : {}),
        ...(typeof args["under"] === "string" || typeof args["under"] === "number"
          ? { under: String(args["under"]) }
          : {}),
      };
      if (dry) {
        const plan = previewLimb(ctx.app, user, repo, number, request);
@@ -50,6 +50,22 @@
const WORDS: Record<LimbAction, { ask: string; does: string; go: string }> = {
    does: "Every open issue that only this limb needs closes as not doing, with your reason said on each.",
    go: "Close as not doing",
  },
  raise: {
    ask: "Raise",
    does: "It moves up one place among its siblings, and the crew takes ready work from the higher limb first.",
    go: "Raise this limb",
  },
  lower: {
    ask: "Lower",
    does: "It moves down one place among its siblings, and the crew takes ready work from the higher limb first.",
    go: "Lower this limb",
  },
};
/** A seat (`top:2`) as a person reads it; anything else as it is. */
const seatWords = (token: string | number): string => {
  const place = /^(?:top|[0-9]+):([0-9]+)$/.exec(String(token))?.[1];
  return place === undefined ? String(token) : `place ${place}`;
};
const shown = (value: FleetValue): string =>
@@ -58,7 +74,7 @@
const shown = (value: FleetValue): string =>
    : Array.isArray(value)
      ? value.length === 0
        ? "filed nowhere"
        : value.join(", ")
        : value.map(seatWords).join(", ")
      : String(value);
/** How many issues a list shows before the rest folds away. */
@@ -134,10 +150,12 @@
function requestOf(
): LimbRequest {
  const reason = get("reason").trim();
  const pillar = get("pillar").trim();
  const under = get("under").trim();
  return {
    action,
    ...(reason === "" ? {} : { reason }),
    ...(pillar === "" ? {} : { pillar }),
    ...(under === "" ? {} : { under }),
  };
}
@@ -179,6 +197,7 @@
export function limbPreviewPage(ctx: Ctx): Response {
  }
  const p = plan.value;
  const willWrite = p.counts.change > 0;
  const moving = action === "raise" || action === "lower";
  const pillars =
    action === "resume" ? pillarsOf(ctx.app.db, repo).pillars : [];
  const body = html`${repoHeader(ctx, repo, "map")}
@@ -189,6 +208,41 @@
export function limbPreviewPage(ctx: Ctx): Response {
      <h1>${words.ask} “${p.limb.title}”?</h1>
      <p>${words.does}</p>
    </div>
    ${when(
      p.order !== undefined,
      () =>
        html`<section class="ms-section" id="limb-order">
          <h2>The order of the limbs</h2>
          <ol class="ms-rows">
            ${(p.order ?? []).map(
              (i) =>
                html`<li ${i.number === p.limb.number ? html`aria-current="true"` : null}>
                  ${i.number === p.limb.number
                    ? html`<b>${i.title}</b>`
                    : html`<a href="${base}/issues/${i.number}">${i.title}</a>`}
                  <span class="muted small">#${i.number}</span>
                </li>`,
            )}
          </ol>
        </section>`,
    )}
    ${when(
      p.ready !== undefined,
      () => {
        const before = (p.ready?.before ?? []).map((i) => i.number);
        const after = p.ready?.after ?? [];
        return html`<section class="ms-section" id="limb-ready">
          <h2>The top of the ready list</h2>
          ${after.length === 0
            ? html`<p class="muted small">Nothing is ready.</p>`
            : before.join() === after.map((i) => i.number).join()
              ? html`<p class="muted small">Unchanged: the same ${after.length} come first.</p>
                  ${issueList(base, after)}`
              : html`<p class="muted small">After the move, the crew takes these first:</p>
                  ${issueList(base, after)}`}
        </section>`;
      },
    )}
    ${when(
      p.taken.length > 0,
      () =>
@@ -213,12 +267,14 @@
export function limbPreviewPage(ctx: Ctx): Response {
          ${issueList(base, p.kept)}
        </section>`,
    )}
    <section class="ms-section" id="limb-rows">
      <h2>What is written</h2>
      ${p.rows.length === 0
        ? html`<p class="muted small">Nothing: no open issue is the limb's alone.</p>`
        : rowList(ctx, base, p.rows)}
    </section>
    ${moving
      ? null
      : html`<section class="ms-section" id="limb-rows">
          <h2>What is written</h2>
          ${p.rows.length === 0
            ? html`<p class="muted small">Nothing: no open issue is the limb's alone.</p>`
            : rowList(ctx, base, p.rows)}
        </section>`}
    ${willWrite
      ? html`<form
          method="post"
@@ -226,6 +282,10 @@
export function limbPreviewPage(ctx: Ctx): Response {
          class="limb-confirm mt"
        >
          <input type="hidden" name="action" value="${action}" />
          ${when(
            request.under,
            (under) => html`<input type="hidden" name="under" value="${under}" />`,
          )}
          ${when(
            action === "close",
            () =>
@@ -305,7 +365,9 @@
export async function limbSubmit(ctx: Ctx): Promise<Response> {
  if (!op.ok)
    return op.error.code === "not_found"
      ? notFoundPage(ctx)
      : redirect(`${milestoneHref(base, number)}/limb?action=${action}`);
      : redirect(
          `${milestoneHref(base, number)}/limb?action=${action}${(field(form, "under") ?? "") === "" ? "" : `&under=${encodeURIComponent(field(form, "under"))}`}`,
        );
  return redirect(`${milestoneHref(base, number)}/limb/${op.value.id}`);
}
@@ -313,6 +375,7 @@
export async function limbSubmit(ctx: Ctx): Promise<Response> {
function done(op: Operation): string {
  if (op.undoOf !== null) return "Undone";
  if (op.verb === "drop") return "Closed as not doing";
  if (op.verb === "place") return "Moved";
  return op.value === "later" ? "Deferred" : "Resumed";
}
@@ -17,7 +17,12 @@
import {
  type LeafState,
  type Limb,
  type Milestone,
  type Plan,
} from "../../core/milestones.ts";
import type { Database } from "bun:sqlite";
import { parseSeat, seating } from "../../core/limb_seats.ts";
import type { Issue } from "../../core/issues.ts";
import type { User } from "../../core/users.ts";
import type { LimbAction } from "../../actions/limbs.ts";
import { isStructural, PILLAR_DAYS, pillarsOf } from "../../core/pillars.ts";
import { canAdmin, canSeeOwnerFacts, type Repo } from "../../core/repos.ts";
@@ -47,7 +52,53 @@
export const limbHref = (
  base: string,
  number: number,
  action: LimbAction,
): string => `${milestoneHref(base, number)}/limb?action=${action}`;
  under?: string,
): string =>
  `${milestoneHref(base, number)}/limb?action=${action}${under === undefined ? "" : `&under=${under}`}`;
/**
 * Raise and Lower for a limb among its siblings in one group (`top`, or a
 * milestone's number): only the moves that change something, and nothing
 * at all where it has no sibling. For whoever administers the repository.
 */
type Mover = ((limb: Issue, group: string) => Html | null) & {
  /** The first group a limb sits in, for its own page. */
  homeOf(limb: Issue): string | undefined;
};
function moverFor(
  db: Database,
      
        sentinelcrew
        1mo ago
        outdated
      
      Medium: this is a second full repoGraph plus limb tree per admin page view, next to the one readPlan already built. Reuse the plan's tree and places.
    
  repo: Repo,
  viewer: User | undefined,
  read: Plan["read"],
): Mover | undefined {
  if (!canAdmin(db, repo, viewer)) return undefined;
  const seats = seating(db, repo, read);
  const base = repoBase(repo);
  const at = (limb: Issue, group: string) => {
    const seat = seats
      .of(limb.id)
      .flatMap((s) => parseSeat(s) ?? [])
      .find((s) => s.group === group);
    if (seat === undefined || seats.size(group) < 2) return null;
    const up = seat.place > 1;
    const down = seat.place < seats.size(group);
    return html`<span class="ms-move small"
      >${up
        ? html`<a href="${limbHref(base, limb.number, "raise", group)}"
            >Raise</a
          >`
        : null}${down
        ? html`<a href="${limbHref(base, limb.number, "lower", group)}"
            >Lower</a
          >`
        : null}</span
    >`;
  };
  return Object.assign(at, {
    homeOf: (limb: Issue) => parseSeat(seats.of(limb.id)[0])?.group,
  });
}
/**
 * The actions on a whole limb, for whoever administers the repository:
@@ -60,10 +111,12 @@
function limbActions(
  m: Milestone,
  furniture: boolean,
  lead: Html | null,
  move: Html | null,
): Html {
  const number = m.issue.number;
  return html`<p class="bar ms-actions" id="limb-actions">
    ${lead}
    ${move}
    ${furniture
      ? null
      : m.deferred
@@ -101,7 +154,7 @@
function weightWords(limb: Limb): Html {
}
/** One limb as one line: a link to it, how far it is, and its weight. */
function limbLine(base: string, limb: Limb): Html {
function limbLine(base: string, limb: Limb, move: Html | null = null): Html {
  const w = limb.weight;
  return html`<li class="ms-limb" data-trim="${limb.trim === undefined ? "no" : "yes"}">
    <a class="ms-name" href="${milestoneHref(base, limb.issue.number)}"
@@ -120,6 +173,7 @@
function limbLine(base: string, limb: Limb): Html {
      (why) =>
        html`<span class="ms-trim small">A candidate to trim: ${why}.</span>`,
    )}
    ${move}
  </li>`;
}
@@ -131,6 +185,7 @@
export function milestonesPage(ctx: Ctx): Response {
    spend: canSeeOwnerFacts(ctx.app.db, repo, ctx.auth.user),
  });
  const base = repoBase(repo);
  const move = moverFor(ctx.app.db, repo, ctx.auth.user, plan.read);
  const body = html`${repoHeader(ctx, repo, "map")}
    <div class="page-head mt">
      <h1>Milestones</h1>
@@ -145,7 +200,7 @@
export function milestonesPage(ctx: Ctx): Response {
          show. <a href="${base}/map">See the map</a>.
        </p>`
      : html`<ul class="ms-limbs" id="ms-limbs">
          ${plan.limbs.map((limb) => limbLine(base, limb))}
          ${plan.limbs.map((limb) => limbLine(base, limb, move?.(limb.issue, "top") ?? null))}
        </ul>`}`;
  return page({
    ctx,
@@ -208,6 +263,7 @@
function milestoneBody(
  m: Milestone,
  names: boolean,
  actions: Html | null,
  move?: Mover,
): Html {
  const base = repoBase(repo);
  const issue = (number: number, title: string): Html =>
@@ -257,7 +313,9 @@
function milestoneBody(
        html`<section class="ms-section" id="ms-limbs">
          <h2>Limbs</h2>
          <ul class="ms-limbs">
            ${m.limbs.map((limb) => limbLine(base, limb))}
            ${m.limbs.map((limb) =>
              limbLine(base, limb, move?.(limb.issue, String(m.issue.number)) ?? null),
            )}
          </ul>
        </section>`,
    )}
@@ -378,10 +436,11 @@
export function milestonePage(ctx: Ctx): Response {
  if (!repo) return notFoundPage(ctx);
  const number = Number(ctx.params.number);
  const owner = canSeeOwnerFacts(ctx.app.db, repo, ctx.auth.user);
  const milestone = Number.isInteger(number)
    ? readPlan(ctx.app.db, repo, { spend: owner }).milestone(number)
  const plan = Number.isInteger(number)
    ? readPlan(ctx.app.db, repo, { spend: owner })
    : undefined;
  if (milestone === undefined) return notFoundPage(ctx);
  const milestone = plan?.milestone(number);
  if (plan === undefined || milestone === undefined) return notFoundPage(ctx);
  const viewer = ctx.auth.user;
  // Watch is each person's own; acting on the whole limb is for whoever
  // administers the repository. One row, Watch first.
@@ -393,12 +452,16 @@
export function milestonePage(ctx: Ctx): Response {
          isWatching(ctx.app.db, viewer.id, milestone.issue.id),
        )
      : null;
  const move = moverFor(ctx.app.db, repo, viewer, plan.read);
  // Its own place: among the limbs of whichever milestone holds it first.
  const seat = move?.homeOf(milestone.issue);
  const actions = canAdmin(ctx.app.db, repo, ctx.auth.user)
    ? limbActions(
        repoBase(repo),
        milestone,
        isStructural(pillarsOf(ctx.app.db, repo), milestone.issue.id),
        watch,
        seat === undefined ? null : (move?.(milestone.issue, seat) ?? null),
      )
    : watch === null
      ? null
@@ -409,7 +472,7 @@
export function milestonePage(ctx: Ctx): Response {
    crumbs: crumbsFor(repo),
    palette: repoPalette(ctx, repo),
    body: html`${repoHeader(ctx, repo, "map")}
    ${milestoneBody(repo, milestone, owner, actions)}`,
    ${milestoneBody(repo, milestone, owner, actions, move)}`,
    styleCss: milestonesCss,
  });
}
@@ -492,6 +555,7 @@
export const milestonesCss = /* css */ `
.ms-top h1, .ms-top p { margin: 0; }
.ms-head { display: grid; grid-template-columns: minmax(0, 1fr); gap: 4px; }
.ms-actions { margin-top: 4px; }
.ms-move { grid-column: 1 / -1; display: flex; gap: 14px; }
.ms-section { margin-top: 22px; }
.ms-section h2 { font-size: 13px; margin: 0 0 6px; }
.ms-rows { list-style: none; margin: 0; padding: 0; display: grid; gap: 6px; font-size: 14px; }
@@ -0,0 +1,358 @@
/**
 * The order of the limbs (#1064): raise or lower a limb against its
 * siblings, and the crew takes ready work in that order.
 *
 * The refusals come first — a reader, a crew agent and a read token move
 * nothing. Then the stored order (kept across a restart), the ready order
 * that follows it, the issue beneath two limbs, the preview, the undo, and
 * every door: the page, the API and the MCP tool.
 */
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 { addToCrew, createAgent } from "../src/actions/crew.ts";
import { linkIssue } from "../src/actions/dependencies.ts";
import { undoFleetOp } from "../src/actions/fleet.ts";
import { openIssue } from "../src/actions/issues.ts";
import { applyLimb, previewLimb } from "../src/actions/limbs.ts";
import { commitToBranch, createRepo } from "../src/actions/repos.ts";
import { readyNow, repoGraph } from "../src/core/dependencies.ts";
import { getIssueById, type Issue } from "../src/core/issues.ts";
import { readPlan } from "../src/core/milestones.ts";
import { getRepoById, type Repo } from "../src/core/repos.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";
describe("the order of the limbs", () => {
  let dataDir: string;
  let app: App;
  let servers: Servers;
  let base: string;
  let alice: User;
  let bob: User;
  let mason: User;
  let repo: Repo;
  let trust: Issue;
  let feed: Issue;
  let s1: Issue;
  let s2: Issue;
  let a1: Issue;
  let b1: Issue;
  let both: Issue;
  let x1: Issue;
  let x2: Issue;
  const fresh = () => getRepoById(app.db, repo.id)!;
  const current = (issue: Issue) => getIssueById(app.db, issue.id)!;
  const open = (title: string): Issue => {
    const opened = openIssue(app, alice, fresh(), { title });
    if (!opened.ok) throw new Error(String(opened.error));
    return opened.value;
  };
  const link = (waiter: Issue, on: Issue): void => {
    const linked = linkIssue(app, alice, fresh(), current(waiter), current(on));
    if (!linked.ok) throw new Error(String(linked.error));
  };
  const ready = (): number[] =>
    readyNow(repoGraph(app.db, repo.id)).map((r) => r.issue.number);
  const names = (...issues: Issue[]) => issues.map((i) => i.number);
  const places = (): string =>
    JSON.stringify(
      app.db
        .query("SELECT parent_id, issue_id, place FROM limb_place ORDER BY 1, 2")
        .all(),
    );
  const top = (): number[] =>
    readPlan(app.db, fresh()).limbs.map((l) => l.issue.number);
  const under = (m: Issue): number[] =>
    readPlan(app.db, fresh())
      .milestone(m.number)!
      .limbs.map((l) => l.issue.number);
  const tokenOf = (user: User, scope: "ro" | "rw" | "admin"): string =>
    createToken(app.db, user.id, scope, scope).token;
  const post = (token: string, path: string, body: unknown) =>
    fetch(`${base}${path}`, {
      method: "POST",
      headers: {
        authorization: `Bearer ${token}`,
        "content-type": "application/json",
      },
      body: JSON.stringify(body),
    });
  const cookies: Record<string, string> = {};
  const get = (who: string, path: string) =>
    fetch(`${base}${path}`, { headers: { cookie: cookies[who]! }, redirect: "manual" });
  const submit = (who: string, path: string, form: Record<string, string>) =>
    fetch(`${base}${path}`, {
      method: "POST",
      headers: { cookie: cookies[who]!, origin: base },
      body: new URLSearchParams(form),
      redirect: "manual",
    });
  let nextId = 1;
  const tool = async (token: string, args: unknown) => {
    const res = await post(token, "/mcp", {
      jsonrpc: "2.0",
      id: nextId++,
      method: "tools/call",
      params: { name: "limb", arguments: args },
    });
    const body = (await res.json()) as any;
    const text: string = body.result.content[0].text;
    return body.result.isError === true
      ? { error: text }
      : { value: JSON.parse(text) };
  };
  /** The ready order with no order set, and with feed's limbs first. */
  let NATURAL: number[] = [];
  let FEED_FIRST: number[] = [];
  const path = () => `/api/v1/repos/alice/order/milestones`;
  beforeAll(async () => {
    dataDir = await mkdtemp(join(tmpdir(), "forge-limb-order-"));
    app = createApp({ dataDir, port: 0 });
    servers = await serve(app);
    base = servers.url;
    for (const [username, adminIfFirst] of [
      ["alice", true],
      ["bob", false],
    ] as const) {
      const made = await createUser(app.db, {
        trusted: true,
        username,
        email: `${username}@forge.local`,
        password: "a-good-passphrase",
        adminIfFirst,
      });
      if (!made.ok) throw new Error(made.error);
    }
    alice = getUserByName(app.db, "alice")!;
    bob = getUserByName(app.db, "bob")!;
    for (const name of ["alice", "bob"])
      cookies[name] = (
        (
          await fetch(`${base}/signin`, {
            method: "POST",
            body: new URLSearchParams({ username: name, password: "a-good-passphrase" }),
            redirect: "manual",
          })
        ).headers.get("set-cookie") ?? ""
      ).split(";")[0]!;
    const made = await createRepo(app, alice, { name: "order", visibility: "public" });
    if (!made.ok) throw new Error(String(made.error));
    const seeded = await commitToBranch(app, alice, made.value, {
      message: "Start",
      files: [{ path: "README.md", content: "# order\n" }],
    });
    if (!seeded.ok) throw new Error(JSON.stringify(seeded.error));
    repo = made.value;
    const agent = await createAgent(app, alice, { username: "mason" });
    if (!agent.ok) throw new Error(String(agent.error));
    expect(addToCrew(app, alice, repo, "mason").ok).toBe(true);
    mason = getUserByName(app.db, "mason")!;
    // Natural ready order: what frees most, then the oldest.
    b1 = open("A feed leaf");
    x1 = open("First sub-limb leaf");
    x2 = open("Second sub-limb leaf");
    both = open("Under both pillars");
    a1 = open("A trust leaf");
    trust = open("P0 Trust: agents contained");
    feed = open("P1 Feed: one front door");
    open("Later: work that serves no pillar now");
    const gate = open("Later gate: nothing behind this starts");
    s1 = open("First sub-limb");
    s2 = open("Second sub-limb");
    link(gate, trust);
    link(gate, feed);
    link(trust, a1);
    link(trust, both);
    link(feed, both);
    link(feed, b1);
    link(feed, s1);
    link(feed, s2);
    link(s1, x1);
    link(s2, x2);
    NATURAL = names(x1, x2, both, b1, a1);
    // An issue beneath both pillars takes the higher one.
    FEED_FIRST = names(both, b1, x1, x2, a1);
  }, 60_000);
  afterAll(async () => {
    servers.stop();
    app.close();
    await rm(dataDir, { recursive: true, force: true });
  });
  test("with no order set, the ready order is the one that never knew limbs", () => {
    expect(places()).toBe("[]");
    expect(ready()).toEqual(NATURAL);
    expect(top()).toEqual(names(trust, feed).concat(top().slice(2)));
  });
  test("refused: a reader, a crew agent and a read token move nothing, by any door", async () => {
    const request = { action: "raise" as const, under: "top" };
    // A reader may look: the one row comes back refused, and says why.
    const looked = previewLimb(app, bob, fresh(), feed.number, request);
    expect(looked.ok && looked.value.rows.map((r) => r.outcome)).toEqual(["refused"]);
    if (looked.ok) expect(looked.value.rows[0]!.reason).toBe("you are not an admin of alice/order");
    const tried = await applyLimb(app, bob, fresh(), feed.number, request);
    expect(tried.ok && tried.value.rows.every((r) => r.outcome === "refused")).toBe(true);
    // An agent never applies; nobody signed in does not either.
    const agent = await applyLimb(app, mason, fresh(), feed.number, request);
    expect(agent.ok ? "applied" : agent.error.code).toBe("forbidden");
    const nobody = await applyLimb(app, undefined, fresh(), feed.number, request);
    expect(nobody.ok ? "applied" : nobody.error.code).toBe("unauthorized");
    // The API: a read token, a write token and an agent's admin token.
    const url = `${path()}/${feed.number}/limb`;
    const apply = { action: "raise", under: "top", dryRun: false };
    expect((await post(tokenOf(alice, "ro"), url, apply)).status).toBe(403);
    expect((await post(tokenOf(alice, "rw"), url, apply)).status).toBe(403);
    expect((await post(tokenOf(mason, "admin"), url, apply)).status).toBe(403);
    // A reader's admin token writes nothing.
    const theirs = await post(tokenOf(bob, "admin"), url, apply);
    const rows = ((await theirs.json()) as { rows?: { outcome: string }[] }).rows;
    expect(rows?.every((r) => r.outcome === "refused") ?? true).toBe(true);
    // MCP: applying takes an admin token, whoever asks.
    const args = { app: "alice/order", issue: feed.number, action: "raise", under: "top", dryRun: false };
    for (const token of [tokenOf(alice, "ro"), tokenOf(alice, "rw"), tokenOf(mason, "rw")])
      expect((await tool(token, args)).error).toContain("forbidden");
    expect((await tool(tokenOf(mason, "admin"), args)).error).toContain("forbidden");
    // The page: a reader sees no Raise, and a posted form moves nothing.
    expect(await (await get("bob", `/alice/order/milestones`)).text()).not.toContain(">Raise<");
    const form = { action: "raise", under: "top" };
    const posted = await submit("bob", `/alice/order/milestones/${feed.number}/limb`, form);
    expect(posted.status).not.toBe(201);
    expect(places()).toBe("[]");
    expect(top().slice(0, 2)).toEqual(names(trust, feed));
    expect(ready()).toEqual(NATURAL);
  });
  test("a move that cannot be made is said, not guessed", async () => {
    const say = async (limb: Issue, request: { action: "raise" | "lower"; under?: string }) => {
      const r = await applyLimb(app, alice, fresh(), limb.number, request);
      return r.ok ? "applied" : r.error.message;
    };
    expect(await say(trust, { action: "raise", under: "top" })).toBe("it is first already");
    expect(await say(a1, { action: "raise" })).toContain("no place to move");
    expect(await say(s1, { action: "raise", under: "top" })).toContain("no place to move");
    expect(await say(feed, { action: "raise", under: "nonsense" })).toContain("under is top");
    expect(places()).toBe("[]");
  });
  test("the preview shows the new order and the top of the ready list, and writes nothing", () => {
    const plan = previewLimb(app, alice, fresh(), feed.number, { action: "raise", under: "top" });
    expect(plan.ok).toBe(true);
    if (!plan.ok) return;
    expect(plan.value.order!.map((i) => i.number).slice(0, 2)).toEqual(names(feed, trust));
    expect(plan.value.ready!.before.map((i) => i.number)).toEqual(NATURAL);
    // The issue beneath both pillars takes the higher, feed, so it comes
    // before the leaves of feed's sub-limbs.
    expect(plan.value.ready!.after.map((i) => i.number)).toEqual(FEED_FIRST);
    expect(plan.value.rows.map((r) => [r.before, r.after, r.outcome])).toEqual([
      [["top:2"], ["top:1"], "change"],
    ]);
    expect(places()).toBe("[]");
  });
  let receipt: string;
  test("raise: the place is stored, shown as the order, and the ready order follows it", async () => {
    const op = await applyLimb(app, alice, fresh(), feed.number, { action: "raise", under: "top" });
    expect(op.ok && op.value.rows.map((r) => r.outcome)).toEqual(["ok"]);
    if (!op.ok) return;
    receipt = op.value.id;
    expect(top().slice(0, 2)).toEqual(names(feed, trust));
    expect(ready()).toEqual(FEED_FIRST);
    expect(JSON.parse(places()).map((r: { place: number }) => r.place).sort()).toEqual([1, 2, 3]);
    // The first cannot be raised again.
    const again = await applyLimb(app, alice, fresh(), feed.number, { action: "raise", under: "top" });
    expect(again.ok ? "applied" : again.error.message).toBe("it is first already");
  });
  test("undo puts the order back, once, and the ready list follows the order shown", async () => {
    const undone = await undoFleetOp(app, alice, receipt);
    expect(undone.ok && undone.value.rows.map((r) => r.outcome)).toEqual(["ok"]);
    expect(top().slice(0, 2)).toEqual(names(trust, feed));
    // Back where it began is no order at all: the rows go and the crew's
    // ready order is the natural one again.
    expect(places()).toBe("[]");
    expect(ready()).toEqual(NATURAL);
    const twice = await undoFleetOp(app, alice, receipt);
    expect(twice.ok ? "undone" : twice.error.code).toBe("already_undone");
  });
  test("lower is the same move the other way, and among a milestone's own limbs", async () => {
    expect(under(feed)).toEqual(names(s1, s2));
    const lowered = await applyLimb(app, alice, fresh(), s1.number, { action: "lower", under: String(feed.number) });
    expect(lowered.ok).toBe(true);
    expect(under(feed)).toEqual(names(s2, s1));
    // Second sub-limb's leaf now comes before the first's.
    expect(ready().indexOf(x2.number)).toBeLessThan(ready().indexOf(x1.number));
    const last = await applyLimb(app, alice, fresh(), s1.number, { action: "lower" });
    expect(last.ok ? "applied" : last.error.message).toBe("it is last already");
    // Undoing it, though others moved since, only where it still holds.
    if (lowered.ok) await undoFleetOp(app, alice, lowered.value.id);
    expect(under(feed)).toEqual(names(s1, s2));
  });
  test("the order survives a restart", async () => {
    const raised = await applyLimb(app, alice, fresh(), feed.number, { action: "raise", under: "top" });
    expect(raised.ok).toBe(true);
    servers.stop();
    app.close();
    app = createApp({ dataDir, port: 0 });
    servers = await serve(app);
    base = servers.url;
    expect(top().slice(0, 2)).toEqual(names(feed, trust));
    expect(ready()).toEqual(FEED_FIRST);
  });
  test("through the API and MCP: a dry run by default, an admin applies", async () => {
    const url = `${path()}/${trust.number}/limb`;
    const dry = await post(tokenOf(alice, "ro"), url, { action: "raise", under: "top" });
    expect(dry.status).toBe(200);
    const planned = (await dry.json()) as { dryRun: boolean; order: { number: number }[] };
    expect(planned.dryRun).toBe(true);
    expect(planned.order.slice(0, 2).map((i) => i.number)).toEqual(names(trust, feed));
    expect(top().slice(0, 2)).toEqual(names(feed, trust));
    const applied = await post(tokenOf(alice, "admin"), url, { action: "raise", under: "top", dryRun: false });
    expect(applied.status).toBe(201);
    expect(top().slice(0, 2)).toEqual(names(trust, feed));
    const viaTool = await tool(tokenOf(alice, "ro"), { app: "alice/order", issue: trust.number, action: "lower", under: "top" });
    expect(viaTool.value.dryRun).toBe(true);
    expect(viaTool.value.order.slice(0, 2).map((i: { number: number }) => i.number)).toEqual(names(feed, trust));
    const done = await tool(tokenOf(alice, "admin"), { app: "alice/order", issue: trust.number, action: "lower", under: "top", dryRun: false });
    expect(done.value.rows[0].outcome).toBe("ok");
    expect(top().slice(0, 2)).toEqual(names(feed, trust));
    const back = await tool(tokenOf(alice, "admin"), { app: "alice/order", action: "undo", operation: done.value.id, dryRun: false });
    expect(back.value.rows[0].outcome).toBe("ok");
    expect(top().slice(0, 2)).toEqual(names(trust, feed));
  });
  test("the page: Raise and Lower for an admin, the preview, the receipt, the undo", async () => {
    const list = await (await get("alice", "/alice/order/milestones")).text();
    expect(list).toContain("/milestones/" + feed.number + "/limb?action=raise&amp;under=top");
    expect(list).not.toContain("/milestones/" + trust.number + "/limb?action=raise");
    const page = await (await get("alice", `/alice/order/milestones/${feed.number}`)).text();
    expect(page).toContain(`/milestones/${s2.number}/limb?action=raise&amp;under=${feed.number}`);
    const preview = await (
      await get("alice", `/alice/order/milestones/${feed.number}/limb?action=raise&under=top`)
    ).text();
    expect(preview).toContain('id="limb-order"');
    expect(preview).toContain('id="limb-ready"');
    const posted = await submit("alice", `/alice/order/milestones/${feed.number}/limb`, { action: "raise", under: "top" });
    expect(posted.status).toBe(303);
    expect(top().slice(0, 2)).toEqual(names(feed, trust));
    const receiptPage = await (await get("alice", posted.headers.get("location")!)).text();
    expect(receiptPage).toContain("Moved");
    expect(receiptPage).toContain("place 2");
    const op = posted.headers.get("location")!.split("/").pop()!;
    const undo = await submit("alice", `/alice/order/milestones/${feed.number}/limb/${op}/undo`, {});
    expect(undo.status).toBe(303);
    expect(top().slice(0, 2)).toEqual(names(trust, feed));
  });
});
		@@ -307,14 +307,26 @@ one undo.
307	307	- Close as not doing closes every open issue that is the limb's own,
308	308	the limb included, as `dropped`, with the reason said on each. What other
309	309	work outside the limb also waits for is not the limb's to close.
	310	- Raise and Lower (#1064) move the limb one place among its
	311	siblings — the pillars and Later at the top, a milestone's limbs under
	312	it. The place is stored per group of siblings (`limb_place`), kept across
	313	a restart, and is the order the limbs are listed in; a limb never placed
	314	follows the placed ones, by number. The preview shows the new order and
	315	how the top of the ready list changes. Once a person has set an order in
	316	a repository, the crew's ready order follows it: an issue beneath a
	317	higher limb comes before one beneath a lower limb (beneath two limbs, the
	318	higher), after them come issues beneath no limb, and within a limb the
	319	order is the old one — what it frees, then age. Until then nothing about
	320	the ready order changes. It is one fleet row, the verb `place`; undo puts
	321	the place back. Through the API and the MCP `limb` tool (`action` raise or
	322	lower, `under` when the limb sits in several places), dry-run by default.
310	323
311	324	An umbrella or the gate is the plan's own and is not filed. A leaf beneath
312	325	a limb that is not deferred cannot be deferred alone: defer the limb. A
313		candidate to trim offers Defer first. Raising and lowering a limb against
314		its siblings is #760; handing one to the planner is #761.
	326	candidate to trim offers Defer first. Handing one to the planner is #761.
315	327
316	328	The same is `POST /api/v1/repos/:owner/:name/milestones/:number/limb`
317		`{ "action": "defer" \| "resume" \| "close", "reason"?, "pillar"?, "dryRun"? }`
	329	`{ "action": "defer" \| "resume" \| "close" \| "raise" \| "lower", "reason"?, "pillar"?, "under"?, "dryRun"? }`
318	330	and the MCP's `limb`, both a dry run unless `dryRun` is false. Applying and
319	331	undoing take an admin token of a person who administers the repository; an
320	332	agent may look and never apply.
		@@ -178,6 +178,7 @@ export const GATE: readonly string[] = [
178	178	"test/issues.test.ts",
179	179	"test/kernel.test.ts",
180	180	"test/keys.test.ts",
	181	"test/limb_order.test.ts",
181	182	"test/limbs.test.ts",
182	183	"test/live-pages.test.ts",
183	184	"test/live.test.ts",
		@@ -34,6 +34,7 @@ import {
34	34	} from "../core/issues.ts";
35	35	import { listCrewRoles } from "../core/agents.ts";
36	36	import { joinMany } from "../core/pulls.ts";
	37	import { seating, type Seating } from "../core/limb_seats.ts";
37	38	import { pillarsOf, type Pillars } from "../core/pillars.ts";
38	39	import {
39	40	canAdmin,
		@@ -178,6 +179,16 @@ function loadTargets(
178	179	const pillars = new Map<string, Pillars>();
179	180	for (const [repoId, repo] of repos) pillars.set(repoId, pillarsOf(app.db, repo));
180	181	const under = umbrellasOver(app, ids, [...pillars.values()]);
	182	// Read on the first ask, once for a repository: only `place` wants it.
	183	const seatings = new Map<string, Seating>();
	184	const seatingOf = (repo: Repo) => () => {
	185	let seats = seatings.get(repo.id);
	186	if (seats === undefined) {
	187	seats = seating(app.db, repo);
	188	seatings.set(repo.id, seats);
	189	}
	190	return seats;
	191	};
181	192	const peers: ReadonlySet<string> = new Set(ids);
182	193	const pull = (id: string) => {
183	194	const p = pulls.get(id);
		@@ -207,6 +218,7 @@ function loadTargets(
207	218	planner: planners.get(repo.id) ?? null,
208	219	pillars: pillars.get(repo.id)!,
209	220	under: under.get(id) ?? [],
	221	seating: seatingOf(repo),
210	222	peers,
211	223	...(viewer === undefined
212	224	? {}
		@@ -16,6 +16,11 @@
16	16	* one reason said on each — and never what something outside the limb
17	17	* also waits for.
18	18	*
	19	* - `raise` and `lower` move the limb one place among its siblings (#1064),
	20	* and the crew takes ready work in that order. One row: the limb, holding
	21	* its seat (`core/limb_seats.ts`). The preview shows the new order and how
	22	* the top of the ready list changes.
	23	*
19	24	* Who may is the fleet's rule, unchanged: a person who administers the
20	25	* repository; an agent may preview and never apply.
21	26	*/
		@@ -23,6 +28,9 @@
23	28	import type { App } from "../app.ts";
24	29	import type { FleetValue, Operation } from "../core/fleet_ops.ts";
25	30	import type { Issue } from "../core/issues.ts";
	31	import { readyNow } from "../core/dependencies.ts";
	32	import { limbRanks, withGroup } from "../core/limb_order.ts";
	33	import { parseSeat, seating } from "../core/limb_seats.ts";
26	34	import { readPlan } from "../core/milestones.ts";
27	35	import { isStructural, pillarsOf } from "../core/pillars.ts";
28	36	import { canRead, type Repo } from "../core/repos.ts";
		@@ -35,7 +43,7 @@ import {
35	43	type Plan,
36	44	} from "./fleet.ts";
37	45
38		export const LIMB_ACTIONS = ["defer", "resume", "close"] as const;
	46	export const LIMB_ACTIONS = ["defer", "resume", "close", "raise", "lower"] as const;
39	47	export type LimbAction = (typeof LIMB_ACTIONS)[number];
40	48
41	49	export const isLimbAction = (value: unknown): value is LimbAction =>
		@@ -47,6 +55,8 @@ export interface LimbRequest {
47	55	readonly reason?: string;
48	56	/** For `resume`: the pillar to put it back under; absent leaves it under none. */
49	57	readonly pillar?: string;
	58	/** For `raise` and `lower`: among whose limbs, `top` or a milestone's number; absent when the limb sits in one place. */
	59	readonly under?: string;
50	60	}
51	61
52	62	/** An issue an action touches or takes along, as a person reads it. */
		@@ -62,8 +72,17 @@ export interface LimbReach {
62	72	readonly taken: readonly LimbIssue[];
63	73	/** For `defer` and `close`: what beneath it stays, because something outside the limb still waits for it. */
64	74	readonly kept: readonly LimbIssue[];
	75	/** For `raise` and `lower`: the limbs of that group as they would stand, and the top of the ready list before and after. */
	76	readonly order?: readonly LimbIssue[];
	77	readonly ready?: {
	78	readonly before: readonly LimbIssue[];
	79	readonly after: readonly LimbIssue[];
	80	};
65	81	}
66	82
	83	/** How many ready issues the preview shows: the top of the list. */
	84	const TOP_READY = 5;
	85
67	86	const brief = (issue: Issue): LimbIssue => ({
68	87	number: issue.number,
69	88	title: issue.title,
		@@ -72,6 +91,66 @@ const brief = (issue: Issue): LimbIssue => ({
72	91	const fail = (code: FleetError["code"], message: string) =>
73	92	err<FleetError>({ code, message });
74	93
	94	/** One step up or down among the limb's siblings, with the order and the ready list it makes. */
	95	function move(
	96	app: App,
	97	repo: Repo,
	98	limb: Issue,
	99	request: LimbRequest,
	100	where: string,
	101	): Result<
	102	{ query: string; action: { verb: string; value: FleetValue }; reach: LimbReach },
	103	FleetError
	104	> {
	105	const seats = seating(app.db, repo);
	106	const held = seats.of(limb.id).flatMap((s) => parseSeat(s) ?? []);
	107	const under = request.under?.trim().toLowerCase();
	108	if (under !== undefined && under !== "top" && !/^[1-9][0-9]{0,8}$/.test(under))
	109	return fail("bad_action", "under is top, or the number of a milestone");
	110	const seat =
	111	under === undefined
	112	? held.length === 1
	113	? held[0]
	114	: undefined
	115	: held.find((s) => s.group === under);
	116	if (seat === undefined)
	117	return fail(
	118	"bad_action",
	119	held.length === 0 \|\| under !== undefined
	120	? "it is not one of the limbs of a milestone, so it has no place to move"
	121	: "it is a limb of several milestones: say which with under",
	122	);
	123	const to = seat.place + (request.action === "raise" ? -1 : 1);
	124	const size = seats.size(seat.group);
	125	if (to < 1) return fail("bad_action", "it is first already");
	126	if (to > size) return fail("bad_action", "it is last already");
	127	const ids = [...seats.order(seat.group)];
	128	ids.splice(seat.place - 1, 1);
	129	ids.splice(to - 1, 0, limb.id);
	130	const group = seats.parentId(seat.group)!;
	131	const after = readyNow({
	132	...seats.graph,
	133	limbRank: limbRanks(seats.tree, withGroup(seats.places, group, ids)),
	134	});
	135	const byId = new Map(seats.graph.issues.map((i) => [i.id, i]));
	136	return ok({
	137	query: `${where} number:${limb.number}`,
	138	action: { verb: "place", value: `${seat.group}:${to}` },
	139	reach: {
	140	limb: brief(limb),
	141	taken: [],
	142	kept: [],
	143	order: ids.flatMap((id) => byId.get(id) ?? []).map(brief),
	144	ready: {
	145	before: readyNow(seats.graph)
	146	.slice(0, TOP_READY)
	147	.map((r) => brief(r.issue)),
	148	after: after.slice(0, TOP_READY).map((r) => brief(r.issue)),
	149	},
	150	},
	151	});
	152	}
	153
75	154	/** The fleet operation a limb action is, and what it reaches. */
76	155	function shape(
77	156	app: App,
		@@ -93,6 +172,8 @@ function shape(
93	172	return fail("not_found", "no such milestone here");
94	173	const limb = brief(rows.own[0]);
95	174	const where = `issue repo:${repo.ownerName}/${repo.name}`;
	175	if (request.action === "raise" \|\| request.action === "lower")
	176	return move(app, repo, rows.own[0], request, where);
96	177	if (request.action === "close") {
97	178	const reason = (request.reason ?? "").trim();
98	179	if (reason === "")
		@@ -14,6 +14,7 @@ import { getIssuesByIds, type CloseReason, type Issue } from "./issues.ts";
14	14	import { pillarsOf, structuralIds } from "./pillars.ts";
15	15	import { getRepoById } from "./repos.ts";
16	16	import { unadoptedAmong } from "../crew/direct.ts";
	17	import { limbRanks, limbTree, readPlaces } from "./limb_order.ts";
17	18
18	19	export type DependencyError = "self" \| "cross_repo" \| "cycle" \| "not_an_issue";
19	20
		@@ -215,6 +216,12 @@ export interface Graph {
215	216	* words, as every surface says it (`deferredWhy`).
216	217	*/
217	218	readonly deferred: ReadonlyMap<string, string>;
	219	/**
	220	* Where each issue stands in the order of the limbs (#1064), the first
	221	* limb that holds it, lower first. Only when a person has set an order
	222	* here; absent, the ready order is the one that never knew limbs.
	223	*/
	224	readonly limbRank?: ReadonlyMap<string, number>;
218	225	}
219	226
220	227	/**
		@@ -318,7 +325,16 @@ export function repoGraph(
318	325	);
319	326	const repo = getRepoById(db, repoId);
320	327	const set = repo === undefined ? undefined : pillarsOf(db, repo);
	328	const places = readPlaces(db, repoId);
321	329	return {
	330	...(set === undefined \|\| places.size === 0
		sentinelcrew 1mo ago This gate is what undo has to bring back. Today it only flips one way: once a group is stored, `limbRank` is on for the repository even after every move is undone.
	331	? {}
	332	: {
	333	limbRank: limbRanks(
	334	limbTree({ issues, edges: kept }, set),
	335	places,
	336	),
	337	}),
322	338	issues,
323	339	unadopted:
324	340	repo === undefined ? new Set() : unadoptedAmong(db, repo, issues),
		@@ -509,14 +525,22 @@ function clearNow(graph: Graph): Ranked[] {
509	525	* reader's suggestion only once someone who writes here adopted it, and
510	526	* never the plan's own furniture: an umbrella or the Later gate is not
511	527	* work. What a free crew slot takes next.
	528	*
	529	* Where a person has ordered the limbs (`limb_order.ts`), an issue beneath
	530	* a higher limb comes before one beneath a lower limb, and one beneath no
	531	* limb after them all; within a limb the order is the one above.
512	532	*/
513	533	export function readyNow(graph: Graph): Ranked[] {
514		return clearNow(graph).filter(
	534	const ready = clearNow(graph).filter(
515	535	(r) =>
516	536	!graph.unadopted.has(r.issue.id) &&
517	537	!graph.structural.has(r.issue.id) &&
518	538	!graph.deferred.has(r.issue.id),
519	539	);
	540	const rank = graph.limbRank;
	541	if (rank === undefined) return ready;
	542	const of = (r: Ranked) => rank.get(r.issue.id) ?? Number.MAX_SAFE_INTEGER;
	543	return ready.sort((a, b) => of(a) - of(b));
520	544	}
521	545
522	546	/**
		@@ -0,0 +1,213 @@
	1	/**
	2	* The order of the limbs (#1064): which of a milestone's limbs comes first,
	3	* set by a person, and the crew's ready order that follows it.
	4	*
	5	* `limbTree` reads the shape once from a graph: what each issue waits for
	6	* with the plan's furniture left out, the top of the plan, and which
	7	* children are limbs (they bring a tree of their own) rather than leaves.
	8	* A person's places are stored per group of siblings — `TOP` for the top of
	9	* the plan, else the issue whose limbs they are — and a limb with no place
	10	* of its own follows the placed ones, by number. `limbRanks` walks the
	11	* ordered tree once: an issue's rank is the first limb that holds it, so one
	12	* beneath two limbs takes the higher. Nothing here queries per issue.
	13	*/
	14
	15	import type { Database } from "bun:sqlite";
	16	import type { Graph } from "./dependencies.ts";
	17	import type { Issue } from "./issues.ts";
	18	import { isStructural, type Pillars } from "./pillars.ts";
	19
	20	/** The group of siblings at the top of the plan. */
	21	export const TOP = "";
	22
	23	/** Stored places: group → limb → place (1 is first). */
	24	export type Places = ReadonlyMap<string, ReadonlyMap<string, number>>;
	25
	26	export interface LimbTree {
	27	/** Every issue that waits for something beyond the furniture, and what for. */
	28	readonly waitsFor: ReadonlyMap<string, readonly string[]>;
	29	readonly waitedBy: ReadonlyMap<string, readonly string[]>;
	30	/** Issues that wait for anything at all, the furniture included. */
	31	readonly waits: ReadonlySet<string>;
	32	/** The top-level limbs in their natural order: the pillars and Later, or the plan's roots. */
	33	readonly top: readonly Issue[];
	34	/** What an issue waits for directly, as its milestone shows it. */
	35	childrenOf(id: string): readonly string[];
	36	/** The children that bring a tree of their own, by number. */
	37	limbsOf(id: string): readonly string[];
	38	/** Every issue that has children. */
	39	parents(): readonly string[];
	40	}
	41
	42	export function limbTree(
	43	graph: Pick<Graph, "issues" \| "edges">,
	44	set: Pillars,
	45	): LimbTree {
	46	const byId = new Map(graph.issues.map((i) => [i.id, i]));
	47	const waitsFor = new Map<string, string[]>();
	48	const waitedBy = new Map<string, string[]>();
	49	const waits = new Set<string>();
	50	for (const edge of graph.edges) {
	51	waits.add(edge.issueId);
	52	if (isStructural(set, edge.blockedById)) continue;
	53	waitsFor.set(edge.issueId, [
	54	...(waitsFor.get(edge.issueId) ?? []),
	55	edge.blockedById,
	56	]);
	57	waitedBy.set(edge.blockedById, [
	58	...(waitedBy.get(edge.blockedById) ?? []),
	59	edge.issueId,
	60	]);
	61	}
	62	// Work behind the gate is Later's whether or not the Later umbrella waits
	63	// for it: its milestone counts what the map's Later row counts.
	64	const behindGate =
	65	set.gate === undefined
	66	? []
	67	: graph.edges
	68	.filter(
	69	(e) =>
	70	e.blockedById === set.gate!.id && !isStructural(set, e.issueId),
	71	)
	72	.map((e) => e.issueId);
	73	if (set.later !== undefined && behindGate.length > 0) waits.add(set.later.id);
	74	const childrenOf = (id: string): readonly string[] =>
	75	id === set.later?.id
	76	? [...new Set([...(waitsFor.get(id) ?? []), ...behindGate])]
	77	: (waitsFor.get(id) ?? []);
	78	const top: Issue[] =
	79	set.pillars.length > 0
	80	? [
	81	...set.pillars.map((p) => p.umbrella),
	82	...(set.later === undefined ? [] : [set.later]),
	83	]
	84	: graph.issues.filter(
	85	(i) =>
	86	i.state === "open" &&
	87	childrenOf(i.id).length > 0 &&
	88	!(waitedBy.get(i.id) ?? []).some(
	89	(id) => byId.get(id)?.state === "open",
	90	),
	91	);
	92	const parents = [
	93	...new Set([
	94	...waitsFor.keys(),
	95	...(set.later !== undefined && behindGate.length > 0 ? [set.later.id] : []),
	96	]),
	97	];
	98	return {
	99	waitsFor,
	100	waitedBy,
	101	waits,
	102	top,
	103	childrenOf,
	104	parents: () => parents,
	105	limbsOf(id) {
	106	const children = childrenOf(id)
	107	.map((c) => byId.get(c))
	108	.filter((i): i is Issue => i !== undefined)
	109	.sort((a, b) => a.number - b.number);
	110	// A child is a limb when it brings a tree of its own; one that only
	111	// waits for its siblings is a leaf in an order.
	112	const siblings = new Set(children.map((c) => c.id));
	113	return children
	114	.filter((c) => (waitsFor.get(c.id) ?? []).some((w) => !siblings.has(w)))
	115	.map((c) => c.id);
	116	},
	117	};
	118	}
	119
	120	/** Every stored place of one repository, in one read. */
	121	export function readPlaces(db: Database, repoId: string): Places {
	122	const out = new Map<string, Map<string, number>>();
	123	for (const row of db
	124	.query<{ parent_id: string; issue_id: string; place: number }, [string]>(
	125	`SELECT parent_id, issue_id, place FROM limb_place WHERE repo_id = ?1`,
	126	)
	127	.all(repoId)) {
	128	const group = out.get(row.parent_id) ?? new Map<string, number>();
	129	group.set(row.issue_id, row.place);
	130	out.set(row.parent_id, group);
	131	}
	132	return out;
	133	}
	134
	135	/** One group of siblings in order: the placed ones by place, then the rest as they came. */
	136	export function seated(
	137	places: Places,
	138	group: string,
	139	ids: readonly string[],
	140	): string[] {
	141	const mine = places.get(group);
	142	if (mine === undefined) return [...ids];
	143	const at = (id: string) => mine.get(id);
	144	const placed = ids
	145	.filter((id) => at(id) !== undefined)
	146	.sort((a, b) => at(a)! - at(b)!);
	147	return [...placed, ...ids.filter((id) => at(id) === undefined)];
	148	}
	149
	150	/** Every group that has limbs, each in order. */
	151	export function groupsOf(tree: LimbTree, places: Places): Map<string, string[]> {
	152	const out = new Map<string, string[]>();
	153	const top = tree.top.map((i) => i.id);
	154	if (top.length > 0) out.set(TOP, seated(places, TOP, top));
	155	for (const id of tree.parents()) {
	156	const limbs = tree.limbsOf(id);
	157	if (limbs.length > 0) out.set(id, seated(places, id, limbs));
	158	}
	159	return out;
	160	}
	161
	162	/**
	163	* Each issue's rank: the first limb, in the order of the limbs, that holds
	164	* it. A lower rank is higher. Issues beneath no limb have none.
	165	*/
	166	export function limbRanks(tree: LimbTree, places: Places): Map<string, number> {
	167	const rank = new Map<string, number>();
	168	const seen = new Set<string>();
	169	let next = 0;
	170	const visit = (id: string): void => {
	171	if (seen.has(id)) return;
	172	seen.add(id);
	173	const n = next++;
	174	if (!rank.has(id)) rank.set(id, n);
	175	for (const child of tree.childrenOf(id)) if (!rank.has(child)) rank.set(child, n);
	176	for (const limb of seated(places, id, tree.limbsOf(id))) visit(limb);
	177	};
	178	for (const id of seated(places, TOP, tree.top.map((i) => i.id))) visit(id);
	179	return rank;
	180	}
	181
	182	/** The places with one group set to this order, 1 for the first. */
	183	export function withGroup(
	184	places: Places,
	185	group: string,
	186	ids: readonly string[],
	187	): Places {
	188	const next = new Map(places);
	189	next.set(group, new Map(ids.map((id, n) => [id, n + 1])));
	190	return next;
	191	}
	192
	193	/** Keep one group's order. */
	194	export function savePlaces(
	195	db: Database,
		sentinelcrew 1mo ago High: this always writes rows, so moving a limb back to where it started (undo, or a raise followed by a lower) leaves `limb_place` non-empty, and the ready order stays limb-ranked for good. When `ids` equals the group's natural order (`seated(new Map(), group, natural)`), delete the group's rows and insert nothing.
	196	repoId: string,
	197	group: string,
	198	ids: readonly string[],
	199	): void {
	200	db.transaction(() => {
	201	db.query(`DELETE FROM limb_place WHERE repo_id = ?1 AND parent_id = ?2`).run(
	202	repoId,
	203	group,
	204	);
	205	ids.forEach((id, n) =>
	206	db
	207	.query(
	208	`INSERT INTO limb_place (repo_id, parent_id, issue_id, place) VALUES (?1, ?2, ?3, ?4)`,
	209	)
	210	.run(repoId, group, id, n + 1),
	211	);
	212	})();
	213	}
		@@ -0,0 +1,104 @@
	1	/**
	2	* A limb's seat (#1064): its place among its siblings, as a fleet row holds
	3	* it. A seat is `<group>:<place>`, the group being `top` or the number of
	4	* the issue whose limbs these are, the place counted from 1. A limb that is
	5	* a limb of several issues holds one seat in each. Moving a limb rewrites
	6	* its group's order whole, so the fleet's undo — the seat from before — puts
	7	* the others back with it.
	8	*/
	9
	10	import { repoGraph, type Graph } from "./dependencies.ts";
	11	import type { Database } from "bun:sqlite";
	12	import {
	13	groupsOf,
	14	limbTree,
	15	type LimbTree,
	16	readPlaces,
	17	savePlaces,
	18	TOP,
	19	type Places,
	20	} from "./limb_order.ts";
	21	import { pillarsOf } from "./pillars.ts";
	22	import type { Repo } from "./repos.ts";
	23
	24	export interface Seating {
	25	/** The seats an issue holds, `top` first, then by the number of the group. */
	26	of(issueId: string): readonly string[];
	27	/** How many limbs sit in a group (`top` or an issue number). */
	28	size(group: string): number;
	29	/** A group's limbs, in order, as issue ids. */
	30	order(group: string): readonly string[];
	31	/** The id of the issue a group names. */
	32	parentId(group: string): string \| undefined;
	33	readonly places: Places;
	34	/** What it was read from, for a caller that asks more of the same graph. */
	35	readonly graph: Graph;
	36	readonly tree: LimbTree;
	37	}
	38
	39	const SEAT = /^(top\|[1-9][0-9]{0,8}):([1-9][0-9]{0,5})$/;
	40
	41	/** A seat's group and place, or nothing when it is not one. */
	42	export function parseSeat(
	43	value: unknown,
	44	): { group: string; place: number } \| undefined {
	45	const m = typeof value === "string" ? SEAT.exec(value) : null;
	46	return m === null ? undefined : { group: m[1]!, place: Number(m[2]) };
	47	}
	48
	49	export function seating(
	50	db: Database,
	51	repo: Repo,
	52	read?: { graph: Graph; tree: LimbTree; places: Places },
	53	): Seating {
	54	const graph = read?.graph ?? repoGraph(db, repo.id);
	55	const tree = read?.tree ?? limbTree(graph, pillarsOf(db, repo));
	56	const places = read?.places ?? readPlaces(db, repo.id);
	57	const groups = groupsOf(tree, places);
	58	const numberOf = new Map(graph.issues.map((i) => [i.id, i.number]));
	59	const idOf = new Map(graph.issues.map((i) => [String(i.number), i.id]));
	60	const name = (id: string): string =>
	61	id === TOP ? "top" : String(numberOf.get(id) ?? 0);
	62	const keys = [...groups.keys()].sort((a, b) =>
	63	a === TOP ? -1 : b === TOP ? 1 : (numberOf.get(a) ?? 0) - (numberOf.get(b) ?? 0),
	64	);
	65	const held = new Map<string, string[]>();
	66	for (const key of keys)
	67	groups.get(key)!.forEach((id, n) =>
	68	held.set(id, [...(held.get(id) ?? []), `${name(key)}:${n + 1}`]),
	69	);
	70	const keyOf = (group: string): string =>
	71	group === "top" ? TOP : (idOf.get(group) ?? "\0");
	72	return {
	73	of: (id) => held.get(id) ?? [],
	74	size: (group) => groups.get(keyOf(group))?.length ?? 0,
	75	order: (group) => groups.get(keyOf(group)) ?? [],
	76	parentId: (group) => (group === "top" ? TOP : idOf.get(group)),
	77	places,
	78	graph,
	79	tree,
	80	};
	81	}
	82
	83	/** Seat a limb at a place in its group; undefined when it sits there, else why not. */
	84	export function moveLimb(
	85	db: Database,
	86	repo: Repo,
	87	issueId: string,
	88	seat: { group: string; place: number },
	89	): string \| undefined {
	90	const seats = seating(db, repo);
	91	const ids = [...seats.order(seat.group)];
	92	const at = ids.indexOf(issueId);
	93	if (at < 0) return "it is not one of those limbs";
	94	if (seat.place > ids.length) return `there are only ${ids.length} limbs there`;
	95	ids.splice(at, 1);
	96	ids.splice(seat.place - 1, 0, issueId);
	97	const group = seats.parentId(seat.group)!;
	98	// Back where it began is no order at all: the rows go, and the crew's
	99	// ready order is the natural one again.
	100	const natural = group === TOP ? seats.tree.top.map((i) => i.id) : seats.tree.limbsOf(group);
	101	const same = ids.length === natural.length && ids.every((id, n) => id === natural[n]);
	102	savePlaces(db, repo.id, group, same ? [] : ids);
	103	return undefined;
	104	}
		@@ -15,6 +15,14 @@
15	15
16	16	import type { Database } from "bun:sqlite";
17	17	import { deferredIn, repoGraph, type Graph } from "./dependencies.ts";
	18	import {
	19	limbTree,
	20	readPlaces,
	21	seated,
	22	TOP,
	23	type LimbTree,
	24	type Places,
	25	} from "./limb_order.ts";
18	26	import type { Issue } from "./issues.ts";
19	27	import {
20	28	isStructural,
		@@ -106,6 +114,8 @@ export interface Milestone extends Limb {
106	114	}
107	115
108	116	export interface Plan {
	117	/** What the plan was read from, for a caller that asks more of the same graph. */
	118	readonly read: { readonly graph: Graph; readonly tree: LimbTree; readonly places: Places };
109	119	/** The top-level limbs, in order: the pillars and Later, or the plan's roots. */
110	120	readonly limbs: readonly Limb[];
111	121	/**
		@@ -165,39 +175,10 @@ export function readPlan(
165	175	const byId = new Map(graph.issues.map((i) => [i.id, i]));
166	176	const byNumber = new Map(graph.issues.map((i) => [i.number, i]));
167	177
168		// What each issue waits for directly, furniture left out.
169		const waitsFor = new Map<string, string[]>();
170		const waitedBy = new Map<string, string[]>();
171		const waits = new Set<string>();
172		for (const edge of graph.edges) {
173		waits.add(edge.issueId);
174		if (isStructural(set, edge.blockedById)) continue;
175		waitsFor.set(edge.issueId, [
176		...(waitsFor.get(edge.issueId) ?? []),
177		edge.blockedById,
178		]);
179		waitedBy.set(edge.blockedById, [
180		...(waitedBy.get(edge.blockedById) ?? []),
181		edge.issueId,
182		]);
183		}
184		// Work behind the gate is Later's whether or not the Later umbrella waits
185		// for it: its milestone counts what the map's Later row counts.
186		const behindGate =
187		set.gate === undefined
188		? []
189		: graph.edges
190		.filter(
191		(e) =>
192		e.blockedById === set.gate!.id && !isStructural(set, e.issueId),
193		)
194		.map((e) => e.issueId);
195		if (set.later !== undefined && behindGate.length > 0) waits.add(set.later.id);
196		/** What an issue waits for directly, as its milestone shows it. */
197		const childrenOf = (id: string): string[] =>
198		id === set.later?.id
199		? [...new Set([...(waitsFor.get(id) ?? []), ...behindGate])]
200		: (waitsFor.get(id) ?? []);
	178	// What each issue waits for directly, furniture left out (`limb_order.ts`).
	179	const tree = limbTree(graph, set);
	180	const places = readPlaces(db, repo.id);
	181	const { waitsFor, waitedBy, waits, childrenOf } = tree;
201	182	const memo = new Map<string, Set<string>>();
202	183	const walking = new Set<string>();
203	184	const beneath = (id: string): Set<string> => {
		@@ -214,6 +195,11 @@ export function readPlan(
214	195	memo.set(id, out);
215	196	return out;
216	197	};
	198	/** Sibling limbs as issues, in the order a person set. */
	199	const arranged = (group: string, ids: readonly string[]): Issue[] =>
	200	seated(places, group, ids)
	201	.map((id) => byId.get(id))
	202	.filter((i): i is Issue => i !== undefined);
217	203
218	204	// Where the crew is: the issue a run is on, or the issue its pull closes.
219	205	const proposed = openPullsClosing(db, repo.id);
		@@ -354,24 +340,13 @@ export function readPlan(
354	340	};
355	341	};
356	342
357		const isMilestone = (id: string): boolean => childrenOf(id).length > 0;
358
359		const top: Issue[] =
360		set.pillars.length > 0
361		? [
362		...set.pillars.map((p) => p.umbrella),
363		...(set.later === undefined ? [] : [set.later]),
364		]
365		: graph.issues.filter(
366		(i) =>
367		i.state === "open" &&
368		isMilestone(i.id) &&
369		!(waitedBy.get(i.id) ?? []).some(
370		(id) => byId.get(id)?.state === "open",
371		),
372		);
	343	const top = arranged(
	344	TOP,
	345	tree.top.map((i) => i.id),
	346	);
373	347
374	348	return {
	349	read: { graph, tree, places },
375	350	limbs: top.map(limbOf),
376	351	limb(number: number): { own: Issue[]; shared: Issue[] } \| undefined {
377	352	const issue = byNumber.get(number);
		@@ -484,11 +459,7 @@ export function readPlan(
484	459	.map((id) => byId.get(id))
485	460	.filter((i): i is Issue => i !== undefined)
486	461	.sort((a, b) => a.number - b.number);
487		// A child is a limb when it brings a tree of its own; one that only
488		// waits for its siblings is a leaf in an order.
489		const siblings = new Set(children.map((c) => c.id));
490		const isLimb = (child: Issue): boolean =>
491		(waitsFor.get(child.id) ?? []).some((id) => !siblings.has(id));
	462	const limbIds = new Set(tree.limbsOf(issue.id));
492	463	const closedThisWeek = under.filter(
493	464	(i) =>
494	465	i.state === "closed" && counted(i) && (i.closedAt ?? "") >= since,
		@@ -534,9 +505,9 @@ export function readPlan(
534	505	.filter((pull) => pull.closes.some((n) => numbers.has(n)))
535	506	.map(({ number: n, title, at }) => ({ number: n, title, at })),
536	507	estimate,
537		limbs: children.filter(isLimb).map(limbOf),
	508	limbs: arranged(issue.id, [...limbIds]).map(limbOf),
538	509	leaves: children
539		.filter((c) => !isLimb(c))
	510	.filter((c) => !limbIds.has(c.id))
540	511	.map((c) => {
541	512	const state = stateOf(c);
542	513	const why =
		@@ -1584,6 +1584,17 @@ export const migrations: readonly string[] = [
1584	1584	ALTER TABLE look ADD COLUMN attached_by TEXT;
1585	1585	ALTER TABLE look ADD COLUMN note TEXT;
1586	1586	`,
	1587	// 75 — a limb's place among its siblings (#1064), set by a person. `parent_id`
	1588	// is the issue whose limbs these are, or '' for the top of the plan.
	1589	`
	1590	CREATE TABLE limb_place (
	1591	repo_id TEXT NOT NULL REFERENCES repo(id) ON DELETE CASCADE,
	1592	parent_id TEXT NOT NULL,
	1593	issue_id TEXT NOT NULL,
		sentinelcrew 1mo ago Minor, not blocking. `issue_id` and `parent_id` have no foreign key to `issue`, so deleting or transferring an issue leaves its `limb_place` rows behind. `readPlaces` then returns a non-empty map, and `repoGraph` keeps setting `limbRank` (and re-sorting `readyNow`) even when no live group has a set order. `seated` drops ids that are not in the tree, so the order shown stays right. Suggested fix: add `REFERENCES issue(id) ON DELETE CASCADE` to `issue_id` in a later migration, or have `moveLimb` prune the rows whose ids are gone.
	1594	place INTEGER NOT NULL,
	1595	PRIMARY KEY (repo_id, parent_id, issue_id)
	1596	);
	1597	`,
1587	1598	];
1588	1599
1589	1600	/**
		@@ -23,6 +23,7 @@ import { cancelRepoRun, requeueRepoRun } from "../actions/runs.ts";
23	23	import { isCrew } from "../core/agents.ts";
24	24	import { mergePull } from "../actions/pulls.ts";
25	25	import { bringUpToDate } from "../crew/autonomy.ts";
	26	import { moveLimb, parseSeat, type Seating } from "../core/limb_seats.ts";
26	27	import { getHold } from "../core/holds.ts";
27	28	import { recordInteraction, removeDismissals } from "../core/interactions.ts";
28	29	import { getPull } from "../core/pulls.ts";
		@@ -69,6 +70,8 @@ export interface Target {
69	70	readonly pillars?: Pillars;
70	71	/** For an issue: the numbers of the umbrellas that wait for it directly, ascending. */
71	72	readonly under?: readonly number[];
	73	/** For an issue: its repository's limbs in order, read on the first ask. */
	74	readonly seating?: () => Seating;
72	75	/** For an issue: the ids of every row this operation is over, itself included. */
73	76	readonly peers?: ReadonlySet<string>;
74	77	}
		@@ -676,4 +679,50 @@ export const VERBS: Record<string, Verb> = {
676	679	);
677	680	},
678	681	},
	682
	683	/**
	684	* Seat a limb among its siblings: the value is a seat, `<group>:<place>`
	685	* (`top` or an issue number, then the place from 1), and the limb takes
	686	* that place with the others moving over. The row holds every seat the
	687	* limb has, so undo is the seats from before. The order is kept here and
	688	* is not the origin's, so a mirror is no reason to refuse.
	689	*/
	690	place: {
	691	kind: "issue",
	692	reversible: true,
	693	parse: (_app, value) =>
	694	parseSeat(value) === undefined
	695	? err("place takes a seat: top:2, or the number of the milestone and the place, 12:1")
	696	: ok(String(value)),
	697	read: (t) => [...(t.seating?.().of(t.id) ?? [])],
	698	next: replace,
	699	nextFor(_t, before, value) {
	700	const want = parseSeat(value);
	701	const held = Array.isArray(before) ? before.map(String) : [];
	702	return want === undefined
	703	? held
	704	: held.map((seat) => (parseSeat(seat)?.group === want.group ? String(value) : seat));
	705	},
	706	refuse(_app, t, after) {
	707	const seats = t.seating?.();
	708	for (const seat of Array.isArray(after) ? after.map(String) : []) {
	709	const want = parseSeat(seat);
	710	if (want === undefined \|\| seats === undefined) return "not a seat";
	711	if (want.place > seats.size(want.group))
	712	return `there are only ${seats.size(want.group)} limbs there`;
	713	}
	714	return undefined;
	715	},
	716	async write(app, _actor, t, after) {
	717	const have = t.seating?.().of(t.id) ?? [];
	718	for (const seat of Array.isArray(after) ? after.map(String) : []) {
	719	const want = parseSeat(seat);
	720	if (want === undefined) return "not a seat";
	721	if (have.includes(seat)) continue;
	722	const why = moveLimb(app.db, t.repo, t.id, want);
	723	if (why !== undefined) return why;
	724	}
	725	return undefined;
	726	},
	727	},
679	728	};