@mclean-capital/neura 3.5.3 → 3.5.4

package/core/server.bundled.mjs

@@ -8013,6 +8013,7 @@ __export(work_item_queries_exports, {
   deleteWorkItem: () => deleteWorkItem,
   getOpenWorkItems: () => getOpenWorkItems,
   getWorkItem: () => getWorkItem,
+  getWorkItemByWorkerId: () => getWorkItemByWorkerId,
   getWorkItems: () => getWorkItems,
   updateWorkItem: () => updateWorkItem
 });
@@ -8051,6 +8052,13 @@ async function getWorkItem(db, id) {
   const result = await db.query("SELECT * FROM work_items WHERE id = $1", [id]);
   return result.rows.length > 0 ? mapWorkItem(result.rows[0]) : null;
 }
+async function getWorkItemByWorkerId(db, workerId) {
+  const result = await db.query(
+    "SELECT * FROM work_items WHERE worker_id = $1 LIMIT 1",
+    [workerId]
+  );
+  return result.rows.length > 0 ? mapWorkItem(result.rows[0]) : null;
+}
 async function createWorkItem(db, title, priority, options) {
   const id = crypto3.randomUUID();
   await db.query(
@@ -76118,7 +76126,6 @@ var ALL_STATUSES = [
 ];
 var COMMENT_TYPES = [
   "progress",
-  "heartbeat",
   "clarification_request",
   "approval_request",
   "clarification_response",
@@ -76218,7 +76225,7 @@ var taskToolDefs = [
   {
     type: "function",
     name: "update_task",
-    description: "Update a task: field changes, status transitions, and/or comment appends (unified with the worker protocol). Workers use this for report_progress / heartbeat / request_clarification / request_approval / complete_task / fail_task. Orchestrator uses it for user responses (clarification_response / approval_response) and field edits.",
+    description: "Update a task: field changes, status transitions, and/or comment appends (unified with the worker protocol). Workers use this for report_progress / request_clarification / request_approval / complete_task / fail_task. Orchestrator uses it for user responses (clarification_response / approval_response) and field edits.",
     parameters: {
       type: "object",
       properties: {
@@ -76958,6 +76965,8 @@ import {
   SessionManager
 } from "@mariozechner/pi-coding-agent";
 var log19 = new Logger("pi-runtime");
+var ALIVE_PULSE_THROTTLE_MS = 3e4;
+var ALIVE_INTERVAL_MS = 6e4;
 var BRIDGE_EVENT_TYPES = /* @__PURE__ */ new Set([
   "agent_start",
   "agent_end",
@@ -77028,6 +77037,15 @@ var PiRuntime = class {
   handleAgentEvent(workerId, event) {
     const worker = this.active.get(workerId);
     if (!worker) return;
+    const now = Date.now();
+    if (now - worker.lastAliveAt >= ALIVE_PULSE_THROTTLE_MS) {
+      worker.lastAliveAt = now;
+      try {
+        worker.callbacks.onAlive?.();
+      } catch (err) {
+        log19.warn("onAlive callback threw", { workerId, err: String(err) });
+      }
+    }
     if (event.type === "agent_start") {
       worker.callbacks.onStatusChange?.("running");
     } else if (event.type === "agent_end") {
@@ -77061,6 +77079,10 @@ var PiRuntime = class {
       worker.callbacks.onStatusChange?.(finalStatus);
       worker.callbacks.onComplete?.(result);
       worker.resolveDone(result);
+      if (worker.aliveInterval) {
+        clearInterval(worker.aliveInterval);
+        worker.aliveInterval = void 0;
+      }
       if (finalStatus !== "idle_partial") {
         this.active.delete(workerId);
       } else {
@@ -77069,6 +77091,28 @@ var PiRuntime = class {
     }
     return result;
   }
+  /**
+   * Start the defense-in-depth interval that refreshes the worker's
+   * lease on a timer, independent of pi's event stream. Pi's bash
+   * tool (and any custom tool that doesn't stream) can go silent for
+   * minutes between `tool_execution_start` and `_end`; without this
+   * pulse the lease would expire and crash-recovery could kill a
+   * perfectly healthy worker that's just waiting on a subprocess.
+   * `unref()` so the timer doesn't keep the process alive on its own.
+   */
+  startAliveInterval(worker) {
+    worker.aliveInterval = setInterval(() => {
+      try {
+        worker.callbacks.onAlive?.();
+      } catch (err) {
+        log19.warn("interval onAlive callback threw", {
+          workerId: worker.workerId,
+          err: String(err)
+        });
+      }
+    }, ALIVE_INTERVAL_MS);
+    worker.aliveInterval.unref?.();
+  }
   /**
    * Authoritative `stopReason` → `WorkerStatus` mapping. Matches the
    * table in docs/phase6-os-core.md exactly:
@@ -77119,9 +77163,11 @@ var PiRuntime = class {
       resolveDone,
       idleWaiters: [],
       pendingPause: false,
-      callbacks
+      callbacks,
+      lastAliveAt: 0
     };
     this.active.set(workerId, worker);
+    this.startAliveInterval(worker);
     session.prompt(task.description).then(() => {
       const stopReason = this.extractStopReasonFromSession(session);
       this.finalizeWorker(workerId, stopReason);
@@ -77155,9 +77201,11 @@ var PiRuntime = class {
       resolveDone,
       idleWaiters: [],
       pendingPause: false,
-      callbacks
+      callbacks,
+      lastAliveAt: 0
     };
     this.active.set(workerId, worker);
+    this.startAliveInterval(worker);
     session.prompt(resumePrompt).then(() => {
       const stopReason = this.extractStopReasonFromSession(session);
       this.finalizeWorker(workerId, stopReason);
@@ -77457,15 +77505,6 @@ async function listComments(db, opts) {
   );
   return result.rows.map((r2) => mapTaskComment(r2));
 }
-async function pruneHeartbeats(db, taskId, author) {
-  const result = await db.query(
-    `DELETE FROM task_comments
-     WHERE task_id = $1 AND type = 'heartbeat' AND author = $2
-     RETURNING id`,
-    [taskId, author]
-  );
-  return result.rows.length;
-}
 async function countOpenRequests(db, taskId) {
   const result = await db.query(
     `SELECT COUNT(*)::TEXT as count FROM task_comments
@@ -77714,6 +77753,7 @@ var WorktreeManager = class {
 
 // src/workers/agent-worker.ts
 var log23 = new Logger("agent-worker");
+var LEASE_WINDOW_MS = 15 * 6e4;
 var CANONICAL_WORKER_SYSTEM_PROMPT = `You are a Neura worker \u2014 a capable engineering agent executing a task dispatched by the Neura orchestrator. The orchestrator is a voice-first assistant that briefed this task with the user, confirmed intent, and handed it off to you.
 
 Your posture: be decisive. You have full tool access \u2014 Read, Write, Edit, Bash \u2014 scoped to an isolated worktree directory (your cwd). Make progress. Don't ask the user to double-check obvious things. Don't propose a plan and wait for approval when the path is clear.
@@ -77738,12 +77778,13 @@ Actions inside your worktree (creating new files, editing files you created, run
 Communication protocol \u2014 use these tools to report back, not prose:
 
 - \`report_progress(message)\` \u2014 brief status updates. Surfaces to the user as ambient voice. Use sparingly: one update per meaningful step, not one per tool call.
-- \`heartbeat(note?)\` \u2014 signal you're alive on long tasks. Emit at least every 2 minutes when you expect to run longer than that, or the orchestrator will treat you as crashed.
 - \`request_clarification(question, context?, urgency?)\` \u2014 ask the user a blocking question. Returns their answer. Only escalate when you genuinely cannot resolve ambiguity from the task context. Try to answer from context first.
 - \`request_approval(action, rationale?, urgency?)\` \u2014 mandatory before destructive actions (see reversibility rule above).
 - \`complete_task(summary)\` \u2014 mark the task done. Include a short summary of what you did, keyed to the acceptance criteria. The invariant layer will reject this if any clarification or approval is still unresolved.
 - \`fail_task(reason, reason_code)\` \u2014 mark the task failed. Use the right reason_code: \`impossible\` (missing precondition), \`already_done\` (no-op), \`user_aborted\` (user stopped you), \`hard_error\` (exception/timeout).
 
+You do not need to emit keepalives or heartbeats. The runtime observes your activity through the tool-call stream and refreshes your lease automatically.
+
 Escalation discipline: escalate sparingly. The orchestrator is mediating a voice conversation with a human \u2014 every clarification interrupts it. Only escalate when:
 - You cannot determine which of several paths the user wants (and context doesn't make it obvious).
 - You hit a blocker that requires user authorization (destructive action, external side effect).
@@ -77969,6 +78010,16 @@ var AgentWorker = class {
         callbacks.onStatusChange?.(status);
       },
       onProgress: callbacks.onProgress,
+      onAlive: () => {
+        void this.refreshTaskLease(task.id).catch((err) => {
+          log23.warn("failed to refresh task lease", {
+            workerId,
+            taskId: task.id,
+            err: String(err)
+          });
+        });
+        callbacks.onAlive?.();
+      },
       onComplete: (result) => {
         void this.persistTerminalResult(workerId, result).catch((err) => {
           log23.warn("failed to persist terminal result", {
@@ -78009,6 +78060,10 @@ var AgentWorker = class {
     if (!row.sessionFile) {
       throw new Error(`resume: worker ${workerId} has no session_file`);
     }
+    const linkedTask = await getWorkItemByWorkerId(this.db, workerId);
+    if (linkedTask) {
+      this.workerTaskIds.set(workerId, linkedTask.id);
+    }
     const wrapped = {
       onStatusChange: (status) => {
         void updateWorker(this.db, workerId, { status }).catch((err) => {
@@ -78017,6 +78072,16 @@ var AgentWorker = class {
         callbacks.onStatusChange?.(status);
       },
       onProgress: callbacks.onProgress,
+      onAlive: linkedTask ? () => {
+        void this.refreshTaskLease(linkedTask.id).catch((err) => {
+          log23.warn("failed to refresh task lease on resume", {
+            workerId,
+            taskId: linkedTask.id,
+            err: String(err)
+          });
+        });
+        callbacks.onAlive?.();
+      } : callbacks.onAlive,
       onComplete: (result) => {
         void this.persistTerminalResult(workerId, result).catch((err) => {
           log23.warn("failed to persist terminal result", {
@@ -78126,6 +78191,29 @@ var AgentWorker = class {
   get activeCount() {
     return this.cancellation.activeCount;
   }
+  /**
+   * Refresh a task's lease. Called from the `onAlive` callback the
+   * runtime fires (throttled) on every pi event. Replaces the explicit
+   * `heartbeat` tool the worker used to emit — pi's event stream is a
+   * stronger signal than a self-reported ping and removes a verb from
+   * the worker protocol prompt.
+   *
+   * Terminal tasks are skipped. Pi emits trailing events (agent_end,
+   * final tool_execution_end) after `complete_task`/`fail_task`; without
+   * this guard the lease bump would rewrite `leaseExpiresAt` on a
+   * `done`/`failed`/`cancelled` row and inflate `version`/`updated_at`,
+   * causing spurious optimistic-lock conflicts for the orchestrator's
+   * next edit.
+   */
+  async refreshTaskLease(taskId) {
+    const task = await getWorkItem(this.db, taskId);
+    if (!task) return;
+    if (task.status === "done" || task.status === "failed" || task.status === "cancelled") {
+      return;
+    }
+    const newLease = new Date(Date.now() + LEASE_WINDOW_MS).toISOString();
+    await updateWorkItem(this.db, taskId, { leaseExpiresAt: newLease });
+  }
   /**
    * Persist a terminal result to the workers table. Called by the
    * callbacks wrapper on `onComplete`. Maps the WorkerResult into the
@@ -78250,8 +78338,10 @@ var ClarificationBridge = class {
         if (signal) {
           const onAbort = () => {
             const idx = this.pending.indexOf(pending);
-            if (idx >= 0) this.pending.splice(idx, 1);
-            reject(new Error("clarification aborted"));
+            if (idx >= 0) {
+              this.pending.splice(idx, 1);
+              reject(new Error("clarification aborted"));
+            }
           };
           if (signal.aborted) {
             onAbort();
@@ -78283,9 +78373,13 @@ var ClarificationBridge = class {
    * clarifications are waiting, the turn is ignored (the user is just
    * talking to Grok normally).
    *
-   * Returns true if the turn was consumed by a pending clarification,
-   * false otherwise — callers can use this to decide whether to also
-   * forward the turn to the normal voice session flow.
+   * Returns `true` synchronously when a pending clarification was
+   * found; `false` when nothing was pending. When `true`, the
+   * response persistence (via `onAnswer`) is in flight and the
+   * worker's `askUser` Promise resolves only after the persistence
+   * completes — so `complete_task`'s open-request gate sees the
+   * committed response comment. Callers use the boolean to decide
+   * whether to forward the turn to the normal voice session flow.
    */
   notifyUserTurn(text) {
     const next = this.pending.shift();
@@ -78295,14 +78389,21 @@ var ClarificationBridge = class {
       textPreview: text.slice(0, 80)
     });
     if (next.onAnswer) {
-      void Promise.resolve(next.onAnswer(text)).catch((err) => {
-        log24.warn("onAnswer persistence hook threw", {
-          workerId: next.workerId,
-          err: String(err)
-        });
-      });
+      void (async () => {
+        try {
+          await Promise.resolve(next.onAnswer(text));
+        } catch (err) {
+          log24.warn("onAnswer persistence hook threw", {
+            workerId: next.workerId,
+            err: String(err)
+          });
+        } finally {
+          next.resolve(text);
+        }
+      })();
+    } else {
+      next.resolve(text);
     }
-    next.resolve(text);
     return true;
   }
   /** How many clarifications are currently waiting for a user turn. */
@@ -78383,7 +78484,6 @@ var ORCHESTRATOR_ALLOWED_FROM = {
 };
 var WORKER_ALLOWED_COMMENT_TYPES = /* @__PURE__ */ new Set([
   "progress",
-  "heartbeat",
   "clarification_request",
   "approval_request",
   "error",
@@ -78504,12 +78604,6 @@ async function applyTaskUpdate(args) {
       urgency: payload.comment.urgency ?? null,
       metadata: payload.comment.metadata ?? null
     });
-    if (payload.comment.type !== "heartbeat" && actor.startsWith("worker:")) {
-      try {
-        await pruneHeartbeats(db, task.id, actor);
-      } catch {
-      }
-    }
   }
   const refreshed = await getWorkItem(db, task.id);
   if (!refreshed) {
@@ -78527,17 +78621,9 @@ async function resolveTask(store, idOrTitle) {
 
 // src/workers/worker-protocol-tools.ts
 var log25 = new Logger("worker-protocol-tools");
-var LEASE_WINDOW_MS = 5 * 6e4;
 var ReportProgressParams = Type.Object({
   message: Type.String({ description: "Short status update the user may hear read aloud." })
 });
-var HeartbeatParams = Type.Object({
-  note: Type.Optional(
-    Type.String({
-      description: "Optional short note. Heartbeats are pruned after your next real comment."
-    })
-  )
-});
 var RequestClarificationParams2 = Type.Object({
   question: Type.String({ description: "Plain-language question to ask the user." }),
   context: Type.Optional(
@@ -78631,26 +78717,6 @@ function buildWorkerProtocolTools(options) {
       });
     }
   });
-  tools.push({
-    name: "heartbeat",
-    label: "Heartbeat",
-    description: "Signal that you're still alive on a long-running task. Refreshes the worker's lease. Emit at least every 2 minutes when you expect to run long so the orchestrator doesn't treat you as crashed.",
-    parameters: HeartbeatParams,
-    execute: async (_toolCallId, rawParams) => {
-      const params = rawParams;
-      const newLease = new Date(Date.now() + LEASE_WINDOW_MS).toISOString();
-      const result = await taskTools.updateTask(taskId, {
-        comment: { type: "heartbeat", content: params.note ?? "still working" },
-        fields: { leaseExpiresAt: newLease }
-      });
-      if (!result) throw new Error(`heartbeat: task ${taskId} not found`);
-      return textResult("Heartbeat recorded.", {
-        taskId,
-        workerId,
-        leaseExpiresAt: newLease
-      });
-    }
-  });
   tools.push({
     name: "request_clarification",
     label: "Request Clarification",