@brainervirus/workit-core 7.6.0 → 7.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-core",
-  "version": "7.6.0",
+  "version": "7.7.0",
   "private": false,
   "description": "Workit shared core — task, policy, evidence, review, decision, worker, and writer state for agentic coding workflows",
   "keywords": [

package/skills/workit-fanout/SKILL.md

@@ -8,60 +8,60 @@ description: Run independent slices in parallel - one worker per isolated worktr
 Fan out only independent slices: disjoint files, no shared mutable state, each
 verifiable alone. Code-coupled work stays with one owner, who fans out after
 the blocking part lands. A worker whose whole job is re-running one command is
-ceremony; do it yourself.
+ceremony; do it yourself. Workit never spawns agents; you do.
 
 1. **Plan the slices** (workit-shape) in a plan file (`references/brief.md`):
-   per slice an id, branch, TIER, the file-scope manifest (SCOPE globs),
-   `owns` for shared files (lockfile, registry, barrels), `dependsOn` only for
-   a real dependency (independent PRs off trunk are the default), and the
-   brief fields. `workit fanout plan <plan.json>` refuses an empty or
-   placeholder (`<goal>`, `TBD`) brief field (exit 2) and two slices that may
-   write one file (exit 3) with a fix: an owner for a shared file, or a
-   dependency that serializes them. Apply it and re-run: refuse to spawn while
-   a field is empty or the plan is refused. Its `waves` say which slices may
-   run together; keep 4-6 in flight.
-2. **Brief each worker** from its slice with the fixed template: GOAL, SCOPE,
-   CONTEXT (pointers, not pasted text), ACCEPTANCE (Given/When/Then), VERIFY
-   (exact commands), TIER, TIMEBOX, SCRATCH, FORBIDDEN, REPORT, STANDING.
-   STANDING is every standing order and user directive so far, pasted
-   verbatim into each spawn and respawn: directives decay across resumes.
-3. **Spawn all workers in one message**, in the background, each in its own
-   worktree: Claude Code's `implementer` agent (first command `workit git
-   branch <branch> --base <base>`); elsewhere `workit fanout worktree create
-   <slice>`, which prints the SCRATCH dir. Refill from `fanout status`.
-4. **Judge liveness by side effects only:** `workit fanout status` (head age,
-   PR, CI, verdict, landed; STUCK past the TIMEBOX, default 30 min). Stop a
-   stuck worker and observe that it exited (a timeout is not proof). Removing
-   a worktree drops its uncommitted changes: `workit fanout worktree release
-   <slice>` records `git status` in the ledger first and refuses them without
-   `--force` (native worktrees: record `git -C <wt> status --short` first).
-   Respawn in `MODE: resume` (brief, directives, last report), same branch.
-   Never two live workers on one branch. Replace at most twice, then re-slice
-   or report the gap. Never chain resumes.
-5. **Verify each slice independently.** A fresh agent that did not write it
-   (Claude Code: the `verifier` agent) runs VERIFY and verify-<app>, then
-   `workit ledger verdict <result> --branch <b> --how "<evidence>"` under the
-   session you started it with (`WORKIT_SESSION_ID=<lead>-v<n>`, set by you,
-   never chosen by the author; Claude Code: the hook names one).
-   A worker's report is a pointer, never evidence.
-6. **Fan in** with `workit fanout check`: out-of-scope files (any file outside
-   it stops the fan-in), and `git merge-tree` conflicts with trunk and between
-   siblings, charged to the slice that lands later. Fix what it names (an
-   out-of-scope edit becomes a follow-up slice) until it exits 0. A slice
-   whose PR merged reads as landed; its dependents stop waiting. Then
-   `workit ledger check --branch <b>` per slice, land in `fanout status` order
-   and release the worktrees you made. Stacks: `workit stack plan <bottom> …
-   <top>` once, then `stack sync` and `land`. Only you touch topology: workers
-   never rebase, retarget or merge. Then ship (workit-ship).
+   per slice an id, branch, TIER, SCOPE globs, `owns` for shared files,
+   `dependsOn` only for a real dependency, and the brief fields. `workit fanout
+   plan <plan.json>` refuses an empty or placeholder brief field (exit 2) and
+   two slices that may write one file (exit 3) with a fix; apply it and re-run:
+   refuse to spawn while a field is empty or the plan is refused. One PR per
+   slice is the default; `"fanIn": "integration"` only when the user wants one
+   PR (`references/orchestration.md`).
+2. **Record standing orders** (`workit ledger standing add "<order>"`): every
+   user directive all workers share. Directives decay across resumes.
+3. **Brief each worker verbatim** with `workit fanout brief <slice>`: plan
+   fields, standing orders, SCRATCH, session id, fan-in rule. Never hand-edit
+   it; change the plan or the standing orders and render again.
+4. **Spawn in a rolling window**, in the background, each in its own worktree:
+   keep 4-6 in flight and refill from `spawnable` in `workit fanout status` as
+   each one finishes. Pick the model from TIER (`references/orchestration.md`).
+   Claude Code: the `implementer` agent; elsewhere first `workit fanout
+   worktree create <slice>`.
+5. **Judge liveness by side effects only:** `workit fanout status` (head age,
+   PR, CI, verdict, landed; STUCK past the TIMEBOX). Stop a stuck worker and
+   observe that it exited (a timeout is not proof). Removing a worktree drops
+   its uncommitted changes: `workit fanout worktree release <slice>` records
+   `git status` in the ledger first and refuses them without `--force`. Never
+   two live workers on one branch.
+6. **Retry once, then escalate.** A stuck or failed slice gets one retry with
+   a fresh brief (`workit fanout brief <slice> --mode resume`, same branch);
+   if that fails too, re-slice it, take it over, or report the gap. Never
+   chain resumes. A hard slice may race instead: N attempts, keep the best
+   verdict (`references/orchestration.md`).
+7. **Verify by the workspace `verification` setting** (`workit grant show`).
+   A report is a pointer, never evidence. `self`: a verifier that wrote none
+   of the slices, or you if you wrote none. `independent` or high risk: a
+   separate verifier session, never yours (doctrine: the ledger only refuses
+   authors). One verifier may take a batch of slices, one verdict per branch
+   (`workit ledger verdict <result> --branch <b> --how "<evidence>"`), in a
+   session never chosen by the author. A review panel on separate models only at high risk.
+8. **Fan in** with `workit fanout check`: out-of-scope files (any file outside
+   it stops the fan-in) and `git merge-tree` conflicts with trunk and between
+   siblings. Fix what it names until it exits 0; a merged slice reads as
+   landed. Then `workit ledger check --branch <b>` per slice, land in `fanout
+   status` order, release the worktrees you made, and `workit ledger standing
+   clear`. Only you touch topology: workers never rebase, retarget or merge,
+   except the integration-tip merge in integration mode. Then ship
+   (workit-ship).
 
 ## Example
 
 Bad brief: "Do the API part and add tests." (no scope, no acceptance, no
 verify command, so nobody can tell when it is done)
 
-Good brief: `references/brief.md` (GOAL: `GET /v1/usage` returns daily run
-counts; SCOPE: `src/routes/usage.ts`, `test/usage.test.ts`; VERIFY:
-`workit check test`; ...).
+Good brief: the output of `workit fanout brief usage-endpoint`
+(`references/brief.md` shows one).
 
 ## Check
 

package/skills/workit-fanout/references/brief.md

@@ -1,8 +1,11 @@
 # Worker brief template
 
-Every field is required. A brief with an empty field is not spawned. Point to
-files and ledger rows instead of pasting their content. Size the slice so the
-worker finishes it in about 150k tokens of context; split a larger one first.
+`workit fanout brief <slice>` renders this brief from the plan, the standing
+orders in force (`workit ledger standing list`) and the slice's scratch dir;
+pass its output verbatim. The template below is what it fills in. Every field
+is required. A brief with an empty field is not spawned. Point to files and
+ledger rows instead of pasting their content. Size the slice so the worker
+finishes it in about 150k tokens of context; split a larger one first.
 
 ```md
 MODE: <new | resume (a replacement continuing an existing branch)>
@@ -16,11 +19,12 @@ VERIFY: <exact commands, e.g. `workit check test`, the verify-<app> feature to d
 TIER: <mundane | standard | hard: how much model the slice needs>
 TIMEBOX: <wall clock or turn budget; past it without a new commit you will be replaced>
 SCRATCH: <your own temp dir: the one `fanout worktree create` printed, else `mktemp -d`; never a shared path>
-FORBIDDEN: <no edits outside SCOPE; no rebase, retarget, merge or force-push; no new dependencies; ...>
+FORBIDDEN: <no edits outside SCOPE; no new dependencies; ...>
+FAN-IN: <one PR per slice: no rebase, retarget, merge or force-push | integration: merge the integration tip before reporting, nothing else>
 REPORT: branch, head SHA, files changed, each VERIFY command with its exit code,
   each ACCEPTANCE line met / not met, rulings you made (`workit ledger ruling`),
   anything out of scope as a follow-up, not a diff.
-STANDING: <the standing orders, verbatim: user preferences and every directive given so far>
+STANDING: <the standing orders, verbatim: `workit ledger standing add` records each one>
   export WORKIT_SESSION_ID=<lead>-w<n>   (set by the lead; a verifier brief gets <lead>-v<n>)
 ```
 
@@ -40,7 +44,8 @@ VERIFY: `workit check test`; verify-api feature "usage"
 TIER: standard
 TIMEBOX: 45 minutes
 SCRATCH: ../app-wt/usage-endpoint/.workit-scratch
-FORBIDDEN: no edits outside SCOPE; no schema migration; no rebase or force-push; no new packages
+FORBIDDEN: no edits outside SCOPE; no schema migration; no new packages
+FAN-IN: one PR per slice. Never rebase, retarget, merge or force-push: the lead owns topology.
 REPORT: as in the template
 STANDING: conventional commits; no comments that restate code; ask nothing, record rulings instead
 ```
@@ -55,7 +60,9 @@ stack); `worktree` defaults to `../<repo>-wt/<id>`. `owns` claims a shared
 file another slice's glob also matches. Globs that match no file yet are compared
 through a sample path. Use `/` as the separator; a backslash only escapes
 literal brackets: `"app/\\[id\\]/page.tsx"`. A `timebox` such as `45 minutes`
-is the slice's STUCK threshold in `workit fanout status`.
+is the slice's STUCK threshold in `workit fanout status`. `"fanIn":
+"integration"` (with an integration branch as `trunk`) is the one-PR mode in
+`orchestration.md`; the default `"prs"` lands one PR per slice.
 
 ```json
 {
@@ -90,7 +97,7 @@ is the slice's STUCK threshold in `workit fanout status`.
 }
 ```
 
-## Worker rules (paste into the brief when the host has no implementer agent)
+## Worker rules (`workit fanout brief` appends them as RULES)
 
 1. First command. `MODE: new`: `workit git branch <branch> --base <base>` (the
    worktree may start on a name that breaks branch policy). `MODE: resume`:

package/skills/workit-fanout/references/orchestration.md

@@ -0,0 +1,117 @@
+# Running a fanout
+
+How the lead picks models, keeps workers flowing, retries, races, verifies
+and fans in. Workit records and checks; the host's own subagents run the work.
+
+## TIER to model
+
+TIER is a field of each slice and of its brief. Map it where the host lets you
+pick a model per spawn; nothing in the workspace config routes it.
+
+| TIER | Claude Code (`model` on the Agent call) | Hosts without a per-spawn model |
+| --- | --- | --- |
+| scouting (read-only search, not a slice) | `haiku` | host default |
+| mundane | `sonnet` | host default |
+| standard | omit it (inherits yours) | host default |
+| hard | omit it (inherits yours); consider a race | host default |
+
+OpenCode takes a subagent's model from its agent config: pick a configured
+agent whose model fits the TIER, else the default. Codex, Cursor and Pi run
+every worker on the host's model, so TIER only sizes the timebox and decides
+whether to race.
+
+## Rolling window
+
+Keep 4-6 workers in flight on Claude Code; elsewhere as many as the host runs
+in the background, never more than 6. Do not wait for a whole wave: when one
+worker finishes (its notification, or a new head or PR in `workit fanout
+status`), verify it, then spawn the next slice from `spawnable` in the same
+status output. A slice whose dependencies landed, or a stacked child whose
+parent is verified, appears there by itself.
+
+## Retry, then escalate
+
+A slice is retried when it is STUCK, its worker exits without meeting
+ACCEPTANCE, or its verdict fails. Stop the worker and observe that it exited.
+Release its worktree: `workit fanout worktree release <slice>` (native
+worktrees: record `git -C <wt> status --short` first). Then spawn one fresh
+worker with `workit fanout brief <slice> --mode resume`: same branch, and the
+brief points at its head and its ledger rows (last report, verdicts,
+rulings). If the retry fails too, escalate instead of a third worker:
+re-slice it smaller (`workit fanout plan` again), take it over yourself, or
+report the gap to the user.
+
+## Race a hard slice
+
+When a hard slice has an uncertain approach and a cheap VERIFY, run 2-3
+attempts at once instead of retrying in series. `workit fanout brief <slice>
+--attempt <n>` gives each attempt its own branch (`<branch>-try<n>`), session
+and scratch dir. Each attempt needs its own worktree: Claude Code's
+`implementer` isolates natively; on other hosts `fanout worktree create` makes
+only the slice's own worktree, so run the attempts one after another there.
+Verify every attempt, keep the one with the best verdict (accepted first,
+then the fewest changed files, then the earliest), point the slice branch at
+it (`git branch <branch> <winner>`), have the verifier record the verdict on
+`<branch>` (same head), and delete the losing attempt branches.
+
+## Verification
+
+Follow the workspace `verification` setting (`workit grant show`); the
+worker never records a verdict on its own work.
+
+- `self` (the default): a verifier that wrote none of the slices records the
+  verdicts. A lead that authored none of the slices may record them in its
+  own session.
+- `independent`, and any slice at high risk: a separate verifier session
+  records them, never the lead's own; at high risk one verifier per slice,
+  plus a review panel (below). This is doctrine, not enforced: the ledger
+  only tells a branch's authors from everyone else, and a lead that wrote
+  none of it counts as independent.
+
+Which session id a verdict carries, per host:
+
+- Claude Code: subagents inherit your `WORKIT_SESSION_ID`, so the
+  SubagentStart hook names each `verifier` and `reviewer` its own session
+  (`<lead>:<agent id>`), passed as `--session`; that one wins over any
+  `<lead>-v<n>` in a brief. An `implementer` uses the session its brief
+  exports for its workit commands.
+- Other hosts: the session the brief sets wins: `export
+  WORKIT_SESSION_ID=<lead>-w-<slice>` from `workit fanout brief` for a
+  worker, `<lead>-v<n>` (or `--as verifier`) for a verifier you start.
+
+A batch verifier takes several slices on one surface in one session: for
+each branch it checks out the head, runs that slice's VERIFY, and records its
+own `workit ledger verdict <result> --branch <b> --how "<evidence>"`. Every
+verdict is keyed to that branch's head SHA; a slice whose head moves after
+it needs a new one. Batch at most what fits one context, about 4 slices.
+
+## Review panel (high risk only)
+
+At risk=high only, 2-3 fresh reviewers (workit-review), each on a model
+other than the author's (Claude Code: a different `model`), each records
+`workit ledger verdict <result> --kind review --branch <b> --how "<findings>"`.
+Land only when every panel verdict passes. Below high risk a panel costs
+more than it finds.
+
+## Integration-branch fan-in (one PR)
+
+Only when the user wants one PR for the whole fanout:
+
+1. Cut the integration branch (`workit git branch <integration> --base
+   <trunk>`) and plan with `"fanIn": "integration"` and `--trunk
+   <integration>`. Planning refuses integration mode on origin's default
+   branch.
+2. Every brief then tells the worker to merge the integration tip into its
+   branch before reporting (the fast-forward rule). That merge is the only
+   one a worker makes, and only in this mode.
+3. Land each verified slice with `git merge --ff-only <slice-branch>` in the
+   integration checkout. Not a fast-forward (the tip moved since the worker
+   merged)? Resume the worker to merge again; never a merge commit of your own.
+4. `workit fanout check` gates against the integration branch; a slice whose
+   tip is on it reads as landed. When all have landed, ship the integration
+   branch as one PR (workit-ship).
+
+## Stacks
+
+For stacked slices (`dependsOn` one parent): `workit stack plan <bottom> …
+<top>` once, then `workit stack sync` and `workit stack land`.

package/src/fanout-brief.ts

@@ -0,0 +1,178 @@
+// `workit fanout brief <slice>`: the complete worker brief, rendered from the
+// plan, the standing orders in force for the fanout (`workit ledger standing`)
+// and the slice's scratch dir, so the lead passes it to the worker verbatim.
+//
+// MODE is `resume` when the branch already exists (a retry continues it),
+// else `new`; `--attempt <n>` renders one attempt of a race on its own branch
+// `<branch>-try<n>` (refused when another slice has that branch), worktree
+// `<worktree>+try<n>` and session `<lead>-w-<slice>+try<n>`: slice ids cannot
+// contain `+`, so no attempt collides with another slice's path or session.
+// The lead must have a WORKIT_SESSION_ID: worker ids derive from it. A
+// worker id longer than the ledger's 128 characters hashes its slice part. The fan-in line follows the plan's `fanIn`:
+// one PR per slice forbids every merge; integration mode has the worker merge
+// the integration tip before reporting, and nothing else. It only reads, apart
+// from hiding `.workit-scratch/` in the repository's info/exclude.
+import { createHash } from "node:crypto";
+import { activeStanding, readLedger, type LedgerActor } from "./ledger";
+import { branchRef, fanoutFail, planLeads, type FanoutFile, type FanoutResult } from "./fanout";
+import {
+  SCRATCH_DIR,
+  excludeScratch,
+  findSlice,
+  listWorktrees,
+  samePath,
+  slicePath,
+} from "./fanout-worktree";
+
+export type BriefMode = "new" | "resume";
+
+export type BriefOutcome = {
+  fanout: string;
+  slice: string;
+  mode: BriefMode;
+  attempt: number | null;
+  branch: string;
+  base: string;
+  tier: string;
+  /** Absolute when the slice's worktree exists, else relative to the worker's worktree root. */
+  scratch: string;
+  session: string;
+  standing: Array<{ id: string; what: string }>;
+  text: string;
+};
+
+export const DEFAULT_TIMEBOX = "30 minutes";
+
+const REPORT = [
+  "REPORT: branch, head SHA, files changed, each VERIFY command with its exit code,",
+  "  each ACCEPTANCE line met / not met, rulings you made (`workit ledger ruling`),",
+  "  anything out of scope as a follow-up, not a diff.",
+];
+
+const rules = (mode: BriefMode, branch: string, base: string): string[] => [
+  "RULES:",
+  mode === "new"
+    ? `  1. First command: \`workit git branch ${branch} --base ${base}\` (your worktree may start on another name).`
+    : `  1. First command: \`git switch ${branch}\`, then continue from its head.`,
+  '  2. Decide ambiguities yourself: `workit ledger ruling "<what>" --why "<why>" --cost-if-wrong "<cost>"`; stop only for an irreversible, security-sensitive or out-of-worktree action.',
+  "  3. Commit with `workit git commit -m <msg> -- <paths in SCOPE>`; push only if this brief says so.",
+  "  4. Never record a verdict on your own work.",
+];
+
+/** A session id fragment that the ledger accepts ([A-Za-z0-9_.:@/+-]). */
+const sessionSafe = (text: string): string => text.replace(/[^A-Za-z0-9_.:@/+-]/gu, "-");
+
+/** The ledger's session id limit. */
+const SESSION_MAX = 128;
+
+/** `<lead>-w-<slice>[+try<n>]`, with the slice part hashed when the whole would be too long. */
+function workerSession(lead: string, slice: string, attempt: number | null): string {
+  const tail = attempt === null ? "" : `+try${attempt}`;
+  const full = `${lead}-w-${slice}${tail}`;
+  if (full.length <= SESSION_MAX) return full;
+  const digest = createHash("sha256").update(slice).digest("hex").slice(0, 12);
+  return `${lead.slice(0, SESSION_MAX - 3 - digest.length - tail.length)}-w-${digest}${tail}`;
+}
+
+export function renderBrief(
+  cwd: string,
+  plan: FanoutFile,
+  input: { slice: string; mode: BriefMode | null; attempt: number | null; actor: LedgerActor },
+): FanoutResult<BriefOutcome> {
+  const found = findSlice(plan, input.slice);
+  if (!found.ok) return found;
+  const slice = found.data;
+  const ledger = readLedger(cwd);
+  if (!ledger.ok) return fanoutFail(ledger.code, ledger.error, ledger.unblock);
+  if (!input.actor.session)
+    return fanoutFail(
+      "blocked",
+      "WORKIT_SESSION_ID is not set: worker session ids derive from the lead's",
+      "export WORKIT_SESSION_ID=<your session id>, then render the brief again",
+    );
+  const branch = input.attempt === null ? slice.branch : `${slice.branch}-try${input.attempt}`;
+  const taken = plan.slices.find((other) => other.id !== slice.id && other.branch === branch);
+  if (taken)
+    return fanoutFail(
+      "invalid_input",
+      `attempt branch ${branch} is slice ${taken.id}'s branch`,
+      "pick another --attempt number, or rename one of the branches in the plan",
+    );
+  const head = branchRef(cwd, branch);
+  const mode: BriefMode = input.mode ?? (head ? "resume" : "new");
+  if (mode === "resume" && !head)
+    return fanoutFail(
+      "not_found",
+      `MODE resume needs the branch ${branch}, which does not exist here`,
+      `workit fanout brief ${slice.id} --mode new`,
+    );
+
+  const planned = `${slicePath(cwd, slice)}${input.attempt === null ? "" : `+try${input.attempt}`}`;
+  const exists = listWorktrees(cwd).some((entry) => samePath(entry.path, planned));
+  excludeScratch(cwd);
+  const scratch = exists ? `${planned}/${SCRATCH_DIR}` : SCRATCH_DIR;
+  const scratchLine = exists
+    ? `SCRATCH: ${scratch}  (yours alone; temp files go here, never a shared path)`
+    : `SCRATCH: ${SCRATCH_DIR}/ at your worktree root (mkdir -p it; git ignores it; never a shared path)`;
+
+  const standing = activeStanding(ledger.value.rows, plan.name, planLeads(plan)).map((row) => ({
+    id: row.id,
+    what: String(row.what),
+  }));
+  const session = workerSession(sessionSafe(input.actor.session), slice.id, input.attempt);
+  const fanIn =
+    plan.fanIn === "integration"
+      ? [
+          `FAN-IN: integration branch ${plan.trunk}. Before you report, merge its tip into your branch`,
+          `  (\`git merge --no-edit ${plan.trunk}\`), resolve conflicts inside SCOPE and re-run VERIFY, so the`,
+          "  lead's merge is a fast-forward. No other merge, and no rebase, retarget or force-push.",
+        ]
+      : [
+          "FAN-IN: one PR per slice. Never rebase, retarget, merge or force-push: the lead owns topology.",
+        ];
+
+  const lines = [
+    `MODE: ${mode}${input.attempt === null ? "" : `  (race attempt ${input.attempt}: the lead keeps the attempt with the best verdict)`}`,
+    `GOAL: ${slice.goal}`,
+    `SCOPE: ${slice.scope.join(", ")}`,
+    ...(slice.owns.length ? [`  owns: ${slice.owns.join(", ")}`] : []),
+    `  branch: ${branch}   base: ${slice.base}`,
+    `CONTEXT: ${slice.context ?? "none given: read the files in SCOPE and the neighbours they import"}`,
+    ...(mode === "resume" && head
+      ? [
+          `  resume: continue ${branch} from ${head.slice(0, 12)}; read \`git log ${slice.base}..${branch}\` and \`workit ledger list --branch ${branch}\` (the last report, verdicts, rulings)`,
+        ]
+      : []),
+    "ACCEPTANCE:",
+    ...slice.acceptance.map((line) => `  - ${line}`),
+    `VERIFY: ${slice.verify.join("; ")}`,
+    `TIER: ${slice.tier}`,
+    `TIMEBOX: ${slice.timebox ?? DEFAULT_TIMEBOX}; past it without a new commit you will be replaced`,
+    scratchLine,
+    `FORBIDDEN: ${slice.forbidden.join("; ")}`,
+    ...fanIn,
+    ...REPORT,
+    "STANDING:",
+    ...(standing.length
+      ? standing.map((order) => `  - ${order.what}`)
+      : ["  - none recorded beyond this brief"]),
+    `  export WORKIT_SESSION_ID=${session}`,
+    ...rules(mode, branch, slice.base),
+  ];
+  return {
+    ok: true,
+    data: {
+      fanout: plan.name,
+      slice: slice.id,
+      mode,
+      attempt: input.attempt,
+      branch,
+      base: slice.base,
+      tier: slice.tier,
+      scratch,
+      session,
+      standing,
+      text: `${lines.join("\n")}\n`,
+    },
+  };
+}

package/src/fanout-check.ts

@@ -293,7 +293,8 @@ export function sliceLandings(
         createdFrom: sliceStart(cwd, rows, plan.name, slice),
         parentHead,
         fanout: plan.name,
-        since: plan.createdAt || null,
+        since: slice.hashSince || plan.createdAt || null,
+        sliceHash: slice.hash || null,
         rows,
       }),
     );

package/src/fanout-landed.ts

@@ -12,8 +12,10 @@
 //   commit (a squash merge that applied without the trunk touching the same
 //   lines). Anything else reads as not landed.
 // A merged PR whose branch is gone counts only when the ledger links that
-// branch to this slice (a worktree row, or a row recorded on its merged
-// head), so a reused branch name from older work is not taken for this slice.
+// branch to this slice: a worktree row made under the slice's current hash,
+// or a row recorded on its merged head since that hash was planned. A reused
+// branch name from older work, an older plan of the same name, or an earlier
+// definition of this slice never links; editing a sibling changes nothing.
 // A landing whose changed paths read on the trunk exactly as before it (a
 // revert) is not landed; the note says so.
 // The forge is asked through a breaker: after the first unavailable answer
@@ -184,24 +186,44 @@ function trunkPatchIds(ctx: LandingContext, fork: string): Set<string> {
   return ids;
 }
 
+/**
+ * Does `row` belong to the slice's current run? A worktree row made under its
+ * hash does; any other row only when recorded since that hash was planned.
+ */
+export function inSliceRun(
+  row: Record<string, unknown>,
+  slice: Pick<Slice, "hash" | "hashSince">,
+): boolean {
+  if (row.type === "fanout.worktree.created" && typeof row.sliceHash === "string" && slice.hash)
+    return row.sliceHash === slice.hash;
+  const since = Date.parse(slice.hashSince);
+  return Number.isNaN(since) || Date.parse(String(row.at)) >= since;
+}
+
 /** The ledger links `branch` to this slice: a worktree row, or a row recorded on `head`. */
 function linked(
   rows: readonly Record<string, unknown>[],
-  input: Pick<LandingInput, "fanout" | "since">,
+  input: Pick<LandingInput, "fanout" | "since" | "sliceHash">,
   slice: Pick<Slice, "id" | "branch">,
   head: string | null,
 ): boolean {
-  // Only rows from this run of the fanout: a plan of the same name made
-  // earlier must not lend its merged PRs to this one.
+  // Only rows from this run of the slice: a plan of the same name made
+  // earlier, or this slice re-planned with another definition, lends nothing.
   const since = input.since ? Date.parse(input.since) : Number.NaN;
-  return rows.some(
-    (row) =>
-      (Number.isNaN(since) || Date.parse(String(row.at)) >= since) &&
-      ((row.type === "fanout.worktree.created" &&
-        row.fanout === input.fanout &&
-        row.slice === slice.id) ||
-        (head !== null && row.branch === slice.branch && row.head === head)),
-  );
+  const recent = (row: Record<string, unknown>) =>
+    Number.isNaN(since) || Date.parse(String(row.at)) >= since;
+  return rows.some((row) => {
+    if (
+      row.type === "fanout.worktree.created" &&
+      row.fanout === input.fanout &&
+      row.slice === slice.id
+    )
+      // A row from before slice hashes falls back to its time.
+      return typeof row.sliceHash === "string" && input.sliceHash
+        ? row.sliceHash === input.sliceHash
+        : recent(row);
+    return recent(row) && head !== null && row.branch === slice.branch && row.head === head;
+  });
 }
 
 export type LandingInput = {
@@ -212,8 +234,10 @@ export type LandingInput = {
   /** Its dependency branch's tip (or merged head) for a stacked slice. */
   parentHead: string | null;
   fanout: string;
-  /** When this fanout plan was first made (FanoutFile.createdAt): older rows do not link. */
+  /** When this slice definition was first planned (Slice.hashSince): older rows do not link. */
   since: string | null;
+  /** The slice's definition hash: worktree rows link only under the same one. */
+  sliceHash: string | null;
   rows: readonly Record<string, unknown>[];
 };
 
@@ -298,7 +322,7 @@ export function sliceStart(
   cwd: string,
   rows: readonly Record<string, unknown>[],
   fanout: string,
-  slice: Pick<Slice, "id" | "branch">,
+  slice: Pick<Slice, "id" | "branch" | "hash" | "hashSince">,
 ): string | null {
   const reflog = branchCreatedAt(cwd, slice.branch);
   if (reflog) return reflog;
@@ -307,7 +331,8 @@ export function sliceStart(
       candidate.type === "fanout.worktree.created" &&
       candidate.fanout === fanout &&
       candidate.slice === slice.id &&
-      typeof candidate.baseSha === "string",
+      typeof candidate.baseSha === "string" &&
+      inSliceRun(candidate, slice),
   );
   return (row?.baseSha as string | undefined) ?? null;
 }

package/src/fanout-status.ts

@@ -20,7 +20,7 @@ import { checksState, gatingChecks, missingRequired, type ChecksState } from "./
 import type { ResolvedForge } from "./forge/resolve";
 import { checkVerdicts, readLedger, type ReadRow, type VerdictBasis } from "./ledger";
 import { sliceLandings } from "./fanout-check";
-import { forgeBreaker } from "./fanout-landed";
+import { forgeBreaker, inSliceRun } from "./fanout-landed";
 import {
   branchRef,
   fanoutFail,
@@ -123,6 +123,8 @@ function activity(cwd: string, plan: FanoutFile, slice: Slice, rows: readonly Re
     ]).stdout,
   );
   const reflog = moved ? isoOf(moved[1]) : null;
+  // Liveness reads every row on the branch or slice: re-planning a slice
+  // never makes a live worker look idle.
   const ledger = rows
     .filter(
       (row) => row.branch === slice.branch || (row.fanout === plan.name && row.slice === slice.id),
@@ -136,7 +138,8 @@ function activity(cwd: string, plan: FanoutFile, slice: Slice, rows: readonly Re
       (row) =>
         row.type === "fanout.worktree.created" &&
         row.fanout === plan.name &&
-        row.slice === slice.id,
+        row.slice === slice.id &&
+        inSliceRun(row, slice),
     ),
   };
 }
@@ -267,7 +270,8 @@ export function fanoutStatus(
         (candidate) =>
           candidate.type === "fanout.worktree.created" &&
           candidate.fanout === plan.name &&
-          candidate.slice === id,
+          candidate.slice === id &&
+          inSliceRun(candidate, byId.get(id) as Slice),
       );
       row.state = created ? "active" : "not_started";
       if (!created) spawnable.push(id);

package/src/fanout-worktree.ts

@@ -12,10 +12,17 @@
 // (`fanout.worktree.released`), refuses while it has uncommitted changes
 // unless forced, then runs `git worktree remove` (which takes the scratch dir
 // with it). The branch is kept. It only removes a worktree that `create` made
-// for this fanout, slice and path (its ledger row says so), on the slice's
-// branch or detached; never the main checkout, the one the command runs in,
-// or a worktree someone else made there, not even with --force. An empty
+// for this fanout, slice and path, on the slice's branch or detached; never
+// the main checkout, the one the command runs in, or a worktree someone else
+// made there, not even with --force. "Made by create" is exact: create writes
+// a random token into git's admin dir for the worktree
+// (`.git/worktrees/<id>/workit-fanout-token`) and records it with the admin
+// dir's id and inode; release and adopt need all three to match. A worktree
+// removed by hand and re-added at the path gets a new admin dir without the
+// token, on any filesystem (no birth time needed). A row from before the
+// token is matched by time only, so release refuses --force for it. An empty
 // directory that existed before `create` is left in place.
+import { randomBytes } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { gitBranch } from "./git/ops";
@@ -68,7 +75,7 @@ const canonical = (target: string): string => {
   }
 };
 
-const samePath = (a: string, b: string): boolean => {
+export const samePath = (a: string, b: string): boolean => {
   const left = canonical(a);
   const right = canonical(b);
   return process.platform === "win32" || process.platform === "darwin"
@@ -82,7 +89,7 @@ const inside = (child: string, parent: string): boolean => {
 };
 
 /** `git worktree list --porcelain -z`; the first entry is the main worktree. */
-function listWorktrees(cwd: string): WorktreeEntry[] {
+export function listWorktrees(cwd: string): WorktreeEntry[] {
   const out: WorktreeEntry[] = [];
   let current: WorktreeEntry | null = null;
   for (const field of gitRun(cwd, ["worktree", "list", "--porcelain", "-z"]).stdout.split("\0")) {
@@ -98,7 +105,7 @@ function listWorktrees(cwd: string): WorktreeEntry[] {
 }
 
 /** The slice's worktree path: absolute since plan time; an older relative one is the main checkout's. */
-const slicePath = (cwd: string, slice: Slice): string =>
+export const slicePath = (cwd: string, slice: Slice): string =>
   path.isAbsolute(slice.worktree)
     ? slice.worktree
     : path.resolve(mainCheckout(cwd), slice.worktree);
@@ -110,8 +117,10 @@ const CLOCK_SLACK_MS = 2000;
  * The live `fanout.worktree.created` row for this fanout, slice and path:
  * the newest one, unless a later release removed that worktree (a row is
  * void once its worktree is gone), and only while the worktree at the path
- * is the one it recorded: git's admin dir for it (`.git/worktrees/<id>`) was
- * made no earlier than the row. Anything else is someone else's worktree.
+ * is the one it recorded. `exact`: the admin dir's token, id and inode match
+ * the row. A row without a token (written before it) matches when the admin
+ * dir is no older than the row, which a re-added worktree also passes, so it
+ * is never exact. Anything else is someone else's worktree.
  */
 function createdRow(cwd: string, plan: FanoutFile, slice: Slice, target: string) {
   const ledger = readLedger(cwd);
@@ -134,24 +143,75 @@ function createdRow(cwd: string, plan: FanoutFile, slice: Slice, target: string)
       atPath(candidate),
   );
   if (removedSince) return null;
-  const made = adminDirTime(target);
-  if (made === null || made + CLOCK_SLACK_MS < Date.parse(row.at)) return null;
-  return row;
+  const admin = adminDir(target);
+  if (!admin) return null;
+  if (typeof row.adminToken === "string")
+    return row.adminToken === admin.token && row.adminId === admin.id && row.adminIno === admin.ino
+      ? { row, exact: true }
+      : null;
+  const made = admin.birthMs ?? admin.mtimeMs;
+  if (made + CLOCK_SLACK_MS < Date.parse(row.at)) return null;
+  return { row, exact: false };
 }
 
-/** When git made the worktree's admin dir (birth time, else mtime); null when unknown. */
-function adminDirTime(worktree: string): number | null {
+const TOKEN_FILE = "workit-fanout-token";
+
+/** The filesystem calls identity relies on; tests stub them. */
+export const worktreeDeps = {
+  stat: (file: string): fs.BigIntStats => fs.statSync(file, { bigint: true }),
+};
+
+type AdminDir = {
+  path: string;
+  /** `<id>` of `.git/worktrees/<id>`. */
+  id: string;
+  ino: string;
+  /** The token create wrote there, or null. */
+  token: string | null;
+  birthMs: number | null;
+  mtimeMs: number;
+};
+
+/** Git's admin dir for the worktree: what tells this worktree from a later one at the path. */
+function adminDir(worktree: string): AdminDir | null {
   const dir = gitRun(worktree, ["rev-parse", "--absolute-git-dir"]);
   if (!dir.ok) return null;
+  const file = dir.stdout.trim();
+  let token: string | null = null;
+  try {
+    token = fs.readFileSync(path.join(file, TOKEN_FILE), "utf8").trim() || null;
+  } catch {
+    token = null;
+  }
+  try {
+    const stat = worktreeDeps.stat(file);
+    return {
+      path: file,
+      id: path.basename(file),
+      ino: stat.ino.toString(),
+      token,
+      birthMs: stat.birthtimeNs > 0n ? Number(stat.birthtimeMs) : null,
+      mtimeMs: Number(stat.mtimeMs),
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** Mark the admin dir of a worktree create just made; null when it cannot. */
+function markAdminDir(worktree: string): (AdminDir & { token: string }) | null {
+  const admin = adminDir(worktree);
+  if (!admin) return null;
+  const token = randomBytes(16).toString("hex");
   try {
-    const stat = fs.statSync(dir.stdout.trim());
-    return stat.birthtimeMs > 0 ? stat.birthtimeMs : stat.mtimeMs;
+    fs.writeFileSync(path.join(admin.path, TOKEN_FILE), `${token}\n`);
   } catch {
     return null;
   }
+  return { ...admin, token };
 }
 
-function findSlice(plan: FanoutFile, id: string): FanoutResult<Slice> {
+export function findSlice(plan: FanoutFile, id: string): FanoutResult<Slice> {
   const slice = plan.slices.find((candidate) => candidate.id === id);
   return slice
     ? { ok: true, data: slice }
@@ -163,7 +223,7 @@ function findSlice(plan: FanoutFile, id: string): FanoutResult<Slice> {
 }
 
 /** Hide the scratch dir from git status and `git add -A` in every worktree. */
-function excludeScratch(cwd: string): void {
+export function excludeScratch(cwd: string): void {
   const common = gitCommonDir(cwd);
   if (!common) return;
   const file = path.join(common, "info", "exclude");
@@ -325,6 +385,7 @@ export function createSliceWorktree(
   const scratch = ensureScratch(target);
   const head = gitRun(target, ["rev-parse", "HEAD"]).stdout.trim();
   const baseSha = mode === "new" ? head : null;
+  const admin = markAdminDir(target);
   appendObserved(cwd, {
     type: "fanout.worktree.created",
     actor: input.actor,
@@ -337,6 +398,8 @@ export function createSliceWorktree(
     head,
     dirExisted,
     planCreatedAt: plan.createdAt,
+    sliceHash: slice.hash,
+    ...(admin ? { adminId: admin.id, adminIno: admin.ino, adminToken: admin.token } : {}),
     ...(baseSha ? { baseSha } : {}),
   });
   return { ok: true, data: { ...base, scratch, head, mode, created: true, notes } };
@@ -410,13 +473,20 @@ export function releaseSliceWorktree(
       "blocked",
       `${entry.path} is on ${entry.branch.replace(/^refs\/heads\//u, "")}, not slice ${slice.id}'s ${slice.branch}; nothing was removed`,
     );
-  const made = createdRow(cwd, plan, slice, entry.path);
-  if (!made)
+  const owned = createdRow(cwd, plan, slice, entry.path);
+  if (!owned)
     return fanoutFail(
       "blocked",
       `${entry.path} was not made by workit fanout worktree create for slice ${slice.id} (no ledger row); nothing was removed`,
       `remove it yourself (git worktree remove ${entry.path}) once you know what it holds`,
     );
+  if (input.force && !owned.exact)
+    return fanoutFail(
+      "blocked",
+      `${entry.path} was created before workit recorded worktree identity, so it cannot be told from a worktree someone re-added there; --force is refused and nothing was removed`,
+      `release it without --force, or remove it yourself (git worktree remove ${entry.path}) once you know what it holds`,
+    );
+  const made = owned.row;
   out.head = entry.head;
   const status = gitRun(entry.path, [
     "status",

package/src/fanout.ts

@@ -18,12 +18,33 @@
 // deterministic suggestion: an owner for known shared files (lockfiles,
 // manifests, barrels, CI config), else a dependency that serializes them.
 //
+// Each slice's `hash` covers what it is (goal, acceptance, verify, forbidden,
+// scope, owns, branch, base, dependencies), not how it is briefed (tier,
+// timebox, context) or where its worktree goes. A re-plan that changes a
+// slice starts a new run for that slice alone: its `hashSince` moves to now,
+// and only ledger rows recorded under its hash (worktree rows carry
+// `sliceHash`) or since then link a gone branch's merged PR to it or count as
+// its worktree. Liveness still reads every row. Its siblings keep their runs.
+//
+// `fanIn: "integration"` is the one-PR mode: the trunk is an integration
+// branch (never origin's default branch), workers merge its tip into their
+// branch before reporting, and the lead fast-forwards it.
+//
 // The CLI never spawns, waits or wakes anything: it only records and checks.
 import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { GIT_TIMEOUTS, gitCommonDir, pushRemoteName, resolveRef } from "./git/rev";
-import { appendObserved, defaultBase, storeRoot, type LedgerActor } from "./ledger";
+import {
+  activeStanding,
+  appendObserved,
+  isDelegateSession,
+  defaultBase,
+  readLedger,
+  storeRoot,
+  type LedgerActor,
+} from "./ledger";
 import { stackFileName } from "./stack";
 
 export const FANOUT_VERSION = 1;
@@ -48,15 +69,28 @@ export type Slice = {
   forbidden: string[];
   context: string | null;
   timebox: string | null;
+  /** sliceHash of this definition: which run of the slice a ledger row belongs to. */
+  hash: string;
+  /** When a slice with this hash was first planned: older rows are not its run. */
+  hashSince: string;
 };
 
+export const FAN_IN_MODES = ["prs", "integration"] as const;
+export type FanInMode = (typeof FAN_IN_MODES)[number];
+
 export type FanoutFile = {
   v: number;
   name: string;
   trunk: string;
+  /** prs: one PR per slice (default); integration: slices fast-forward one integration branch. */
+  fanIn: FanInMode;
   /** Extra shared-file globs on top of DEFAULT_SHARED. */
   shared: string[];
   slices: Slice[];
+  /** The lead: the session that made the plan or took it over (`--take-lead`). */
+  leadSession: string | null;
+  /** Leads it took over from: their standing orders stay in force until cleared. */
+  formerLeads: string[];
   createdAt: string;
   updatedAt: string;
 };
@@ -308,6 +342,9 @@ export function parsePlan(raw: unknown, defaults: PlanDefaults, name?: string |
     if ("error" in normalized) problems.push(`shared "${entry}" ${normalized.error}`);
     else shared.push(normalized.pattern);
   }
+  const fanIn = raw.fanIn ?? "prs";
+  if (!(FAN_IN_MODES as readonly unknown[]).includes(fanIn))
+    problems.push(`fanIn must be one of ${FAN_IN_MODES.join(", ")}`);
   if (!Array.isArray(raw.slices) || raw.slices.length === 0)
     return { ok: false, problems: [...problems, "slices: list at least one slice"] };
 
@@ -388,6 +425,8 @@ export function parsePlan(raw: unknown, defaults: PlanDefaults, name?: string |
       forbidden,
       context: optional("context"),
       timebox: optional("timebox"),
+      hash: "",
+      hashSince: "",
     });
   });
 
@@ -419,8 +458,11 @@ export function parsePlan(raw: unknown, defaults: PlanDefaults, name?: string |
       v: FANOUT_VERSION,
       name: planName,
       trunk,
+      fanIn: fanIn as FanInMode,
       shared,
       slices,
+      leadSession: null,
+      formerLeads: [],
       createdAt: "",
       updatedAt: "",
     },
@@ -728,6 +770,29 @@ export function worktreeRoot(cwd: string): string {
   return path.join(path.dirname(main), `${path.basename(main)}-wt`);
 }
 
+/** Whose standing orders count: the lead and those it took over from; null before leads. */
+export const planLeads = (
+  plan: Pick<FanoutFile, "leadSession" | "formerLeads">,
+): string[] | null => (plan.leadSession ? [plan.leadSession, ...plan.formerLeads] : null);
+
+/**
+ * sha256 (16 hex) of the slice's definition. Brief-only fields (tier,
+ * timebox, context) and the worktree path are left out, so fixing a typo in
+ * them never re-dispatches landed work.
+ */
+export function sliceHash(slice: Slice): string {
+  const {
+    worktree: _worktree,
+    hash: _hash,
+    hashSince: _since,
+    tier: _tier,
+    timebox: _timebox,
+    context: _context,
+    ...definition
+  } = slice;
+  return createHash("sha256").update(JSON.stringify(definition)).digest("hex").slice(0, 16);
+}
+
 // ---------------------------------------------------------------------------
 // store
 
@@ -777,8 +842,12 @@ function parseStored(raw: unknown): FanoutFile | null {
       forbidden: list(item.forbidden),
       context: typeof item.context === "string" ? item.context : null,
       timebox: typeof item.timebox === "string" ? item.timebox : null,
+      hash: text(item.hash),
+      // A plan written before slice hashes: its run began at createdAt.
+      hashSince: text(item.hashSince) || text(raw.createdAt),
     });
   }
+  for (const slice of slices) slice.hash ||= sliceHash(slice);
   const shared = globs(raw.shared);
   const ids = new Set(slices.map((slice) => slice.id));
   if (
@@ -788,13 +857,18 @@ function parseStored(raw: unknown): FanoutFile | null {
     findCycle(slices)
   )
     return null;
+  const fanIn = raw.fanIn === "integration" ? "integration" : "prs";
+  const createdAt = text(raw.createdAt);
   return {
     v: typeof raw.v === "number" ? raw.v : FANOUT_VERSION,
     name: raw.name,
     trunk: raw.trunk,
+    fanIn,
     shared,
     slices,
-    createdAt: text(raw.createdAt),
+    leadSession: typeof raw.leadSession === "string" && raw.leadSession ? raw.leadSession : null,
+    formerLeads: list(raw.formerLeads),
+    createdAt,
     updatedAt: text(raw.updatedAt),
   };
 }
@@ -890,6 +964,7 @@ function writeFanout(cwd: string, plan: FanoutFile): FanoutResult<string> {
 export type PlanOutcome = {
   name: string;
   trunk: string;
+  fanIn: FanInMode;
   file: string;
   created: boolean;
   slices: Array<
@@ -899,6 +974,8 @@ export type PlanOutcome = {
   waves: string[][];
   landingOrder: string[];
   notes: string[];
+  /** A new plan under a name that still has standing orders in force (an earlier run's?). */
+  warnings: string[];
 };
 
 /** Above this many slices in one wave, the lead queues the rest (4-6 in flight). */
@@ -906,11 +983,31 @@ export const IN_FLIGHT_CAP = 6;
 
 export function planFanout(
   cwd: string,
-  input: { raw: unknown; name: string | null; trunk: string | null; actor: LedgerActor },
+  input: {
+    raw: unknown;
+    name: string | null;
+    trunk: string | null;
+    actor: LedgerActor;
+    /** Record this session as the lead (a lead resuming in a new session). */
+    takeLead?: boolean;
+  },
   now: Date = new Date(),
 ): FanoutResult<PlanOutcome> {
   const dir = fanoutsDir(cwd);
   if (!dir.ok) return dir;
+  const session = input.actor.session;
+  if (input.takeLead && !session)
+    return fanoutFail(
+      "blocked",
+      "--take-lead needs a session: WORKIT_SESSION_ID is not set",
+      "export WORKIT_SESSION_ID=<your session id>, then plan again with --take-lead",
+    );
+  if (input.takeLead && isDelegateSession(session))
+    return fanoutFail(
+      "blocked",
+      `session ${session} is a worker or verifier id; only a lead takes the lead`,
+      "run --take-lead from the lead's own session",
+    );
   const parsed = parsePlan(
     input.trunk && isRecord(input.raw) ? { ...input.raw, trunk: input.trunk } : input.raw,
     {
@@ -928,6 +1025,12 @@ export function planFanout(
       { problems: parsed.problems },
     );
   const plan = parsed.plan;
+  if (plan.fanIn === "integration" && plan.trunk === defaultTrunk(cwd))
+    return fanoutFail(
+      "invalid_input",
+      `fanIn "integration" needs an integration branch as the trunk, not ${plan.trunk}`,
+      `workit git branch <integration-branch> --base ${plan.trunk}, then plan with --trunk <integration-branch>`,
+    );
   const badBranches = plan.slices
     .filter((slice) => !gitRun(cwd, ["check-ref-format", "--branch", slice.branch]).ok)
     .map((slice) => `slice ${slice.id}: ${slice.branch} is not a valid branch name`);
@@ -975,20 +1078,60 @@ export function planFanout(
   const existing = readFanout(cwd, plan.name);
   const previous = existing.ok ? existing.data : null;
   plan.createdAt = previous?.createdAt || now.toISOString();
+  // A re-plan keeps the lead (and a plan from before leads stays without one)
+  // unless this session takes it over.
+  plan.leadSession = input.takeLead ? session : previous ? previous.leadSession : session;
+  plan.formerLeads = [
+    ...new Set([
+      ...(previous?.formerLeads ?? []),
+      ...(previous?.leadSession && previous.leadSession !== plan.leadSession
+        ? [previous.leadSession]
+        : []),
+    ]),
+  ].filter((former) => former !== plan.leadSession);
   plan.updatedAt = now.toISOString();
+  // Per slice: the same definition continues its run; a changed one starts anew.
+  for (const slice of plan.slices) {
+    slice.hash = sliceHash(slice);
+    const before = previous?.slices.find((old) => old.id === slice.id);
+    slice.hashSince =
+      before && before.hash === slice.hash ? before.hashSince || plan.updatedAt : plan.updatedAt;
+  }
   const written = writeFanout(cwd, plan);
   if (!written.ok) return written;
+  if (previous && plan.leadSession !== previous.leadSession)
+    appendObserved(cwd, {
+      type: "fanout.lead.changed",
+      actor: input.actor,
+      fanout: plan.name,
+      from: previous.leadSession,
+      to: plan.leadSession,
+    });
   appendObserved(cwd, {
     type: "fanout.planned",
     actor: input.actor,
     fanout: plan.name,
     trunk: plan.trunk,
+    fanIn: plan.fanIn,
     slices: plan.slices.length,
     ids: plan.slices.slice(0, 20).map((slice) => slice.id),
   });
 
   const grouped = waves(plan.slices);
   const notes: string[] = [];
+  const warnings: string[] = [];
+  if (!input.takeLead && previous?.leadSession && session && session !== previous.leadSession)
+    notes.push(
+      `the lead stays ${previous.leadSession}; this session is ${session}. Leading from this session now? workit fanout plan <plan.json> --take-lead`,
+    );
+  if (previous === null) {
+    const ledger = readLedger(cwd);
+    const inForce = ledger.ok ? activeStanding(ledger.value.rows, plan.name, planLeads(plan)) : [];
+    if (inForce.length)
+      warnings.push(
+        `${inForce.length} standing order${inForce.length === 1 ? " is" : "s are"} already in force for fanout ${plan.name}, and every brief will carry ${inForce.length === 1 ? "it" : "them"}: ${inForce.map((row) => `"${String(row.what)}"`).join("; ")}. From an earlier run? workit ledger standing clear --fanout ${plan.name}`,
+      );
+  }
   if (!ref)
     notes.push(
       `trunk ${plan.trunk} does not resolve here; only sample paths of each glob were compared`,
@@ -1009,6 +1152,7 @@ export function planFanout(
     data: {
       name: plan.name,
       trunk: plan.trunk,
+      fanIn: plan.fanIn,
       file: written.data,
       created: previous === null,
       slices: plan.slices.map(({ id, branch, base, worktree, tier, dependsOn, scope, owns }) => ({
@@ -1025,6 +1169,7 @@ export function planFanout(
       waves: grouped,
       landingOrder: landingOrder(plan.slices),
       notes,
+      warnings,
     },
   };
 }

package/src/ledger.ts

@@ -130,8 +130,22 @@ export type VerdictRow = RowCommon & {
   evidenceRefs: string[];
 };
 export type HandoffRow = RowCommon & { type: "handoff"; note: string | null; next: string };
+/** A lead's standing order for every worker of a fanout ("no new dependencies"). */
+export type StandingRow = RowCommon & { type: "standing"; fanout: string; what: string };
+/** Ends one standing order (`target`), or every one recorded before it (null). */
+export type StandingClearedRow = RowCommon & {
+  type: "standing.cleared";
+  fanout: string;
+  target: string | null;
+};
 
-export type LedgerRow = DecisionRow | RulingRow | VerdictRow | HandoffRow;
+export type LedgerRow =
+  | DecisionRow
+  | RulingRow
+  | VerdictRow
+  | HandoffRow
+  | StandingRow
+  | StandingClearedRow;
 /** A row as read back: any known or future type, plus its position. */
 export type ReadRow = RowCommon &
   Record<string, unknown> & {
@@ -1076,6 +1090,142 @@ export function recordRuling(
   );
 }
 
+/**
+ * May this row speak for the fanout's lead? With recorded leads (the current
+ * one and any it took over from) only their rows count; a plan from before
+ * leads (null) takes any session.
+ */
+const fromLead = (row: ReadRow, leads: readonly string[] | null): boolean =>
+  leads === null || (row.actor.session !== null && leads.includes(row.actor.session));
+
+/**
+ * The standing orders in force for `fanout`, oldest first (D17: odd rows are
+ * skipped). Given the plan's lead session, orders and clears recorded by any
+ * other session are ignored, so a worker can neither add nor clear one.
+ */
+export function activeStanding(
+  rows: readonly ReadRow[],
+  fanout: string,
+  leads: readonly string[] | null = null,
+): ReadRow[] {
+  const active: ReadRow[] = [];
+  for (const row of rows) {
+    if (row.fanout !== fanout || !fromLead(row, leads)) continue;
+    if (row.type === "standing" && typeof row.what === "string" && row.what.trim()) {
+      if (!row.superseded) active.push(row);
+    } else if (row.type === "standing.cleared") {
+      const target = str(row.target);
+      if (target === null) active.length = 0;
+      else {
+        const index = active.findIndex((order) => order.id === target);
+        if (index >= 0) active.splice(index, 1);
+      }
+    }
+  }
+  return active;
+}
+
+/**
+ * A worker or verifier session by the ids workit hands out: `fanout brief`'s
+ * `<lead>-w-<slice>[+try<n>]`, a verifier's `<lead>-v<n>`, the Claude Code
+ * hook's `<lead>:<agent id>` and `--as` ids (`<session>:<role>:<hex>`). Host
+ * session ids carry no colon. Used where no recorded lead decides: plans that
+ * predate `leadSession`, and `fanout plan --take-lead`.
+ */
+export const isDelegateSession = (session: string | null): boolean =>
+  session !== null &&
+  (/-w-[a-z0-9._-]+(?:\+try\d)?$/u.test(session) ||
+    /-v\d+$/u.test(session) ||
+    session.includes(":"));
+
+/**
+ * Standing orders come from the fanout's lead: the session that first made
+ * the plan (`lead`). A plan without one falls back to refusing the session
+ * ids handed to workers and verifiers.
+ */
+function leadOnly(context: RecordContext, lead: string | null): LedgerResult<void> {
+  const session = context.actor.session;
+  if (lead !== null ? session === lead : !isDelegateSession(session))
+    return { ok: true, value: undefined };
+  return err(
+    "blocked",
+    lead !== null
+      ? `session ${session ?? "(none)"} is not the fanout's lead (${lead}): standing orders come from the lead`
+      : `session ${session} is a worker or verifier: standing orders come from the lead`,
+    lead !== null
+      ? `the lead in a new session? workit fanout plan <plan.json> --take-lead from this session; a worker or verifier reports the order to the lead instead`
+      : "a worker or verifier reports the order to the lead instead",
+  );
+}
+
+export function recordStanding(
+  context: RecordContext,
+  input: { fanout: string; lead: string | null; what?: string },
+): LedgerResult<StandingRow> {
+  const what = required(input.what, "<order>");
+  if (!what.ok) return what;
+  // One order per line of every brief: a newline or control character would
+  // let an order forge other brief fields.
+  if (/\p{Cc}/u.test(what.value))
+    return err(
+      "invalid_input",
+      "a standing order is one line: no newlines or control characters",
+      'add each order separately: workit ledger standing add "<order>"',
+    );
+  const lead = leadOnly(context, input.lead);
+  if (!lead.ok) return lead;
+  const link = checkSupersede(context, "standing");
+  if (!link.ok) return link;
+  return appendRow<StandingRow>(
+    context.cwd,
+    {
+      ...common(context, noteKey(context)),
+      type: "standing",
+      fanout: input.fanout,
+      what: what.value,
+    },
+    { now: context.now },
+  );
+}
+
+/** Clear one standing order by id (it must be in force), or all of them; lead only. */
+export function clearStanding(
+  context: RecordContext,
+  input: {
+    fanout: string;
+    lead: string | null;
+    leads?: readonly string[] | null;
+    target: string | null;
+  },
+): LedgerResult<StandingClearedRow> {
+  const lead = leadOnly(context, input.lead);
+  if (!lead.ok) return lead;
+  if (input.target !== null) {
+    const ledger = readLedger(context.cwd);
+    if (!ledger.ok) return ledger;
+    if (
+      !activeStanding(ledger.value.rows, input.fanout, input.leads ?? null).some(
+        (row) => row.id === input.target,
+      )
+    )
+      return err(
+        "not_found",
+        `no standing order ${input.target} in force for fanout ${input.fanout}`,
+        `workit ledger standing list --fanout ${input.fanout}`,
+      );
+  }
+  return appendRow<StandingClearedRow>(
+    context.cwd,
+    {
+      ...common(context, noteKey(context)),
+      type: "standing.cleared",
+      fanout: input.fanout,
+      target: input.target,
+    },
+    { now: context.now },
+  );
+}
+
 /**
  * Record an agent-asserted verdict on a branch's committed head. Refused on a
  * dirty worktree (the head would not be what was judged) and, for an author
@@ -1221,6 +1371,12 @@ export function summarizeRow(row: ReadRow): RowSummary {
     case "handoff":
       summary = `next: ${text("next")}${text("note") ? ` (note: ${text("note")})` : ""}`;
       break;
+    case "standing":
+      summary = `${text("what")} (fanout ${text("fanout")})`;
+      break;
+    case "standing.cleared":
+      summary = `cleared ${text("target") || "every standing order"} (fanout ${text("fanout")})`;
+      break;
     case "commit.recorded":
       summary = `${(row.head ?? "?").slice(0, 12)} ${text("subject")}${row.actor.session ? "" : " (no session)"}`;
       break;