@noopolis/daimon 0.2.0 → 0.2.2

package/dist/runtime/agentSkillsDirectory.js

@@ -0,0 +1,101 @@
+import { constants } from "node:fs";
+import { lstat, open, readdir } from "node:fs/promises";
+import path from "node:path";
+import { AGENT_SKILLS_BOUNDS, parseAgentSkills } from "./grokWorkerSkills.js";
+const invalid = (detail) => new TypeError(`invalid agent skills directory: ${detail}`);
+const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+/**
+ * Reads a skills tree — `<root>/<name>/SKILL.md` plus any supporting files —
+ * into the engine-neutral {@link AgentSkill} input, or `undefined` when `root`
+ * does not exist.
+ *
+ * It is the same reader for both ends of the Grok skills path: provisioning
+ * reads the compiled workspace's `.agents/skills` (the tree Codex reads in
+ * place), and the broker re-reads the rendered `$GROK_HOME/skills` before every
+ * turn under a root-owned, read-only policy. Symlinks, special files, hard
+ * links (read-only policy), non-UTF-8 content and anything past the
+ * {@link AGENT_SKILLS_BOUNDS} are refused rather than skipped, because a
+ * skipped entry would make the attested digest describe less than Grok loads.
+ */
+export async function readAgentSkillsDirectory(root, policy = {}) {
+    let top;
+    try {
+        top = await lstat(root);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw invalid("unreadable root");
+    }
+    assertEntry(top, "directory", policy, ".");
+    const names = await boundedEntries(root, AGENT_SKILLS_BOUNDS.skills);
+    const skills = [];
+    let budget = AGENT_SKILLS_BOUNDS.totalBytes;
+    for (const name of names) {
+        const directory = path.join(root, name);
+        assertEntry(await lstat(directory), "directory", policy, name);
+        const files = [];
+        const walk = async (relative, depth) => {
+            for (const child of await boundedEntries(path.join(directory, relative), AGENT_SKILLS_BOUNDS.filesPerSkill)) {
+                const childRelative = relative === "" ? child : `${relative}/${child}`;
+                const absolute = path.join(directory, childRelative);
+                const where = `${name}/${childRelative}`;
+                const entry = await lstat(absolute);
+                if (entry.isDirectory()) {
+                    if (depth + 1 >= AGENT_SKILLS_BOUNDS.depth)
+                        throw invalid(`too deep at ${JSON.stringify(where)}`);
+                    assertEntry(entry, "directory", policy, where);
+                    await walk(childRelative, depth + 1);
+                    continue;
+                }
+                assertEntry(entry, "file", policy, where);
+                if (files.length >= AGENT_SKILLS_BOUNDS.filesPerSkill)
+                    throw invalid(`too many files in ${JSON.stringify(name)}`);
+                const content = await readPinnedFile(absolute, where, entry, Math.min(AGENT_SKILLS_BOUNDS.fileBytes, budget));
+                budget -= Buffer.byteLength(content, "utf8");
+                files.push({ path: childRelative, content });
+            }
+        };
+        await walk("", 0);
+        skills.push({ name, files });
+    }
+    return parseAgentSkills(skills);
+}
+/** `where` is the entry's path relative to the skills root, named in every refusal. */
+function assertEntry(entry, kind, policy, where) {
+    if (entry.isSymbolicLink() || (kind === "directory" ? !entry.isDirectory() : !entry.isFile()))
+        throw invalid(`expected a plain ${kind} at ${JSON.stringify(where)}`);
+    if (policy.ownerUid !== undefined && entry.uid !== policy.ownerUid)
+        throw invalid(`unexpected owner of ${JSON.stringify(where)}`);
+    if (policy.readOnly === true && ((Number(entry.mode) & 0o7222) !== 0 || (kind === "file" && entry.nlink !== 1)))
+        throw invalid(`writable or linked entry ${JSON.stringify(where)}`);
+}
+async function boundedEntries(directory, limit) {
+    const entries = await readdir(directory);
+    if (entries.length > limit)
+        throw invalid(`too many entries in ${JSON.stringify(path.basename(directory))}`);
+    return entries.sort();
+}
+/** Opens without following links and requires the inode `lstat` saw, so a swap between the two cannot change the bytes read. */
+async function readPinnedFile(file, where, seen, limit) {
+    if (seen.size > limit)
+        throw invalid(`file too large ${JSON.stringify(where)}`);
+    const handle = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    try {
+        const opened = await handle.stat();
+        if (!opened.isFile() || opened.dev !== seen.dev || opened.ino !== seen.ino || opened.uid !== seen.uid || opened.mode !== seen.mode || opened.nlink !== seen.nlink || opened.size > limit)
+            throw invalid(`file changed while read ${JSON.stringify(where)}`);
+        const bytes = await handle.readFile();
+        if (bytes.length > limit)
+            throw invalid(`file too large ${JSON.stringify(where)}`);
+        try {
+            return decoder.decode(bytes);
+        }
+        catch {
+            throw invalid(`file is not UTF-8 ${JSON.stringify(where)}`);
+        }
+    }
+    finally {
+        await handle.close().catch(() => undefined);
+    }
+}

package/dist/runtime/agySubscriptionBootstrap.js

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process";
+import { spawnRealTime as spawn } from "./taskClockProcess.js";
 import { cliChildEnvironment } from "../pi/cliEnvironment.js";
 import { startAgySubscriptionRealm } from "./agySubscriptionRealm.js";
 import { prepareEngineExecutable, verifyAgySubscriptionEnrollment } from "./engineReadiness.js";

package/dist/runtime/agySubscriptionRealm.js

@@ -1,5 +1,5 @@
 import { constants } from "node:fs";
-import { spawn } from "node:child_process";
+import { spawnRealTime as spawn } from "./taskClockProcess.js";
 import { chmod, lstat, mkdir, mkdtemp, open, realpath, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";

package/dist/runtime/attention.d.ts

@@ -1,4 +1,5 @@
 import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { StoredWakeAcceptanceRecord } from "./wakeAcceptanceRecord.js";
 import type { AttentionConfig } from "../contracts/attentionContract.js";
 export type { AttentionConfig } from "../contracts/attentionContract.js";
 export type AttentionMessage = Readonly<{
@@ -10,12 +11,16 @@ export type AttentionMessage = Readonly<{
 }>;
 export type AttentionTurn = Readonly<{
     executionId: string;
+    /** Projected once by the dispatcher; already in the agent's clock domain. */
     messages: readonly AttentionMessage[];
     budget(): Promise<unknown>;
     disposition(deliveryId: string, disposition: "complete" | "defer"): Promise<void>;
 }>;
 /** Owned by one control host; never shared across hosts or agent identities. */
 export type AttentionRegistry = Map<string, AttentionTurn>;
+/** Project real delivery instants, preserving queue age and relative offsets.
+ * Only the private durable provenance exempts a native task-calendar occurrence. */
+export declare function taskClockAttentionMessages(records: readonly Pick<StoredWakeAcceptanceRecord, "acceptance_id" | "delivery_id" | "event" | "native_schedule">[]): readonly AttentionMessage[];
 export declare function attentionTools(agentId: string, registry: AttentionRegistry): ToolDefinition[];
 export declare function parseAttention(value: unknown): AttentionConfig;
 //# sourceMappingURL=attention.d.ts.map

package/dist/runtime/attention.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attention.d.ts","sourceRoot":"","sources":["../../src/runtime/attention.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACzE,YAAY,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACzE,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AACzI,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACtC,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3B,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,GAAG,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnF,CAAC,CAAC;AACH,gFAAgF;AAChF,MAAM,MAAM,iBAAiB,GAAG,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAE3D,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,iBAAiB,GAAG,cAAc,EAAE,CAqB7F;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAS9D"}
+{"version":3,"file":"attention.d.ts","sourceRoot":"","sources":["../../src/runtime/attention.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEtE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAC;AAE5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACzE,YAAY,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACzE,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AACzI,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,6EAA6E;IAC7E,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACtC,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3B,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,GAAG,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnF,CAAC,CAAC;AACH,gFAAgF;AAChF,MAAM,MAAM,iBAAiB,GAAG,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAE3D;oFACoF;AACpF,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,SAAS,IAAI,CAAC,0BAA0B,EAAE,eAAe,GAAG,aAAa,GAAG,OAAO,GAAG,iBAAiB,CAAC,EAAE,GAAG,SAAS,gBAAgB,EAAE,CAK3L;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,iBAAiB,GAAG,cAAc,EAAE,CAyB7F;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAS9D"}

package/dist/runtime/attention.js

@@ -1,3 +1,12 @@
+import { readTaskClock, taskClockTimestamp } from "./taskClock.js";
+/** Project real delivery instants, preserving queue age and relative offsets.
+ * Only the private durable provenance exempts a native task-calendar occurrence. */
+export function taskClockAttentionMessages(records) {
+    const clock = readTaskClock();
+    return records.map((record) => ({ acceptance_id: record.acceptance_id, delivery_id: record.delivery_id, ...record.event,
+        occurred_at: record.native_schedule === true ? record.event.occurred_at : taskClockTimestamp(record.event.occurred_at, clock)
+    }));
+}
 export function attentionTools(agentId, registry) {
     const current = () => { const turn = registry.get(agentId); if (!turn)
         throw new Error("No active inbox turn"); return turn; };
@@ -6,7 +15,11 @@ export function attentionTools(agentId, registry) {
             parameters: { type: "object", additionalProperties: false, properties: {} },
             async execute() {
                 const turn = current();
-                const details = { version: "noopolis.daimon.inbox.v1", execution_id: turn.executionId, messages: turn.messages, budget: await turn.budget() };
+                const budget = await turn.budget();
+                const clock = readTaskClock();
+                const visibleBudget = clock !== undefined && budget !== null && typeof budget === "object" && "epoch" in budget && typeof budget.epoch === "string"
+                    ? { ...budget, epoch: budget.epoch.replace(/^(organization-[a-f0-9]{64}-)\d{4}-\d{2}-\d{2}$/u, `$1${new Date(clock.now()).toISOString().slice(0, 10)}`) } : budget;
+                const details = { version: "noopolis.daimon.inbox.v1", execution_id: turn.executionId, messages: turn.messages, budget: visibleBudget };
                 return { content: [{ type: "text", text: JSON.stringify(details) }], details };
             }
         }, {

package/dist/runtime/attentionDispatcher.d.ts

@@ -1,8 +1,9 @@
-import type { AttentionRegistry } from "./attention.js";
+import { type AttentionRegistry } from "./attention.js";
 import type { OrganizationRuntimeAgentConfig, OrganizationRuntimeHost } from "./organizationRuntime.js";
 import { WakeAcceptanceStore } from "./wakeAcceptanceStore.js";
-import type { StoredWakeAcceptanceRecord } from "./wakeAcceptanceRecord.js";
+import { type StoredWakeAcceptanceRecord } from "./wakeAcceptanceRecord.js";
 import { WakeFuse } from "./wakeFuse.js";
+import { type WakeMomentOptions } from "./wakeMomentRecorder.js";
 type Options = Readonly<{
     store: WakeAcceptanceStore;
     host: OrganizationRuntimeHost;
@@ -11,6 +12,7 @@ type Options = Readonly<{
     registry: AttentionRegistry;
     token: string | undefined;
     onIdle(agentId: string): void;
+    recordingOptionsForTest?: WakeMomentOptions;
 }>;
 /** Durable deliveries wait here; only a selected execution reserves a budget slot. */
 export declare class AttentionDispatcher {
@@ -23,6 +25,10 @@ export declare class AttentionDispatcher {
     private readonly active;
     private readonly errors;
     private stopping;
+    /** Reversible drain: no new execution starts; durable deliveries stay queued. */
+    private paused;
+    /** Agents whose inbox loop gave up its turn to a drain; resume owes each one a pass. */
+    private readonly pausedOut;
     private fatal;
     constructor(options: Options);
     notify(agentId: string, fresh?: boolean): void;
@@ -37,6 +43,12 @@ export declare class AttentionDispatcher {
     failure(agentId: string): string | undefined;
     stop(): Promise<void>;
     halt(): void;
+    /** Stops admitting executions; a running turn finishes and its records settle as usual. */
+    pause(): void;
+    /** Admits again and revisits every agent whose inbox moved while paused. */
+    resume(queued?: Iterable<string>): void;
+    /** True once no inbox loop is alive: nothing runs, and nothing can start until resume. */
+    quiescent(): boolean;
     private drain;
     private execute;
     private failClosed;

package/dist/runtime/attentionDispatcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attentionDispatcher.d.ts","sourceRoot":"","sources":["../../src/runtime/attentionDispatcher.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,8BAA8B,EAAE,uBAAuB,EAAiC,MAAM,0BAA0B,CAAC;AAEvI,OAAO,EAAE,mBAAmB,EAAwD,MAAM,0BAA0B,CAAC;AACrH,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAC;AAC5E,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAKzC,KAAK,OAAO,GAAG,QAAQ,CAAC;IAAE,KAAK,EAAE,mBAAmB,CAAC;IAAC,IAAI,EAAE,uBAAuB,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,SAAS,8BAA8B,EAAE,CAAC;IAAC,QAAQ,EAAE,iBAAiB,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAAC;AAEjP,sFAAsF;AACtF,qBAAa,mBAAmB;IAUlB,OAAO,CAAC,QAAQ,CAAC,OAAO;IATpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAoC;IACzD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;IACtD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6B;IACzD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;IACjD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuE;IAC9F,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IACpD,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,KAAK,CAAmC;gBACnB,OAAO,EAAE,OAAO;IAE7C,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,UAAQ,GAAG,IAAI;IAW5C,WAAW,IAAI,oBAAoB,GAAG,SAAS;IAC/C,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAC9B,gBAAgB;;sBAnB0C,MAAM;sBAAgB,MAAM,EAAE;;;IAoBxF,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IACtC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAM3B,IAAI,IAAI,IAAI;YAEE,KAAK;YA2BL,OAAO;IAqErB,OAAO,CAAC,UAAU;YASJ,SAAS;CAOxB;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,SAAS,0BAA0B,EAAE,EAAE,KAAK,EAAE,8BAA8B,EAAE,eAAe,EAAE,OAAO,GAAG,0BAA0B,EAAE,CAmBzK;AAcD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,EAAE,MAAM,EAAE,8BAA8B,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,QAAQ,SAAQ,GAAG,MAAM,CAsB5I"}
+{"version":3,"file":"attentionDispatcher.d.ts","sourceRoot":"","sources":["../../src/runtime/attentionDispatcher.ts"],"names":[],"mappings":"AACA,OAAO,EAA8B,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACpF,OAAO,KAAK,EAAE,8BAA8B,EAAE,uBAAuB,EAAiC,MAAM,0BAA0B,CAAC;AAEvI,OAAO,EAAE,mBAAmB,EAAwD,MAAM,0BAA0B,CAAC;AACrH,OAAO,EAA0B,KAAK,0BAA0B,EAAE,MAAM,2BAA2B,CAAC;AAEpG,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAIzC,OAAO,EAAoB,KAAK,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAGnF,KAAK,OAAO,GAAG,QAAQ,CAAC;IAAE,KAAK,EAAE,mBAAmB,CAAC;IAAC,IAAI,EAAE,uBAAuB,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,SAAS,8BAA8B,EAAE,CAAC;IAAC,QAAQ,EAAE,iBAAiB,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,uBAAuB,CAAC,EAAE,iBAAiB,CAAA;CAAE,CAAC,CAAC;AAE9R,sFAAsF;AACtF,qBAAa,mBAAmB;IAclB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAbpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAoC;IACzD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;IACtD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6B;IACzD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;IACjD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuE;IAC9F,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IACpD,OAAO,CAAC,QAAQ,CAAS;IACzB,iFAAiF;IACjF,OAAO,CAAC,MAAM,CAAS;IACvB,wFAAwF;IACxF,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqB;IAC/C,OAAO,CAAC,KAAK,CAAmC;gBACnB,OAAO,EAAE,OAAO;IAE7C,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,UAAQ,GAAG,IAAI;IAkB5C,WAAW,IAAI,oBAAoB,GAAG,SAAS;IAC/C,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAC9B,gBAAgB;;sBA9B0C,MAAM;sBAAgB,MAAM,EAAE;;;IA+BxF,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IACtC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAM3B,IAAI,IAAI,IAAI;IACZ,2FAA2F;IAC3F,KAAK,IAAI,IAAI;IACb,4EAA4E;IAC5E,MAAM,CAAC,MAAM,GAAE,QAAQ,CAAC,MAAM,CAAM,GAAG,IAAI;IAO3C,0FAA0F;IAC1F,SAAS,IAAI,OAAO;YAEN,KAAK;YA0CL,OAAO;IAmFrB,OAAO,CAAC,UAAU;YASJ,SAAS;CAOxB;AAkBD,wBAAgB,WAAW,CAAC,OAAO,EAAE,SAAS,0BAA0B,EAAE,EAAE,KAAK,EAAE,8BAA8B,EAAE,eAAe,EAAE,OAAO,GAAG,0BAA0B,EAAE,CAmBzK;AAcD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,EAAE,MAAM,EAAE,8BAA8B,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,QAAQ,SAAQ,GAAG,MAAM,CAsB5I"}

package/dist/runtime/attentionDispatcher.js

@@ -1,8 +1,13 @@
 import { randomUUID } from "node:crypto";
+import { taskClockAttentionMessages } from "./attention.js";
 import { engineFailureDetail } from "./organizationRuntimeHost.js";
 import { WakeExecutionClaimLostError } from "./wakeAcceptanceStore.js";
+import { sanitizeExecutionError } from "./wakeAcceptanceRecord.js";
+import { STALE_QUEUED_DELIVERY_MS } from "./wakeAcceptanceRetention.js";
 import { ORGANIZATION_RUNTIME_MAX_STRING_CODEPOINTS, ORGANIZATION_RUNTIME_MAX_WAKE_TEXT_BYTES } from "../contracts/organizationRuntimeContract.js";
 import { grokDaimonToolName } from "../contracts/grokWorkerContract.js";
+import { verifyHostRecordingStore, wakeFromDurableInbox } from "./organizationRuntimeAdmission.js";
+import { recordWakeMoment } from "./wakeMomentRecorder.js";
 /** Durable deliveries wait here; only a selected execution reserves a budget slot. */
 export class AttentionDispatcher {
     options;
@@ -14,6 +19,10 @@ export class AttentionDispatcher {
     active = new Map();
     errors = new Map();
     stopping = false;
+    /** Reversible drain: no new execution starts; durable deliveries stay queued. */
+    paused = false;
+    /** Agents whose inbox loop gave up its turn to a drain; resume owes each one a pass. */
+    pausedOut = new Set();
     fatal;
     constructor(options) {
         this.options = options;
@@ -21,11 +30,22 @@ export class AttentionDispatcher {
     notify(agentId, fresh = false) {
         if (fresh)
             this.generations.set(agentId, (this.generations.get(agentId) ?? 0) + 1);
-        if (this.stopping || this.work.has(agentId))
+        if (this.stopping)
+            return;
+        // Every pass a drain withholds is owed back on resume.
+        if (this.paused) {
+            this.pausedOut.add(agentId);
+            return;
+        }
+        if (this.work.has(agentId))
             return;
-        const task = this.drain(agentId).catch((error) => { this.observed.set(agentId, this.generations.get(agentId) ?? 0); this.errors.set(agentId, engineFailureDetail(error) ?? "inbox_storage_unavailable"); }).finally(() => {
+        // An owed pass is not new input: it starts from the generation already seen, so
+        // deferred deliveries stay deferred unless something really arrived meanwhile.
+        const baseline = this.pausedOut.delete(agentId) ? this.observed.get(agentId) ?? 0 : 0;
+        const task = this.drain(agentId, baseline).catch((error) => { this.observed.set(agentId, this.generations.get(agentId) ?? 0); this.errors.set(agentId, engineFailureDetail(error) ?? "inbox_storage_unavailable"); }).finally(() => {
             this.work.delete(agentId);
-            if (!this.stopping && (this.generations.get(agentId) ?? 0) > (this.observed.get(agentId) ?? 0))
+            // A resume that landed while this loop was still unwinding its paused exit found it busy; run the owed pass now.
+            if (!this.stopping && ((this.generations.get(agentId) ?? 0) > (this.observed.get(agentId) ?? 0) || this.pausedOut.has(agentId)))
                 this.notify(agentId);
             this.options.onIdle(agentId);
         });
@@ -44,12 +64,36 @@ export class AttentionDispatcher {
     }
     halt() { this.stopping = true; for (const finish of this.waiters)
         finish(); }
-    async drain(agentId) {
+    /** Stops admitting executions; a running turn finishes and its records settle as usual. */
+    pause() { this.paused = true; for (const finish of this.waiters)
+        finish(); }
+    /** Admits again and revisits every agent whose inbox moved while paused. */
+    resume(queued = []) {
+        this.paused = false;
+        // Agents with queued work get an owed pass too: a delivery parked before the
+        // drain (a budget pause, say) has no generation of its own to wake it.
+        for (const agentId of queued)
+            this.pausedOut.add(agentId);
+        for (const agent of this.options.agents)
+            if ((this.generations.get(agent.id) ?? 0) > (this.observed.get(agent.id) ?? 0) || this.pausedOut.has(agent.id))
+                this.notify(agent.id);
+    }
+    /** True once no inbox loop is alive: nothing runs, and nothing can start until resume. */
+    quiescent() { return this.work.size === 0; }
+    async drain(agentId, baseline = 0) {
         const agent = this.options.agents.find((value) => value.id === agentId);
-        let observedGeneration = 0;
+        let observedGeneration = baseline;
         while (!this.stopping) {
+            if (this.paused) {
+                this.pausedOut.add(agentId);
+                return;
+            }
             const generation = this.generations.get(agentId) ?? 0;
-            const records = (await this.options.store.recoverable(new Set(this.options.agents.map((value) => value.id)))).filter((record) => record.agent_id === agentId);
+            const stale = [];
+            const records = (await this.options.store.recoverable(new Set(this.options.agents.map((value) => value.id)), (record) => { if (record.agent_id === agentId)
+                stale.push(record); })).filter((record) => record.agent_id === agentId);
+            for (const record of stale)
+                await expireStaleDelivery(this.options.store, record);
             const selected = selectBatch(records, agent, generation > observedGeneration);
             observedGeneration = generation;
             this.observed.set(agentId, generation);
@@ -59,6 +103,10 @@ export class AttentionDispatcher {
             const budget = await this.options.fuse.snapshot(agentId, agent.attention);
             if (budget.state !== "available")
                 return;
+            if (this.paused) {
+                this.pausedOut.add(agentId);
+                return;
+            }
             const executionId = selected[0].execution_id ?? randomUUID();
             const acquired = await this.options.store.acquireClaim(selected[0].acceptance_id, this.owner, selected.map((record) => record.acceptance_id), executionId);
             if (acquired.state === "held") {
@@ -70,8 +118,22 @@ export class AttentionDispatcher {
             const claimed = selected.map((record) => ({ record, claim: acquired.claim, done: false }));
             for (const item of claimed)
                 item.record = await this.options.store.transitionClaimed(item.record.acceptance_id, item.claim, "running", undefined, undefined, agent.attention === undefined ? undefined : { execution_id: executionId, deferred: false });
-            const verdict = await this.options.fuse.admit(agentId, randomUUID(), agent.attention);
-            if (verdict.state !== "admitted" || this.stopping) {
+            // A member ended between selection and claim (another host's expiry or stop
+            // reached it first): never wake cognition on a batch that includes it.
+            if (claimed.some((item) => item.record.state !== "running")) {
+                for (const item of claimed.filter((value) => value.record.state === "running"))
+                    await this.options.store.transitionClaimed(item.record.acceptance_id, item.claim, "accepted");
+                await this.options.store.releaseClaim(claimed[0].claim);
+                continue;
+            }
+            // A drain that arrived after the claim releases it before any budget is spent.
+            // Admission is the drain's linearization point: a turn the fuse admitted before
+            // the loop saw the drain is a running turn, and keeps the host "draining".
+            const pausedBeforeAdmit = this.paused;
+            const verdict = pausedBeforeAdmit ? undefined : await this.options.fuse.admit(agentId, randomUUID(), agent.attention);
+            if (verdict?.state !== "admitted" || this.stopping) {
+                if (pausedBeforeAdmit)
+                    this.pausedOut.add(agentId);
                 for (const item of claimed)
                     await this.options.store.transitionClaimed(item.record.acceptance_id, item.claim, "accepted");
                 await this.options.store.releaseClaim(claimed[0].claim);
@@ -101,31 +163,34 @@ export class AttentionDispatcher {
             }).catch((error) => this.failClosed(agent.id, error));
         }, store.claimHeartbeatIntervalMs());
         this.active.set(agent.id, { execution_id: agent.attention === undefined ? claimed[0].record.delivery_id : executionId, delivery_ids: claimed.map((item) => item.record.delivery_id) });
-        const messages = claimed.map(({ record }) => ({ acceptance_id: record.acceptance_id, delivery_id: record.delivery_id, ...record.event }));
-        if (agent.attention !== undefined)
-            registry.set(agent.id, {
-                executionId, messages, budget: () => fuse.snapshot(agent.id, agent.attention),
-                disposition: (deliveryId, disposition) => serialize(async () => {
-                    const item = claimed.find((value) => value.record.delivery_id === deliveryId);
-                    if (!item)
-                        throw new Error("Delivery is outside this agent's selected inbox turn");
-                    if (item.done && item.record.state === "completed") {
-                        if (disposition !== "complete")
-                            throw new Error("A completed delivery cannot be deferred");
-                        return;
-                    }
-                    if (item.done && disposition === "defer")
-                        return;
-                    item.record = await store.transitionClaimed(item.record.acceptance_id, item.claim, disposition === "complete" ? "completed" : "accepted", undefined, disposition === "complete" ? "" : undefined, disposition === "defer" ? { deferred: true, clear_execution: true, execution_error: null } : { execution_id: executionId, deferred: false, execution_error: null });
-                    item.done = true;
-                })
-            });
         let result;
         try {
+            const messages = taskClockAttentionMessages(claimed.map(({ record }) => record));
+            if (agent.attention !== undefined)
+                registry.set(agent.id, {
+                    executionId, messages, budget: () => fuse.snapshot(agent.id, agent.attention),
+                    disposition: (deliveryId, disposition) => serialize(async () => {
+                        const item = claimed.find((value) => value.record.delivery_id === deliveryId);
+                        if (!item)
+                            throw new Error("Delivery is outside this agent's selected inbox turn");
+                        if (item.done && item.record.state === "completed") {
+                            if (disposition !== "complete")
+                                throw new Error("A completed delivery cannot be deferred");
+                            return;
+                        }
+                        if (item.done && disposition === "defer")
+                            return;
+                        item.record = await store.transitionClaimed(item.record.acceptance_id, item.claim, disposition === "complete" ? "completed" : "accepted", undefined, disposition === "complete" ? "" : undefined, disposition === "defer" ? { deferred: true, clear_execution: true, execution_error: null } : { execution_id: executionId, deferred: false, execution_error: null });
+                        item.done = true;
+                    })
+                });
             const first = claimed[0].record;
-            result = await host.wake({ token, agentId: agent.id, event: {
+            if (agent.recording) {
+                await recordWakeMoment(agent, agent.attention === undefined ? first.delivery_id : executionId, claimed.map(({ record }) => record), { ...this.options.recordingOptionsForTest, verifyStore: () => verifyHostRecordingStore(host, agent.id) });
+            }
+            result = await wakeFromDurableInbox(host, { token, agentId: agent.id, event: {
                     version: "noopolis.daimon.wake.v1", id: agent.attention === undefined ? first.delivery_id : executionId, kind: first.event.kind,
-                    occurredAt: first.event.occurred_at,
+                    occurredAt: messages[0].occurred_at,
                     text: agent.attention === undefined ? first.event.text : inboxPrompt(messages, agent.engine.kind, agent.attention.maxBatchBytes)
                 } });
         }
@@ -152,9 +217,21 @@ export class AttentionDispatcher {
                     await store.transitionClaimed(item.record.acceptance_id, item.claim, "accepted", result.code);
                 }
                 else if (agent.attention !== undefined) {
-                    // Successful reading is not completion. A failed execution also keeps
-                    // unfinished deliveries, and its execution id for idempotent retry.
-                    await store.transitionClaimed(item.record.acceptance_id, item.claim, "accepted", undefined, undefined, { deferred: true, clear_execution: result.status === "completed", execution_error: executionError });
+                    // Successful reading is not completion: an undisposed delivery of a
+                    // completed execution waits, deferred, for new input.
+                    //
+                    // A failed execution is retried ONCE, at once, under a fresh execution
+                    // id. Keeping its id made every retry the same broker turn — a sealed
+                    // failure replays forever and a changed prompt is a turn conflict — and
+                    // deferring it left work a turn died on (a token ceiling after a
+                    // validated revision) waiting for mail that might never come. The
+                    // record's `execution_error` is the bound: it is set by the failure and
+                    // cleared only by a disposition or a completed execution, so a delivery
+                    // that fails again is deferred like any other.
+                    const retry = result.status === "failed" && item.record.execution_error === undefined;
+                    await store.transitionClaimed(item.record.acceptance_id, item.claim, "accepted", undefined, undefined, { deferred: !retry, clear_execution: result.status !== "rejected", execution_error: executionError });
+                    if (retry)
+                        console.error(`daimon: wake requeued once agent=${agent.id} delivery=${item.record.delivery_id} after ${sanitizeExecutionError(executionError ?? "engine_failed")}`);
                 }
                 else if (result.status === "completed")
                     await store.transitionClaimed(item.record.acceptance_id, item.claim, "completed", undefined, result.text);
@@ -179,7 +256,7 @@ export class AttentionDispatcher {
         void this.options.host.stop().catch(() => undefined);
     }
     async waitUntil(timestamp) {
-        if (this.stopping)
+        if (this.stopping || this.paused)
             return;
         await new Promise((resolve) => {
             const finish = () => { clearTimeout(timer); this.waiters.delete(finish); resolve(); };
@@ -188,6 +265,23 @@ export class AttentionDispatcher {
         });
     }
 }
+/**
+ * A delivery past `STALE_QUEUED_DELIVERY_MS` is stopped `queued_wake_stopped`
+ * where the dispatcher meets it, and the stop is logged: an expiry nobody can
+ * see reads, in every artifact, like work that was never sent. Stopping goes
+ * through the store's accepted-only seam, so a delivery claimed in the meantime
+ * is left alone; a failure to stop is logged and retried on the next drain.
+ */
+async function expireStaleDelivery(store, record) {
+    try {
+        const stopped = await store.transitionAcceptedToStopped(record.acceptance_id, "queued_wake_stopped");
+        if (stopped.state === "stopped")
+            console.error(`daimon: wake expired agent=${record.agent_id} delivery=${record.delivery_id} accepted_at=${record.accepted_at} unhandled past ${STALE_QUEUED_DELIVERY_MS / 3_600_000}h; stopped queued_wake_stopped${record.execution_error === undefined ? "" : ` (last failure: ${record.execution_error})`}`);
+    }
+    catch (error) {
+        console.error(`daimon: wake expiry failed agent=${record.agent_id} delivery=${record.delivery_id}: ${error instanceof Error ? error.message : "unknown error"}`);
+    }
+}
 export function selectBatch(records, agent, revisitDeferred) {
     const eligible = records.filter((record) => !record.deferred || revisitDeferred);
     const first = eligible[0];

package/dist/runtime/cli.js

@@ -139,6 +139,11 @@ async function handleRequest(request, response, host, control, expectedToken) {
             const availability = await control.availability(expectedToken);
             return availability === undefined ? respond(response, 404, { error: "not_found" }) : respond(response, 200, availability);
         }
+        if (control !== undefined && request.method === "POST" && (url.pathname === "/v2/drain" || url.pathname === "/v2/resume")) {
+            assertQuery(url, []);
+            const availability = url.pathname === "/v2/drain" ? await control.drain(expectedToken) : await control.resume(expectedToken);
+            return availability === undefined ? respond(response, 404, { error: "not_found" }) : respond(response, 200, availability);
+        }
         if (control !== undefined && request.method === "GET" && url.pathname === "/v2/activity") {
             assertQuery(url, []);
             const activity = await control.activityV2(expectedToken);