larkin 0.4.18 → 0.4.20

package/dist/runtime/pi-subagent-record-watchdog.bundle.js

@@ -0,0 +1,183 @@
+// @bun
+// src/runtime/pi-subagent-ledger.ts
+import fs from "fs";
+import path from "path";
+var PI_SUBAGENT_RECORD_DIRNAME = "pi-subagent-records";
+var PI_SUBAGENT_SESSION_OWNER_ENV = "LARKIN_PI_SESSION_OWNER";
+var TERMINAL_STATUSES = new Set([
+  "completed",
+  "failed",
+  "cancelled",
+  "timed_out",
+  "orphaned"
+]);
+function isTerminalPiSubagentRecord(record) {
+  if (!record || typeof record !== "object")
+    return false;
+  const status = record.status;
+  return typeof status === "string" && status.length > 0 && status !== "running" && status !== "queued";
+}
+function isConsumedTerminalPiSubagentRecord(record) {
+  if (!isTerminalPiSubagentRecord(record))
+    return false;
+  return record.resultConsumed === true;
+}
+function ledgerStatusFromPiSubagentRecord(record) {
+  const status = typeof record === "object" && record && "status" in record ? String(record.status || "").trim().toLowerCase() : "";
+  if (status === "error")
+    return "failed";
+  if (status === "aborted")
+    return "timed_out";
+  if (status === "stopped")
+    return "cancelled";
+  if (status === "steered")
+    return "timed_out";
+  return "completed";
+}
+function readPersistedPiSubagentTerminal(file) {
+  return readPiSubagentTerminalFile(file, false);
+}
+function writePersistedPiSubagentTerminal(file, input, options) {
+  writePiSubagentTerminalFile(file, input, options?.resultConsumed === true);
+}
+function dispatchedSubagentRecordDir(stateDir) {
+  return path.join(stateDir, PI_SUBAGENT_RECORD_DIRNAME);
+}
+function sweepAbsentPiSubagentRecordFiles(recordDir, getRecord, options) {
+  let names;
+  try {
+    names = fs.readdirSync(recordDir);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return [];
+    throw error;
+  }
+  const removed = [];
+  for (const name of names) {
+    if (!name || name.startsWith("."))
+      continue;
+    const file = path.join(recordDir, name);
+    try {
+      const stat = fs.lstatSync(file);
+      if (stat.isSymbolicLink() || !stat.isFile())
+        continue;
+    } catch {
+      continue;
+    }
+    const owner = typeof options?.owner === "string" && options.owner.trim() ? options.owner.trim() : undefined;
+    if (owner && readPiSubagentRecordOwner(file) !== owner)
+      continue;
+    const record = getRecord(name);
+    if (isTerminalPiSubagentRecord(record)) {
+      try {
+        writePersistedPiSubagentTerminal(file, {
+          taskId: name,
+          status: ledgerStatusFromPiSubagentRecord(record)
+        }, { resultConsumed: isConsumedTerminalPiSubagentRecord(record) });
+      } catch {}
+      continue;
+    }
+    if (record != null)
+      continue;
+    if (readPersistedPiSubagentTerminal(file))
+      continue;
+    try {
+      fs.unlinkSync(file);
+      removed.push(name);
+    } catch {}
+  }
+  return removed;
+}
+function readPiSubagentTerminalFile(file, requireConsumed) {
+  if (!file)
+    return null;
+  try {
+    const stat = fs.lstatSync(file);
+    if (stat.isSymbolicLink() || !stat.isFile())
+      return null;
+    const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    if (!parsed || typeof parsed !== "object")
+      return null;
+    if (requireConsumed && parsed.resultConsumed !== true && parsed.consumed !== true)
+      return null;
+    if (typeof parsed.taskId !== "string" || parsed.taskId.length === 0)
+      return null;
+    if (parsed.status !== "completed" && parsed.status !== "failed" && parsed.status !== "cancelled" && parsed.status !== "timed_out") {
+      return null;
+    }
+    return { taskId: parsed.taskId, status: parsed.status };
+  } catch {
+    return null;
+  }
+}
+function writePiSubagentTerminalFile(file, input, resultConsumed) {
+  const existing = (() => {
+    try {
+      return fs.lstatSync(file);
+    } catch {
+      return null;
+    }
+  })();
+  if (existing?.isSymbolicLink())
+    throw new Error("subagent record file must not be a symlink");
+  const owner = readPiSubagentRecordOwner(file);
+  const payload = `${JSON.stringify({
+    taskId: input.taskId,
+    ...resultConsumed ? { resultConsumed: true } : {},
+    status: input.status,
+    ...owner ? { owner } : {}
+  })}
+`;
+  if (existing?.isFile()) {
+    try {
+      if (fs.readFileSync(file, "utf8") === payload)
+        return;
+    } catch {}
+  }
+  fs.writeFileSync(file, payload, { mode: 384 });
+  fs.chmodSync(file, 384);
+}
+function readPiSubagentRecordOwner(file) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    return typeof parsed?.owner === "string" && parsed.owner.trim() ? parsed.owner.trim() : undefined;
+  } catch {
+    return;
+  }
+}
+
+// src/runtime/pi-subagent-record-watchdog.ts
+var PI_SUBAGENTS_MANAGER = Symbol.for("pi-subagents:manager");
+var DEFAULT_SWEEP_INTERVAL_MS = 15000;
+function piSubagentRecordWatchdog(pi) {
+  const stateDir = process.env.LARKIN_STATE_DIR;
+  const owner = process.env[PI_SUBAGENT_SESSION_OWNER_ENV];
+  if (!stateDir || !owner)
+    return;
+  const recordDir = dispatchedSubagentRecordDir(stateDir);
+  const intervalMs = sweepIntervalMs();
+  const tick = () => {
+    try {
+      const manager = globalThis[PI_SUBAGENTS_MANAGER];
+      if (typeof manager?.getRecord !== "function")
+        return;
+      sweepAbsentPiSubagentRecordFiles(recordDir, (taskId) => manager.getRecord(taskId), { owner });
+    } catch {}
+  };
+  const timer = setInterval(tick, intervalMs);
+  timer.unref?.();
+  const stop = () => {
+    clearInterval(timer);
+    tick();
+  };
+  pi.on("session_shutdown", stop);
+}
+function sweepIntervalMs() {
+  const raw = Number.parseInt(process.env.LARKIN_PI_SUBAGENT_RECORD_SWEEP_MS || "", 10);
+  if (Number.isInteger(raw) && raw > 0)
+    return raw;
+  return DEFAULT_SWEEP_INTERVAL_MS;
+}
+export {
+  piSubagentRecordWatchdog as default
+};

package/dist/runtime/pi-subagent-record-watchdog.mjs

@@ -0,0 +1,46 @@
+import { dispatchedSubagentRecordDir, PI_SUBAGENT_SESSION_OWNER_ENV, sweepAbsentPiSubagentRecordFiles, } from "./pi-subagent-ledger.mjs";
+const PI_SUBAGENTS_MANAGER = Symbol.for("pi-subagents:manager");
+const DEFAULT_SWEEP_INTERVAL_MS = 15_000;
+/**
+ * Pi-process watchdog: delete Larkin record sidecars once AgentManager no longer
+ * has the in-memory task. Persist any terminal AgentRecord — including an
+ * unconsumed completion Pi may evict after ten minutes — before treating a
+ * missing getRecord as a genuine orphan. A get_subagent_result consume also
+ * suppresses the canonical notification; bridge that consumed marker before
+ * cleanup can delete the sidecar. Leftover transcripts are intentionally
+ * ignored. Sidecars are owner-tagged so a staged Pi sharing LARKIN_STATE_DIR
+ * cannot sweep another session's records. This extension registers
+ * session_shutdown first so the final sweep still sees getRecord.
+ */
+export default function piSubagentRecordWatchdog(pi) {
+    const stateDir = process.env.LARKIN_STATE_DIR;
+    const owner = process.env[PI_SUBAGENT_SESSION_OWNER_ENV];
+    if (!stateDir || !owner)
+        return;
+    const recordDir = dispatchedSubagentRecordDir(stateDir);
+    const intervalMs = sweepIntervalMs();
+    const tick = () => {
+        try {
+            const manager = globalThis[PI_SUBAGENTS_MANAGER];
+            if (typeof manager?.getRecord !== "function")
+                return;
+            sweepAbsentPiSubagentRecordFiles(recordDir, (taskId) => manager.getRecord(taskId), { owner });
+        }
+        catch {
+            // Best-effort: a transient EACCES/EMFILE must not crash the Pi timer.
+        }
+    };
+    const timer = setInterval(tick, intervalMs);
+    timer.unref?.();
+    const stop = () => {
+        clearInterval(timer);
+        tick();
+    };
+    pi.on("session_shutdown", stop);
+}
+function sweepIntervalMs() {
+    const raw = Number.parseInt(process.env.LARKIN_PI_SUBAGENT_RECORD_SWEEP_MS || "", 10);
+    if (Number.isInteger(raw) && raw > 0)
+        return raw;
+    return DEFAULT_SWEEP_INTERVAL_MS;
+}

package/dist/runtime/pi-subagents-notification.mjs

@@ -20,6 +20,20 @@ const TERMINAL_STATUS_TOKENS = new Set([
     "turn-limit",
     "turn_limit",
 ]);
+export function ledgerStatusFromPiNotificationStatus(status) {
+    const normalized = status.trim().toLowerCase();
+    if (normalized.startsWith("error") || normalized === "error")
+        return "failed";
+    if (normalized.startsWith("stopped"))
+        return "cancelled";
+    if (normalized.startsWith("aborted")
+        || normalized.includes("turn limit")
+        || normalized.includes("turn-limit")
+        || normalized.includes("turn_limit")
+        || normalized.includes("steered"))
+        return "timed_out";
+    return "completed";
+}
 export function isCanonicalTerminalPiSubagentStatus(status) {
     const normalized = status.trim().toLowerCase();
     if (!normalized)