pi-herdsman 0.22.1 → 0.22.2

package/dist/index.js

@@ -8,14 +8,14 @@ import {
   SessionManager as SessionManager2
 } from "@earendil-works/pi-coding-agent";
 import { readFileSync as readFileSync9, statSync as statSync7, unlinkSync as unlinkSync9 } from "node:fs";
-import { basename as basename6, dirname as dirname7, resolve as resolve6 } from "node:path";
+import { basename as basename6, dirname as dirname7, resolve as resolve7 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // package.json
 var package_default = {
   name: "pi-herdsman",
-  version: "0.22.1",
+  version: "0.22.2",
   type: "module",
   description: "Asynchronous Pi subagents and agent fleet orchestration for parallel coding agents with nested delegation, background work, and supervision in herdr.",
   license: "Apache-2.0",
@@ -1135,7 +1135,7 @@ function parseControlMarker(text) {
   return UUID2.test(id) && id.length === 36 ? id : void 0;
 }
 function waitForState(path, predicate, options) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     let done = false;
     let abortListener;
     const finish = (error2, state) => {
@@ -1145,7 +1145,7 @@ function waitForState(path, predicate, options) {
       clearInterval(interval);
       if (abortListener && options.signal)
         options.signal.removeEventListener("abort", abortListener);
-      error2 ? reject(error2) : resolve7(state);
+      error2 ? reject(error2) : resolve8(state);
     };
     const check = () => {
       try {
@@ -15722,6 +15722,7 @@ import { visibleWidth as visibleWidth2 } from "@earendil-works/pi-tui";
 import { contentText as contentText4, getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 import { randomUUID as randomUUID10 } from "node:crypto";
 import { realpathSync as realpathSync5, statSync as statSync6, unlinkSync as unlinkSync8 } from "node:fs";
+import { isAbsolute as isAbsolute5, resolve as resolve6 } from "node:path";
 var LEAD_INSTANCE_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 function createLeadRuntimeState() {
   return {
@@ -15976,6 +15977,13 @@ function createLeadSessionStartRuntime(host) {
         ...host.ownToolsSnapshot()
       });
       const activeManager = host.isLead() && host.roleTransitions.activeManager();
+      if (activeManager && !sessionSignal.aborted) {
+        try {
+          await host.roleTransitions.reconcileCurrentManagerAssignments(ctx);
+        } catch (error2) {
+          host.appendRoleError(ctx, error2);
+        }
+      }
       if (host.isLead() && (host.roleTransitions.chiefModeActive() || activeManager)) {
         host.startSupervisionUI(ctx);
       } else host.leadStatusRuntime.start(ctx);
@@ -16889,6 +16897,7 @@ function registerLeadRuntime(pi, options) {
     pi,
     isCurrentChief: (ctx) => options.leadRuntime.chiefMode === "active" && !!options.leadRuntime.chiefLease && options.leadRuntime.chiefLease.descriptor.piSessionId === ctx.sessionManager.getSessionId(),
     currentManager: (...args) => roleTransitions.currentManager(...args),
+    reconcileProjectAssignments: (...args) => roleTransitions.reconcileProjectAssignments(...args),
     currentChief: (...args) => roleTransitions.currentChief(...args),
     currentChiefAuthority: (...args) => roleTransitions.currentChiefAuthority(...args),
     latestMessageText: (ctx) => coordinationRuntime.latestCustomMessageText(
@@ -17239,6 +17248,7 @@ function registerLeadRuntime(pi, options) {
     liveAgent,
     liveLead,
     currentManager: (...args) => roleTransitions.currentManager(...args),
+    reconcileProjectAssignments: (...args) => roleTransitions.reconcileProjectAssignments(...args),
     sameManagerDescriptor: projectHost.sameManagerDescriptor,
     withProjectWorkLock: (...args) => roleTransitions.withProjectWorkLock(...args),
     withProjectAssignmentLock: (...args) => roleTransitions.withProjectAssignmentLock(...args),
@@ -17713,6 +17723,8 @@ function createLeadSupervisionRuntime(host) {
         manager.workspaceId,
         ctx.signal
       );
+      if (group.repoKey !== manager.repoKey || group.primaryWorkspaceId !== manager.workspaceId)
+        throw new Error("Manager workspace is not the assigned project");
       const [leads, topology] = await Promise.all([
         directReports(ctx, suppliedInventory, suppliedAgents),
         host.runHerdr(
@@ -17722,8 +17734,15 @@ function createLeadSupervisionRuntime(host) {
           { signal: ctx.signal }
         )
       ]);
-      if (topology?.source?.repo_key !== group.repoKey || !Array.isArray(topology?.worktrees))
+      if (topology?.source?.repo_key !== group.repoKey || topology?.source?.source_workspace_id !== group.primaryWorkspaceId || !Array.isArray(topology?.worktrees))
         throw new Error("Herdr worktree topology is not authoritative");
+      if (typeof topology.source.source_checkout_path === "string")
+        await host.reconcileProjectAssignments?.(
+          ctx,
+          group.repoKey,
+          group.primaryWorkspaceId,
+          topology.source.source_checkout_path
+        );
       const assignments = host.listProjectAssignments(
         host.supervisionRuntime(),
         group.repoKey
@@ -18760,7 +18779,8 @@ function createLeadProjectRuntime(host) {
     stopHerdrAgentPreservingPane: stopHerdrAgentPreservingPane2,
     expectedSession: expectedSession3,
     liveLead,
-    withProjectWorkLock
+    withProjectWorkLock,
+    withProjectAssignmentLock
   } = host;
   const {
     activeRole,
@@ -18830,35 +18850,44 @@ function createLeadProjectRuntime(host) {
       );
     const primaryWorkspaceId = group.primaryWorkspaceId;
     const runtime = supervisionRuntime2();
-    const existing = readProjectAssignment2(
-      runtime,
-      manager.repoKey,
-      operation.branch
+    const branch = operation.branch;
+    const topology = await runHerdr2(
+      pi,
+      ctx,
+      ["worktree", "list", "--workspace", primaryWorkspaceId],
+      { signal }
     );
+    if (topology?.source?.source_workspace_id !== primaryWorkspaceId || topology?.source?.repo_key !== manager.repoKey || !Array.isArray(topology?.worktrees))
+      throw new Error("Herdr worktree topology is not authoritative");
+    if (operation.action === "resume")
+      await host.reconcileProjectAssignments(
+        ctx,
+        manager.repoKey,
+        primaryWorkspaceId,
+        typeof topology.source.source_checkout_path === "string" ? topology.source.source_checkout_path : "",
+        true,
+        branch
+      );
+    const existing = readProjectAssignment2(runtime, manager.repoKey, branch);
     if (existing && existing.repoKey !== manager.repoKey)
       throw new Error("Project assignment belongs to another repository");
     if (operation.action === "delegate" && existing)
       throw new Error(
-        `Work already exists on ${operation.branch}; resume it with resume_project.`
+        `Work already exists on ${branch}; resume it with resume_project.`
       );
     if (operation.action === "resume" && !existing)
       throw new Error(
-        `No existing work was found on ${operation.branch}; start it with delegate_project and a task.`
+        `No existing work was found on ${branch}; start it with delegate_project and a task.`
       );
     const presentationTask = operation.action === "resume" ? projectTaskSummary(existing.text) : void 0;
     const id = operation.action === "resume" ? existing.id : operation.id;
-    const branch = operation.branch;
-    const topology = await runHerdr2(
-      pi,
-      ctx,
-      ["worktree", "list", "--workspace", primaryWorkspaceId],
-      { signal }
-    );
-    if (topology?.source?.source_workspace_id !== primaryWorkspaceId || topology?.source?.repo_key !== manager.repoKey || !Array.isArray(topology?.worktrees))
-      throw new Error("Herdr worktree topology is not authoritative");
     const branchWorktrees = topology.worktrees.filter(
       (worktree) => worktree?.branch === branch
     );
+    if (operation.action === "resume" && branchWorktrees.length === 0)
+      throw new Error(
+        "Worktree availability could not be verified; the existing assignment was preserved. Retry when repository access is available."
+      );
     if (branchWorktrees.length > 1)
       throw new Error(`Multiple Herdr worktrees match branch ${branch}`);
     const live = operation.action === "resume" ? await liveAgent(ctx, existing.id) : [];
@@ -18977,7 +19006,6 @@ function createLeadProjectRuntime(host) {
         text: prepared.text,
         ...prepared.resultBindings.length ? { resultBindings: prepared.resultBindings } : {}
       };
-      writeProjectAssignment2(runtime, assignment);
     }
     const promptPaths = [];
     try {
@@ -19024,6 +19052,8 @@ function createLeadProjectRuntime(host) {
             );
         }
       } else {
+        if (operation.action === "resume")
+          throw new Error("The existing project checkout is unavailable");
         const args = [
           "worktree",
           "create",
@@ -19033,44 +19063,7 @@ function createLeadProjectRuntime(host) {
           assignment.branch,
           "--no-focus"
         ];
-        if (operation.action === "resume") {
-          let savedCwd;
-          if (assignment.piSessionFile) {
-            const saved = SessionManager3.open(assignment.piSessionFile);
-            if (saved.getSessionId() !== assignment.id)
-              throw new Error(
-                "Persisted project session identity does not match"
-              );
-            savedCwd = saved.getCwd();
-          } else {
-            const saved = (await SessionManager3.listAll()).filter(
-              (session) => session.id === assignment.id
-            );
-            if (saved.length > 1)
-              throw new Error(
-                `Pi session ${assignment.id} is ambiguous; project work was preserved.`
-              );
-            if (saved.length === 1) {
-              const sessionFile = saved[0].path;
-              if (typeof sessionFile !== "string" || !sessionFile)
-                throw new Error(
-                  "Legacy project session has no exact file path"
-                );
-              const session = SessionManager3.open(sessionFile);
-              if (session.getSessionId() !== assignment.id)
-                throw new Error(
-                  "Persisted project session identity does not match"
-                );
-              savedCwd = session.getCwd();
-              assignment = await persistLeadSessionFile(
-                assignment,
-                realpathSync5(sessionFile)
-              );
-            }
-          }
-          args.push("--base", assignment.branch);
-          if (savedCwd) args.push("--path", savedCwd);
-        } else args.push("--base", operation.base ?? "HEAD");
+        args.push("--base", operation.base ?? "HEAD");
         const created = await runHerdr2(pi, ctx, args, { signal });
         workspaceId = created?.workspace?.workspace_id;
         paneId = created?.root_pane?.pane_id;
@@ -19085,6 +19078,40 @@ function createLeadProjectRuntime(host) {
         (value2) => typeof value2 === "string" && value2
       ))
         throw new Error("Herdr did not return exact worktree identities");
+      if (operation.action === "delegate") {
+        const [common, branchResult] = await Promise.all([
+          pi.exec(
+            "git",
+            ["rev-parse", "--path-format=absolute", "--git-common-dir"],
+            { cwd, signal, timeout: 1e4 }
+          ),
+          pi.exec("git", ["symbolic-ref", "--quiet", "--short", "HEAD"], {
+            cwd,
+            signal,
+            timeout: 1e4
+          })
+        ]);
+        if (common.code !== 0 || common.killed || common.stderr?.trim() || branchResult.code !== 0 || branchResult.killed || branchResult.stderr?.trim() || !isAbsolute5(String(common.stdout ?? "").trim()) || realpathSync5(String(common.stdout).trim()) !== realpathSync5(manager.repoKey) || String(branchResult.stdout ?? "").trim() !== assignment.branch)
+          throw new Error(
+            "Herdr checkout does not match the assigned repository and branch"
+          );
+        const fresh = await currentManager(ctx);
+        if (!fresh || !sameManagerDescriptor2(fresh, manager))
+          throw new Error(
+            "Manager changed before project assignment was published"
+          );
+        await withProjectAssignmentLock(
+          manager.repoKey,
+          assignment.branch,
+          () => {
+            if (readProjectAssignment2(runtime, manager.repoKey, assignment.branch))
+              throw new Error(
+                `Work already exists on ${assignment.branch}; resume it with resume_project.`
+              );
+            writeProjectAssignment2(runtime, assignment);
+          }
+        );
+      }
       await assertUnoccupied(workspaceId);
       let lead;
       let startedLead = false;
@@ -20056,8 +20083,8 @@ function createLeadCoordinationRuntime(host) {
   const enterCoordinationPublication = async () => {
     const previous = coordinationPublication;
     let release;
-    coordinationPublication = new Promise((resolve7) => {
-      release = resolve7;
+    coordinationPublication = new Promise((resolve8) => {
+      release = resolve8;
     });
     await previous;
     return release;
@@ -21113,12 +21140,75 @@ async function resolveLeadControllerRole(state, ctx, requestedRole, deps, option
     );
   }
 }
+function gitPathStatus(path) {
+  try {
+    return statSync6(path).isDirectory() ? "present" : "unknown";
+  } catch (error2) {
+    const code = error2.code;
+    return code === "ENOENT" || code === "ENOTDIR" ? "absent" : "unknown";
+  }
+}
+function parseGitWorktreeInventory(output) {
+  if (!output.endsWith("\0\0")) return void 0;
+  const fields = output.split("\0");
+  if (fields.pop() !== "") return void 0;
+  const records = [];
+  let record = [];
+  for (const field of fields) {
+    if (field) record.push(field);
+    else if (record.length) {
+      records.push(record);
+      record = [];
+    }
+  }
+  if (record.length) records.push(record);
+  if (!records.length) return void 0;
+  const worktrees = [];
+  for (const values of records) {
+    if (!values[0]?.startsWith("worktree ")) return void 0;
+    let path;
+    let head;
+    let branch;
+    let bare = false;
+    let detached = false;
+    let locked = false;
+    let prunable = false;
+    const seen = /* @__PURE__ */ new Set();
+    for (const value2 of values) {
+      const key = value2.startsWith("worktree ") ? "worktree" : value2.startsWith("HEAD ") ? "HEAD" : value2.startsWith("branch refs/heads/") ? "branch" : value2 === "detached" || value2 === "bare" ? value2 : /^locked(?: |$)/.test(value2) ? "locked" : /^prunable(?: |$)/.test(value2) ? "prunable" : void 0;
+      if (key && seen.has(key)) return void 0;
+      if (key) seen.add(key);
+      if (value2.startsWith("worktree ") && !path) path = value2.slice(9);
+      else if (value2.startsWith("HEAD ") && !head) head = value2.slice(5);
+      else if (value2.startsWith("branch refs/heads/") && !branch)
+        branch = value2.slice("branch refs/heads/".length);
+      else if (value2 === "detached" || value2 === "bare") {
+        if (value2 === "bare") bare = true;
+        else detached = true;
+      } else if (/^locked(?: .*)?$/.test(value2)) locked = true;
+      else if (/^prunable(?: .*)?$/.test(value2)) prunable = true;
+      else if (!/^[^\s]+(?: .*)?$/.test(value2)) return void 0;
+    }
+    if (!path || !isAbsolute5(path) || (bare ? !!branch || detached : !head || !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(head) || !branch && !detached) || branch !== void 0 && !branch)
+      return void 0;
+    worktrees.push({
+      path,
+      ...branch ? { branch } : {},
+      ...detached ? { detached: true } : {},
+      ...locked ? { locked: true } : {},
+      ...prunable ? { prunable: true } : {}
+    });
+  }
+  if (new Set(worktrees.map((worktree) => worktree.path)).size !== worktrees.length)
+    return void 0;
+  return worktrees;
+}
 function createLeadRoleTransitions(state, host) {
   const projectWorkLocks = /* @__PURE__ */ new Map();
   const withProjectWorkLock = async (key, operation) => {
     const previous = projectWorkLocks.get(key);
     let release;
-    const current = new Promise((resolve7) => release = resolve7);
+    const current = new Promise((resolve8) => release = resolve8);
     projectWorkLocks.set(key, current);
     await previous;
     try {
@@ -21331,29 +21421,177 @@ function createLeadRoleTransitions(state, host) {
     const assignment = scope ? projectAssignmentForScope(scope, ctx.sessionManager.getSessionId()) : void 0;
     return assignment ? currentManager(ctx, scope) : host.currentChiefAuthority(ctx);
   };
-  const removeProjectAssignmentState = (assignment, ctx) => {
+  const removeProjectAssignmentState = (assignment, _ctx) => {
     const runtime = host.supervisionRuntime();
     const current = host.readProjectAssignment(
       runtime,
       assignment.repoKey,
       assignment.branch
     );
-    if (!current || current.id !== assignment.id) return false;
+    if (!current || current.repoKey !== assignment.repoKey || current.branch !== assignment.branch || current.id !== assignment.id)
+      return false;
+    host.removeProjectMessages(runtime, assignment.repoKey, assignment.branch);
     host.removeProjectAssignment(
       runtime,
       assignment.repoKey,
       assignment.branch
     );
+    return true;
+  };
+  const gitWorktreeInventory = async (ctx, repoKey, primaryWorkspaceId, sourceCheckoutPath) => {
+    if (!isAbsolute5(sourceCheckoutPath)) return void 0;
     try {
-      host.removeProjectMessages(
-        runtime,
-        assignment.repoKey,
-        assignment.branch
+      const scope = await host.worktreeGroupScope(
+        ctx,
+        primaryWorkspaceId,
+        ctx.signal
       );
-    } catch (error2) {
-      host.appendDurableError(host.pi, ctx, "pi_herdsman_state_error", error2);
+      if (scope.repoKey !== repoKey || scope.primaryWorkspaceId !== primaryWorkspaceId)
+        return void 0;
+      const rootResult = await host.pi.exec(
+        "git",
+        ["rev-parse", "--path-format=absolute", "--git-common-dir"],
+        { cwd: sourceCheckoutPath, signal: ctx.signal, timeout: 1e4 }
+      );
+      if (rootResult.code !== 0 || rootResult.killed || rootResult.stderr?.trim())
+        return void 0;
+      const commonDir = String(rootResult.stdout ?? "").trim();
+      if (!commonDir || !isAbsolute5(commonDir)) return void 0;
+      const result = await host.pi.exec(
+        "git",
+        ["worktree", "list", "--porcelain", "-z"],
+        { cwd: sourceCheckoutPath, signal: ctx.signal, timeout: 1e4 }
+      );
+      if (result.code !== 0 || result.killed || result.stderr?.trim())
+        return void 0;
+      const inventory = parseGitWorktreeInventory(String(result.stdout ?? ""));
+      if (!inventory || realpathSync5(commonDir) !== realpathSync5(repoKey) || gitPathStatus(sourceCheckoutPath) !== "present")
+        return void 0;
+      return inventory;
+    } catch {
+      return void 0;
+    }
+  };
+  const reconcileProjectAssignments = async (ctx, repoKey, primaryWorkspaceId, sourceCheckoutPath, projectWorkLocked = false, onlyBranch, retryLockContention = false) => {
+    const manager = await currentManager(ctx);
+    if (!manager || manager.repoKey !== repoKey || manager.workspaceId !== primaryWorkspaceId)
+      return;
+    const assignments = listProjectAssignments(
+      host.supervisionRuntime(),
+      repoKey
+    );
+    const initialInventory = await gitWorktreeInventory(
+      ctx,
+      repoKey,
+      primaryWorkspaceId,
+      sourceCheckoutPath
+    );
+    if (!initialInventory) return;
+    const knownCheckoutPath = (assignment) => {
+      if (!assignment.piSessionFile) return void 0;
+      try {
+        const session = host.SessionManager.open(assignment.piSessionFile);
+        if (session.getSessionId() !== assignment.id) return void 0;
+        return resolve6(session.getCwd());
+      } catch {
+        return void 0;
+      }
+    };
+    const checkoutMaySurvive = (assignment, inventory) => {
+      const cwd = knownCheckoutPath(assignment);
+      if (cwd)
+        return inventory.some(
+          (worktree) => resolve6(worktree.path) === cwd && gitPathStatus(worktree.path) !== "absent"
+        );
+      return inventory.some(
+        (worktree) => resolve6(worktree.path) !== resolve6(sourceCheckoutPath) && gitPathStatus(worktree.path) !== "absent"
+      );
+    };
+    for (const observed of assignments) {
+      if (onlyBranch && observed.branch !== onlyBranch) continue;
+      if (checkoutMaySurvive(observed, initialInventory)) continue;
+      const initialMatches = initialInventory.filter(
+        (worktree) => worktree.branch === observed.branch
+      );
+      if (initialMatches.length > 1 || initialMatches.some(
+        (worktree) => worktree.locked || !worktree.prunable || gitPathStatus(worktree.path) !== "absent"
+      ))
+        continue;
+      const retireIfAbsent = async () => {
+        const latestManager = await currentManager(ctx);
+        if (!latestManager || !host.sameManagerDescriptor(latestManager, manager))
+          return;
+        const retireUnderAssignmentLock = async () => {
+          const latestManager2 = await currentManager(ctx);
+          if (!latestManager2 || !host.sameManagerDescriptor(latestManager2, manager))
+            return;
+          const current = host.readProjectAssignment(
+            host.supervisionRuntime(),
+            repoKey,
+            observed.branch
+          );
+          if (!current || current.repoKey !== repoKey || current.branch !== observed.branch || current.id !== observed.id)
+            return;
+          const inventory = await gitWorktreeInventory(
+            ctx,
+            repoKey,
+            primaryWorkspaceId,
+            sourceCheckoutPath
+          );
+          if (!inventory) return;
+          if (checkoutMaySurvive(current, inventory)) return;
+          const matches = inventory.filter(
+            (worktree) => worktree.branch === observed.branch
+          );
+          if (matches.length > 1 || matches.some(
+            (worktree) => worktree.locked || !worktree.prunable || gitPathStatus(worktree.path) !== "absent"
+          ))
+            return;
+          removeProjectAssignmentState(current, ctx);
+        };
+        const deadline = retryLockContention ? Date.now() + 3e4 : 0;
+        for (; ; ) {
+          try {
+            await withProjectAssignmentLock(
+              repoKey,
+              observed.branch,
+              retireUnderAssignmentLock
+            );
+            return;
+          } catch (error2) {
+            if (!(error2 instanceof ProcessLockOccupiedError)) throw error2;
+            if (!retryLockContention) return;
+            if (ctx.signal.aborted) throw ctx.signal.reason;
+            if (Date.now() >= deadline) throw error2;
+            await host.delay(50, void 0, { signal: ctx.signal });
+          }
+        }
+      };
+      if (projectWorkLocked) await retireIfAbsent();
+      else
+        await withProjectWorkLock(
+          `${repoKey}\0${observed.branch}`,
+          retireIfAbsent
+        );
     }
-    return true;
+  };
+  const reconcileCurrentManagerAssignments = async (ctx) => {
+    const manager = await currentManager(ctx);
+    if (!manager) return;
+    const topology = await host.runHerdr(
+      host.pi,
+      ctx,
+      ["worktree", "list", "--workspace", manager.workspaceId],
+      { signal: ctx.signal }
+    );
+    if (topology?.source?.repo_key !== manager.repoKey || topology?.source?.source_workspace_id !== manager.workspaceId || typeof topology?.source?.source_checkout_path !== "string")
+      throw new Error("Manager worktree topology is not authoritative");
+    await reconcileProjectAssignments(
+      ctx,
+      manager.repoKey,
+      manager.workspaceId,
+      topology.source.source_checkout_path
+    );
   };
   const takeover = async (ctx) => {
     if (activeLeadRole(state) !== "lead" || state.chiefMode === "active" || state.roleSuspended)
@@ -21392,38 +21630,31 @@ function createLeadRoleTransitions(state, host) {
     return true;
   };
   const retireRemovedProjectWork = async (removed, ctx, signal) => {
-    const runtime = host.supervisionRuntime();
-    const observed = host.readProjectAssignment(
-      runtime,
-      removed.repoKey,
-      removed.branch
-    );
-    if (!observed) return;
-    const scope = await currentWorktreeScope(ctx);
+    let scope;
+    try {
+      scope = await currentWorktreeScope(ctx);
+    } catch (error2) {
+      if (error2 instanceof OperationError && error2.detail.details?.herdrCode === "workspace_not_found")
+        return;
+      throw error2;
+    }
     if (!scope || scope.repoKey !== removed.repoKey) return;
-    await withProjectWorkLock(
-      `${removed.repoKey}\0${removed.branch}`,
-      async () => {
-        const deadline = Date.now() + 3e4;
-        for (; ; ) {
-          if (signal.aborted)
-            throw signal.reason ?? new Error("operation aborted");
-          try {
-            await withProjectAssignmentLock(
-              removed.repoKey,
-              removed.branch,
-              async () => {
-                removeProjectAssignmentState(observed, ctx);
-              }
-            );
-            return;
-          } catch (error2) {
-            if (!(error2 instanceof ProcessLockOccupiedError) || Date.now() >= deadline)
-              throw error2;
-            await host.delay(50, void 0, { signal });
-          }
-        }
-      }
+    const topology = await host.runHerdr(
+      host.pi,
+      ctx,
+      ["worktree", "list", "--workspace", scope.primaryWorkspaceId],
+      { signal }
+    );
+    if (topology?.source?.repo_key !== removed.repoKey || topology?.source?.source_workspace_id !== scope.primaryWorkspaceId || typeof topology?.source?.source_checkout_path !== "string")
+      return;
+    await reconcileProjectAssignments(
+      ctx,
+      removed.repoKey,
+      scope.primaryWorkspaceId,
+      topology.source.source_checkout_path,
+      false,
+      removed.branch,
+      true
     );
   };
   const beginShutdownRole = () => {
@@ -21692,6 +21923,11 @@ function createLeadRoleTransitions(state, host) {
       host.advancePeerPresenceGeneration();
       if (host.coordinationHealthy()) await host.schedulePeerPresence(ctx);
       await host.publishLeadRole(ctx, "inactive", state.chiefModeGeneration);
+      try {
+        await reconcileCurrentManagerAssignments(ctx);
+      } catch (error2) {
+        host.appendDurableError(host.pi, ctx, "pi_herdsman_state_error", error2);
+      }
       return "Manager mode active.";
     } catch (error2) {
       state.controllerRole = "lead";
@@ -22033,11 +22269,13 @@ function createLeadRoleTransitions(state, host) {
     withProjectAssignmentLock,
     publishProjectMessage,
     currentManager,
+    reconcileCurrentManagerAssignments,
     currentChief,
     currentChiefAuthority,
     currentSupervisor,
     takeover,
     retireRemovedProjectWork,
+    reconcileProjectAssignments,
     clearLeadContext: () => {
       state.leadContext = void 0;
     }
@@ -22707,9 +22945,9 @@ Use reply_agent with agent="${ask.agentLabel}" to answer this question.`,
   const reconcileRoleTools = () => roleTransitions.reconcileRoleTools();
   const isCurrentChief = (ctx) => leadRuntime.chiefMode === "active" && !!leadRuntime.chiefLease && leadRuntime.chiefLease.descriptor.piSessionId === ctx.sessionManager.getSessionId();
   const chiefSystemPrompt = (options) => {
-    const agentDir = resolve6(getAgentDir4());
+    const agentDir = resolve7(getAgentDir4());
     const globalInstructions = (options?.contextFiles ?? []).filter(
-      ({ path, content }) => typeof path === "string" && typeof content === "string" && resolve6(dirname7(path)) === agentDir && content.length > 0
+      ({ path, content }) => typeof path === "string" && typeof content === "string" && resolve7(dirname7(path)) === agentDir && content.length > 0
     ).map(({ content }) => content).join("\n\n");
     return [
       CHIEF_ROLE_CHARTER,
@@ -22744,6 +22982,7 @@ ${globalInstructions}
     paneId: () => process.env.HERDR_PANE_ID,
     getSessionName: () => pi.getSessionName(),
     runHerdr,
+    SessionManager: SessionManager2,
     reportLeadMetadata,
     workspaceId: () => process.env.HERDR_WORKSPACE_ID,
     identity: {