open-agents-ai 0.187.514 → 0.187.516

package/dist/index.js

@@ -525083,14 +525083,31 @@ var init_errorClusterTracker = __esm({
       // Style B: file(line,col): severity CODE: message  (TypeScript)
       {
         re: /^([^\s(]+):?\s*\((\d+),(\d+)\)\s*:?\s*(error|warning|note)\s+([A-Z]+\d+)\s*:\s*(.*)$/gm,
-        build: (m2) => ({
-          file: m2[1],
-          line: parseInt(m2[2], 10),
-          col: parseInt(m2[3], 10),
-          severity: m2[4],
-          code: m2[5],
-          message: (m2[6] ?? "").trim().slice(0, 240)
-        })
+        build: (m2) => {
+          const code8 = m2[5];
+          const message2 = (m2[6] ?? "").trim().slice(0, 240);
+          let hint;
+          if ((code8 === "TS2305" || code8 === "TS2724") && process.env["OA_DISABLE_TS_HINT"] !== "1") {
+            const dym = message2.match(/Did you mean ['"]([^'"]+)['"]\??/);
+            if (dym) {
+              hint = `TS suggests "${dym[1]}" exists in the imported module, but with a different identifier. Before retrying:
+  (1) file_read the imported module's source
+  (2) check whether the suggested name is declared with 'interface'/'type' (TYPE-only — cannot be used as a runtime value) or with 'class'/'function'/'const'/'let'/'var' (RUNTIME value).
+If your import expects a runtime value but the suggested name is a type, ADD a runtime export to the source module (e.g. 'export const X = ...' or 'export class X {...}'). Renaming the import will only fix the error if the suggested name is ALREADY a runtime value.`;
+            }
+          }
+          const out = {
+            file: m2[1],
+            line: parseInt(m2[2], 10),
+            col: parseInt(m2[3], 10),
+            severity: m2[4],
+            code: code8,
+            message: message2
+          };
+          if (hint)
+            out.hint = hint;
+          return out;
+        }
       },
       // Style C: error[CODE]: message ... --> file:line:col   (Rust-style)
       {
@@ -525153,16 +525170,19 @@ var init_errorClusterTracker = __esm({
         for (const e2 of errors) {
           const key = clusterKey(toolKey, e2.file, e2.code);
           const cur = observedClusters.get(key);
-          if (cur)
+          if (cur) {
             cur.count += 1;
-          else
-            observedClusters.set(key, { count: 1, sample: e2.message });
+            if (!cur.hint && e2.hint)
+              cur.hint = e2.hint;
+          } else {
+            observedClusters.set(key, { count: 1, sample: e2.message, hint: e2.hint });
+          }
         }
         const changes = [];
         const lines = [];
         let hasCritical = false;
         const nowMs = this.now();
-        for (const [key, { count, sample }] of observedClusters) {
+        for (const [key, { count, sample, hint }] of observedClusters) {
           const prior = this.clusters.get(key);
           if (!prior) {
             const ck = parseClusterKey(key);
@@ -525173,7 +525193,8 @@ var init_errorClusterTracker = __esm({
               observations: 1,
               attemptsSinceCountChange: 1,
               lastUpdated: nowMs,
-              previousCount: 0
+              previousCount: 0,
+              hint
             };
             this.clusters.set(key, entry);
             changes.push({ kind: "new", cluster: entry });
@@ -525182,6 +525203,8 @@ var init_errorClusterTracker = __esm({
           prior.observations++;
           prior.lastUpdated = nowMs;
           prior.sample = sample;
+          if (hint)
+            prior.hint = hint;
           if (count === prior.count) {
             prior.attemptsSinceCountChange++;
           } else {
@@ -525242,6 +525265,30 @@ var init_errorClusterTracker = __esm({
         this.lastEmittedAt.clear();
         this.observationCounter = 0;
       }
+      /**
+       * RCA-3 (root-cause from batch517 stax): top-N clusters by observation
+       * count, returned as shallow snapshots. Used by REG-58/59/60 to surface
+       * the specific repeating error in the structured replan inject. Caller
+       * must not mutate.
+       */
+      topClusters(n2 = 3) {
+        const all2 = [...this.clusters.values()];
+        all2.sort((a2, b) => b.observations - a2.observations || b.lastUpdated - a2.lastUpdated);
+        const lim = Math.max(1, Math.min(20, n2));
+        return all2.slice(0, lim).map((c9) => {
+          const out = {
+            pattern: `${c9.key.code} ${c9.sample.slice(0, 80)}`.trim(),
+            count: c9.count,
+            observations: c9.observations,
+            sample: c9.sample.slice(0, 240),
+            file: c9.key.file,
+            code: c9.key.code
+          };
+          if (c9.hint)
+            out.hint = c9.hint;
+          return out;
+        });
+      }
       evictIfNeeded() {
         if (this.clusters.size <= this.opts.maxClusters)
           return;
@@ -525785,6 +525832,15 @@ var init_agenticRunner = __esm({
       // etc. Fires stagnation independent of failure/variant thresholds because
       // those metrics get diluted by successful file_reads.
       _lastFileWriteTurn = -1;
+      // RCA-2 (root-cause from batch517 osm slow-grind): rolling timestamps of
+      // recent file_write events. REG-60 detects glacial progress that REG-58's
+      // binary turn-gap check misses — agent that writes 1 file every 25 turns
+      // never trips REG-58 but is still effectively stuck.
+      _fileWriteTimestamps = [];
+      // RCA-1 (root-cause from batch517 zombies): set true when SIGTERM received
+      // (daemon timeout). End-of-Task block uses this to set finalStatus="timeout"
+      // in the session_gist instead of "abandoned".
+      _aborting = false;
       // MEM_PATH item #9: adaptive retrieval cache. When the (goalHash, recent-tool-sig)
       // hasn't changed since last retrieval, skip the PPR call entirely and reuse
       // the previous memoryLines.
@@ -526114,6 +526170,46 @@ ${graphSummary}`,
        * Returns null if no session id OR no file. Used by buildPlanSkeleton
        * and by the turn-counter reminder.
        */
+      /**
+       * RCA-3 Part A: build an "RECENT FAILURE PATTERN" preamble for stagnation
+       * replan injects. Pulls the top cluster (by observation count) from the
+       * ErrorClusterTracker and includes its sample + any TS-aware hint. Returns
+       * empty string when no tracker is live or no clusters exist — caller
+       * concatenates the result, so empty is a valid no-op.
+       *
+       * Generic: works for any error pattern the cluster tracker has seen, not
+       * tied to any project-specific symbol or signature.
+       */
+      _buildErrorContextPreamble() {
+        try {
+          const ec = this._errorClusterTracker;
+          if (!ec || typeof ec.topClusters !== "function")
+            return "";
+          const top = ec.topClusters(1);
+          if (!Array.isArray(top) || top.length === 0)
+            return "";
+          const t2 = top[0];
+          const obs = typeof t2.observations === "number" ? t2.observations : 0;
+          const code8 = (t2.code || "").toString();
+          const sample = (t2.sample || "").toString().slice(0, 240);
+          let body = `
+RECENT FAILURE PATTERN (from error-cluster tracker, hit ${obs}× in this run):
+  ${code8} ${sample}
+`;
+          if (t2.hint) {
+            body += `
+HINT (semantic, generic):
+  ${t2.hint}
+`;
+          }
+          body += `
+Your hypotheses MUST address this specific error, not generic causes.
+`;
+          return body;
+        } catch {
+          return "";
+        }
+      }
       readSessionTodos() {
         try {
           const sid = process.env["OA_SESSION_ID"] || this._sessionId || "default";
@@ -527925,6 +528021,19 @@ Respond with your assessment, then take action.`;
         this._runErrorPatterns = [];
         this._runWhatWorked = [];
         this._lastFileWriteTurn = -1;
+        this._fileWriteTimestamps = [];
+        this._aborting = false;
+        if (!globalThis.__oa_rca1_sigterm_installed) {
+          globalThis.__oa_rca1_sigterm_installed = true;
+          const _sigtermHandler = () => {
+            this._aborting = true;
+            setTimeout(() => process.exit(124), 5e3).unref();
+          };
+          try {
+            process.on("SIGTERM", _sigtermHandler);
+          } catch {
+          }
+        }
         this._fileRegistry.clear();
         this._memexArchive.clear();
         this._sessionId = process.env["OA_SESSION_ID"] && String(process.env["OA_SESSION_ID"]) || `session-${Date.now()}`;
@@ -528340,9 +528449,10 @@ TASK: ${task}` : task;
           const REG58_NO_WRITE_BUDGET = 30;
           if (turn > stagnationCooldownUntilTurn && this._lastFileWriteTurn >= 0 && turn - this._lastFileWriteTurn >= REG58_NO_WRITE_BUDGET && process.env["OA_DISABLE_REG58"] !== "1") {
             const gap = turn - this._lastFileWriteTurn;
+            const _errCtx = this._buildErrorContextPreamble();
             const replan = `[STAGNATION REPLAN — REG-58 no-write convergence]
 You have made ${gap} tool calls without a single file_write/file_edit/batch_edit/file_patch since turn ${this._lastFileWriteTurn}. That is exploration-without-action. STOP retrying the current approach.
-
+` + _errCtx + `
 Respond with EXACTLY this structure before your next tool call:
   HYPOTHESES (3 distinct theories why progress stalled):
   1. ...
@@ -528363,6 +528473,36 @@ If the hypothesis cannot be tested by a creative edit, ask the human via task_co
             });
             this._lastFileWriteTurn = turn;
           }
+          const REG60_WINDOW_MS = 60 * 60 * 1e3;
+          const REG60_MIN_WRITES = 3;
+          const REG60_COOLDOWN_TURNS = 10;
+          if (turn > stagnationCooldownUntilTurn && this._runStartTime > 0 && Date.now() - this._runStartTime >= REG60_WINDOW_MS && process.env["OA_DISABLE_REG60"] !== "1") {
+            const cutoff = Date.now() - REG60_WINDOW_MS;
+            const recentWrites = this._fileWriteTimestamps.filter((ts) => ts >= cutoff).length;
+            if (recentWrites < REG60_MIN_WRITES) {
+              const _errCtx60 = this._buildErrorContextPreamble();
+              const _replan60 = `[STAGNATION REPLAN — REG-60 low-write-rate]
+Over the last 60 minutes you have made only ${recentWrites} creative edit(s) (file_write/file_edit/batch_edit/file_patch). That is a glacial pace — your current approach is producing exploration without action.
+` + _errCtx60 + `
+Respond with EXACTLY this structure before your next tool call:
+  HYPOTHESES (3 NEW theories why progress stalled — must be DIFFERENT from
+              anything tried so far):
+  1. ...
+  2. ...
+  3. ...
+  PICK: <number 1-3>
+  WHY: <one sentence>
+  FALSIFICATION: <observable signal that would refute the pick>
+  NEXT ACTION: <a single creative edit — file_write / file_edit / batch_edit>`;
+              messages2.push({ role: "system", content: _replan60 });
+              stagnationCooldownUntilTurn = turn + REG60_COOLDOWN_TURNS;
+              this.emit({
+                type: "status",
+                content: `REG-60 LOW-WRITE-RATE — ${recentWrites} creative edits in last 60 min (threshold ${REG60_MIN_WRITES})`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            }
+          }
           if (turn > stagnationCooldownUntilTurn && stagnationWindow.length >= STAG_MIN_SAMPLES) {
             const cutoffTurn = turn - STAG_WINDOW_TURNS;
             const cutoffTs = Date.now() - STAG_WINDOW_MS;
@@ -530281,11 +530421,12 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
                               if (obs.hasCritical) {
                                 messages2.push({ role: "system", content: obs.summaryLine });
                                 if (process.env["OA_DISABLE_REG59"] !== "1") {
+                                  const _errCtx59 = this._buildErrorContextPreamble();
                                   messages2.push({
                                     role: "system",
                                     content: `[STAGNATION REPLAN — REG-59 same-error escalation]
 The error cluster you keep hitting has occurred 5+ times. Your current approach is NOT working. STOP retrying it.
-
+` + _errCtx59 + `
 Respond with EXACTLY this structure before your next tool call:
   HYPOTHESES (3 NEW theories — must be DIFFERENT from anything tried so far):
   1. ...
@@ -531006,6 +531147,10 @@ Respond with EXACTLY this structure before your next tool call:
                 const creativeTools = ["file_write", "file_edit", "batch_edit", "file_patch"];
                 if (creativeTools.includes(tc.name)) {
                   this._lastFileWriteTurn = turn;
+                  this._fileWriteTimestamps.push(Date.now());
+                  if (this._fileWriteTimestamps.length > 200) {
+                    this._fileWriteTimestamps.shift();
+                  }
                 }
               }
               if (result && result.success === false) {
@@ -532357,8 +532502,9 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                   toolCounts.set(t2, (toolCounts.get(t2) ?? 0) + 1);
                 const topToolNames = [...toolCounts.entries()].sort((a2, b) => b[1] - a2[1]).slice(0, 3).map(([n2]) => n2);
                 const whatWorked = this._runLessons.slice(-3).map((l2) => l2.whatWorked).filter(Boolean);
+                const _wasTimeout = this._aborting === true;
                 const _wasStagnationExit = !!this._pendingStagnationEntry || /^\s*BLOCKED\b/i.test(summary || "");
-                const finalStatus = completed ? _wasStagnationExit ? "stagnation_exit" : "complete" : "abandoned";
+                const finalStatus = _wasTimeout ? "timeout" : completed ? _wasStagnationExit ? "stagnation_exit" : "complete" : "abandoned";
                 const gist2 = memMod.buildGist({
                   goal,
                   durationMs: durationMs2,
@@ -595852,6 +595998,159 @@ function checkConcurrentJobLimit(auth) {
   }
   return null;
 }
+function adoptHandoffRuns() {
+  if (process.env["OA_DISABLE_RUN_HANDOFF"] === "1") return;
+  const fs7 = require3("node:fs");
+  const path8 = require3("node:path");
+  const home = require3("node:os").homedir();
+  const handoffPath2 = path8.join(home, ".open-agents", "runs-handoff.json");
+  if (!fs7.existsSync(handoffPath2)) return;
+  let handoff = {};
+  try {
+    const raw = fs7.readFileSync(handoffPath2, "utf-8");
+    handoff = JSON.parse(raw);
+  } catch (e2) {
+    process.stderr.write(`  WARN: handoff file unreadable (${e2.message}) — discarding.
+`);
+    try {
+      fs7.unlinkSync(handoffPath2);
+    } catch {
+    }
+    return;
+  }
+  try {
+    fs7.unlinkSync(handoffPath2);
+  } catch {
+  }
+  const runs = handoff.runs ?? [];
+  if (runs.length === 0) return;
+  const adopted = [];
+  const orphaned = [];
+  for (const r2 of runs) {
+    if (!r2.pid || r2.pid <= 0) continue;
+    let alive = false;
+    try {
+      process.kill(r2.pid, 0);
+      alive = true;
+    } catch {
+      alive = false;
+    }
+    const jobsDir3 = path8.join(home, ".open-agents", "jobs");
+    const jobFile = path8.join(jobsDir3, `${r2.jobId}.json`);
+    let job = null;
+    try {
+      if (fs7.existsSync(jobFile)) job = JSON.parse(fs7.readFileSync(jobFile, "utf-8"));
+    } catch {
+    }
+    if (!alive) {
+      orphaned.push(r2.jobId);
+      if (job) {
+        let finalJson = "";
+        try {
+          if (r2.outputFile && fs7.existsSync(r2.outputFile)) {
+            const raw = fs7.readFileSync(r2.outputFile, "utf-8");
+            const lines = raw.trim().split("\n");
+            for (let i2 = lines.length - 1; i2 >= 0; i2--) {
+              if (lines[i2].trimEnd() === "{" || lines[i2].startsWith("{") && !lines[i2].startsWith('{"type":"tool_call"')) {
+                finalJson = lines.slice(i2).join("\n");
+                break;
+              }
+            }
+          }
+        } catch {
+        }
+        try {
+          const parsed = finalJson ? JSON.parse(finalJson) : null;
+          if (parsed && parsed.status) job.status = parsed.status;
+          else job.status = "failed";
+          job.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+          if (parsed?.summary) job.summary = parsed.summary;
+          if (parsed?.error) job.error = parsed.error;
+          job.adoptedAs = "orphaned";
+        } catch {
+          job.status = "failed";
+          job.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+          job.adoptedAs = "orphaned";
+        }
+        try {
+          fs7.writeFileSync(jobFile, JSON.stringify(job, null, 2), "utf-8");
+        } catch {
+        }
+      }
+      continue;
+    }
+    adopted.push(r2.jobId);
+    const adoptedShim = {
+      pid: r2.pid,
+      // Stub stdio (we never read from it again — the child writes directly
+      // to the on-disk output file which /v1/runs/{id}/output already reads).
+      stdout: { on: () => {
+      } },
+      stderr: { on: () => {
+      } },
+      __adopted: true
+    };
+    runningProcesses.set(r2.jobId, adoptedShim);
+    if (job) {
+      job.adoptedAs = "live";
+      job.adoptedAt = (/* @__PURE__ */ new Date()).toISOString();
+      try {
+        fs7.writeFileSync(jobFile, JSON.stringify(job, null, 2), "utf-8");
+      } catch {
+      }
+    }
+    const pollHandle = setInterval(() => {
+      let stillAlive = false;
+      try {
+        process.kill(r2.pid, 0);
+        stillAlive = true;
+      } catch {
+        stillAlive = false;
+      }
+      if (stillAlive) return;
+      clearInterval(pollHandle);
+      runningProcesses.delete(r2.jobId);
+      try {
+        const jf = jobFile;
+        if (!fs7.existsSync(jf)) return;
+        const j = JSON.parse(fs7.readFileSync(jf, "utf-8"));
+        if (j.status !== "running") return;
+        let finalJson = "";
+        try {
+          if (r2.outputFile && fs7.existsSync(r2.outputFile)) {
+            const raw = fs7.readFileSync(r2.outputFile, "utf-8");
+            const lines = raw.trim().split("\n");
+            for (let i2 = lines.length - 1; i2 >= 0; i2--) {
+              if (lines[i2].trimEnd() === "{" || lines[i2].startsWith("{") && !lines[i2].startsWith('{"type":"tool_call"')) {
+                finalJson = lines.slice(i2).join("\n");
+                break;
+              }
+            }
+          }
+        } catch {
+        }
+        try {
+          const parsed = finalJson ? JSON.parse(finalJson) : null;
+          if (parsed && parsed.status) j.status = parsed.status;
+          else j.status = "completed";
+          j.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+          if (parsed?.summary) j.summary = parsed.summary;
+          if (parsed?.error) j.error = parsed.error;
+          fs7.writeFileSync(jf, JSON.stringify(j, null, 2), "utf-8");
+        } catch {
+        }
+      } catch {
+      }
+    }, 3e3);
+    pollHandle.unref();
+  }
+  process.stderr.write(`  Adopted ${adopted.length} live run(s) from previous daemon, ${orphaned.length} orphaned.
+`);
+  if (adopted.length > 0) process.stderr.write(`    live: ${adopted.join(", ")}
+`);
+  if (orphaned.length > 0) process.stderr.write(`    orphaned: ${orphaned.join(", ")}
+`);
+}
 function incrementActiveJobs(user) {
   if (!user) return;
   getKeyUsage(user).activeJobs++;
@@ -597730,6 +598029,43 @@ async function handleV1Run(req2, res) {
     });
   } catch {
   }
+  let _rca1DeadlineFired = false;
+  const _rca1KillSwitch = process.env["OA_DISABLE_DAEMON_TIMEOUT_KILL"] === "1";
+  const _rca1EffectiveTimeoutS = timeout2 && timeout2 > 0 ? timeout2 : activeProfile?.limits?.timeout_s && activeProfile.limits.timeout_s > 0 ? activeProfile.limits.timeout_s : 1800;
+  const _rca1Deadline = _rca1KillSwitch ? null : setTimeout(() => {
+    if (job.status !== "running") return;
+    _rca1DeadlineFired = true;
+    job.status = "timeout";
+    job.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    atomicJobWrite(dir, id, job);
+    try {
+      if (child.pid) process.kill(-child.pid, "SIGTERM");
+    } catch {
+    }
+    try {
+      if (child.pid) process.kill(child.pid, "SIGTERM");
+    } catch {
+    }
+    setTimeout(() => {
+      try {
+        if (child.pid) process.kill(-child.pid, "SIGKILL");
+      } catch {
+      }
+      try {
+        if (child.pid) process.kill(child.pid, "SIGKILL");
+      } catch {
+      }
+    }, 3e4).unref();
+    try {
+      publishEvent(
+        "run.timeout",
+        { run_id: id, deadline_s: _rca1EffectiveTimeoutS },
+        { subject: authUser, aimsControl: "A.6.2.6" }
+      );
+    } catch {
+    }
+  }, (_rca1EffectiveTimeoutS + 60) * 1e3);
+  if (_rca1Deadline) _rca1Deadline.unref();
   if (streamMode) {
     res.writeHead(200, {
       "Content-Type": "text/event-stream",
@@ -597752,7 +598088,9 @@ async function handleV1Run(req2, res) {
 `);
     });
     onChildExit(child, (code8) => {
-      job.status = code8 === 0 ? "completed" : "failed";
+      if (_rca1Deadline) clearTimeout(_rca1Deadline);
+      if (_rca1DeadlineFired) {
+      } else job.status = code8 === 0 ? "completed" : "failed";
       job.completedAt = (/* @__PURE__ */ new Date()).toISOString();
       atomicJobWrite(dir, id, job);
       runningProcesses.delete(id);
@@ -597800,6 +598138,7 @@ async function handleV1Run(req2, res) {
       }
     });
     onChildExit(child, (code8) => {
+      if (_rca1Deadline) clearTimeout(_rca1Deadline);
       try {
         const lines = output.trim().split("\n");
         let finalJson = "";
@@ -597810,14 +598149,18 @@ async function handleV1Run(req2, res) {
           }
         }
         const result = finalJson ? JSON.parse(finalJson) : { status: code8 === 0 ? "completed" : "failed" };
-        job.status = result["status"] === "completed" ? "completed" : code8 === 0 ? "completed" : "failed";
+        if (!_rca1DeadlineFired) {
+          job.status = result["status"] === "completed" ? "completed" : code8 === 0 ? "completed" : "failed";
+        }
         job.completedAt = (/* @__PURE__ */ new Date()).toISOString();
         job.summary = result["summary"];
         job.output = result["assistant_text"] || result["text"] || result["summary"];
         job.durationMs = result["durationMs"];
         job.error = result["error"];
       } catch {
-        job.status = code8 === 0 ? "completed" : "failed";
+        if (!_rca1DeadlineFired) {
+          job.status = code8 === 0 ? "completed" : "failed";
+        }
         job.completedAt = (/* @__PURE__ */ new Date()).toISOString();
       }
       atomicJobWrite(dir, id, job);
@@ -601424,6 +601767,12 @@ function startApiServer(options2 = {}) {
 `);
     log22(`  Primary: ${config.backendUrl} (${config.backendType || "ollama"})
 `);
+    try {
+      adoptHandoffRuns();
+    } catch (e2) {
+      log22(`  WARN: handoff adoption crashed: ${e2.message}
+`);
+    }
     const _retCheck = process.env["OA_RUN_RETENTION_H"];
     const _retOff = _retCheck === "0";
     if (!_retOff) {
@@ -601470,8 +601819,96 @@ function startApiServer(options2 = {}) {
     }).catch(() => {
     });
   });
-  const shutdown = () => {
-    log22("\n  Shutting down API server...\n");
+  const shutdown = (signal) => {
+    const hardKill = signal === "SIGINT" || process.env["OA_DAEMON_HARD_SHUTDOWN"] === "1";
+    log22(`
+  Shutting down API server (signal=${signal}, mode=${hardKill ? "hard-kill" : "graceful-handoff"}) ...
+`);
+    if (!hardKill && runningProcesses.size > 0) {
+      try {
+        const handoffPath2 = (() => {
+          try {
+            const home = require3("node:os").homedir();
+            return require3("node:path").join(home, ".open-agents", "runs-handoff.json");
+          } catch {
+            return "";
+          }
+        })();
+        if (handoffPath2) {
+          const handoff = [];
+          for (const [id, child] of runningProcesses) {
+            const pid = child.pid;
+            if (!pid || pid <= 0) continue;
+            let outputFile = null;
+            let startedAt2 = null;
+            let user = null;
+            let scope = null;
+            let cwd5 = null;
+            try {
+              const fs7 = require3("node:fs");
+              const path8 = require3("node:path");
+              const home = require3("node:os").homedir();
+              const jobsDir3 = path8.join(home, ".open-agents", "jobs");
+              const jobFile = path8.join(jobsDir3, `${id}.json`);
+              if (fs7.existsSync(jobFile)) {
+                const j = JSON.parse(fs7.readFileSync(jobFile, "utf-8"));
+                outputFile = j.outputFile ?? path8.join(jobsDir3, `${id}.output`);
+                startedAt2 = j.startedAt ?? null;
+                user = j.user ?? null;
+                scope = j.scope ?? null;
+                cwd5 = j.cwd ?? null;
+              }
+            } catch {
+            }
+            handoff.push({ jobId: id, pid, outputFile, startedAt: startedAt2, user, scope, cwd: cwd5, handoffAt: (/* @__PURE__ */ new Date()).toISOString() });
+          }
+          if (handoff.length > 0) {
+            try {
+              const fs7 = require3("node:fs");
+              const path8 = require3("node:path");
+              const home = require3("node:os").homedir();
+              const dir = path8.join(home, ".open-agents");
+              fs7.mkdirSync(dir, { recursive: true });
+              fs7.writeFileSync(handoffPath2, JSON.stringify({
+                writtenAt: (/* @__PURE__ */ new Date()).toISOString(),
+                fromPid: process.pid,
+                runs: handoff
+              }, null, 2), "utf-8");
+              log22(`  Wrote handoff for ${handoff.length} in-flight run(s) → ${handoffPath2}
+`);
+              log22(`  Children will continue running; next daemon will adopt them.
+`);
+            } catch (e2) {
+              log22(`  WARN: failed to write handoff (${e2.message}) — falling back to hard-kill.
+`);
+              for (const [id, child] of runningProcesses) {
+                const pid = child.pid;
+                if (pid && pid > 0) {
+                  try {
+                    process.kill(-pid, "SIGTERM");
+                  } catch {
+                  }
+                  try {
+                    process.kill(pid, "SIGTERM");
+                  } catch {
+                  }
+                }
+                runningProcesses.delete(id);
+              }
+            }
+          }
+        }
+      } catch (e2) {
+        log22(`  WARN: handoff block crashed (${e2.message}) — proceeding to server.close()
+`);
+      }
+      server2.close(() => {
+        log22("  Server stopped (children preserved for adoption).\n");
+        process.exit(0);
+      });
+      setTimeout(() => process.exit(0), 8e3).unref();
+      return;
+    }
     for (const [id, child] of runningProcesses) {
       const pid = child.pid;
       if (pid && pid > 0) {
@@ -601507,8 +601944,8 @@ function startApiServer(options2 = {}) {
     });
     setTimeout(() => process.exit(1), 5e3).unref();
   };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
   return server2;
 }
 async function handleVisionEmbed(req2, res) {

package/dist/postinstall-daemon.cjs

@@ -145,6 +145,105 @@ function effectiveUser() {
   return process.env.USER || process.env.LOGNAME || os.userInfo().username;
 }
 
+// ─── Force-kill port holder (regardless of how it was launched) ────────────
+//
+// Critical for upgrade correctness: when an OLD daemon (started before this
+// install) is running, it holds port 11435 with stale in-memory code. The
+// systemctl/launchctl `restart` calls below CANNOT reach it because the
+// service manager doesn't own that process — it was started detached by
+// `oa serve --daemon` from a previous TUI session.
+//
+// Result without this kill: postinstall tries to start a NEW systemd
+// daemon, port-bind fails, old daemon stays alive serving stale code,
+// and the user's runs continue with broken patches.
+//
+// Strategy (matches packages/cli/src/daemon.ts:forceKillDaemon):
+//   1. SIGTERM via known PID files (~/.open-agents/daemon.pid + .oa/nexus/daemon.pid)
+//   2. lsof / fuser port probe — find ANY other holder
+//   3. 2s graceful grace, then SIGKILL stragglers
+//   4. Poll /health up to 5s for confirmation
+//
+// Skips when OA_DISABLE_FORCE_KILL_DAEMON=1 (escape valve).
+function forceKillPortHolder(port, cb) {
+  if (process.env.OA_DISABLE_FORCE_KILL_DAEMON === "1") {
+    log("OA_DISABLE_FORCE_KILL_DAEMON=1 — skipping port-holder kill (upgrades may not pick up new code).");
+    return cb(0);
+  }
+
+  var killed = 0;
+
+  // Step 1: SIGTERM via PID files (graceful)
+  var pidFiles = [
+    path.join(HOME, ".open-agents", "daemon.pid"),
+    path.join(process.cwd(), ".oa", "nexus", "daemon.pid"),
+  ];
+  pidFiles.forEach(function (pidFile) {
+    try {
+      if (!fs.existsSync(pidFile)) return;
+      var n = parseInt(fs.readFileSync(pidFile, "utf8").trim(), 10);
+      if (!n || n <= 0) return;
+      try { process.kill(n, "SIGTERM"); killed++; log("SIGTERM old daemon (pid " + n + ", from " + pidFile + ")"); } catch (e) { /* dead */ }
+    } catch (e) { /* */ }
+  });
+
+  // Step 2: port probe — lsof/fuser to find ANY pid holding the port
+  try {
+    var out = "";
+    try {
+      out = cp.execSync("lsof -ti :" + port + " 2>/dev/null || fuser " + port + "/tcp 2>/dev/null || true", {
+        encoding: "utf8", timeout: 3000,
+      }).trim();
+    } catch (e) { /* tools unavailable */ }
+    if (out) {
+      var pids = out.split(/[\s\n]+/).map(function (s) { return parseInt(s, 10); }).filter(function (n) {
+        return Number.isFinite(n) && n > 0 && n !== process.pid;
+      });
+      pids.forEach(function (otherPid) {
+        try { process.kill(otherPid, "SIGTERM"); killed++; log("SIGTERM port-holder (pid " + otherPid + ")"); } catch (e) { /* */ }
+      });
+    }
+  } catch (e) { /* */ }
+
+  if (killed === 0) {
+    // Nothing to kill — port was already free.
+    return cb(0);
+  }
+
+  // Step 3: 2s grace, then SIGKILL stragglers
+  setTimeout(function () {
+    try {
+      var out = cp.execSync("lsof -ti :" + port + " 2>/dev/null || fuser " + port + "/tcp 2>/dev/null || true", {
+        encoding: "utf8", timeout: 3000,
+      }).trim();
+      if (out) {
+        var pids = out.split(/[\s\n]+/).map(function (s) { return parseInt(s, 10); }).filter(function (n) {
+          return Number.isFinite(n) && n > 0 && n !== process.pid;
+        });
+        pids.forEach(function (otherPid) {
+          try { process.kill(otherPid, "SIGKILL"); log("SIGKILL straggler (pid " + otherPid + ")"); } catch (e) { /* */ }
+        });
+      }
+    } catch (e) { /* */ }
+
+    // Step 4: poll until port is free (up to 5s) — required so the next
+    // service-manager restart binds without conflict.
+    var pollStart = Date.now();
+    function pollFree() {
+      if (Date.now() - pollStart > 5000) return cb(killed);
+      tryHealth(port, function (alive) {
+        if (!alive) return cb(killed);
+        setTimeout(pollFree, 200);
+      });
+    }
+    pollFree();
+
+    // Clean up PID files now that the processes are dead
+    pidFiles.forEach(function (pidFile) {
+      try { if (fs.existsSync(pidFile)) fs.unlinkSync(pidFile); } catch (e) { /* */ }
+    });
+  }, 2000);
+}
+
 // ─── Nexus cleanup (preserve prior postinstall behaviour) ──────────────────
 
 function cleanNexus() {
@@ -572,7 +671,25 @@ function main() {
     return safeExit(0);
   }
 
+  // Force-kill any process holding the daemon port BEFORE we try to install
+  // a service. This handles the orphan-detached-daemon case (started by
+  // `oa serve --daemon` from a previous TUI session) — systemctl/launchctl
+  // restart can't reach it, so we have to clean up explicitly. Without this,
+  // the new service-managed daemon fails to bind port 11435 and the user
+  // ends up running stale in-memory code from the previous version.
+  forceKillPortHolder(PORT, function (killedCount) {
+    if (killedCount > 0) {
+      log("Killed " + killedCount + " stale daemon process(es) holding port " + PORT + ".");
+    }
+    runMainAfterKill();
+  });
+}
+
+function runMainAfterKill() {
   // Fast path: daemon already answering /health on the target port.
+  // After forceKillPortHolder, this should be false unless a service manager
+  // already auto-restarted (rare race). We still check so the rest of the
+  // flow stays idempotent.
   tryHealth(PORT, function (alreadyUp) {
     var user = effectiveUser();
     var nodeBin = resolveNodeBinary();
@@ -584,10 +701,10 @@ function main() {
     }
 
     if (alreadyUp) {
-      log("OA daemon already responding on port " + PORT + " — reinstalling service definition so it picks up the new build.");
-      // Fall through to (re)install service files; the serve command's
-      // daemon-mode /health pre-check will no-op if the existing daemon
-      // is still healthy.
+      log("OA daemon answering /health on port " + PORT + " — re-checking version drift before service (re)install.");
+      // Note: we already force-killed any stale process — anything answering
+      // now is a fresh service-managed daemon. Service (re)install below is
+      // idempotent and ensures the unit file matches the current bundle.
     }
 
     log("Installing OA API daemon service for port " + PORT + " ...");

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.514",
+  "version": "0.187.516",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "open-agents-ai",
-      "version": "0.187.514",
+      "version": "0.187.516",
       "hasInstallScript": true,
       "license": "CC-BY-NC-4.0",
       "dependencies": {
@@ -1570,20 +1570,29 @@
         "node": ">=8.0.0"
       }
     },
+    "node_modules/@peculiar/utils": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/@peculiar/utils/-/utils-2.0.2.tgz",
+      "integrity": "sha512-lHhrK/1QAXGn0GUYkme7t4zo0mQ5QIp+/8YED6pzu8AQFdjA9bAXeNURAHk4sw7n9i89MMNQVom0LkuuLUZMog==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.8.1"
+      }
+    },
     "node_modules/@peculiar/webcrypto": {
-      "version": "1.5.0",
-      "resolved": "https://registry.npmjs.org/@peculiar/webcrypto/-/webcrypto-1.5.0.tgz",
-      "integrity": "sha512-BRs5XUAwiyCDQMsVA9IDvDa7UBR9gAvPHgugOeGng3YN6vJ9JYonyDc0lNczErgtCWtucjR5N7VtaonboD/ezg==",
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/webcrypto/-/webcrypto-1.7.0.tgz",
+      "integrity": "sha512-04vwLd8VKfvsq3CsW5Xix6Xs9wAMK/xci/TO2T/VFLRGlYa06RGiUS9eClwnAx3z5XIjf0EdmHlmGcNzlBJLmA==",
       "license": "MIT",
       "dependencies": {
-        "@peculiar/asn1-schema": "^2.3.8",
+        "@peculiar/asn1-schema": "^2.6.0",
         "@peculiar/json-schema": "^1.1.12",
-        "pvtsutils": "^1.3.5",
-        "tslib": "^2.6.2",
-        "webcrypto-core": "^1.8.0"
+        "@peculiar/utils": "^2.0.1",
+        "tslib": "^2.8.1",
+        "webcrypto-core": "^1.9.0"
       },
       "engines": {
-        "node": ">=10.12.0"
+        "node": ">=14.18.0"
       }
     },
     "node_modules/@peculiar/x509": {
@@ -2072,9 +2081,9 @@
       }
     },
     "node_modules/b4a": {
-      "version": "1.8.0",
-      "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.8.0.tgz",
-      "integrity": "sha512-qRuSmNSkGQaHwNbM7J78Wwy+ghLEYF1zNrSeMxj4Kgw6y33O3mXcQ6Ie9fRvfU/YnxWkOchPXbaLb73TkIsfdg==",
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.8.1.tgz",
+      "integrity": "sha512-aiqre1Nr0B/6DgE2N5vwTc+2/oQZ4Wh1t4NznYY4E00y8LCt6NqdRv81so00oo27D8MVKTpUa/MwUUtBLXCoDw==",
       "license": "Apache-2.0",
       "optional": true,
       "peerDependencies": {
@@ -3629,9 +3638,9 @@
       }
     },
     "node_modules/hono": {
-      "version": "4.12.15",
-      "resolved": "https://registry.npmjs.org/hono/-/hono-4.12.15.tgz",
-      "integrity": "sha512-qM0jDhFEaCBb4TxoW7f53Qrpv9RBiayUHo0S52JudprkhvpjIrGoU1mnnr29Fvd1U335ZFPZQY1wlkqgfGXyLg==",
+      "version": "4.12.16",
+      "resolved": "https://registry.npmjs.org/hono/-/hono-4.12.16.tgz",
+      "integrity": "sha512-jN0ZewiNAWSe5khM3EyCmBb250+b40wWbwNILNfEvq84VREWwOIkuUsFONk/3i3nqkz7Oe1PcpM2mwQEK2L9Kg==",
       "license": "MIT",
       "engines": {
         "node": ">=16.9.0"
@@ -4780,9 +4789,9 @@
       "license": "Apache-2.0 OR MIT"
     },
     "node_modules/nanoid": {
-      "version": "5.1.9",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-5.1.9.tgz",
-      "integrity": "sha512-ZUvP7KeBLe3OZ1ypw6dI/TzYJuvHP77IM4Ry73waSQTLn8/g8rpdjfyVAh7t1/+FjBtG4lCP42MEbDxOsRpBMw==",
+      "version": "5.1.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-5.1.11.tgz",
+      "integrity": "sha512-v+KEsUv2ps74PaSKv0gHTxTCgMXOIfBEbaqa6w6ISIGC7ZsvHN4N9oJ8d4cmf0n5oTzQz2SLmThbQWhjd/8eKg==",
       "funding": [
         {
           "type": "github",
@@ -6065,9 +6074,9 @@
       }
     },
     "node_modules/sharp/node_modules/tar-stream": {
-      "version": "3.1.8",
-      "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-3.1.8.tgz",
-      "integrity": "sha512-U6QpVRyCGHva435KoNWy9PRoi2IFYCgtEhq9nmrPPpbRacPs9IH4aJ3gbrFC8dPcXvdSZ4XXfXT5Fshbp2MtlQ==",
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-3.2.0.tgz",
+      "integrity": "sha512-ojzvCvVaNp6aOTFmG7jaRD0meowIAuPc3cMMhSgKiVWws1GyHbGd/xvnyuRKcKlMpt3qvxx6r0hreCNITP9hIg==",
       "license": "MIT",
       "optional": true,
       "dependencies": {
@@ -6818,16 +6827,16 @@
       }
     },
     "node_modules/webcrypto-core": {
-      "version": "1.8.1",
-      "resolved": "https://registry.npmjs.org/webcrypto-core/-/webcrypto-core-1.8.1.tgz",
-      "integrity": "sha512-P+x1MvlNCXlKbLSOY4cYrdreqPG5hbzkmawbcXLKN/mf6DZW0SdNNkZ+sjwsqVkI4A4Ko2sPZmkZtCKY58w83A==",
+      "version": "1.9.0",
+      "resolved": "https://registry.npmjs.org/webcrypto-core/-/webcrypto-core-1.9.0.tgz",
+      "integrity": "sha512-ULMJZdRaACcQym3tuBEVcFHRfIbO2sbgBd2eIzo+KYk5eRk9wNxB8td9mX3mmAytLrtE4MRfYSwE1irSw1iGAg==",
       "license": "MIT",
       "dependencies": {
-        "@peculiar/asn1-schema": "^2.3.13",
+        "@peculiar/asn1-schema": "^2.6.0",
         "@peculiar/json-schema": "^1.1.12",
-        "asn1js": "^3.0.5",
-        "pvtsutils": "^1.3.5",
-        "tslib": "^2.7.0"
+        "@peculiar/utils": "^2.0.1",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
       }
     },
     "node_modules/webidl-conversions": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.514",
+  "version": "0.187.516",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",