@zq-silk/yui 0.6.0 → 0.6.2

package/dist/controller/runtimeEventInbox.js

@@ -66,7 +66,7 @@ export class FileRuntimeEventInbox {
     }
     enqueueProviderProgress(input) {
         const normalized = normalizeProviderProgressInput(input);
-        return this.publish(Object.freeze({
+        return this.publishProgress(Object.freeze({
             schemaVersion: 1,
             id: runtimeEventId("native-turn-progress", normalized),
             type: "native-turn-progress",
@@ -74,6 +74,16 @@ export class FileRuntimeEventInbox {
             ...normalized
         }));
     }
+    enqueueDurableJobTerminal(input) {
+        const normalized = normalizeDurableJobTerminalInput(input);
+        return this.publish(Object.freeze({
+            schemaVersion: 1,
+            id: runtimeEventId("durable-job-terminal", normalized),
+            type: "durable-job-terminal",
+            receivedAt: this.now().toISOString(),
+            ...normalized
+        }));
+    }
     list() {
         if (!existsSync(this.directory))
             return [];
@@ -99,8 +109,7 @@ export class FileRuntimeEventInbox {
                 }
             }
         }
-        return events.sort((left, right) => (left.receivedAt.localeCompare(right.receivedAt)
-            || left.id.localeCompare(right.id)));
+        return events.sort(compareRuntimeEvents);
     }
     read(id) {
         assertEventId(id);
@@ -145,6 +154,44 @@ export class FileRuntimeEventInbox {
             throw error;
         }
     }
+    acknowledgeMany(ids) {
+        if (ids.length === 0)
+            return [];
+        const acknowledged = [];
+        try {
+            for (const id of ids) {
+                assertEventId(id);
+                try {
+                    unlinkSync(this.eventPath(id));
+                    acknowledged.push(id);
+                }
+                catch (error) {
+                    if (!isNodeError(error, "ENOENT"))
+                        throw error;
+                }
+            }
+        }
+        finally {
+            // Preserve the old per-event durability guarantee even when a later
+            // unlink in the batch fails after earlier entries were removed.
+            if (acknowledged.length > 0)
+                fsyncDirectory(this.directory);
+        }
+        return acknowledged;
+    }
+    publishProgress(event) {
+        return withUpgradeCoordinationLock(this.home, () => {
+            this.hooks.afterAdmission?.();
+            const result = this.publishUnlocked(event);
+            if (!result.created)
+                return result;
+            const superseded = this.supersededProgressIds(event);
+            if (superseded.length === 0)
+                return result;
+            this.acknowledgeMany(superseded);
+            return { ...result, coalescedEventCount: superseded.length };
+        });
+    }
     publish(event) {
         // The fence check and the complete durable write share one sibling
         // coordination lock with upgrade's final inbox scan/copy/two-step switch.
@@ -153,45 +200,77 @@ export class FileRuntimeEventInbox {
         // UpgradeFenceError after the cutover holder releases the lock.
         return withUpgradeCoordinationLock(this.home, () => {
             this.hooks.afterAdmission?.();
-            const content = `${JSON.stringify(event)}\n`;
-            if (Buffer.byteLength(content, "utf8") > MAX_RUNTIME_EVENT_FILE_BYTES) {
-                throw new RuntimeEventInboxError("RUNTIME_EVENT_TOO_LARGE", "Runtime event exceeds the durable inbox limit.");
-            }
-            ensureInboxDirectory(this.directory);
-            const target = this.eventPath(event.id);
-            const temporary = join(this.directory, `.${event.id}.tmp-${process.pid}-${randomUUID()}`);
-            let descriptor = null;
+            return this.publishUnlocked(event);
+        });
+    }
+    publishUnlocked(event) {
+        const content = `${JSON.stringify(event)}\n`;
+        if (Buffer.byteLength(content, "utf8") > MAX_RUNTIME_EVENT_FILE_BYTES) {
+            throw new RuntimeEventInboxError("RUNTIME_EVENT_TOO_LARGE", "Runtime event exceeds the durable inbox limit.");
+        }
+        ensureInboxDirectory(this.directory);
+        const target = this.eventPath(event.id);
+        const temporary = join(this.directory, `.${event.id}.tmp-${process.pid}-${randomUUID()}`);
+        let descriptor = null;
+        try {
+            descriptor = openSync(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o600);
+            writeFileSync(descriptor, content, "utf8");
+            fchmodSync(descriptor, 0o600);
+            fsyncSync(descriptor);
+            closeSync(descriptor);
+            descriptor = null;
             try {
-                descriptor = openSync(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o600);
-                writeFileSync(descriptor, content, "utf8");
-                fchmodSync(descriptor, 0o600);
-                fsyncSync(descriptor);
-                closeSync(descriptor);
-                descriptor = null;
-                try {
-                    linkSync(temporary, target);
-                    unlinkSync(temporary);
-                    fsyncDirectory(this.directory);
-                    return { event, created: true };
-                }
-                catch (error) {
-                    if (!isNodeError(error, "EEXIST"))
-                        throw error;
-                    const existing = this.read(event.id);
-                    if (existing === null)
-                        return { event, created: false };
-                    if (!hasSameIdentity(existing, event)) {
-                        throw new RuntimeEventInboxError("RUNTIME_EVENT_CONFLICT", `Runtime event id conflicts with an existing file: ${event.id}`);
-                    }
-                    return { event: existing, created: false };
+                linkSync(temporary, target);
+                unlinkSync(temporary);
+                fsyncDirectory(this.directory);
+                return { event, created: true };
+            }
+            catch (error) {
+                if (!isNodeError(error, "EEXIST"))
+                    throw error;
+                const existing = this.read(event.id);
+                if (existing === null)
+                    return { event, created: false };
+                if (!hasSameIdentity(existing, event)) {
+                    throw new RuntimeEventInboxError("RUNTIME_EVENT_CONFLICT", `Runtime event id conflicts with an existing file: ${event.id}`);
                 }
+                return { event: existing, created: false };
             }
-            finally {
-                if (descriptor !== null)
-                    closeSync(descriptor);
-                rmSync(temporary, { force: true });
+        }
+        finally {
+            if (descriptor !== null)
+                closeSync(descriptor);
+            rmSync(temporary, { force: true });
+        }
+    }
+    supersededProgressIds(event) {
+        const events = this.list();
+        const segment = semanticSegment(events, event);
+        const candidates = events.filter((candidate) => (candidate.type === "native-turn-progress"
+            && sameProgressStream(candidate, event)
+            && compareRuntimeEvents(candidate, segment.before) > 0
+            && (segment.after === undefined || compareRuntimeEvents(candidate, segment.after) < 0)));
+        let latestReceivedAt = "";
+        let greatestSequence;
+        for (const candidate of candidates) {
+            const receivedAtOrder = candidate.receivedAt.localeCompare(latestReceivedAt);
+            if (receivedAtOrder > 0) {
+                latestReceivedAt = candidate.receivedAt;
+                greatestSequence = candidate.sequence;
             }
-        });
+            else if (receivedAtOrder === 0
+                && candidate.sequence !== undefined
+                && (greatestSequence === undefined || candidate.sequence > greatestSequence)) {
+                greatestSequence = candidate.sequence;
+            }
+        }
+        return candidates.flatMap((candidate) => (candidate.receivedAt.localeCompare(latestReceivedAt) < 0
+            || (candidate.receivedAt === latestReceivedAt
+                && candidate.sequence !== undefined
+                && greatestSequence !== undefined
+                && candidate.sequence < greatestSequence)
+            ? [candidate.id]
+            : []));
     }
     eventPath(id) {
         return join(this.directory, `${id}.json`);
@@ -221,22 +300,37 @@ export class RuntimeEventInboxError extends Error {
     }
 }
 function runtimeEventId(type, input) {
+    if (type === "durable-job-terminal") {
+        const job = input;
+        return `turn-${createHash("sha256").update(JSON.stringify([
+            1,
+            type,
+            job.scope,
+            job.taskId,
+            job.jobId,
+            job.status,
+            job.outcome
+        ])).digest("hex")}`;
+    }
+    // The durable-job-terminal branch returned above; narrow the union so
+    // provider-only identity fields are accessible without `in` guards.
+    const provider = input;
     const common = [
         1,
         type,
-        input.scope,
-        input.taskId ?? null,
-        input.roleName,
-        input.agentId,
-        input.adapterId,
-        input.launchId ?? null,
-        input.nativeSessionId,
-        "turnId" in input ? input.turnId : null,
-        input.runId ?? null,
-        "progressId" in input ? input.progressId : null,
-        "sequence" in input ? input.sequence ?? null : null,
-        "sessionSource" in input ? input.sessionSource ?? null : null,
-        "receiptId" in input ? input.receiptId ?? null : null
+        provider.scope,
+        provider.taskId ?? null,
+        provider.roleName,
+        provider.agentId,
+        provider.adapterId,
+        provider.launchId ?? null,
+        provider.nativeSessionId,
+        "turnId" in provider ? provider.turnId : null,
+        provider.runId ?? null,
+        "progressId" in provider ? provider.progressId : null,
+        "sequence" in provider ? provider.sequence ?? null : null,
+        "sessionSource" in provider ? provider.sessionSource ?? null : null,
+        "receiptId" in provider ? provider.receiptId ?? null : null
     ];
     return `turn-${createHash("sha256").update(JSON.stringify(common)).digest("hex")}`;
 }
@@ -357,6 +451,23 @@ function normalizeProviderProgressInput(input) {
         ...(input.sequence === undefined ? {} : { sequence: input.sequence })
     };
 }
+function normalizeDurableJobTerminalInput(input) {
+    if (input.scope !== "task")
+        throw invalidEvent();
+    const terminalStatuses = [
+        "succeeded", "failed", "timed-out", "cancelled", "unknown-needs-attention"
+    ];
+    if (!terminalStatuses.includes(input.status)) {
+        throw invalidEvent();
+    }
+    return {
+        scope: "task",
+        taskId: requireIdentityText(input.taskId, "Task id"),
+        jobId: requireIdentityText(input.jobId, "Job id"),
+        status: input.status,
+        outcome: requireIdentityText(input.outcome, "Job outcome")
+    };
+}
 function parseRuntimeEvent(value) {
     if (!isObject(value))
         throw invalidEvent();
@@ -366,6 +477,7 @@ function parseRuntimeEvent(value) {
         case "native-session-lifecycle": return parseSessionLifecycleEvent(value);
         case "native-prompt-accepted": return parsePromptAcceptedEvent(value);
         case "native-turn-progress": return parseProviderProgressEvent(value);
+        case "durable-job-terminal": return parseDurableJobTerminalEvent(value);
         default: throw invalidEvent();
     }
 }
@@ -420,6 +532,22 @@ function parseProviderProgressEvent(value) {
         ...normalized
     });
 }
+function parseDurableJobTerminalEvent(value) {
+    const expected = [
+        "schemaVersion", "id", "type", "receivedAt", "scope", "taskId",
+        "jobId", "status", "outcome"
+    ];
+    if (value.schemaVersion !== 1 || !hasExactKeys(value, expected))
+        throw invalidEvent();
+    const normalized = normalizeDurableJobTerminalInput(value);
+    return Object.freeze({
+        schemaVersion: 1,
+        id: requireIdentityText(value.id, "Event id"),
+        type: "durable-job-terminal",
+        receivedAt: requireTimestamp(value.receivedAt),
+        ...normalized
+    });
+}
 function parseCodexEvent(value) {
     const scope = value.scope;
     const expected = scope === "task"
@@ -535,17 +663,66 @@ function hasSameIdentity(left, right) {
         && left.type === right.type
         && left.scope === right.scope
         && left.taskId === right.taskId
+        && (!("roleName" in left) || !("roleName" in right) || left.roleName === right.roleName)
+        && (!("agentId" in left) || !("agentId" in right) || left.agentId === right.agentId)
+        && (!("adapterId" in left) || !("adapterId" in right) || left.adapterId === right.adapterId)
+        && (!("launchId" in left) || !("launchId" in right) || left.launchId === right.launchId)
+        && (!("nativeSessionId" in left)
+            || !("nativeSessionId" in right)
+            || left.nativeSessionId === right.nativeSessionId)
+        && (!("runId" in left) || !("runId" in right) || left.runId === right.runId)
+        && (!("turnId" in left) || !("turnId" in right) || left.turnId === right.turnId)
+        && (!("progressId" in left)
+            || !("progressId" in right)
+            || left.progressId === right.progressId)
+        && (!("sequence" in left) || !("sequence" in right) || left.sequence === right.sequence)
+        && (!("jobId" in left) || !("jobId" in right) || left.jobId === right.jobId);
+}
+function compareRuntimeEvents(left, right) {
+    return left.receivedAt.localeCompare(right.receivedAt)
+        || left.id.localeCompare(right.id);
+}
+/** Chooses one latest fact inside an already-isolated exact progress stream. */
+export function compareRuntimeProgressRecency(left, right) {
+    const receivedAt = left.receivedAt.localeCompare(right.receivedAt);
+    if (receivedAt !== 0)
+        return receivedAt;
+    if (left.sequence !== undefined
+        && right.sequence !== undefined
+        && left.sequence !== right.sequence) {
+        return left.sequence - right.sequence;
+    }
+    // A content-derived event id is identity, not arrival evidence. Without two
+    // comparable provider sequences, same-timestamp facts remain incomparable.
+    return 0;
+}
+function semanticSegment(events, current) {
+    let before = {
+        receivedAt: "",
+        id: ""
+    };
+    let after;
+    for (const event of events) {
+        if (event.type === "native-turn-progress")
+            continue;
+        const order = compareRuntimeEvents(event, current);
+        if (order < 0 && compareRuntimeEvents(event, before) > 0) {
+            before = event;
+        }
+        else if (order > 0 && (after === undefined || compareRuntimeEvents(event, after) < 0)) {
+            after = event;
+        }
+    }
+    return { before, ...(after === undefined ? {} : { after }) };
+}
+function sameProgressStream(left, right) {
+    return left.taskId === right.taskId
         && left.roleName === right.roleName
         && left.agentId === right.agentId
         && left.adapterId === right.adapterId
         && left.launchId === right.launchId
         && left.nativeSessionId === right.nativeSessionId
-        && left.runId === right.runId
-        && (!("turnId" in left) || !("turnId" in right) || left.turnId === right.turnId)
-        && (!("progressId" in left)
-            || !("progressId" in right)
-            || left.progressId === right.progressId)
-        && (!("sequence" in left) || !("sequence" in right) || left.sequence === right.sequence);
+        && left.runId === right.runId;
 }
 function hasExactKeys(value, expected) {
     const actual = Object.keys(value).sort();