parallelclaw 1.2.0 → 1.2.2

package/CHANGELOG.md

@@ -2,6 +2,42 @@
 
 Notable changes to parallelclaw (formerly memex-mvp). Older history lives in the git log.
 
+## 1.2.2 — durable execution: claim lease + auto-requeue for dead executors
+
+Found live: a research task outran Kimi's 240-second cron tick. The executor had
+already written `working` (the claim), but its agentTurn was killed before it
+could write a terminal event → the task was stranded in `working` forever. Fixes:
+- **Claim lease + lazy auto-requeue (#3b).** A `working` claim is leased (default
+  15 min). A stale `working` (claimer died — cron timeout, crash, laptop sleep)
+  becomes claimable again and reappears in `task-list --inbox`, so the next
+  poller retries it. No task is lost to a dead executor, and no sweeper is needed.
+  `claimTask`/`listTasks` gain `now`/`leaseMs` knobs; the Mac executor passes them.
+- **Executor prompt + docs:** read the FULL prompt from the `task-claim` output
+  (or `task-claim <id> --json`), never the 80-char `task-list` display line; on a
+  too-big task write `failed` with partial progress instead of spinning until the
+  run is killed or closing `done` with a placeholder (which would block requeue —
+  the exact thing that lost the first research delegation).
+
+Tests: +2 (stale working is re-claimable and back in inbox; terminal never
+requeues). Full npm test green.
+
+## 1.2.1 — patch: make the Mac executor's `claude -p` actually complete
+
+The Phase 2b headless executor invoked `claude -p` but every run hung until the
+4-minute timeout. Two fixes, live-verified end-to-end (delegate → Mac executor →
+real `claude -p` result returned in ~7s):
+- **Close the child's stdin.** `claude -p` reads stdin to EOF even with the prompt
+  passed as an arg; `execFile` left it open, so the process waited forever. Ending
+  stdin lets the run finish and exit.
+- **Strip Claude-session env markers** (`CLAUDECODE`, `CLAUDE_CODE_ENTRYPOINT`,
+  `CLAUDE_CODE_SSE_PORT`) before spawning, so the headless child is a clean,
+  separate session instead of being rejected as "nested inside another Claude
+  Code session" (matters when `task-run-once` is invoked from a Claude shell;
+  launchd already runs clean).
+
+Upgrade required for the installed Mac executor: `npm i -g parallelclaw@1.2.1`
+(the launchd job picks up the fixed code on its next tick — no reinstall needed).
+
 ## 1.2.0 — delegate by talking + the laptop as executor
 
 Coordination, now from natural language. Two MCP tools so any MCP client (Claude

package/lib/executor.js

@@ -64,8 +64,16 @@ function buildExecPrompt(env) {
 function claudeRunner(prompt, { timeoutMs = DEFAULT_TIMEOUT_MS, cwd } = {}) {
   return new Promise((res, rej) => {
     const bin = process.env.PARALLELCLAW_CLAUDE_BIN || 'claude';
-    execFile(bin, ['-p', prompt],
-      { timeout: timeoutMs, maxBuffer: 8 * 1024 * 1024, encoding: 'utf8', cwd: cwd || DATA },
+    // `claude -p` refuses to launch "inside another Claude Code session". The
+    // headless executor IS a separate, legitimate session — strip the inherited
+    // session markers so the child starts clean. launchd already runs without
+    // them; this also lets `task-run-once` work when invoked from a Claude shell.
+    const env = { ...process.env };
+    delete env.CLAUDECODE;
+    delete env.CLAUDE_CODE_ENTRYPOINT;
+    delete env.CLAUDE_CODE_SSE_PORT;
+    const child = execFile(bin, ['-p', prompt],
+      { timeout: timeoutMs, maxBuffer: 8 * 1024 * 1024, encoding: 'utf8', cwd: cwd || DATA, env },
       (err, stdout, stderr) => {
         if (err) {
           if (err.killed) return rej(new Error(`claude -p timed out after ${timeoutMs}ms`));
@@ -73,6 +81,10 @@ function claudeRunner(prompt, { timeoutMs = DEFAULT_TIMEOUT_MS, cwd } = {}) {
         }
         res(String(stdout || '').trim());
       });
+    // `claude -p` reads stdin until EOF even when the prompt is passed as an arg.
+    // execFile leaves the child's stdin open → it hangs until the timeout. Close
+    // it so the run completes and exits (verified: 240s timeout → ~7s with EOF).
+    try { child.stdin && child.stdin.end(); } catch (_) {}
   });
 }
 
@@ -92,7 +104,9 @@ export async function runInboxOnce({
   const me = getOrigin();
   const exec = runner || claudeRunner;
   const acted = [];
-  let inbox = listTasks({ inbox: true, db, limit: 50 });
+  // Passing `now` keeps the lease/stale-working check on the same clock as claimTask
+  // below, and lets the executor pick up tasks abandoned by a dead claimer (#3b).
+  let inbox = listTasks({ inbox: true, db, limit: 50, now });
   inbox = inbox.filter((t) => t.to === me || (includeBroadcast && t.to === 'any'));
   for (const t of inbox) {
     if (!allowKinds.includes(t.kind)) {

package/lib/tasks.js

@@ -34,6 +34,17 @@ const SOURCE = 'agent-task';
 const STATUSES = ['submitted', 'working', 'done', 'failed'];
 const TERMINAL = new Set(['done', 'failed']);
 
+// A claimed ('working') task whose claimer dies (cron agentTurn timeout, crash,
+// laptop sleep) would otherwise be stranded in 'working' forever. We LEASE the
+// claim: a 'working' event older than LEASE_MS is treated as abandoned and
+// becomes re-claimable by the next poller (lazy requeue — no sweeper, no extra
+// event type). Generous so modest cross-node clock skew can't expire a LIVE
+// claim. Tunable per call via opts.leaseMs.
+const LEASE_MS = 15 * 60 * 1000;
+function isStaleWorking(status, eventTsSec, nowMs, leaseMs) {
+  return status === 'working' && (nowMs - (eventTsSec || 0) * 1000) > leaseMs;
+}
+
 // Pick the CURRENT event of a task WITHOUT trusting wall-clock ts — clock skew
 // across nodes regressed state on the live mesh (a 'done' on a fast clock could
 // sort before a later 'working'). Order by the monotonic per-task `seq`, then a
@@ -141,14 +152,18 @@ export function updateTask(id, status, { result = null, db = null, now = Date.no
  * the task wasn't claimable (already taken / terminal) or another node won.
  * opts: { db?, now? }.
  */
-export function claimTask(id, { db = null, now = Date.now() } = {}) {
+export function claimTask(id, { db = null, now = Date.now(), leaseMs = LEASE_MS } = {}) {
   const ownDb = !db;
   db = db || openDb();
   try {
     const me = getOrigin();
     const prev = latestEvent(db, id);
     if (!prev) throw new Error(`claimTask: no task "${id}"`);
-    if (prev.envelope.status !== 'submitted') return null; // already working/terminal — not claimable
+    const status = prev.envelope.status;
+    // Claimable if fresh-submitted OR a STALE 'working' (its claimer died — the
+    // lease expired). A fresh 'working' or a terminal state is not claimable.
+    const reclaimStale = isStaleWorking(status, prev.ts, now, leaseMs);
+    if (status !== 'submitted' && !reclaimStale) return null;
     const seq = (prev.envelope.seq ?? 0) + 1;
     const env = { ...prev.envelope, status: 'working', seq, result: prev.envelope.result ?? null };
     writeEvent(db, { taskId: id, status: 'working', seq, origin: me, now, text: env.prompt || '', envelope: env });
@@ -180,7 +195,7 @@ function latestEvent(db, id) {
  *   inbox  — tasks addressed to me AND currently 'submitted' (ready to take)
  * Returns [{ id, from, to, kind, status, prompt, result, ts }] newest-first.
  */
-export function listTasks({ forOrigin = null, status = null, mine = false, inbox = false, limit = 50, db = null } = {}) {
+export function listTasks({ forOrigin = null, status = null, mine = false, inbox = false, limit = 50, db = null, now = Date.now(), leaseMs = LEASE_MS } = {}) {
   const ownDb = !db;
   db = db || openDb();
   try {
@@ -201,7 +216,9 @@ export function listTasks({ forOrigin = null, status = null, mine = false, inbox
     }
     let out = [...latest.values()];
     // #2 'any' is a broadcast: it lands in EVERY node's inbox (claim resolves the winner).
-    if (inbox) out = out.filter((t) => (t.to === me || t.to === 'any') && t.status === 'submitted');
+    // inbox = ready to run: 'submitted', OR a stale 'working' whose claimer died.
+    if (inbox) out = out.filter((t) => (t.to === me || t.to === 'any')
+      && (t.status === 'submitted' || isStaleWorking(t.status, t.ts, now, leaseMs)));
     if (mine) out = out.filter((t) => t.from === me);
     if (forOrigin) out = out.filter((t) => t.to === forOrigin || t.from === forOrigin);
     if (status) out = out.filter((t) => t.status === status);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parallelclaw",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Local-first personal AI ops layer. Shared verbatim memory across your agents (Claude Code, Cursor, OpenClaw, Hermes, Obsidian, Telegram) in one SQLite + FTS5 corpus — plus a coordination layer where any of your agents can delegate tasks to any other. Searchable from any MCP-compatible client.",
   "type": "module",
   "main": "server.js",