@warren-dean/code-kit 0.21.0 → 0.22.0

package/hooks/lane-audit.mjs

@@ -79,6 +79,26 @@ function takeNote(input) {
   }
 }
 
+/**
+ * SESS-5: the files git said a command's checkout, merge or rebase would overwrite, when it refused for
+ * uncommitted work: [] when it didn't.
+ */
+export function overwrittenFiles(response) {
+  const text = typeof response === 'string' ? response : JSON.stringify(response ?? '');
+  const said = text.replace(/\\n/g, '\n').replace(/\\t/g, '\t');
+  const files = [];
+  for (const m of said.matchAll(
+    /(?:local changes to the following files|untracked working tree files) would be (?:overwritten|removed) by [\w-]+:\n((?:\t[^\n]+\n?)+)/g,
+  ))
+    files.push(
+      ...m[1]
+        .split('\n')
+        .map((l) => l.trim())
+        .filter(Boolean),
+    );
+  return [...new Set(files)];
+}
+
 export function auditProblems(input, config) {
   const root = actorRoot(input);
   if (!root) return [];
@@ -99,8 +119,25 @@ export function auditProblems(input, config) {
 
 if (import.meta.url === `file://${process.argv[1]}`) {
   const { block, start } = await import('./lib/hook.mjs');
-  const { input, config, error } = start();
+  const { input, project, config, error } = start();
   if (error) process.exit(0); // guard-paths and stop-check report an invalid config
+  // SESS-5: git refused because of uncommitted files another session wrote: say whose they are.
+  const overwritten = overwrittenFiles(input.tool_response);
+  if (overwritten.length) {
+    const { memberOf, writersOf } = await import('./lib/sessions.mjs');
+    const whose = Object.entries(writersOf(project, overwritten, input.session_id ?? null));
+    if (whose.length)
+      block(
+        `Git refused because of uncommitted files another session wrote in this checkout:\n  ${whose
+          .map(
+            ([f, w]) =>
+              `${f}: ${w.map((s) => `${memberOf(s)}${s.task ? `, working on "${s.task.title}"` : ''}${s.live ? '' : ' (ended)'}`).join('; ')}`,
+          )
+          .join(
+            '\n  ',
+          )}\nAsk that session to commit or stash them; don't stash or discard another session's work. Better, work in a worktree of your own, where no other session's files can block you.`,
+      );
+  }
   const problems = auditProblems(input, config);
   if (problems.length) {
     block(

package/hooks/lib/config.mjs

@@ -96,20 +96,38 @@ export function withDefaults(c) {
     tests: c.tests ?? [],
     regression: { prepare: c.regression?.prepare ?? null },
     branches: { protected: c.branches?.protected ?? ['main', 'master'] },
-    approvals: { lead: c.approvals?.lead === true, delegate: delegateRules(c.approvals?.delegate) },
+    approvals: {
+      lead: c.approvals?.lead === true,
+      delegate: delegateRules(c.approvals?.delegate, c.protected ?? []),
+    },
     harness: harnessSettings(c.harness),
   };
 }
 
+/** WHO-1: the approvals the person keeps when the config says nothing: product, design, CI and the kit. */
+export const PERSON_KEEPS = ['spec', 'design', 'ci', 'kit'];
+
 /**
  * The rules within which the lead approves on its own (`approvals.delegate`), or null when it may not:
- * the protected approvals it may grant, and the dependency rule packages must meet.
+ * the protected approvals it may grant, the dependency rule packages must meet, merges, and weakened
+ * tests on a lane's branch. WHO-1: with no `approvals.delegate`, the lead decides everything technical:
+ * every protected approval but the person's (PERSON_KEEPS), dependencies within the registry's
+ * defaults, merges and weakened tests. `false` keeps everything for the person.
  */
-function delegateRules(d) {
-  if (!d) return null;
+function delegateRules(given, protectedPaths = []) {
+  if (given === false) return null;
+  const d = given ?? {
+    protected: [...new Set(protectedPaths.map((p) => p.approval))].filter(
+      (a) => a && !PERSON_KEEPS.includes(a),
+    ),
+    merge: true,
+    tests: true,
+    dependencies: {},
+  };
   return {
     protected: d.protected ?? [],
     merge: d.merge === true,
+    tests: d.tests === true,
     dependencies: d.dependencies
       ? {
           licences: d.dependencies.licences ?? [
@@ -149,6 +167,129 @@ const isRegExp = (v) => {
  * security reviewer (ONB-7, spec 17). A project set up before (no `setup`, or a lower one) is told what
  * re-running init adds.
  */
+/**
+ * WHO-3: who decides each approval, as the Settings tab's Approvals rows: one per protected approval
+ * (but the kit, which is always the person's), dependencies with the registry's rules, merges and
+ * weakened tests. Each row: { key, value, default, about, choices?, section: 'Approvals' }.
+ */
+export function approvalSettings(config) {
+  const rules = config.approvals.delegate;
+  const who = (lead) => (lead ? 'lead' : 'person');
+  const names = [...new Set(config.protected.map((p) => p.approval))].filter((n) => n !== 'kit');
+  const fallback = delegateRules(undefined, config.protected) ?? {};
+  const deps = rules?.dependencies ?? delegateRules({ dependencies: {} }).dependencies;
+  const row = (key, value, dflt, about, choices) => ({
+    key,
+    value,
+    default: dflt,
+    about,
+    section: 'Approvals',
+    ...(choices ? { choices } : {}),
+  });
+  return [
+    ...names.map((n) =>
+      row(
+        `approvals.${n}`,
+        who(rules?.protected.includes(n)),
+        who(fallback.protected?.includes(n)),
+        `Who approves a lane's change to what's protected as "${n}"`,
+        ['lead', 'person'],
+      ),
+    ),
+    row(
+      'approvals.dependencies',
+      who(Boolean(rules?.dependencies)),
+      'lead',
+      "Who approves a lane's new package: the lead within the registry's rules, or you",
+      ['lead', 'person'],
+    ),
+    row(
+      'approvals.dependencies.licences',
+      deps.licences.join(','),
+      'MIT,Apache-2.0,BSD-2-Clause,BSD-3-Clause,ISC',
+      'The licences a package the lead approves may have, comma-separated',
+    ),
+    row(
+      'approvals.dependencies.minWeeklyDownloads',
+      deps.minWeeklyDownloads,
+      10_000,
+      'The weekly downloads a package the lead approves must have, at least',
+    ),
+    row(
+      'approvals.dependencies.maxMonthsSinceRelease',
+      deps.maxMonthsSinceRelease,
+      18,
+      "Months since a package's last release, at most, for the lead to approve it",
+    ),
+    row(
+      'approvals.dependencies.allowInstallScripts',
+      Array.isArray(deps.allowInstallScripts)
+        ? deps.allowInstallScripts.join(',')
+        : deps.allowInstallScripts,
+      false,
+      'Install scripts a package the lead approves may run: true, false, or kinds (binary, build, other)',
+    ),
+    row(
+      'approvals.merge',
+      who(Boolean(rules?.merge)),
+      'lead',
+      'Who merges a reviewed branch into the base: merging is not releasing',
+      ['lead', 'person'],
+    ),
+    row(
+      'approvals.tests',
+      who(Boolean(rules?.tests)),
+      'lead',
+      "Who approves a weakened test on a lane's branch, after review; on the lead's own branches it is always you",
+      ['lead', 'person'],
+    ),
+  ];
+}
+
+/** WHO-3: the raw config with one approval setting changed (a copy), the rules written out in full. */
+export function withApprovalSetting(raw, config, key, text) {
+  const rules = config.approvals.delegate;
+  const deps = rules?.dependencies ?? null;
+  const delegate = {
+    protected: [...(rules?.protected ?? [])],
+    merge: Boolean(rules?.merge),
+    tests: Boolean(rules?.tests),
+    ...(deps ? { dependencies: { ...deps } } : {}),
+  };
+  const lead = text === 'lead' ? true : text === 'person' ? false : null;
+  const rule = key.replace(/^approvals\./, '');
+  const depRule = rule.startsWith('dependencies.') ? rule.slice('dependencies.'.length) : null;
+  if (depRule) {
+    const base = delegate.dependencies ?? delegateRules({ dependencies: {} }).dependencies;
+    const list = String(text)
+      .split(',')
+      .map((x) => x.trim())
+      .filter(Boolean);
+    const value =
+      depRule === 'licences'
+        ? list
+        : depRule === 'allowInstallScripts'
+          ? text === 'true' || (text === 'false' ? false : list)
+          : /^\d+$/.test(text)
+            ? Number(text)
+            : text;
+    delegate.dependencies = { ...base, [depRule]: value };
+  } else if (lead === null) return null;
+  else if (rule === 'dependencies')
+    lead
+      ? (delegate.dependencies = deps ?? delegateRules({ dependencies: {} }).dependencies)
+      : delete delegate.dependencies;
+  else if (rule === 'merge' || rule === 'tests') delegate[rule] = lead;
+  else if (config.protected.some((p) => p.approval === rule) && rule !== 'kit')
+    delegate.protected = lead
+      ? [...new Set([...delegate.protected, rule])]
+      : delegate.protected.filter((n) => n !== rule);
+  else return null;
+  const copy = structuredClone(raw);
+  copy.approvals = { ...(copy.approvals ?? {}), delegate };
+  return copy;
+}
+
 export const SETUP_VERSION = 3;
 
 /** Every problem with a parsed config, as readable sentences; empty when it is valid. */
@@ -236,9 +377,11 @@ export function validate(c) {
   const isCount = (v) => v === undefined || (Number.isInteger(v) && v >= 0);
   need(
     d === undefined ||
+      d === false ||
       (isObj(d) &&
         (d.protected === undefined || isList(d.protected)) &&
         [undefined, true, false].includes(d.merge) &&
+        [undefined, true, false].includes(d.tests) &&
         (dep === undefined ||
           (isObj(dep) &&
             (dep.licences === undefined || isList(dep.licences)) &&
@@ -247,7 +390,7 @@ export function validate(c) {
             ([undefined, true, false].includes(dep.allowInstallScripts) ||
               (isList(dep.allowInstallScripts) &&
                 dep.allowInstallScripts.every((k) => ['binary', 'build', 'other'].includes(k))))))),
-    '"approvals.delegate" must be { protected?: [approval names], merge?: true|false, dependencies?: { licences?, minWeeklyDownloads?, maxMonthsSinceRelease?, allowInstallScripts?: true|false|["binary","build","other"] } }',
+    '"approvals.delegate" must be false, or { protected?: [approval names], merge?: true|false, tests?: true|false, dependencies?: { licences?, minWeeklyDownloads?, maxMonthsSinceRelease?, allowInstallScripts?: true|false|["binary","build","other"] } }',
   );
   need(
     c.branches === undefined || isList(c.branches?.protected),

package/hooks/lib/decisionstore.mjs

@@ -0,0 +1,89 @@
+// Decisions owned by the session that raised them (docs/specs/23-the-team.md, OWN-1 to OWN-4). What the
+// person settles comes from two logs code-kit already keeps, each record now carrying its session: the
+// lead's questions (lib/questions.mjs) and the approvals a refusal asked for (lib/rules.mjs). This reads
+// both as one list, each decision with its member, subject and context, so a session sees, asks and
+// answers only its own, and the others only a count. A decision from before sessions were recorded
+// belongs to no session and shows in any.
+import { openQuestions } from './questions.mjs';
+import { openRequests } from './rules.mjs';
+import { memberOf, readSession, sessions, shortSession } from './sessions.mjs';
+
+/** The stories that are done: a decision about one of them has lost its cause (OWN-4). */
+const doneIn = (stories) =>
+  new Set((stories ?? []).filter((s) => s.state === 'done').map((s) => s.id));
+
+/**
+ * Every open decision, oldest first: [{ id, kind, session, member, subject, what, context, options,
+ * blocks, count, opened, source }]. `kind` is `answer` (a question for the person) or `approve`.
+ */
+export function openDecisions(root, { stories = [] } = {}, now = Date.now()) {
+  const done = doneIn(stories);
+  const byId = new Map(sessions(root, now).map((s) => [s.id, s]));
+  const member = (session) =>
+    session ? (memberOf(byId.get(session)) ?? shortSession(session)) : null;
+  const questions = openQuestions(root)
+    .filter((q) => !(q.story && done.has(q.story)))
+    .map((q) => ({
+      id: q.id,
+      kind: 'answer',
+      session: q.session ?? null,
+      member: member(q.session),
+      subject: q.story ?? null,
+      what: q.question,
+      context: q.why ?? null,
+      options: q.options ?? [],
+      blocks: Boolean(q.blocks),
+      count: q.count ?? 1,
+      opened: q.at,
+      source: q,
+    }));
+  const requests = openRequests(root, now).map((r) => ({
+    id: `R:${r.at}`,
+    kind: 'approve',
+    session: r.session ?? null,
+    member: member(r.session),
+    subject: r.lane ?? null,
+    what: r.what,
+    context: r.why ?? null,
+    options: [],
+    blocks: true,
+    count: 1,
+    opened: r.at,
+    source: r,
+  }));
+  return [...questions, ...requests].sort((a, b) => Date.parse(a.opened) - Date.parse(b.opened));
+}
+
+/** The sessions whose decisions `session` answers for: its own, and those whose task it took over. */
+function ownedBy(root, session) {
+  const me = readSession(root, session);
+  return new Set([session, ...(me?.took ?? [])]);
+}
+
+/**
+ * OWN-1: the decisions `session` sees and answers ({ mine }), and the count waiting in each other live
+ * session ({ elsewhere: [{ session, member, count }] }). A decision of a session that has ended stays with
+ * it: it isn't handed to another session's lead.
+ */
+export function decisionsFor(root, session, context = {}, now = Date.now()) {
+  const all = openDecisions(root, context, now);
+  const own = ownedBy(root, session);
+  const live = new Set(
+    sessions(root, now)
+      .filter((s) => s.live)
+      .map((s) => s.id),
+  );
+  const mine = all.filter((d) => !d.session || own.has(d.session));
+  const counts = new Map();
+  for (const d of all)
+    if (d.session && !own.has(d.session) && live.has(d.session))
+      counts.set(d.session, (counts.get(d.session) ?? 0) + 1);
+  return {
+    mine,
+    elsewhere: [...counts].map(([s, count]) => ({
+      session: s,
+      member: all.find((d) => d.session === s)?.member ?? shortSession(s),
+      count,
+    })),
+  };
+}

package/hooks/lib/harness.mjs

@@ -71,6 +71,13 @@ export const SETTINGS = {
     about:
       "The context a lane agent may reach before it's asked to wrap up and hand its story to a fresh agent; 0 for no limit",
   },
+  'slices.open': {
+    default: 1,
+    problem: (v) =>
+      Number.isInteger(v) && v >= 1 && v <= 10 ? null : 'must be a whole number from 1 to 10',
+    about:
+      "How many slices are in focus at once: a free lane builds an open slice's stories first, and may start the next slice only while fewer are open",
+  },
   'background.pauseAtPercent': {
     default: 80,
     problem: (v) =>

package/hooks/lib/hook.mjs

@@ -2,6 +2,7 @@
 import { readFileSync } from 'node:fs';
 import { loadConfig } from './config.mjs';
 import { projectDir } from './rules.mjs';
+import { seeSession } from './sessions.mjs';
 
 /** Exit 2 with a message: Claude Code blocks the call and shows Claude the reason. */
 export function block(message) {
@@ -15,5 +16,11 @@ export function start() {
   const project = projectDir();
   const { config, error } = loadConfig(project);
   if (!config && !error) process.exit(0);
+  // SESS-1: the session acting is still there; one code-kit hadn't seen starts here.
+  try {
+    seeSession(project, input.session_id);
+  } catch {
+    // a read-only checkout: the session goes unrecorded
+  }
   return { input, project, config, error };
 }

package/hooks/lib/instructions.mjs

@@ -14,7 +14,7 @@ import {
 } from './standards.mjs';
 
 /** The version of code-kit's instructions: raised whenever the templates' rules change. */
-export const INSTRUCTIONS_VERSION = 6;
+export const INSTRUCTIONS_VERSION = 7;
 
 const TEMPLATES = fileURLToPath(new URL('../../templates/', import.meta.url));
 const BEGIN = (v) => `<!-- code-kit:begin v${v} -->`;

package/hooks/lib/laneclaims.mjs

@@ -0,0 +1,89 @@
+// One agent per lane, across every session in the project (docs/specs/23-the-team.md, SCHED-1). Two
+// agents in one lane build on overlapping files in their worktrees and conflict at merge; the plan's
+// graph is for running different lanes at once. Starting a lane's agent claims the lane, and the claim
+// ends when the agent finishes, its session ends, or the lead releases a lane whose agent has stopped.
+// Kept in the main checkout, one file per lane, so every session and worktree on the machine sees them,
+// and two agents started in the same moment can't both take a lane: the file is created exclusively.
+import { mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { projectWorktrees } from './rules.mjs';
+
+export const LANE_CLAIMS_DIR = '.claude/state/lanes';
+/** A claim this old is taken to be left over from an agent nobody saw stop. */
+export const LANE_CLAIM_STALE_MS = 12 * 3600_000;
+
+const dirOf = (root) => join(projectWorktrees(root)[0] ?? root, LANE_CLAIMS_DIR);
+const fileOf = (root, lane) => join(dirOf(root), `${lane.replace(/[^\w.-]/g, '_')}.json`);
+
+/** A session's id as people read it: its first 8 characters. */
+export const shortSession = (session) => (session ? String(session).slice(0, 8) : null);
+
+function read(root, lane) {
+  try {
+    return JSON.parse(readFileSync(fileOf(root, lane), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+const withAge = (claim, now) =>
+  claim && { ...claim, stale: now - Date.parse(claim.since) >= LANE_CLAIM_STALE_MS };
+
+/** Every lane claimed now: [{ lane, story, session, since, stale }], by lane. */
+export function laneClaims(root, now = Date.now()) {
+  let files = [];
+  try {
+    files = readdirSync(dirOf(root)).filter((f) => f.endsWith('.json'));
+  } catch {
+    return [];
+  }
+  return files
+    .map((f) => {
+      try {
+        return withAge(JSON.parse(readFileSync(join(dirOf(root), f), 'utf8')), now);
+      } catch {
+        return null;
+      }
+    })
+    .filter((c) => c?.lane)
+    .sort((a, b) => a.lane.localeCompare(b.lane));
+}
+
+/** The lane's claim, or null. */
+export const laneClaim = (root, lane, now = Date.now()) => withAge(read(root, lane), now);
+
+/**
+ * SCHED-1: claims `lane` for `story` in `session`: { ok: true } or { ok: false, claim } naming who has it.
+ * The session already holding it for the same story (a restart, a send-back) takes it again; so does
+ * anyone, from a stale claim.
+ */
+export function claimLane(root, { lane, story = null, session = null }, now = Date.now()) {
+  const record = { lane, story, session, since: new Date(now).toISOString() };
+  mkdirSync(dirOf(root), { recursive: true });
+  try {
+    writeFileSync(fileOf(root, lane), `${JSON.stringify(record)}\n`, { flag: 'wx' });
+    return { ok: true };
+  } catch {
+    // held already: by whom, and whether it may be taken over
+  }
+  const held = laneClaim(root, lane, now);
+  const same = held && held.session === session && (held.story === story || !held.story);
+  if (held && !same && !held.stale) return { ok: false, claim: held };
+  writeFileSync(fileOf(root, lane), `${JSON.stringify(record)}\n`);
+  return { ok: true };
+}
+
+/** Ends the lane's claim; with `session`, only that session's. True when one ended. */
+export function releaseLane(root, lane, { session = null } = {}) {
+  const held = read(root, lane);
+  if (!held || (session && held.session !== session)) return false;
+  rmSync(fileOf(root, lane), { force: true });
+  return true;
+}
+
+/** Ends every claim a session holds, as it ends: the lanes it named. */
+export function releaseSession(root, session, now = Date.now()) {
+  const ended = laneClaims(root, now).filter((c) => c.session === session);
+  for (const c of ended) releaseLane(root, c.lane, { session });
+  return ended.map((c) => c.lane);
+}

package/hooks/lib/loop-state.mjs

@@ -5,6 +5,7 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { projectWorktrees } from './rules.mjs';
+import { leadSession, makeLead, readSession } from './sessions.mjs';
 
 export const LOOP_FILE = '.claude/state/loop.json';
 /** LOOP-10: a lead session renews its lease well within this; one not renewed for this long has ended. */
@@ -34,10 +35,19 @@ const liveLead = (state, now) => {
   return now - Date.parse(lead.at) < LEAD_LEASE_MS ? { session: lead.session, at: lead.at } : null;
 };
 
-/** { paused, at, lead }: not paused when nothing was recorded; `lead` is the live lead session or null. */
+/**
+ * { paused, at, lead }: not paused when nothing was recorded; `lead` is the live lead session or null.
+ * SESS-2: where sessions are recorded, the lead session is the lead; the lease is for a session code-kit's
+ * session hook never saw.
+ */
 export function readLoop(root, now = Date.now()) {
   const state = readRaw(root);
-  return { paused: state.paused === true, at: state.at ?? null, lead: liveLead(state, now) };
+  const lead = leadSession(root, now);
+  return {
+    paused: state.paused === true,
+    at: state.at ?? null,
+    lead: lead ? { session: lead.id, at: lead.seen } : liveLead(state, now),
+  };
 }
 
 export function writeLoop(root, paused, now = Date.now()) {
@@ -49,6 +59,14 @@ export function writeLoop(root, paused, now = Date.now()) {
  * person moved the loop here): { ok: true } or { ok: false, lead } naming the session that has it.
  */
 export function claimLead(root, session, { take = false } = {}, now = Date.now()) {
+  // SESS-2: the loop runs in the lead session; Lead from here (`take`) makes this session the lead.
+  if (readSession(root, session)) {
+    if (take) makeLead(root, session, now);
+    const lead = leadSession(root, now);
+    return lead?.id === session
+      ? { ok: true, lead: null }
+      : { ok: false, lead: lead ? { session: lead.id, at: lead.seen } : null };
+  }
   const state = readRaw(root);
   const lead = liveLead(state, now);
   if (lead && lead.session !== session && !take) return { ok: false, lead };

package/hooks/lib/next.mjs

@@ -12,6 +12,8 @@ import { readQueue, waiting } from './queue.mjs';
 import { decidedBy, laneOf, openRequests } from './rules.mjs';
 import { instructionsState } from './instructions.mjs';
 import { SECURITY_AGENT_FILE } from './security.mjs';
+import { laneClaims } from './laneclaims.mjs';
+import { pickPerLane } from './schedule.mjs';
 
 export const DRAFT_FILE = '.claude/code-kit.draft.json';
 export const BRIEF_STATES = ['framed', 'explored', 'scoped', 'specified', 'planned', 'ready'];
@@ -280,7 +282,9 @@ export function nextStep(root, base) {
   }
   // HELM-4: a lane waiting on something the lead decides goes first: the lane can't go on without it.
   const forLeadToDecide = openRequests(root).flatMap((r, i) =>
-    r.lane && decidedBy(r.names, config) === 'lead' ? [{ ...r, n: i + 1 }] : [],
+    r.lane && decidedBy(r.names, config, { kind: 'lane', lane: r.lane }) === 'lead'
+      ? [{ ...r, n: i + 1 }]
+      : [],
   );
   if (forLeadToDecide.length)
     return result(
@@ -311,6 +315,29 @@ export function nextStep(root, base) {
       `${queued[0]} passed review and is next in the merge queue${queued.length > 1 ? ` (then ${queued.slice(1).join(', ')})` : ''}.`,
       { args: queued[0] },
     );
+  // SCHED-1, SCHED-2: one story for each free lane, across every session; the open slice's first.
+  const busy = new Set([
+    ...laneClaims(root)
+      .filter((c) => !c.stale)
+      .map((c) => c.lane),
+    ...status.stories.filter((s) => s.state === 'in progress' && s.lane).map((s) => s.lane),
+  ]);
+  const sched = pickPerLane(status.stories, {
+    fixes,
+    ready,
+    busy,
+    open: config.harness.slices.open,
+  });
+  for (const list of [fixes, ready])
+    list.splice(0, list.length, ...list.filter((id) => sched.pick.includes(id)));
+  for (const a of sched.ahead)
+    attention.push(
+      `${a.id} is ahead of its slice (${a.slice}): its lane has nothing ready in the open slice.`,
+    );
+  if (sched.waiting.length)
+    attention.push(
+      `${sched.waiting.join(', ')} ${sched.waiting.length === 1 ? 'waits' : 'wait'} for ${sched.waiting.length === 1 ? 'its lane' : 'their lanes'}: a lane runs one story at a time.`,
+    );
   const then = [];
   // A sent-back story goes back to its lane with the review's findings, before new work starts.
   const toDispatch = [...fixes, ...ready];
@@ -358,6 +385,12 @@ export function nextStep(root, base) {
       'update',
       `${missingWords} Re-run /code-kit:init before the next story: it shows the person the difference before anything changes.`,
     );
+  // SCHED-1: ready stories whose lanes are all running one.
+  if (!building.length && sched.waiting.length)
+    return result(
+      'wait',
+      `${sched.waiting.join(', ')} ${sched.waiting.length === 1 ? 'waits' : 'wait'} for ${sched.waiting.length === 1 ? 'its lane' : 'their lanes'}, running another story; a lane runs one story at a time.`,
+    );
   if (building.length)
     return result(
       'wait',

package/hooks/lib/plan.mjs

@@ -52,7 +52,7 @@ const field = (lines, name) =>
     .trim() ?? '';
 
 /**
- * Every story in the plan: [{ id, title, lane, requirements, dependsOn, status, fixes, milestone }]. A story's
+ * Every story in the plan: [{ id, title, lane, requirements, dependsOn, status, fixes, milestone, slice }]. A story's
  * milestone is the `## ` heading above it ("Milestone 5: Your own key"), or null.
  */
 export function readStories(root, planPath) {
@@ -80,6 +80,8 @@ export function readStories(root, planPath) {
         dependsOn: [...field(body, 'Depends on').matchAll(/\bST-\d+\b/g)].map((r) => r[0]),
         status: STATES.includes(status) ? status : 'todo',
         milestone,
+        // SCHED-2: the slice it belongs to, a feature built across lanes, or null.
+        slice: field(body, 'Slice') || null,
       });
     });
   }

package/hooks/lib/questions.mjs

@@ -35,16 +35,25 @@ function append(root, record) {
 }
 
 /**
- * Every question, oldest first: { id, at, by, question, why, story, blocks, options: [{ label, effect }],
+ * Every question, oldest first: { id, at, by, session, count, question, why, story, blocks, options: [{ label, effect }],
  * state: 'open' | 'answered' | 'withdrawn', answer: { text, at, by, via } | null, withdrawn: { at, reason } | null }.
  */
 export function readQuestions(root) {
   const byId = new Map();
   for (const r of records(root)) {
     if (r.kind === 'ask')
-      byId.set(r.id, { ...r, kind: undefined, state: 'open', answer: null, withdrawn: null });
+      byId.set(r.id, {
+        ...r,
+        kind: undefined,
+        session: r.session ?? null,
+        count: 1,
+        state: 'open',
+        answer: null,
+        withdrawn: null,
+      });
     const q = byId.get(r.id);
     if (!q || q.state !== 'open') continue;
+    if (r.kind === 'again') q.count += 1;
     if (r.kind === 'answer') {
       q.state = 'answered';
       q.answer = { text: r.answer, at: r.at, by: r.by, via: r.via };
@@ -73,20 +82,29 @@ export function parseOption(text) {
  */
 export function askQuestion(
   root,
-  { by, question, why = null, story = null, blocks = false, options = [] },
+  { by, question, why = null, story = null, blocks = false, options = [], session = null },
   now = Date.now(),
 ) {
   const text = String(question).trim();
+  // OWN-3: the same question still open in the same session is one decision, asked again.
   const open = openQuestions(root).find(
-    (q) => q.question === text && (q.story ?? null) === (story ?? null),
+    (q) =>
+      q.question === text &&
+      (q.story ?? null) === (story ?? null) &&
+      (q.session ?? null) === (session ?? null),
   );
-  if (open) return { question: open, existed: true };
+  if (open) {
+    append(root, { kind: 'again', id: open.id, at: new Date(now).toISOString() });
+    return { question: readQuestions(root).find((q) => q.id === open.id), existed: true };
+  }
   const n = readQuestions(root).length + 1;
   const record = {
     kind: 'ask',
     id: `Q-${n}`,
     at: new Date(now).toISOString(),
     by,
+    // OWN-1: the session that asked it: it's asked, answered and heard there only.
+    session: session ?? null,
     question: text,
     why: why?.trim() || null,
     story: story ?? null,

package/hooks/lib/regression.mjs

@@ -1,6 +1,7 @@
 // Regression (docs/specs/18-regression.md). REG-1: a fix comes with a test that fails without it, as the
 // bug, and passes with it. REG-2: a test isn't weakened (deleted, skipped, cut down, its snapshot
-// rewritten) without the person's `tests` approval, which the lead can't delegate. The commit hook
+// rewritten) without a `tests` approval: the lead's on a lane's branch where tests are delegated (spec 23,
+// WHO-2), the person's otherwise and always on the lead's own. The commit hook
 // refuses a weakening commit; verify finds what a branch weakened, from git.
 import { execFileSync, spawnSync } from 'node:child_process';
 import { existsSync, mkdtempSync, readFileSync, rmSync, symlinkSync } from 'node:fs';