parallelclaw 1.2.1 → 1.2.2

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 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

package/lib/executor.js

@@ -104,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.1",
+  "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",