llm-orchestrator 1.2.2 → 1.2.3

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "llm-orchestrator",
   "description": "Write /task once — it plans the work, shards it across parallel subagents, gates every phase and verifies before claiming done. Claude Code, Codex, OpenCode, Kilo.",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "author": {
     "name": "Bogdan-Gabriel Torcescu",
     "url": "https://www.linkedin.com/in/bogdantorcescu/"

package/lib/flow-gate.mjs

@@ -14,7 +14,7 @@
  * tool inputs or file contents. `doctor` reads it back as the adherence audit.
  */
 import { createHash, randomUUID } from 'node:crypto';
-import { appendFile, mkdir, readdir, readFile, rename, rmdir, stat, writeFile } from 'node:fs/promises';
+import { appendFile, mkdir, readdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 
 /**
@@ -412,18 +412,37 @@ const LOCK_STALE_MS = 5000;
  * an atomic mkdir lock; a lock older than LOCK_STALE_MS belongs to a crashed
  * handler and is taken over. Failing to lock in time throws — the gate fails open.
  */
+/** A lock whose recorded owner process no longer exists was left by a killed handler. */
+async function ownerIsDead(lock) {
+  try {
+    const pid = Number.parseInt(await readFile(join(lock, 'owner'), 'utf8'), 10);
+    if (!Number.isInteger(pid) || pid <= 0) return false;
+    process.kill(pid, 0);
+    return false;
+  } catch (error) {
+    return error.code === 'ESRCH';
+  }
+}
+
+async function releaseLock(lock) {
+  await rm(lock, { recursive: true, force: true }).catch(() => {});
+}
+
 async function withSessionLock(path, work) {
   const lock = `${path}.lock`;
   const deadline = Date.now() + LOCK_WAIT_MS;
   while (true) {
     try {
       await mkdir(lock);
+      await writeFile(join(lock, 'owner'), `${process.pid}\n`).catch(() => {});
       break;
     } catch (error) {
       if (error.code !== 'EEXIST') throw error;
+      // Harnesses kill hooks that overrun their timeout; a lock they held must not
+      // swallow every event behind it until the stale timeout.
       const held = await stat(lock).then((info) => Date.now() - info.mtimeMs).catch(() => 0);
-      if (held > LOCK_STALE_MS) {
-        await rmdir(lock).catch(() => {});
+      if (held > LOCK_STALE_MS || await ownerIsDead(lock)) {
+        await releaseLock(lock);
         continue;
       }
       if (Date.now() > deadline) throw new Error('ledger session is locked');
@@ -433,13 +452,16 @@ async function withSessionLock(path, work) {
   try {
     return await work();
   } finally {
-    await rmdir(lock).catch(() => {});
+    await releaseLock(lock);
   }
 }
 
 export async function handleHook({ payload, project, now = Date.now(), cli = 'llm-orchestrator' }) {
   const event = normalizePayload(payload);
   if (event.kind === 'other') return null;
+  // Subagent tool calls change nothing (they work under the parent's run), so they
+  // take no lock and do no I/O — a busy subagent must not starve the parent's events.
+  if (event.kind === 'tool' && event.isSubagent) return null;
   // An explicit run command opts the project in; anything else needs the project to use the core.
   if (!event.run && !(await projectUsesOrchestrator(project))) return null;
   const directory = await ensureLedger(project);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-orchestrator",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "Write /task once — it plans the work, shards it across parallel subagents, gates every phase and verifies before claiming done. Claude Code, Codex, OpenCode, Kilo.",
   "type": "module",
   "engines": {