@warren-dean/code-kit 0.21.0 → 0.22.1

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/adapters/hub/client.mjs

@@ -17,6 +17,7 @@ import {
   chmodSync,
   existsSync,
   mkdirSync,
+  readdirSync,
   readFileSync,
   renameSync,
   statSync,
@@ -104,6 +105,40 @@ const mainRoot = (cwd) => {
 const stateDir = (root) => join(mainRoot(root), '.claude', 'state');
 const hubDown = (root) => readJson(join(stateDir(root), 'hub-down.json'), {});
 
+/** The Claude Code session calling: code-kit passes it on, and Claude Code tells every command an agent runs. */
+const sessionOf = () =>
+  String(process.env.CODE_KIT_SESSION ?? process.env.CLAUDE_CODE_SESSION_ID ?? '').replace(
+    /[^\w-]/g,
+    '',
+  ) || null;
+const streamFileOf = (root, session) => join(stateDir(root), `hub-stream-${session}.json`);
+
+/**
+ * A session's live link: up while its daemon runs and its event stream is connected. Each session holds
+ * its own, so one session's link never makes another look live.
+ */
+function linkOf(root, session) {
+  const daemon = readJson(join(stateDir(root), `hub-daemon-${session}.json`));
+  const stream = readJson(streamFileOf(root, session), {});
+  return {
+    up: Boolean(daemon?.pid && alive(daemon.pid) && stream.connected),
+    why: stream.why ?? null,
+  };
+}
+
+/** The sessions on this checkout whose live link is up. */
+function linkedSessions(root) {
+  let names = [];
+  try {
+    names = readdirSync(stateDir(root));
+  } catch {
+    // no state yet
+  }
+  return names
+    .map((n) => n.match(/^hub-daemon-([\w-]+)\.json$/)?.[1])
+    .filter((s) => s && linkOf(root, s).up);
+}
+
 // --- talking to the hub ------------------------------------------------------------------------
 
 async function hub(method, path, body, { timeoutMs = 15_000 } = {}) {
@@ -153,8 +188,7 @@ export async function provide(op, input, root = process.cwd()) {
   // The daemon keeps the state fresh from the stream: read it from disk unless asked for fresh.
   if (op === 'state' && !input.fresh) {
     const kept = readJson(join(stateDir(root), 'team.json'));
-    const live = readJson(join(stateDir(root), 'hub-stream.json'), {});
-    if (kept?.hub && live.connected && Date.now() - Date.parse(kept.at) < 5 * 60_000)
+    if (kept?.hub && linkedSessions(root).length && Date.now() - Date.parse(kept.at) < 5 * 60_000)
       return named(kept, root);
   }
   const { team: _team, ...body } = input;
@@ -189,20 +223,23 @@ export async function provide(op, input, root = process.cwd()) {
 }
 
 /**
- * The state names what coordinates the team, for code-kit's Team pane: the hub, whether this session's
- * stream is live, and who this machine is signed in as.
+ * The state names what coordinates the team, for code-kit's Team pane: the hub, whether the calling
+ * session's own link is live (any session's, when no session is calling), and who this machine is
+ * signed in as.
  */
 function named(state, root) {
-  const live = readJson(join(stateDir(root), 'hub-stream.json'), {});
+  const session = sessionOf();
+  const link = session ? linkOf(root, session) : { up: linkedSessions(root).length > 0 };
   return {
     ...state,
     provider: {
       name: 'code-kit hub',
-      live: Boolean(live.connected),
+      live: link.up,
       account: credentials()?.login ?? null,
-      detail: live.connected
+      detail: link.up
         ? 'claims, leases, intents and presence as they happen; every push checked for drift'
-        : (live.why ?? 'not connected to its live updates; read on each refresh'),
+        : (link.why ??
+          "this session has no live link, so the team's state is read on each refresh; a session links as it starts"),
     },
   };
 }
@@ -449,6 +486,132 @@ async function connect(root) {
   console.log(
     `This repository now coordinates through the hub (${state.claims.length} claims, ${state.intents.length} open intents). Commit .claude/code-kit.json and .mcp.json so the team does too.`,
   );
+  // The session that ran connect links now, rather than at its next start.
+  const session = sessionOf();
+  if (session) {
+    startDaemon(root, session, claudeOf(), url);
+    console.log(
+      'This session is linked to the hub now; other sessions link as they start, or run connect in them.',
+    );
+  }
+}
+
+/** The Claude Code process this command runs under, for the link to end with it; null when there's none. */
+function claudeOf() {
+  let pid = process.ppid;
+  for (let i = 0; i < 8 && pid > 1; i += 1) {
+    const line = psOf(pid);
+    if (!line) return null;
+    if (/(^|\/)claude(\s|$)/.test(line.command)) return pid;
+    pid = line.ppid;
+  }
+  return null;
+}
+function psOf(pid) {
+  try {
+    const out = execFileSync('ps', ['-o', 'ppid=,command=', '-p', String(pid)], {
+      encoding: 'utf8',
+    }).trim();
+    const m = out.match(/^(\d+)\s+(.*)$/);
+    return m ? { ppid: Number(m[1]), command: m[2] } : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * `team provider status`: whether this repository is connected to the hub, one check a line, each failing
+ * one saying what to do, then the answer. Connected means this machine is signed in, the config here and
+ * on the base branch name the hub, and the hub can see the repository with nothing left to set up; live
+ * means the calling session's own link is up. True when connected.
+ */
+async function status(root) {
+  const lines = [];
+  const check = (ok, text) => (lines.push(`  ${ok ? '✓' : '✗'} ${text}`), ok);
+  const repo = repoOf(originOf(root));
+  const cred = credentials();
+  const url = (() => {
+    try {
+      return hubUrl();
+    } catch {
+      return null;
+    }
+  })();
+  const names = (config) => Boolean(url) && config?.team?.provider?.hub?.replace(/\/$/, '') === url;
+  const signed = check(
+    Boolean(cred?.token),
+    cred?.token
+      ? `this machine is signed in as ${cred.login}`
+      : "this machine isn't signed in: run /code-kit:team-init (it signs in through GitHub)",
+  );
+  const here = check(
+    names(readJson(join(root, '.claude', 'code-kit.json'))),
+    names(readJson(join(root, '.claude', 'code-kit.json')))
+      ? 'the config here names the hub'
+      : 'the config here doesn\'t name the hub: set "team": { "provider": { "hub": "' +
+          (url ?? '<the hub>') +
+          '" } } in .claude/code-kit.json',
+  );
+  const base =
+    git(root, 'symbolic-ref', '--short', 'refs/remotes/origin/HEAD') ??
+    (git(root, 'rev-parse', '--verify', '-q', 'origin/main') ? 'origin/main' : null);
+  const committed = (() => {
+    if (!base) return false;
+    try {
+      return names(JSON.parse(git(root, 'show', `${base}:.claude/code-kit.json`) ?? ''));
+    } catch {
+      return false;
+    }
+  })();
+  check(
+    committed,
+    committed
+      ? `${base}'s config names the hub, so the team's sessions use it`
+      : `${base ?? 'the base branch'}'s config doesn't name the hub yet (as last fetched): commit the team section and merge it, so the hub knows the tech lead and every teammate's session uses it`,
+  );
+  const mcp = readJson(join(root, '.mcp.json'), {})?.mcpServers?.['code-kit-hub'];
+  check(
+    Boolean(url) && mcp?.url === `${url}/mcp`,
+    mcp
+      ? "the project's MCP servers include the hub's"
+      : "the project's MCP servers don't include the hub's: run /code-kit:team-init, and commit .mcp.json",
+  );
+  let seen = false;
+  if (signed && repo && url) {
+    const state = await provide('state', { fresh: true }, root);
+    const setup = Array.isArray(state.setup) ? state.setup : [];
+    seen = check(
+      !state.unreachable && state.ok !== false,
+      state.unreachable || state.ok === false
+        ? `the hub can't use ${repo}: ${state.why}`
+        : `the hub sees ${repo}`,
+    );
+    // What the hub says is left to set up doesn't stop the connection: it's shown, not failed.
+    for (const line of seen ? setup : []) lines.push(`  ! ${line}`);
+  } else if (!repo)
+    check(false, "this repository has no GitHub origin, so the hub can't be used here");
+  const session = sessionOf();
+  const linked = linkedSessions(root);
+  const live = session ? linkOf(root, session).up : linked.length > 0;
+  check(
+    live,
+    session
+      ? live
+        ? 'this session is linked: claims, intents and presence arrive as they happen'
+        : "this session isn't linked yet: run /code-kit:team-init, or start a new session, once the checks above pass"
+      : `${linked.length} session${linked.length === 1 ? '' : 's'} on this checkout linked`,
+  );
+  const connected = signed && here && committed && seen;
+  console.log(`code-kit hub${url ? ` (${url})` : ''}${repo ? `, for ${repo}` : ''}:`);
+  for (const line of lines) console.log(line);
+  console.log(
+    connected
+      ? live || !session
+        ? 'Connected.'
+        : "Connected, but this session isn't linked yet."
+      : 'Not connected yet: fix each ✗ above, in order.',
+  );
+  return connected;
 }
 
 // --- the daemon (HUB-5): the stream, the team's state on disk, presence --------------------------
@@ -457,7 +620,7 @@ async function daemon({ root, session, watch }) {
   const dir = stateDir(root);
   const repo = repoOf(originOf(root));
   if (!repo || !credentials()?.token) return;
-  const streamFile = join(dir, 'hub-stream.json');
+  const streamFile = streamFileOf(root, session);
   const eventsFile = join(dir, 'team-events.jsonl');
   writeJson(join(dir, `hub-daemon-${session}.json`), { pid: process.pid, started: Date.now() });
   let lastId = readJson(streamFile, {}).lastId ?? 0;
@@ -498,10 +661,10 @@ async function daemon({ root, session, watch }) {
     stopping = true;
     clearInterval(tick);
     await hub('POST', `/v1/repos/${repo}/leave`, { session }, { timeoutMs: 3000 }).catch(() => {});
-    writeJson(streamFile, { lastId, connected: false });
-    try {
-      unlinkSync(join(dir, `hub-daemon-${session}.json`));
-    } catch {}
+    for (const file of [streamFile, join(dir, `hub-daemon-${session}.json`)])
+      try {
+        unlinkSync(file);
+      } catch {}
     process.exit(0);
   };
   process.on('SIGTERM', stop);
@@ -670,18 +833,7 @@ async function main(argv) {
     console.log('Signed out of code-kit hub on this machine.');
     return 0;
   }
-  if (cmd === 'status') {
-    const cred = credentials();
-    console.log(
-      cred?.token ? `Signed in to ${cred.url} as ${cred.login}.` : `Not signed in: run ${SIGN_IN}.`,
-    );
-    const repo = repoOf(originOf(process.cwd()));
-    if (repo && cred?.token) {
-      const live = readJson(join(stateDir(process.cwd()), 'hub-stream.json'), {});
-      console.log(`${repo}: ${live.connected ? 'live' : (live.why ?? 'not connected')}`);
-    }
-    return 0;
-  }
+  if (cmd === 'status') return status(process.cwd()).then((ok) => (ok ? 0 : 1));
   if (cmd === 'connect') return connect(process.cwd()).then(() => 0);
   if (cmd === 'drift-model') {
     const choice = args[0];

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} -->`;