@zq-silk/yui 2.6.0 → 2.8.0

package/dist/runtime/managedCaller.js

@@ -16,12 +16,31 @@ export function requireManagedGlobalCaller(store, env) {
         || !role || !binding || !set || !session || session.status !== "active"
         || set.activeAgentId !== role.activeAgentId || session.agentId !== binding.agentId
         || session.adapterId !== binding.adapterId || nativeSessionId !== session.nativeSessionId
+        || (env.YUI_WORKSPACE !== undefined && env.YUI_WORKSPACE !== session.effective.workspace.root)
         || (env.YUI_AGENT_ID !== undefined && env.YUI_AGENT_ID !== session.agentId)
         || (env.YUI_ADAPTER_ID !== undefined && env.YUI_ADAPTER_ID !== session.adapterId)) {
         throw new ManagedRuntimeDriftError("This command requires the current managed global native Session; the previous Session has no write authority.");
     }
     return { roleName: role.name, agentId: session.agentId, adapterId: session.adapterId, nativeSessionId };
 }
+/** Historical self diagnostics remain readable, but never authorize inbox
+ * handling, configuration, another Role's records, or lifecycle mutation. */
+export function requireManagedGlobalReader(store, env) {
+    try {
+        requireManagedGlobalCaller(store, env);
+        return;
+    }
+    catch (error) {
+        const set = env.YUI_ROLE === undefined ? null : store.getGlobalRoleSessionSet(env.YUI_ROLE);
+        const known = [...Object.values(set?.sessions ?? {}), ...Object.values(set?.history ?? {})].some(session => session.nativeSessionId === identity(session.adapterId === "codex"
+            ? env.CODEX_THREAD_ID ?? env.YUI_NATIVE_SESSION_ID : env.YUI_NATIVE_SESSION_ID)
+            && (env.YUI_AGENT_ID === undefined || env.YUI_AGENT_ID === session.agentId)
+            && (env.YUI_ADAPTER_ID === undefined || env.YUI_ADAPTER_ID === session.adapterId)
+            && (env.YUI_WORKSPACE === undefined || env.YUI_WORKSPACE === session.effective.workspace.root));
+        if (env.YUI_SESSION_SCOPE !== "global" || env.YUI_TASK_ID !== undefined || !known)
+            throw error;
+    }
+}
 /**
  * A managed Session presented valid self-identity but is no longer the current
  * runtime of its Task Role. This is a bounded diagnosis rather than a bare
@@ -62,7 +81,12 @@ export function resolveManagedTaskCaller(store, environment) {
     const self = managedTaskSessionIdentity(environment);
     if (self === undefined)
         return undefined;
-    return requireCurrentRuntime(store, self);
+    const caller = requireCurrentRuntime(store, self);
+    if (environment?.YUI_AGENT_ID !== undefined && environment.YUI_AGENT_ID !== caller.agentId
+        || environment?.YUI_ADAPTER_ID !== undefined && environment.YUI_ADAPTER_ID !== caller.adapterId) {
+        throw new ManagedRuntimeDriftError("Managed Task Agent/adapter hints conflict with the current native Session.");
+    }
+    return caller;
 }
 /** Same as resolveManagedTaskCaller, but requires a managed Task Session. */
 export function requireManagedTaskCaller(store, environment) {

package/dist/runtime/managedIdentity.js

@@ -2,5 +2,5 @@
  * silently acquire the authority of an unbound public caller. */
 export function hasManagedIdentity(environment) {
     return ["YUI_SESSION_SCOPE", "YUI_ROLE", "YUI_AGENT_ID", "YUI_NATIVE_SESSION_ID",
-        "YUI_TASK_ID", "YUI_SESSION_MANIFEST"].some(key => environment[key] !== undefined);
+        "YUI_TASK_ID", "YUI_SESSION_MANIFEST", "CODEX_THREAD_ID"].some(key => environment[key] !== undefined);
 }

package/dist/runtime/providerRetry.js

@@ -176,7 +176,7 @@ export function providerRetryPrompt(retry, original) {
         original
     ].join("\n");
 }
-/** The same presentation is consumed by CLI, Context and Web. */
+/** The same presentation is consumed by explicit detail reads and Web. */
 export function providerRetryProjection(binding) {
     const retry = binding?.retry;
     if (retry === undefined)
@@ -209,6 +209,24 @@ export function providerRetryProjection(binding) {
         ...(retry.successorRunId === undefined ? {} : { successorRunId: retry.successorRunId })
     };
 }
+/** Entry-point facts, never accumulated retry history or raw diagnostics.
+ * Exact Session retry/show and failureRef retain the original evidence. */
+export function providerRetrySummary(binding) {
+    const view = providerRetryProjection(binding);
+    if (view === null)
+        return null;
+    const { history, error, currentTurn, ...facts } = view;
+    return {
+        ...facts,
+        error: { source: error.source, phase: error.phase, category: error.category,
+            code: error.code, inputDisposition: error.inputDisposition,
+            sessionDisposition: error.sessionDisposition, retryable: error.retryable },
+        currentTurn: currentTurn === null ? null : {
+            attemptId: currentTurn.attemptId, status: currentTurn.status, nativeTurnId: currentTurn.nativeTurnId
+        },
+        historyCount: history.length, detailOmitted: true
+    };
+}
 export function controlProviderRetry(binding, action, at) {
     if (action === "enable")
         return { ...binding, retryDisabled: false };

package/dist/runtime/sessionCaller.js

@@ -0,0 +1,53 @@
+import { hasManagedIdentity } from "./managedIdentity.js";
+import { ManagedRuntimeDriftError, requireManagedGlobalCaller, requireManagedTaskCaller } from "./managedCaller.js";
+/** Resolve location from this Home's registry, not from a launch environment.
+ * The returned hints are not authority: consumers still validate the current
+ * binding (including revocation, Assignment and captured workspace).
+ * Native children with their own Codex thread cannot borrow a parent's hints.
+ */
+export function sessionCallerEnvironment(store, env) {
+    const native = env.CODEX_THREAD_ID ?? env.YUI_NATIVE_SESSION_ID;
+    if (native === undefined) {
+        if (hasManagedIdentity(env))
+            throw new ManagedRuntimeDriftError("Managed Session identity has no native session id.");
+        return env;
+    }
+    if (!native || native.trim() !== native || native.includes("\0")) {
+        throw new ManagedRuntimeDriftError("Managed native Session identity is invalid.");
+    }
+    // Reuse the existing derived active-Session inventory; no new identity index
+    // or scan of every Task body/history is needed.
+    const matches = store.listRuntimeSessionCandidates().filter(session => session.nativeSessionId === (session.adapterId === "codex" ? env.CODEX_THREAD_ID ?? env.YUI_NATIVE_SESSION_ID : env.YUI_NATIVE_SESSION_ID));
+    if (matches.length !== 1) {
+        throw new ManagedRuntimeDriftError(matches.length
+            ? "Native Session identity is ambiguous in this YUI_HOME; no caller authority was selected."
+            : "Native Session is not registered in this YUI_HOME; refusing to infer public user authority.");
+    }
+    const match = matches[0];
+    const set = match.owner.scope === "global" ? store.getGlobalRoleSessionSet(match.owner.roleName)
+        : store.getTaskRoleSessionSet(match.owner.taskId, match.owner.roleName);
+    const session = set?.sessions[match.agentId];
+    if (set === null || session === undefined || session.nativeSessionId !== match.nativeSessionId) {
+        throw new ManagedRuntimeDriftError("Native Session registration changed during caller resolution; read current state again.");
+    }
+    const hints = {
+        YUI_SESSION_SCOPE: set.owner.scope, YUI_ROLE: set.owner.roleName,
+        YUI_AGENT_ID: session.agentId, YUI_ADAPTER_ID: session.adapterId,
+        YUI_WORKSPACE: session.effective.workspace.root,
+        ...(set.owner.scope === "task" ? { YUI_TASK_ID: set.owner.taskId } : {})
+    };
+    for (const key of [...Object.keys(hints), "YUI_TASK_ID"]) {
+        if (env[key] !== undefined && env[key] !== hints[key]) {
+            throw new ManagedRuntimeDriftError(`Managed Session hint ${key} conflicts with this Home's native Session registration.`);
+        }
+    }
+    return { ...env, ...hints };
+}
+/** One current caller for inbox and other own-address operations. */
+export function requireManagedCaller(store, env) {
+    const current = sessionCallerEnvironment(store, env);
+    if (current.YUI_SESSION_SCOPE === "global") {
+        return { scope: "global", ...requireManagedGlobalCaller(store, current) };
+    }
+    return { scope: "task", ...requireManagedTaskCaller(store, current) };
+}

package/dist/scheduler/operatorEvent.js

@@ -1,6 +1,55 @@
 import { enqueueWork } from "../coordination/workMailboxQueue.js";
 import { createTaskEvent } from "../event/taskEvent.js";
+import { claimPending } from "../coordination/workMailbox.js";
 export const LEADER_ATTENTION_REQUIRED_EVENT = "leader.attention-required";
+/** Bound each Operator pass, retaining the exact unclaimed sequence suffix. */
+export function claimOperatorAttention(mailbox, options) {
+    const pending = mailbox.pending;
+    if (pending === null || pending.requestCount <= 64)
+        return claimPending(mailbox, options);
+    // Operator producers append one unique source ref per signal. Mailbox merge
+    // preserves insertion order for refs and keys, including the supported
+    // default sequence keys used by Provider retry attention. Preserve those
+    // keys verbatim; they are valid current data, not a migration or repair.
+    if (pending.requestCount !== pending.dedupeKeys.length
+        || pending.refs.length !== pending.requestCount
+        || pending.toSequence - pending.fromSequence + 1 !== pending.requestCount
+        || pending.dedupeKeys.some((key, index) => {
+            const ref = pending.refs[index];
+            return (ref.type !== "event" && ref.type !== "input")
+                || key !== `operator-${ref.type}:${ref.taskId}:${ref.id}`
+                    && key !== `sequence:${pending.fromSequence + index}`;
+        })) {
+        throw new Error("Operator attention batch cannot be safely partitioned; inspect its source refs and sequence before retrying.");
+    }
+    const prefixKeys = pending.dedupeKeys.slice(0, 64);
+    const suffixKeys = pending.dedupeKeys.slice(64);
+    const through = pending.fromSequence + 63;
+    const prefix = { ...pending, toSequence: through, requestCount: 64,
+        dedupeKeys: prefixKeys, refs: pending.refs.slice(0, 64) };
+    const claimed = claimPending({ ...mailbox, pending: prefix }, {
+        ...options, batchId: `operator:${prefix.fromSequence}-${prefix.toSequence}`
+    });
+    return { ...claimed, pending: { ...pending, fromSequence: through + 1,
+            requestCount: pending.requestCount - 64, dedupeKeys: suffixKeys,
+            refs: pending.refs.slice(64) } };
+}
+/**
+ * Fixed source admission at the durable event write, in the same transaction.
+ * The existing mailbox is the incremental restart cursor: periodic scheduling
+ * reads only outstanding refs, never re-scans or replays historical events.
+ * Context, idle observations and ordinary progress are deliberately absent.
+ */
+export function enqueueDurableOperatorFact(store, event) {
+    const now = new Date(event.createdAt);
+    if (event.type === "input.requested" && typeof event.payload.requestId === "string") {
+        enqueueWork(store, { kind: "operator" }, "input-requested", now, [{ type: "input", taskId: event.taskId, id: event.payload.requestId }], { source: "input-request", dedupeKey: `operator-input:${event.taskId}:${event.payload.requestId}` });
+    }
+    else if (["task.completed", "task.cancelled", "task.retired", "publication.recorded",
+        "publication.candidate-adopted", LEADER_ATTENTION_REQUIRED_EVENT].includes(event.type)) {
+        enqueueOperatorEvent(store, event, event.type.startsWith("task.") ? "task-terminal" : event.type, now);
+    }
+}
 /** One event, one supervisor signal; the Leader wake is this mailbox's projection. */
 export function enqueueSupervisorEvent(store, event, recipient, reason, now) {
     if (store.getTask(event.taskId)?.status === "archived")

package/dist/scheduler/operatorInputNotificationProcessor.js

@@ -28,8 +28,9 @@ export async function processOperatorInputNotifications(store, selection, now =
         }
         if (ref.type !== "event")
             return [];
-        const event = store.listEvents(ref.taskId).find(({ id }) => id === ref.id);
-        return event === undefined ? [] : [{ kind: "event", event }];
+        const event = store.getEvent !== undefined ? store.getEvent(ref.taskId, ref.id)
+            : store.listEvents(ref.taskId).find(({ id }) => id === ref.id);
+        return event == null ? [] : [{ kind: "event", event }];
     }));
     if (attentions.length === 0) {
         store.completeWorkMailbox(targetMailbox, processing.batchId);
@@ -42,9 +43,9 @@ export async function processOperatorInputNotifications(store, selection, now =
             receiptId: presentation.receiptId,
             text: presentation.text
         }, now);
-        if (outcome.status === "unavailable") {
+        if (outcome.status === "unavailable" || outcome.status === "deferred") {
             store.releaseWorkMailbox(targetMailbox, processing.batchId);
-            return attentions.map((attention) => skipped(attention, "operator-unavailable"));
+            return attentions.map((attention) => skipped(attention, outcome.status === "deferred" ? "notice-pending" : "operator-unavailable"));
         }
         return attentions.map((attention) => ({
             ...attentionIdentity(attention),

package/dist/scheduler/taskWake.js

@@ -1,6 +1,7 @@
 import { requireIdentity, requirePositiveInteger, requireText, requireTimestamp } from "../domain/validation.js";
 import { TASK_RECORD_ID_PREFIXES } from "../task/taskRecordReference.js";
 import { copyRef } from "../coordination/workMailbox.js";
+import { validateInboxReceipt } from "../message/inboxReceipt.js";
 export const CURRENT_TASK_WAKE_SCHEMA_VERSION = 1;
 export function createTaskWake(input) {
     if (Object.hasOwn(input, "runId"))
@@ -21,6 +22,10 @@ export function createTaskWake(input) {
     return wake;
 }
 export function validateTaskWake(wake) {
+    validateInboxReceipt(wake.inbox);
+    if (wake.inboxPendingId !== undefined && (!/^pending-[a-f0-9]{64}$/.test(wake.inboxPendingId) || !wake.inbox)) {
+        throw new Error("An active inbox wake requires its exact pending identity and handling claim.");
+    }
     if (Object.hasOwn(wake, "runId"))
         throw new Error("Run-backed wakes are not current notification records.");
     if (wake.refs !== undefined) {

package/dist/sqlite/driver.js

@@ -0,0 +1,108 @@
+import { createRequire } from "node:module";
+export const SQLITE_CANDIDATES = Object.freeze([
+    // N-API avoids node::ObjectWrap's GC cleanup abort on Node 24.19/24.20.
+    Object.freeze({ name: "sqlite-modern", version: "13.0.3", minimumNapi: 10 }),
+    Object.freeze({ name: "sqlite-compat", version: "10.1.0", minimumNapi: 0 })
+]);
+/** Only errors attributable to loading this native candidate, never database errors. */
+function nativeUnavailable(error, candidate) {
+    if (!(error instanceof Error))
+        return false;
+    const code = error.code;
+    const firstLine = error.message.split("\n")[0];
+    if (code === "MODULE_NOT_FOUND") {
+        if (firstLine === `Cannot find module '${candidate.name}'`)
+            return true;
+        // v13 loads its bundled prebuild or these node-gyp paths directly.
+        // Do not swallow an unrelated missing transitive JS dependency.
+        const missing = /^Cannot find module '([^']+)'$/.exec(firstLine)?.[1];
+        return missing !== undefined && ["Debug", "Release"].some((mode) => missing.endsWith(`/node_modules/${candidate.name}/build/${mode}/better_sqlite3.node`));
+    }
+    const tries = error.tries;
+    if (error.message.startsWith("Could not locate the bindings file.") && Array.isArray(tries)) {
+        return tries.length > 0 && tries.every((path) => typeof path === "string" && path.includes(`/node_modules/${candidate.name}/`)
+            && path.endsWith("/better_sqlite3.node"));
+    }
+    if (code !== "ERR_DLOPEN_FAILED")
+        return false;
+    return /NODE_MODULE_VERSION \d+/.test(error.message)
+        || /(?:GLIBC|GLIBCXX|CXXABI)_[\d.]+['’] not found/.test(error.message)
+        || /(?:cannot open shared object file|Library not loaded:|wrong ELF class:|invalid ELF header|incompatible architecture)/.test(error.message);
+}
+const require = createRequire(import.meta.url);
+function selectionFailure(failures) {
+    return new AggregateError(failures, "No usable SQLite driver. " + SQLITE_CANDIDATES.map((candidate, index) => `${candidate.name}@${candidate.version}: ${failures[index] instanceof Error ? failures[index].message : String(failures[index])}`).join("; ")
+        + ". Reinstall with npm optional dependencies enabled (do not use --omit=optional); "
+        + "check Node ABI, system libraries and native build tools. Older systems may require an OS/toolchain upgrade.");
+}
+/**
+ * Selection is isolated from every real database open. No real Home operation
+ * is inside a fallback catch, and successful selection stays fixed per process.
+ * Loader injection supports deterministic native-failure tests, not user config.
+ */
+export function createSqliteDriverSelector(load = (candidate) => require(candidate.name), napiVersion = Number(process.versions.napi ?? 0)) {
+    let selected;
+    return () => {
+        if (selected)
+            return selected;
+        const failures = [];
+        for (const candidate of SQLITE_CANDIDATES) {
+            // An unsupported Node-API constructor can crash outside JS exception
+            // handling. Exclude it before loading native code, not after probing.
+            if (napiVersion < candidate.minimumNapi) {
+                failures.push(new Error(`${candidate.name} requires Node-API ${candidate.minimumNapi}; runtime provides ${napiVersion}`));
+                continue;
+            }
+            let Driver;
+            let probe;
+            try {
+                Driver = load(candidate);
+                probe = new Driver(":memory:");
+            }
+            catch (error) {
+                if (!nativeUnavailable(error, candidate)) {
+                    // Stop on unknown errors, but retain the modern failure when the
+                    // compatibility candidate also fails. This does not permit retry.
+                    if (failures.length)
+                        throw selectionFailure([...failures, error]);
+                    throw error;
+                }
+                failures.push(error);
+                continue;
+            }
+            // SQL and close failures are deliberately outside the native-load catch.
+            let sqliteVersion;
+            try {
+                try {
+                    const result = probe.prepare("SELECT sqlite_version() AS version, 1 AS value").get();
+                    if (typeof result?.version !== "string" || result.value !== 1) {
+                        throw new Error(`SQLite probe returned an invalid result for ${candidate.name}.`);
+                    }
+                    sqliteVersion = result.version;
+                }
+                finally {
+                    probe.close();
+                }
+            }
+            catch (error) {
+                if (failures.length)
+                    throw selectionFailure([...failures, error]);
+                throw error;
+            }
+            selected = Object.freeze({
+                ...candidate, Database: Driver, sqliteVersion,
+                ...(failures.length ? { fallbackReason: failures[0].message } : {})
+            });
+            return selected;
+        }
+        throw selectionFailure(failures);
+    };
+}
+export const selectSqliteDriver = createSqliteDriverSelector();
+// Preserve the existing constructor/type contract without loading native code
+// during module import. All runtime consumers share the same selector.
+const Database = function (filename, options) {
+    const Driver = selectSqliteDriver().Database;
+    return new Driver(filename, options);
+};
+export default Database;

package/dist/storage/contextRecords.js

@@ -58,6 +58,34 @@ export function queryContextRecords(db, taskId, query) {
         where.push(`${id} IN (SELECT value FROM json_each(@ids))`);
         params.ids = JSON.stringify(query.ids);
     }
+    if (query.unhandledMessages) {
+        if (query.family !== "task-message")
+            throw new Error("Unhandled selection requires Messages.");
+        where.push(`json_extract(r.payload, '$.inbox.ack') IS NULL`);
+        where.push(`NOT EXISTS (SELECT 1 FROM events e WHERE e.task_id = r.task_id
+      AND e.type = 'task.record-retired'
+      AND json_extract(e.payload, '$.payload.recordKind') = 'message'
+      AND json_extract(e.payload, '$.payload.recordId') = r.message_id)`);
+        // Match taskMessageInboxReceipt: a direct claim owns the Message, otherwise
+        // a wake receipt covers its exact reference and latest revision event.
+        where.push(`(json_extract(r.payload, '$.inbox') IS NOT NULL OR (
+      SELECT json_extract(w.payload, '$.inbox.ack') FROM task_wakes w
+      WHERE w.task_id = r.task_id AND json_extract(w.payload, '$.inbox') IS NOT NULL
+        AND EXISTS (SELECT 1 FROM json_each(w.payload, '$.refs') ref
+          WHERE json_extract(ref.value, '$.type') = 'message'
+            AND json_extract(ref.value, '$.taskId') = r.task_id
+            AND json_extract(ref.value, '$.id') = r.message_id)
+        AND (NOT EXISTS (SELECT 1 FROM events e WHERE e.task_id = r.task_id AND e.type = 'message.updated'
+          AND json_extract(e.payload, '$.payload.messageId') = r.message_id)
+        OR EXISTS (SELECT 1 FROM json_each(w.payload, '$.refs') update_ref
+          WHERE json_extract(update_ref.value, '$.type') = 'event'
+            AND json_extract(update_ref.value, '$.taskId') = r.task_id
+            AND json_extract(update_ref.value, '$.id') = (
+              SELECT e.event_id FROM events e WHERE e.task_id = r.task_id AND e.type = 'message.updated'
+                AND json_extract(e.payload, '$.payload.messageId') = r.message_id
+              ORDER BY CAST(substr(e.event_id, 7) AS INTEGER) DESC LIMIT 1)))
+      ORDER BY w.seq ASC LIMIT 1) IS NULL)`);
+    }
     for (const [label, statuses, not] of [
         ["statuses", query.statuses, ""],
         ["excludeStatuses", query.excludeStatuses, "NOT"]

package/dist/storage/sqliteSchema.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import Database from "better-sqlite3";
+import Database from "../sqlite/driver.js";
 import { BASELINE_SCHEMA_SQL, SQLITE_SCHEMA_TABLES } from "./baselineSchema.js";
 import { migrateTaskMainWorkspaces } from "./upgrade/taskMainWorkspaceMigration.js";
 import { migrateProjectKnowledge } from "./upgrade/projectKnowledgeMigration.js";
@@ -76,6 +76,26 @@ const MINOR_UPGRADES = Object.freeze([{
         targetChecksum: CURRENT_SCHEMA_CHECKSUM,
         // Optional sourced monetary observations; historical missing costs stay unknown.
         sql: ""
+    }, {
+        fromVersion: "1.6",
+        toVersion: "1.7",
+        name: "agent-inbox-consumption",
+        introducedIn: "next",
+        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
+        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        // Additive handling receipts on canonical Messages and wakes. Never invent
+        // historical processing or Provider acceptance; existing records stay intact.
+        sql: ""
+    }, {
+        fromVersion: "1.7",
+        toVersion: "1.8",
+        name: "model-management-connection",
+        introducedIn: "next",
+        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
+        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        // Optional non-secret connection references. Existing Homes remain unconfigured;
+        // never infer local credentials or adopt an existing external service.
+        sql: ""
     }]);
 export function storageMinorUpgradePlan(from) {
     if (from === CURRENT_STORAGE_VERSION)

package/dist/storage/sqliteStore.js

@@ -32,7 +32,7 @@
  * including writes, reads and explicit Home diagnostics. There is no weaker
  * in-process contract or deferred validation phase.
  */
-import Database from "better-sqlite3";
+import Database from "../sqlite/driver.js";
 import { existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { isDeepStrictEqual } from "node:util";
@@ -40,8 +40,10 @@ import { runPurposeAdmitsTaskState } from "../agentRun/agentRun.js";
 import { validateTaskBrief } from "../brief/taskBrief.js";
 import { validateContextSnapshot } from "../context/contextSnapshot.js";
 import { consumePendingBatch, mailboxTargetKey, validateWorkMailbox } from "../coordination/workMailbox.js";
+import { enqueueDurableOperatorFact } from "../scheduler/operatorEvent.js";
 import { validateDurableJob, validDurableJobTransition } from "../job/durableJob.js";
 import { validateGlobalRoleMessage } from "../message/message.js";
+import { assertInboxOriginalPreserved, assertInboxReceiptPreserved } from "../message/inboxReceipt.js";
 import { validatePluginIntent, validatePluginIntentFailure } from "../plugins/pluginIntent.js";
 import { validatePluginValidation } from "../plugins/pluginPackage.js";
 import { generateHomeIdentity, validateHomeIdentity } from "../repository/homeIdentity.js";
@@ -975,10 +977,58 @@ export class SqliteTaskStore {
     listGlobalRoleMessages(roleName) {
         return this.#sortById(this.#listPayload("global_role_messages", "name = ?", [roleName]), (message) => message.id);
     }
+    queryGlobalRoleMessages(roleName, query) {
+        if (!Number.isSafeInteger(query.limit) || query.limit < 0 || query.limit > 64
+            || !Number.isSafeInteger(query.afterSequence ?? 0) || (query.afterSequence ?? 0) < 0) {
+            throw new Error("Global Message query exceeds its bounded contract.");
+        }
+        const where = ["name = @name"];
+        const params = { name: roleName };
+        if (query.handling)
+            where.push(`json_extract(payload, '$.inbox.claim') IS NOT NULL
+      AND json_extract(payload, '$.inbox.ack') IS NULL`);
+        if (query.pending)
+            where.push(`json_extract(payload, '$.delivery') IS NULL
+      AND json_extract(payload, '$.inbox.ack') IS NULL
+      AND json_extract(payload, '$.notDelivered') IS NULL
+      AND (json_extract(payload, '$.inputControl.action') = 'queue'
+        OR json_extract(payload, '$.interruptThen') IS NOT NULL)`);
+        if (query.interruptThen)
+            where.push("json_extract(payload, '$.interruptThen') IS NOT NULL");
+        if (query.operatorNotice)
+            where.push("json_extract(payload, '$.inputControl.requestId') LIKE 'operator-notice:%'");
+        if (query.afterSequence !== undefined) {
+            where.push("seq > @after");
+            params.after = query.afterSequence;
+        }
+        if (query.id !== undefined) {
+            where.push("message_id = @id");
+            params.id = query.id;
+        }
+        if (query.requestId !== undefined) {
+            where.push("COALESCE(json_extract(payload, '$.inputControl.requestId'), json_extract(payload, '$.interruptThen.reusedInput.requestId')) = @request");
+            params.request = query.requestId;
+        }
+        const filter = where.join(" AND ");
+        const summary = this.#db.prepare(`SELECT count(*) AS count, min(created_at) AS oldestCreatedAt
+      FROM global_role_messages WHERE ${filter}`).get(params);
+        const rows = this.#db.prepare(`SELECT payload FROM global_role_messages WHERE ${filter}
+      ORDER BY seq ${query.descending ? "DESC" : "ASC"} LIMIT @limit`)
+            .all({ ...params, limit: query.limit });
+        return { ...summary, messages: rows.map(row => {
+                const message = this.#parse(row.payload);
+                validateGlobalRoleMessage(message);
+                return message;
+            }) };
+    }
     updateGlobalRoleMessage(message) {
         validateGlobalRoleMessage(message);
         this.#requireGlobalRole(message.roleName);
         this.#mutate(() => {
+            const existing = this.#db.prepare("SELECT payload FROM global_role_messages WHERE name = ? AND message_id = ?")
+                .get(message.roleName, message.id);
+            assertInboxOriginalPreserved(existing === undefined ? undefined
+                : this.#parse(existing.payload), message);
             const seq = this.#globalMessageSequence(message.id);
             const result = this.#db.prepare(`UPDATE global_role_messages SET seq = ?, payload = ? WHERE name = ? AND message_id = ?`).run(seq, this.#recordJson("global_role_messages", message), message.roleName, message.id);
             if (result.changes === 0) {
@@ -2001,6 +2051,10 @@ export class SqliteTaskStore {
         }
         this.#requireTask(taskId);
         this.#mutate(() => {
+            const existing = this.#db.prepare("SELECT payload FROM messages WHERE task_id = ? AND message_id = ?")
+                .get(taskId, message.id);
+            assertInboxOriginalPreserved(existing === undefined ? undefined
+                : this.#parse(existing.payload), message);
             const result = this.#db.prepare(`UPDATE messages SET payload = ? WHERE task_id = ? AND message_id = ?`).run(this.#recordJson("messages", message), taskId, message.id);
             if (result.changes !== 1) {
                 throw new StorageRecordError(`Message does not exist: ${taskId}/${message.id}`);
@@ -2086,6 +2140,7 @@ export class SqliteTaskStore {
             // Events are terminal/semantic: retained individually, never pruned (§9).
             this.#db.prepare(`INSERT INTO events (task_id, event_id, type, occurred_at, payload) VALUES (?, ?, ?, ?, ?)`).run(taskId, event.id, event.type, event.createdAt, this.#recordJson("events", event));
             this.#observeHighWater(taskId, "event", seq);
+            enqueueDurableOperatorFact(this, event);
         });
     }
     listEvents(taskId) {
@@ -2113,6 +2168,14 @@ export class SqliteTaskStore {
         validateTaskWake(wake);
         this.#requireTask(taskId);
         this.#mutate(() => {
+            const existing = this.#db.prepare("SELECT payload FROM task_wakes WHERE task_id = ? AND wake_id = ?")
+                .get(taskId, wake.id);
+            const previous = existing === undefined ? undefined : this.#parse(existing.payload);
+            if (previous !== undefined && !isDeepStrictEqual(previous.refs, wake.refs)) {
+                throw new StorageRecordError("A notification window's original revision references are immutable.");
+            }
+            assertInboxReceiptPreserved(existing === undefined ? undefined
+                : this.#parse(existing.payload).inbox, wake.inbox);
             const seq = this.#idSequence(wake.id, "taskWake");
             this.#db.prepare(`INSERT INTO task_wakes
           (task_id, wake_id, seq, status, from_cursor, to_cursor, reasons, payload, created_at, consumed_at)

package/dist/storage/storageSchema.js

@@ -1,6 +1,6 @@
 import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
-import Database from "better-sqlite3";
+import Database from "../sqlite/driver.js";
 import { inspectSqliteSchema, storageMinorUpgradePlan, SqliteSchemaError } from "./sqliteSchema.js";
 import { compareStorageVersions, CURRENT_STORAGE_VERSION, MIN_SUPPORTED_STORAGE_VERSION } from "./storageVersions.js";
 export { CURRENT_STORAGE_VERSION, MIN_SUPPORTED_STORAGE_VERSION } from "./storageVersions.js";

package/dist/storage/storageVersions.js

@@ -1,4 +1,4 @@
-export const CURRENT_STORAGE_VERSION = "1.6";
+export const CURRENT_STORAGE_VERSION = "1.8";
 export const MIN_SUPPORTED_STORAGE_VERSION = "1.0";
 export const STORAGE_FORMAT = "yui-home";
 export function isStorageVersion(value) {

package/dist/storage/storeRpc.js

@@ -48,6 +48,7 @@ const READ_ONLY_STORE_METHODS = new Set([
     "getGlobalRoleSessionSet",
     "listGlobalRoleSessionSets",
     "listGlobalRoleMessages",
+    "queryGlobalRoleMessages",
     "listTasks",
     "getTask",
     "readNextActionFacts",

package/dist/storage/taskStore.js

@@ -1,5 +1,6 @@
 import { lstatSync, mkdirSync, realpathSync } from "node:fs";
 import { homedir } from "node:os";
+import { validateModelConnection } from "../models/modelManagementConfig.js";
 import { basename, dirname, join, resolve } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { resolveTimeZone } from "../config/timeZone.js";
@@ -117,6 +118,7 @@ export function validateYuiConfig(config) {
     try {
         const optionalFields = [
             "defaultAgent",
+            "modelManagement",
             "defaultWorkspace",
             "timeZone",
             "currentTaskId",
@@ -146,6 +148,8 @@ export function validateYuiConfig(config) {
         }
         reconciliationIntervalMilliseconds(config.reconciliationIntervalSeconds);
         resolveTimeZone(config.timeZone);
+        if (config.modelManagement !== undefined)
+            validateModelConnection(config.modelManagement);
         if (config.review !== undefined)
             validateReviewConfig(config.review);
         resolveResourcesGcMode(config.resourcesGcMode);

package/dist/storage/upgrade/upgradeOrchestrator.js

@@ -1,6 +1,6 @@
 import { join } from "node:path";
 import { copyFileSync, existsSync, mkdirSync, rmdirSync, rmSync } from "node:fs";
-import Database from "better-sqlite3";
+import Database from "../../sqlite/driver.js";
 import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation } from "../../runtime/runtimeObservation.js";
 import { RUNTIME_PROCESS_EXIT_TASK_EVENT, validateRuntimeProcessExitObservation } from "../../runtime/processExitObservation.js";
 import { SqliteTaskStore } from "../sqliteStore.js";

package/dist/task/completionReadiness.js

@@ -1,12 +1,18 @@
 import { governingWorkItemDeliveries, integrationAttemptRequiresSettlement, workItemDeliverySettled } from "../integration/deliveryObligation.js";
+import { isLeaderSteer, taskMessageInboxReceipt } from "../message/taskInboxOwnership.js";
 import { operationalTaskRecords } from "./taskRecordRetirement.js";
-/** Mailbox refs locate original durable user intent. No separate acknowledgement
- * state is introduced: finish the current native turn and let the existing
- * notification delivery present the new input before declaring completion. */
+/** Mailbox refs locate original durable user intent. Active inbox handling
+ * retains the same completion fence until the exact window is acknowledged. */
 export function pendingCompletionMessages(store, taskId) {
     const mailbox = store.getWorkMailbox({ kind: "role", taskId, roleName: "leader" });
     const refs = [...(mailbox?.pending?.refs ?? [])];
+    for (const wake of store.listTaskWakes(taskId)) {
+        if (wake.inbox?.ack === undefined)
+            refs.push(...(wake.refs ?? []));
+    }
     const processing = mailbox?.processing;
+    if (processing?.owner.startsWith("agent-inbox:"))
+        refs.push(...processing.batch.refs);
     if (processing?.owner.startsWith("leader-notification:")) {
         const native = store.getTaskRoleSessionSet(taskId, "leader")?.providerBinding?.run;
         if (native?.attemptId !== processing.batchId
@@ -16,7 +22,8 @@ export function pendingCompletionMessages(store, taskId) {
     }
     const ids = new Set(refs.filter(ref => ref.type === "message" && ref.taskId === taskId).map(ref => ref.id));
     return operationalTaskRecords(store.listMessages(taskId), store.listEvents(taskId), "message")
-        .filter(message => ids.has(message.id)
+        .filter(message => (ids.has(message.id) || isLeaderSteer(message) && message.inbox !== undefined)
+        && taskMessageInboxReceipt(store, message)?.ack === undefined
         && (message.kind === "user" || message.kind === "operator"));
 }
 const ACTIVE_JOB_STATUSES = new Set([
@@ -34,8 +41,8 @@ export function projectCompletionReadiness(facts) {
         blockers.push({
             code: "pending-user-input",
             ref: ref("message", message.id),
-            reason: `User message ${message.id} is still awaiting Leader delivery.`,
-            fix: `finish the current native turn, read the next notification and message ${message.id}, then reconsider completion`
+            reason: `User message ${message.id} is still awaiting Leader delivery or explicit handling.`,
+            fix: `read message ${message.id} and its inbox window; claim and acknowledge after handling, or finish this turn if delivery is still pending`
         });
     }
     // A pending/running Task-final Review must be resumed or blocked first.

package/dist/telemetry/sqliteTelemetryStore.js

@@ -1,4 +1,4 @@
-import Database from "better-sqlite3";
+import Database from "../sqlite/driver.js";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { CURRENT_DATABASE_FILENAME as COMMITTED_DATABASE_FILENAME } from "../storage/currentTaskStore.js";