agent-lyceum 0.24.1 → 0.25.0

package/dist/cli.js

@@ -545,7 +545,7 @@ program
         }
         const lease = takeLock(pr, full, { checkout: false });
         try {
-            const plan = planRunCleanup(pr, full, { keepWorktrees: opts.keepWorktrees });
+            const plan = planRunCleanup(pr, full, { keepWorktrees: opts.keepWorktrees, lockHeld: true });
             if (plan.refusals.length)
                 refuse(plan);
             showPlan(plan);

package/dist/run-cleanup.d.ts

@@ -35,9 +35,12 @@ export interface CleanupReport {
 /**
  * What clearing a run would do. Deletes nothing. Refuses (see `refusals`) while the run is running, or while
  * a worktree holds work that is not in the repo, unless `keepWorktrees` keeps the worktrees and their branches.
+ * `lockHeld`: the caller holds this run's lock (taking it would have thrown while a dispatcher was alive), so the
+ * run cannot be running and the lock, which is the caller's own, is not consulted.
  */
 export declare function planRunCleanup(project: ResolvedProject, runId: string, opts?: {
     keepWorktrees?: boolean;
+    lockHeld?: boolean;
 }): CleanupPlan;
 export interface ExecuteHooks {
     /** Test seam: called after each item is done and recorded. */

package/dist/run-cleanup.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { atomicWrite } from "./fs-util.js";
 import { assertName } from "./paths.js";
+import { inspectRunLock } from "./project-lock.js";
 import { loadRunState } from "./run-store.js";
 import { runIsAlive } from "./status.js";
 import { deleteSnapshotRefs, existingAgentWorkspace, inspectWorkspace, listSnapshotRefs, listWorkspaceAgents, removeAgentWorkspace } from "./worktree.js";
@@ -20,6 +21,8 @@ const lexists = (p) => {
 /**
  * What clearing a run would do. Deletes nothing. Refuses (see `refusals`) while the run is running, or while
  * a worktree holds work that is not in the repo, unless `keepWorktrees` keeps the worktrees and their branches.
+ * `lockHeld`: the caller holds this run's lock (taking it would have thrown while a dispatcher was alive), so the
+ * run cannot be running and the lock, which is the caller's own, is not consulted.
  */
 export function planRunCleanup(project, runId, opts = {}) {
     assertName("run", runId);
@@ -33,8 +36,10 @@ export function planRunCleanup(project, runId, opts = {}) {
     if (hasRun) {
         const state = loadRunState(runDir);
         plan.summary = `${runId}: ${state.task_summary}`;
-        if (!state.end_reason && runIsAlive(state, project))
-            plan.refusals.push(`Run ${runId} is still running (pid ${state.pid}); stop it first.`);
+        if (!state.end_reason && !opts.lockHeld && runIsAlive(state, project)) {
+            const holder = state.schema_version >= 2 ? inspectRunLock(project.paths.root, runId) : undefined;
+            plan.refusals.push(`Run ${runId} is still running (pid ${holder?.pid ?? state.pid}); stop it first.`);
+        }
     }
     // A concurrent run has a worktree for the lead: members' work lands there, and the lead's branch is what you merge.
     const leadWs = existingAgentWorkspace(project, runId, project.lead);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-lyceum",
-  "version": "0.24.1",
+  "version": "0.25.0",
   "description": "Config + dispatcher for teams of Claude Code / Codex agents with scoped context and file-based mailboxes",
   "keywords": [
     "ai",