pi-durable-subagents 1.0.10 → 1.0.11

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 1.0.11
+
+- A gate whose processes outlive their fence is reported once: when the gate
+  and the background sweep both recorded the failure at the same moment, a
+  workflow could show the same "processes may still run" attention item twice
+  (and the failure, the gate's unknown outcome and the resolution likewise).
+
 ## 1.0.10
 
 - Provider failover for a used-up usage window. An error such as `503 No

package/dist/orchestrator/executor/effects/gate.js

@@ -5,15 +5,17 @@ import { join } from "node:path";
 import { publishFile } from "../../../kernel/mailbox.js";
 import { callDir } from "../../../paths.js";
 import { validate } from "../../../agent/child/schema.js";
-import { recordFenceFailure, resolveFenceAttention } from "../sweep.js";
+import { fenceAttentionResolved, recordFenceFailure, recordOnce } from "../sweep.js";
 const tracked = (journal, id) => journal.entries().filter(e => e.type === "gate-tracked" && e.id === id).map(e => e.process);
 // Calls parked on an unfenced gate, woken when the sweep records the gate's outcome.
 const parked = new Map();
 /** P30, F1: A gate proven retired after a failed fence gets its unknown outcome once and its attention resolved. */
 export async function gateRetired(journal, id) {
-    if (!journal.entries().some(e => e.type === "gate" && e.id === id))
-        await journal.append("gate", { id, unknown: true });
-    await resolveFenceAttention(journal, id);
+    await recordOnce(journal, async () => {
+        if (!journal.entries().some(e => e.type === "gate" && e.id === id))
+            await journal.append("gate", { id, unknown: true });
+        await fenceAttentionResolved(journal, id);
+    });
     for (const wake of parked.get(id) ?? [])
         wake();
 }
@@ -52,8 +54,9 @@ async function fenceGate(journal, intent, containment) {
             console.error(`durable-subagents: fence of ${id} failed: ${String(error)}`);
         if (/Fence timeout/.test(String(error)))
             await recordFenceFailure(journal, id, String(intent.call), error);
-        else if (!journal.entries().some(e => e.type === "fence-failed" && e.exec === id))
-            await journal.append("fence-failed", { exec: id, error: String(error) });
+        else
+            await recordOnce(journal, async () => { if (!journal.entries().some(e => e.type === "fence-failed" && e.exec === id))
+                await journal.append("fence-failed", { exec: id, error: String(error) }); });
         return false;
     }
 }

package/dist/orchestrator/executor/sweep.js

@@ -21,8 +21,23 @@ export async function skipLostCandidate(journal, orch, exec) {
     if (tail.length === 3 && tail.every(e => e.type === "candidate-loss" && e.model === name))
         await orch.append("skip", { pool: selected.pool, model: name, until: Date.now() + 600000 });
 }
+// The gate path records outside the executor's serial section and the sweep inside it: each check-then-append of a
+// fence record runs in this per-journal section, so two recorders that both find no record still write it once (A5).
+const sections = new WeakMap();
+/** A5: Run a check-then-append of fence records alone on its journal. Not reentrant: never nest two. */
+export function recordOnce(journal, operation) {
+    const result = (sections.get(journal) ?? Promise.resolve()).then(operation);
+    const tail = result.catch(() => { });
+    sections.set(journal, tail);
+    void tail.then(() => { if (sections.get(journal) === tail)
+        sections.delete(journal); });
+    return result;
+}
 /** F1: Record a fence timeout of an execution or gate identity once, with one unknown attention item for the origin. */
-export async function recordFenceFailure(journal, id, call, error) {
+export function recordFenceFailure(journal, id, call, error) {
+    return recordOnce(journal, () => fenceFailure(journal, id, call, error));
+}
+async function fenceFailure(journal, id, call, error) {
     if (!journal.entries().some(e => e.type === "fence-failed" && e.exec === id))
         await journal.append("fence-failed", { exec: id, error: String(error) });
     const item = `fence:${id}`;
@@ -34,7 +49,11 @@ export async function recordFenceFailure(journal, id, call, error) {
     await journal.append(JT.attention, { item: { id: item, rev: 1, kind: "unknown", text, wid: call.slice(0, call.lastIndexOf("@", call.indexOf("/"))), call } });
 }
 /** F1: Resolve the fence attention item of an identity that a later fence proved retired. */
-export async function resolveFenceAttention(journal, id) {
+export function resolveFenceAttention(journal, id) {
+    return recordOnce(journal, () => fenceAttentionResolved(journal, id));
+}
+/** The same, inside a `recordOnce` section. */
+export async function fenceAttentionResolved(journal, id) {
     const item = journal.entries().find(e => e.type === JT.attention && e.item.id === `fence:${id}`)?.item;
     if (item && !journal.entries().some(e => e.type === JT.attentionResolved && e.id === `fence:${id}` && e.rev === item.rev))
         await journal.append(JT.attentionResolved, { id: `fence:${id}`, rev: item.rev, resolution: "fenced" });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-durable-subagents",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "Subagents for pi that never lose work and never do it twice. Crash-safe workflows, automatic recovery, and a live view just like the main agent.",
   "type": "module",
   "license": "MIT",