@staix/agent-hub 0.12.41 → 0.12.43

package/src/hub/daemon.ts

@@ -80,7 +80,7 @@ import { closeSync, constants as fsConstants, openSync, lstatSync, readSync, sta
 import { basename, isAbsolute } from "node:path";
 import { fileURLToPath } from "node:url";
 import { realPath, hubHome } from "./project.ts";
-import { mainCheckoutWarning } from "./main-checkout.ts";
+import { mainCheckoutBranch, mainCheckoutWarning } from "./main-checkout.ts";
 import type { BusEvent, PublishResult } from "./bus.ts";
 import { CONDUCTOR_TOOLS, CONDUCTOR_TOOL_NAMES, DEFAULT_ROLES, roleContract, TASK_TOOL_NAMES, TASK_TOOLS, BOUNDED_TASK_TOOLS, profileTaskTools } from "./hub-tools.ts";
 import { Conductor, ConductorHolds, conductorPeer, conductorProgressSink, publicConductorTask, publicPeerBudget, type ConductEvent } from "./conductor.ts";
@@ -110,7 +110,7 @@ import { Facts, FACTS_PREFIX, type FactScope } from "./facts.ts";
 import { crashPlan, lossNotice, readSessions, removeSessions, writeSessions, type SessionsFile } from "./crash.ts";
 import type { JournalDelivery } from "./delivery-journal.ts";
 import { DEFAULT_LIMITS, Limiter, PROJECT_LIMITS, type LimitsConfig } from "./limits.ts";
-import { changedPaths, hasTree, repoOf, snapshot, Turns, type TurnRecord } from "./snapshots.ts";
+import { changedPaths, knownChangedPaths, hasTree, headState, headMoveCursor, incomingHeadPaths, repoOf, snapshot, SnapshotBudgetExceeded, Turns, type SnapshotBudget, type HeadMoveCursor, type Repo, type TurnRecord } from "./snapshots.ts";
 import { archiveRestartSnapshot, readRecoveryWaivers, readRestartSnapshot, removeRestartSnapshot, restartPath, writeRestartSnapshot, type RecoveryPhase, type RestartPeerSnapshot, type RestartSnapshot } from "./restart.ts";
 import { consumeRecoveryContinuity, readRecoveryContinuity, retireRecoveryContinuity } from "./recovery-continuity.ts";
 import { shellQuote, publishTerminalLaunch, terminalLaunchCandidate } from "../cli/terminal-recovery.ts";
@@ -465,6 +465,10 @@ function mlxPinProblem(routing: Routing, project: boolean): string | undefined {
 }
 
 export interface DaemonOptions {
+  /** Host-only snapshot/probe seams; never read from project config or tool arguments. */
+  snapshot?: typeof snapshot;
+  snapshotBurstMs?: number;
+  checkoutBranch?: typeof mainCheckoutBranch;
   /** Host-only admission transport; never selected by project config or tools. */
   releaseHostAdmission?: (cwd: string) => Promise<ReleaseHostAdmission>;
   projectId?: string;
@@ -954,7 +958,7 @@ export async function startDaemon(opts: DaemonOptions) {
   // silence without facts would leave overlapping owners blind. Facts and silence ask the same question, so both switch
   // together. Cached until the board changes: it is asked per recipient of every message.
   let turnFreeNow: boolean | undefined;
-  const turns = new Map<PeerId, { capture?: boolean; id: string; start: number; tokens: number; tree?: string; snapshotMs?: number; private?: boolean; deliveryTask?: number; attribution: TaskAttribution; preparedRoles: RoleIdentity[] | null }>();
+  const turns = new Map<PeerId, { capture?: boolean; id: string; start: number; tokens: number; tree?: string; head?: string | null; reflog?: HeadMoveCursor; snapshotMs?: number; private?: boolean; deliveryTask?: number; attribution: TaskAttribution; preparedRoles: RoleIdentity[] | null }>();
   const turnFree = (): boolean => (config.coordination === "turn-free" || tasks.cohorts.list().some(cohort => cohort.silent)) && ![...turns.values()].some(turn => turn.private) && (turnFreeNow ??= !board.list().some((t) => !isClosedTaskState(t.state) && tasks.isPii(t)));
   /**
    * Why `to` does not get an agent's message (issue #107): sender and recipient are in one silent cohort, and the sender
@@ -1551,7 +1555,7 @@ export async function startDaemon(opts: DaemonOptions) {
   const worktreeFacts = new Map<string, Facts>();
   const worktreeProjections = new Map<string, TextProjections>();
   const executionRoot = (peer: string) => executionRoots.get(peer) ?? opts.cwd;
-  const repoFor = (peer: string) => executionRoot(peer) === opts.cwd ? factsRepo : repoOf(executionRoot(peer));
+  const repoFor = (peer: string, budget?: SnapshotBudget) => executionRoot(peer) === opts.cwd ? factsRepo : repoOf(executionRoot(peer), budget);
   const projectionsFor = (peer: string): TextProjections => {
     const root = executionRoot(peer);
     if (root === opts.cwd) return projections;
@@ -1904,23 +1908,42 @@ export async function startDaemon(opts: DaemonOptions) {
     if (!tasks.nameable(text) || looksSecret(text) || !screenMemory([{ title: null, text }]).length) return;
     memoryObservations?.cite(peer, text, id, envs);
   };
-  /**
-   * A snapshot that fails costs the undo record of that turn and nothing else. The peer's prompt waits for it (it
-   * runs inside the state change): three git calls at a turn's start and four at its end, each with the 10 s timeout
-   * in snapshots.ts.
-   */
-  const snap = (what: string, capture = config.snapshots.enabled, peer?: string): { tree?: string; ms: number } => {
-    const repo = peer ? repoFor(peer) : factsRepo;
+  // Preserve real synchronous native boundaries, but never spend an unbounded sequence of Git waits
+  // inside a single callback burst. Failed/slow captures are explicitly unknown, never stale baselines.
+  let snapshotBudget: SnapshotBudget | undefined, snapshotBudgetNoticed = false;
+  const reserveSnapshotBudget = (): SnapshotBudget => {
+    if (!snapshotBudget) {
+      const requested = opts.snapshotBurstMs ?? 250;
+      const ms = Number.isFinite(requested) ? Math.max(1, Math.min(250, requested)) : 250;
+      snapshotBudget = { deadline: performance.now() + ms };
+      setImmediate(() => { snapshotBudget = undefined; snapshotBudgetNoticed = false; });
+    }
+    return snapshotBudget;
+  };
+  const snapshotFailure = (what: string, error: unknown) => {
+    if (error instanceof SnapshotBudgetExceeded) {
+      if (!snapshotBudgetNoticed) log(`snapshot unavailable: ${error.message}`);
+      snapshotBudgetNoticed = true;
+    } else log(`snapshot failed at ${what}: ${(error as Error).message}`);
+  };
+  const snap = (what: string, capture = config.snapshots.enabled, peer?: string): { tree?: string; head?: string | null; reflog?: HeadMoveCursor; ms: number; budget?: SnapshotBudget; repo?: Repo } => {
     if (!capture) return { ms: 0 };
-    const t0 = performance.now();
-    let tree: string | undefined;
+    const t0 = performance.now(), budget = reserveSnapshotBudget();
+    let tree: string | undefined, head: string | null | undefined, repo: Repo | undefined, reflog: HeadMoveCursor | undefined;
     try {
-      tree = repo && snapshot(repo);
+      repo = peer ? repoFor(peer, budget) : factsRepo;
+      const before = repo && headState(repo, budget);
+      tree = repo && (opts.snapshot ?? snapshot)(repo, budget);
+      const after = repo && headState(repo, budget);
+      head = after?.tree;
+      if (!before || !after || before.tree !== after.tree) tree = undefined;
+      if (tree && repo && head !== undefined && after) reflog = headMoveCursor(repo, head, budget, after.head);
       if (repo && !tree) log(`snapshot failed at ${what}`);
     } catch (error) {
-      log(`snapshot failed at ${what}: ${(error as Error).message}`);
+      tree = undefined; head = undefined; reflog = undefined;
+      snapshotFailure(what, error);
     }
-    return { tree, ms: Math.round(performance.now() - t0) };
+    return { tree, head, reflog, budget, repo, ms: Math.round(performance.now() - t0) };
   };
   function privateSnapshotWindow(): boolean {
     return [...turns.values()].some(turn => turn.private) || board.list().some(task => !isClosedTaskState(task.state) && tasks.isPii(task));
@@ -2294,7 +2317,7 @@ export async function startDaemon(opts: DaemonOptions) {
         if (t.state === "backlog") return line(t);
         const overlap = tasks.overlaps(t, t.owner === by);
         if (t.owner === by && tasks.silentFor(t.id) && factsOn()) factsFor(by).sawPlans(by, tasks.overlapTasks(t)); // as for an accept
-        return [line(t), overlap, tasks.claimRoleGuidance(t, by), t.owner === by ? tasks.planGuardText(t) : ""].filter(Boolean).join("\n");
+        return [line(t), tasks.namedOwnerNote(t, a.owner as PeerId | undefined, by), overlap, tasks.claimRoleGuidance(t, by), t.owner === by ? tasks.planGuardText(t) : ""].filter(Boolean).join("\n");
       }
       case "hub_task_accept": {
         // S1 spec acceptance and S9 plan review are checked against one task snapshot before acceptance.
@@ -2733,6 +2756,14 @@ export async function startDaemon(opts: DaemonOptions) {
     for (const task of open) for (const peer of [task.owner, task.reviewer]) if (peer && !membershipAllowed(peer)) ids.add(peer);
     return [...ids].filter(peer => membershipAllowed(peer) || reservations.includes(peer) || bus.queued(peer) > 0 || (() => { const summary = bus.queueSummary(peer); return summary.needsReview > 0 || !!summary.liveAccepted?.length; })() || open.some(task => task.owner === peer || task.reviewer === peer));
   };
+  let checkoutInTick: { branch: ReturnType<typeof mainCheckoutBranch> } | undefined;
+  const checkoutBranch = () => {
+    if (!checkoutInTick) {
+      checkoutInTick = { branch: (opts.checkoutBranch ?? mainCheckoutBranch)(opts.cwd) };
+      queueMicrotask(() => { checkoutInTick = undefined; });
+    }
+    return checkoutInTick.branch;
+  };
   const status = (includeAttentionItems = false, includeAttentionInput = false) => {
     const taskNeeds = board.statusTasks();
     const taskStalls = tasks.stalled();
@@ -2746,7 +2777,7 @@ export async function startDaemon(opts: DaemonOptions) {
     pluginBundle: SERVER_JS,
     pendingRestart,
     retainedConfig,
-    ...(() => { const warning = mainCheckoutWarning(opts.cwd, tasks.publicMetadataText); return warning ? { mainCheckout: warning } : {}; })(),
+    ...(() => { const warning = mainCheckoutWarning(opts.cwd, tasks.publicMetadataText, checkoutBranch); return warning ? { mainCheckout: warning } : {}; })(),
     startModes: Object.fromEntries(START_MODE_PEERS.map(peer => [peer, startModeOf(config.peers, peer, declarations)])),
     memoryProfile: memoryProfileStatus(includeAttentionItems),
     lifecycleStages: [...lifecycleConfig.stages],
@@ -2912,28 +2943,57 @@ export async function startDaemon(opts: DaemonOptions) {
   /** Work a conflict notice is about: open tasks and tasks in review (#91); a notice for anything else is dropped (#106). */
   const CONFLICT_STATES: Task["state"][] = ["proposed", "in_progress", "changes_requested", "in_review"];
   const detectConcurrentConflicts = (record: TurnRecord, mine: Task[]) => {
+    const hits: { ours: Task; theirs: Task; paths: string[]; turn: TurnRecord }[] = [];
     for (const otherTurn of turnLog!.concurrentWith(record)) {
       const otherTasks = (turnTasks.get(otherTurn.id) ?? []).flatMap((id) => { const task = board.get(id); return task ? [task] : []; });
       if (otherTasks.some(tasks.isPii)) continue;
-      const shared = record.changed.filter((p) => otherTurn.changed.includes(p));
-      const pairs = mine.flatMap((ours) => otherTasks.map((theirs) => ({ ours, theirs })));
-      for (const { ours, theirs } of pairs) {
+      const theirs = new Set(otherTurn.changed);
+      const shared = record.changed.filter(path => theirs.has(path));
+      for (const ours of mine) for (const theirs of otherTasks) {
         if (ours.id === theirs.id) continue;
         const pair = [ours.id, theirs.id].sort((a, b) => a - b).join(":");
-        const paths = shared.filter((p) => !conflictSeen.has(`concurrent:${pair}:${p}`));
+        const paths = shared.filter(path => !conflictSeen.has(`concurrent:${pair}:${path}`));
         if (!paths.length) continue;
         for (const path of paths) conflictSeen.add(`concurrent:${pair}:${path}`);
-        const named = paths.filter(tasks.nameable);
-        const files = [...named, ...(paths.length > named.length ? [`${paths.length - named.length} file(s) whose names are withheld (they match a PII pattern)`] : [])].join(", ");
-        const together = tasks.silentFor(ours.id) && tasks.silentFor(theirs.id) ? "Check the working tree before continuing; do not message the other owner (you are in one turn-free cohort: the hub shows you its changes)." : "Check the working tree together before continuing.";
-        const text = `Concurrent edit: ${record.id} (task #${ours.id}) and ${otherTurn.id} (task #${theirs.id}) both include changes to ${files}. These snapshots do not attribute the changes to either peer. ${together}`;
-        notify(`conflict: ${text}`);
-        event({ type: "conflict", peer: record.peer, task: ours.id, other: theirs.id, owner: otherTurn.peer, paths: named, concurrent: true, turns: [record.id, otherTurn.id] });
-        recordConflictLink(ours.id, theirs.id, [record.peer, otherTurn.peer]);
-        // Each owner hears it while its own task is open; once that task is closed the notice is dropped (issue #106).
-        for (const [owner, task] of [[record.peer, ours.id], [otherTurn.peer, theirs.id]] as const) if (owner !== USER && owner !== HUB) tasks.whileOpen(owner, task, text, CONFLICT_STATES);
+        hits.push({ ours, theirs, paths, turn: otherTurn });
       }
     }
+    if (!hits.length) return;
+    const paths = [...new Set(hits.flatMap(hit => hit.paths))];
+    const named = paths.filter(tasks.nameable), visible = new Set(named);
+    const files = (shared: string[]) => {
+      const shown = shared.filter(path => visible.has(path));
+      return [...shown, ...(shared.length > shown.length ? [`${shared.length - shown.length} file(s) whose names are withheld (they match a PII pattern)`] : [])].join(", ");
+    };
+    const affected = new Map<string, Map<number, Task>>();
+    const add = (owner: string, task: Task) => {
+      if (!affected.has(owner)) affected.set(owner, new Map());
+      affected.get(owner)!.set(task.id, task);
+    };
+    for (const hit of hits) { add(record.peer, hit.ours); add(hit.turn.peer, hit.theirs); }
+    const labels = (rows: Task[]) => `${rows.length === 1 ? "task" : "tasks"} ${rows.map(task => `#${task.id}`).join(", ")}`;
+    const descriptions = [`${record.id} (${labels([...affected.get(record.peer)!.values()])}): ${files(paths)}`];
+    const byTurn = new Map<string, { tasks: Map<number, Task>; paths: Set<string> }>();
+    for (const hit of hits) {
+      if (!byTurn.has(hit.turn.id)) byTurn.set(hit.turn.id, { tasks: new Map(), paths: new Set() });
+      const group = byTurn.get(hit.turn.id)!;
+      group.tasks.set(hit.theirs.id, hit.theirs);
+      for (const path of hit.paths) group.paths.add(path);
+    }
+    for (const [id, group] of byTurn) descriptions.push(`${id} (${labels([...group.tasks.values()])}): ${files([...group.paths])}`);
+    const rows = [...affected.values()].flatMap(group => [...group.values()]);
+    const together = rows.every(task => tasks.silentFor(task.id)) ? "Check the working tree before continuing; do not message the other owner (you are in one turn-free cohort: the hub shows you its changes)." : rows.some(task => tasks.silentFor(task.id)) ? "Check the working tree before continuing. Do not message another owner for tasks in the same turn-free cohort; the hub shows their changes. Check other work together." : "Check the working tree together before continuing.";
+    const text = `Concurrent edit: shared changes by turn: ${descriptions.join("; ")}. These snapshots do not attribute the changes to any peer. ${together}`;
+    notify(`conflict: ${text}`);
+    // Research retains task-pair evidence. Durable notices are computed once across all overlapping turns,
+    // and each affected task gets only one owner-fenced notice for this change set.
+    for (const hit of hits) {
+      event({ type: "conflict", peer: record.peer, task: hit.ours.id, other: hit.theirs.id, owner: hit.turn.peer, paths: hit.paths.filter(path => visible.has(path)), concurrent: true, turns: [record.id, hit.turn.id] });
+      recordConflictLink(hit.ours.id, hit.theirs.id, [record.peer, hit.turn.peer]);
+    }
+    for (const [owner, group] of affected) {
+      if (owner !== USER && owner !== HUB) for (const task of group.values()) tasks.whileOpen(owner, task.id, text, CONFLICT_STATES);
+    }
   };
   const detectConflicts = (peer: PeerId, turnId: string, since: number, changed: string[]) => {
     const open = board.list().filter((t) => t.owner && CONFLICT_STATES.includes(t.state));
@@ -3102,7 +3162,7 @@ export async function startDaemon(opts: DaemonOptions) {
         const start = capture && !pii ? snap(`the start of ${id}`, config.snapshots.enabled, e.peer) : undefined; // before the peer is handed anything: the tap runs inside setState
         try { if (capture) turnLog?.begin(id, e.peer, start?.tree, declarations[e.peer] ? executionRoot(e.peer) : undefined); } catch (error) { log(`turn record ${id}: ${(error as Error).message}`); }
         const preparedRoles = preparedSessionRoleIdentities.get(e.peer)?.map(role => ({ ...role })) ?? null;
-        turns.set(e.peer, { id, capture, start: Date.now(), tokens: 0, deliveryTask: delivery, attribution, preparedRoles, ...(start ? { tree: start.tree, snapshotMs: start.ms } : {}), ...(pii ? { private: true } : {}) });
+        turns.set(e.peer, { id, capture, start: Date.now(), tokens: 0, deliveryTask: delivery, attribution, preparedRoles, ...(start ? { tree: start.tree, head: start.head, reflog: start.reflog, snapshotMs: start.ms } : {}), ...(pii ? { private: true } : {}) });
         event({ type: "turn_start", peer: e.peer, turn: id });
       } else if (!busy && open) {
         turns.delete(e.peer);
@@ -3113,7 +3173,48 @@ export async function startDaemon(opts: DaemonOptions) {
           try { turnLog.end(open.id, undefined, [], Math.max(1, Number(config.snapshots.keep) || 20)); } catch (error) { log(`turn record ${open.id}: ${(error as Error).message}`); }
         } else if (open.capture && turnLog) {
           const end = snap(`the end of ${open.id}`, true, e.peer);
-          const changed = open.tree && end.tree ? changedPaths(repoFor(e.peer)!, open.tree, end.tree) : [];
+          let changed: string[] = [];
+          if (open.tree && end.tree) {
+            const turnRepo = end.repo!;
+            try {
+              const observed = knownChangedPaths(turnRepo, open.tree, end.tree, end.budget);
+              if (!observed) throw new Error("turn diff evidence is unavailable");
+              changed = observed;
+              // HEAD movement alone does not identify incoming work: commits/amends/rebases/cherry-picks
+              // are normal peer edits. Only a bounded, append-fenced reflog classifies an incoming move.
+              if (open.head !== end.head || open.reflog || end.reflog) {
+                const paths = open.reflog && end.reflog ? incomingHeadPaths(turnRepo, open.reflog, end.reflog, end.budget) : undefined;
+                if (!paths) throw new Error("HEAD move evidence is ambiguous or unavailable");
+                if (paths.length) {
+                  if (!end.head) throw new Error("end HEAD evidence is unavailable");
+                  const dirtyPaths = knownChangedPaths(turnRepo, end.head, end.tree, end.budget);
+                  if (!dirtyPaths) throw new Error("end worktree diff evidence is unavailable");
+                  const checkBudget = () => { if (end.budget && performance.now() >= end.budget.deadline) throw new SnapshotBudgetExceeded(); };
+                  const dirty = new Set(dirtyPaths), dirtyScope = new Set(dirtyPaths), incoming = new Set(paths);
+                  for (const path of dirtyPaths) {
+                    checkBudget();
+                    for (let at = path.lastIndexOf("/"); at > 0; at = path.lastIndexOf("/", at - 1)) {
+                      checkBudget(); dirtyScope.add(path.slice(0, at));
+                    }
+                  }
+                  // Autostash and checkout -m can carry uncommitted edits across an incoming move.
+                  // Preserve every still-dirty path (including file/directory overlaps), never subtract it.
+                  changed = changed.filter(path => {
+                    checkBudget();
+                    if (!incoming.has(path) || dirtyScope.has(path)) return true;
+                    for (let at = path.lastIndexOf("/"); at > 0; at = path.lastIndexOf("/", at - 1)) {
+                      checkBudget(); if (dirty.has(path.slice(0, at))) return true;
+                    }
+                    return false;
+                  });
+                  checkBudget();
+                }
+              }
+            } catch (error) {
+              end.tree = undefined; end.head = undefined; changed = [];
+              snapshotFailure(`the diff of ${open.id}`, error);
+            }
+          }
           if (open.tree && end.tree) files = changed.length; // unknown, not zero, when a snapshot failed
           snapshotMs = (snapshotMs ?? 0) + end.ms;
           try { turnLog.end(open.id, end.tree, changed, Math.max(1, Number(config.snapshots.keep) || 20)); } catch (error) { log(`turn record ${open.id}: ${(error as Error).message}`); }
@@ -5356,6 +5457,10 @@ export async function startDaemon(opts: DaemonOptions) {
             return;
           }
           const offered = factsOn() && (native.event === "PreInvocation" || native.event === "SessionStart") ? offerFor(peer, native.toolUseId ?? `${native.sessionId}:invocation`) : undefined;
+          // The decoded native read (agy view_file or read_file, as `Read`) is a peer fact: its target is observed before it runs and the
+          // view moves after it. Nothing is offered here: agy's hook encodes an offer only on SessionStart/PreInvocation.
+          if (factsOn() && native.event === "PreToolUse") factsFor(peer).preTool(peer, native.toolUseId, native.tool, native.input);
+          if (factsOn() && native.event === "PostToolUse") factsFor(peer).postTool(peer, native.toolUseId, native.tool, native.input);
           return void reply({ ok: true, ...(offered ? { text: offered.text } : {}) });
         };
         if (owner.claiming) {

package/src/hub/hub-tools.ts

@@ -97,7 +97,7 @@ export const TASK_TOOL_NAMES = new Set(TASK_TOOLS.map((t) => t.name));
 export const CONDUCTOR_TOOLS: HubTool[] = [
   tool("hub_status", "Inspect public team state, holds, quota windows, task counts and pending approval peer/tool/age. Only the configured conductor may use this tool.", {}),
   tool("hub_task_show", "Read a task's public view and history, its done summary and check result included. PII tasks remain stubs. Only the conductor and the task's current owner and reviewer may use this tool.", { id }, ["id"]),
-  tool("hub_task_assign", "Name an owner (default role) or reviewer. Only the conductor may name a reviewer through this tool. A proposer may redirect an unaccepted proposed task's owner; a task that still waits reserves that owner. Pull-only peers receive work when named or when they claim it. With an explicit capabilities list, the conductor needs assign capability for either role, the proposer only to give ownership to another peer.", { id, peer: str, role: { type: "string", enum: ["owner", "reviewer"] } }, ["id", "peer"]),
+  tool("hub_task_assign", "Name an owner (default role) or reviewer. Only the conductor may name a reviewer through this tool. A proposer may redirect an unaccepted proposed task's owner; a task that still waits reserves that owner. Pull-only peers receive work when named while attached or when they claim it; a peer that cannot take the task is refused with the reason, and the task is unchanged. With an explicit capabilities list, the conductor needs assign capability for either role, the proposer only to give ownership to another peer.", { id, peer: str, role: { type: "string", enum: ["owner", "reviewer"] } }, ["id", "peer"]),
   tool("hub_task_escalate", "Escalate a task through the normal task flow, as the conductor. Requires assign capability when explicitly listed.", { id }, ["id"]),
   tool("hub_peer_start", "Start local, kimi, qwen, jcode, pi, claude or codex in the start mode a person set for it; you cannot choose the mode. A headless peer starts at once. A TUI peer (claude, and pi and codex by default) opens in a terminal with a fixed command; when the hub cannot open a terminal the call fails with the command for the person to run.", { peer: { type: "string", enum: CONDUCTOR_START_PEERS } }, ["peer"]),
   tool("hub_peer_hold", "Hold a peer's deliveries as the conductor. This hold is separate from the person's hold and budget pauses.", { peer: str }, ["peer"]),

package/src/hub/main-checkout.ts

@@ -27,8 +27,8 @@ export function mainCheckoutBranch(cwd: string): { branch: string; defaultBranch
  * whole public-text screen (`Tasks.publicMetadataText`: the configured PII patterns, secret shapes and private paths). A name it refuses, or any text
  * that is not a plain ref name, is replaced by a generic sentence that carries no part of it (#572 review I2).
  */
-export function mainCheckoutWarning(cwd: string, nameable: (text: string) => boolean = () => false): string | undefined {
-  const found = mainCheckoutBranch(cwd);
+export function mainCheckoutWarning(cwd: string, nameable: (text: string) => boolean = () => false, read: typeof mainCheckoutBranch = mainCheckoutBranch): string | undefined {
+  const found = read(cwd);
   if (!found) return undefined;
   const plain = /^[A-Za-z0-9][A-Za-z0-9._\/-]{0,99}$/.test(found.branch) && nameable(found.branch);
   return plain ? `the main checkout is on \`${found.branch}\`; move the work to a worktree under .worktrees/`

package/src/hub/manager.ts

@@ -241,8 +241,9 @@ export async function openManager(options: ManagerOptions = {}): Promise<string>
   const f = files(home);
   mkdirSync(f.dir, { recursive: true, mode: 0o700 });
   const log = openSync(join(f.dir, "manager.log"), "a");
+  let proc: ReturnType<typeof spawn>;
   try {
-    const proc = spawn(process.execPath, [options.cli ?? join(import.meta.dir, "../cli/main.ts"), "manager"], {
+    proc = spawn(process.execPath, [options.cli ?? join(import.meta.dir, "../cli/main.ts"), "manager"], {
       cwd: home, detached: true, stdio: ["ignore", log, log], env: { ...scrubEnv(process.env), AGENTHUB_HOME: home },
     });
     proc.on("error", () => {}); proc.unref();
@@ -250,7 +251,14 @@ export async function openManager(options: ManagerOptions = {}): Promise<string>
   const deadline = Date.now() + 8000;
   let error: unknown;
   while (Date.now() < deadline) {
-    try { return (await managerRequest(home, "/open", options.liveTest)).body.url; }
+    try {
+      const answered = await managerRequest(home, "/open", options.liveTest);
+      // #584: concurrent opens each spawn a manager and one wins the owner claim. A spawn that lost, or is still booting when
+      // another manager answers, would claim the owner row once that manager is stopped and then run with nobody to stop it.
+      // Only the manager that answered is wanted; stop the process this open started if it is a different one.
+      if (answered.status.pid !== proc.pid) proc.kill("SIGTERM");
+      return answered.body.url;
+    }
     catch (caught) { error = caught; await Bun.sleep(100); }
   }
   throw new Error(`manager readiness not confirmed: ${safeError(error)}; see ${join(f.dir, "manager.log")}`);

package/src/hub/settings.ts

@@ -87,7 +87,7 @@ export function projectSettings(instances?: KindMap): readonly SettingDef[] {
       path: Object.freeze(base.path.map(part => part === adapter.kind ? peer : part)),
       ...(base.values ? { values: Object.freeze([...base.values]) } : {}),
     });
-    for (const prefix of ["roster", "permission", "permission_modes"]) {
+    for (const prefix of ["roster", "permission", "permission_modes", "tasks.wip_limits"]) {
       const base = SETTINGS.find(def => def.key === `${prefix}.${adapter.kind}`);
       if (base) extra.push(copy(base, `${prefix}.${peer}`));
     }