@zq-silk/yui 2.5.0 → 2.7.1

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/taskExecutionProjection.js

@@ -5,6 +5,7 @@ import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
 import { mailboxBatches } from "../coordination/workMailbox.js";
 import { actionableExecutionLaneRecoveries, summarizeExecutionGroupHealth } from "../execution/executionHealth.js";
 import { buildTaskObservabilityProjection } from "./taskObservabilityProjection.js";
+import { projectTaskSessions } from "../runtime/taskSessions.js";
 import { isRoleRunStalled, latestStallProgressAt } from "./roleRunStall.js";
 import { resolveRuntimeHealth } from "../config/yuiConfig.js";
 import { projectSessionTokenMetrics, resolveSessionTokenIdentity } from "../runtime/sessionTokenMetrics.js";
@@ -13,7 +14,7 @@ import { projectSessionTokenMetrics, resolveSessionTokenIdentity } from "../runt
  * aggregate. This function only reads; it never starts a Controller, queues a
  * wake, writes a Message, or mutates any record.
  */
-export function buildTaskExecutionProjection(store, taskId, now = new Date()) {
+export function buildTaskExecutionProjection(store, taskId, now = new Date(), nativeSessions) {
     const task = store.getTask(taskId);
     if (task === null)
         return null;
@@ -23,6 +24,7 @@ export function buildTaskExecutionProjection(store, taskId, now = new Date()) {
     const workItems = store.listWorkItems(taskId);
     const reviewRounds = store.listReviewRounds(taskId);
     const runs = operationalTaskRecords(usageRuns, events, "run");
+    const brief = store.getTaskBrief(taskId);
     const leaderMailbox = store.getWorkMailbox({
         kind: "role",
         taskId,
@@ -36,6 +38,12 @@ export function buildTaskExecutionProjection(store, taskId, now = new Date()) {
     });
     return projectTaskExecution({
         task,
+        jobs: store.listDurableJobs(taskId),
+        nativeSessions: nativeSessions ?? projectTaskSessions({
+            taskId, sessionSets: store.listRoleSessionSets(taskId), events, now,
+            ...(brief?.updatedAt === undefined ? {} : { semanticProgressAt: brief.updatedAt }),
+            policy: resolveRuntimeHealth(store.getConfig().runtimeHealth)
+        }),
         usageFacts: store.readTaskUsageFacts(taskId),
         roles,
         runs,
@@ -56,7 +64,7 @@ export function buildTaskExecutionProjection(store, taskId, now = new Date()) {
         changeSets: store.listChangeSets(taskId),
         integrations: store.listIntegrationAttempts(taskId),
         events,
-        brief: store.getTaskBrief(taskId),
+        brief,
         pendingWakeup: store.getPendingWakeup(taskId),
         leaderMailbox,
         leaderFailure: store.getLeaderFailure(taskId),
@@ -118,8 +126,27 @@ export function projectTaskExecution(facts) {
         now
     });
     const laneRecovery = actionableExecutionLaneRecoveries(groupSummaries)[0];
+    const jobs = facts.jobs ?? [];
+    const native = facts.nativeSessions;
+    const activity = {
+        jobs: {
+            queued: jobs.filter(job => job.status === "queued").length,
+            running: jobs.filter(job => job.status === "running").length,
+            unknown: jobs.filter(job => job.status === "unknown-needs-attention").length
+        },
+        openInputs: inputRequests.filter(input => input.status === "open").length,
+        native: {
+            active: (native?.counts.active ?? 0) + (native?.counts.quiet ?? 0),
+            waiting: native?.counts.waiting ?? 0,
+            unknown: (native?.counts.unknown ?? 0) + (native?.counts.diagnostic ?? 0)
+                + (native?.sessions.reduce((sum, session) => sum
+                    + session.background.filter(child => child.execution === "unknown").length, 0) ?? 0),
+            background: native?.sessions.reduce((sum, session) => sum + session.background.length, 0) ?? 0
+        }
+    };
     const render = (input) => projection({
         ...input,
+        activity,
         executionGroups: groupSummaries,
         observability
     });
@@ -128,10 +155,12 @@ export function projectTaskExecution(facts) {
         const known = facts.runDelivery?.[run.id];
         if (known !== undefined && known !== "unobserved")
             return known;
-        const observed = events.map(runtimeObservationFromTaskEvent).filter((event) => event?.fence.runId === run.id && event.authority !== "transport"
+        const observed = events.map(runtimeObservationFromTaskEvent).filter((event) => event?.fence.runId === run.id && event.fence.taskId === task.id
+            && event.fence.roleName === run.roleName && event.fence.agentId === run.effective.agentId
+            && event.authority !== "transport"
             && ["turn.accepted", "turn.completed", "turn.failed", "turn.cancelled"].includes(event.kind)).at(-1);
         return observed === undefined || observed === null ? "unobserved"
-            : observed.kind.slice("run.".length);
+            : observed.kind.slice("turn.".length);
     };
     const runHasSession = (run) => roleSessions.some((session) => (session.roleName === run.roleName
         && session.agentId === run.effective.agentId
@@ -206,7 +235,7 @@ export function projectTaskExecution(facts) {
     const activeLeader = activeRuns.find((run) => run.roleName === "leader");
     const pendingDeliveryRuns = activeRuns.filter((run) => deliveryOf(run) !== "accepted");
     const hasPendingLeaderWork = pendingWakeup !== null
-        || leaderMailbox?.pending !== null;
+        || leaderMailbox?.pending != null;
     const recoveryPending = isRecoveryPending(pendingWakeup, leaderMailbox, leaderFailure);
     const providerRecoveries = (facts.providerRetries ?? []).filter(retry => retry.status === "waiting" || retry.status === "in-flight");
     const recoveringRunIds = new Set(providerRecoveries.flatMap(retry => [retry.previousRunId, retry.successorRunId].filter((id) => id !== undefined)));
@@ -257,13 +286,30 @@ export function projectTaskExecution(facts) {
             summary: openInputs[0].question,
             reason: "open-input-request",
             monitoring,
-            failClosed: false,
+            failClosed: activity.jobs.unknown > 0 || activity.native.unknown > 0,
             activeRuns: activeRunViews,
             attention,
             blockers,
             pendingWakeup
         });
     }
+    if (activity.jobs.unknown > 0 || activity.native.unknown > 0) {
+        return render({
+            task, status: "attention", owner: "leader", action: "inspect-attention",
+            summary: `${activity.jobs.unknown} Job(s) have unknown outcomes; ${activity.native.unknown} native observation(s) need attention. Other parallel activity remains visible; do not infer completion or replay.`,
+            reason: "parallel-execution-unknown", monitoring, failClosed: true,
+            activeRuns: activeRunViews, attention, blockers, pendingWakeup
+        });
+    }
+    const nativeWait = native?.sessions.find(session => session.group === "waiting" && ["user", "permission"].includes(session.waitingReason ?? ""));
+    if (nativeWait) {
+        return render({
+            task, status: "waiting-user", owner: "user", action: "inspect-attention",
+            summary: `Native Session ${nativeWait.roleName} is waiting for ${nativeWait.waitingReason}; other activity remains visible.`,
+            reason: "native-input-wait", monitoring, failClosed: false,
+            activeRuns: activeRunViews, attention, blockers, pendingWakeup
+        });
+    }
     if (laneRecovery !== undefined && (laneRecovery.runId === undefined || !recoveringRunIds.has(laneRecovery.runId))) {
         return render({
             task,
@@ -382,6 +428,15 @@ export function projectTaskExecution(facts) {
             pendingWakeup
         });
     }
+    if (native?.sessions.some(session => session.roleName === "leader"
+        && ["active", "quiet"].includes(session.group))) {
+        return render({
+            task, status: "working", owner: "leader", action: "advance-task",
+            summary: "Leader native input is accepted; managed AgentRuns and parallel background work remain separate facts.",
+            reason: "leader-native-turn", monitoring, failClosed: false,
+            activeRuns: activeRunViews, attention, blockers, pendingWakeup
+        });
+    }
     if (hasPendingLeaderWork) {
         return render({
             task,
@@ -449,6 +504,22 @@ export function projectTaskExecution(facts) {
             pendingWakeup
         });
     }
+    if (activity.jobs.queued + activity.jobs.running > 0) {
+        return render({
+            task, status: "waiting-on-jobs", owner: "none", action: "wait-for-jobs",
+            summary: `${activity.jobs.running} background Job(s) running; ${activity.jobs.queued} queued. Leader is not currently executing.`,
+            reason: "background-jobs", monitoring, failClosed: false,
+            activeRuns: activeRunViews, attention, blockers, pendingWakeup
+        });
+    }
+    if (activity.native.active + activity.native.waiting + activity.native.background > 0) {
+        return render({
+            task, status: "waiting-on-agents", owner: "none", action: "wait-for-agents",
+            summary: "Recorded native execution or retained background activity remains unsettled; this is separate from managed AgentRuns.",
+            reason: "native-execution", monitoring, failClosed: false,
+            activeRuns: activeRunViews, attention, blockers, pendingWakeup
+        });
+    }
     if (candidateReady || unresolvedIntegration) {
         return render({
             task,
@@ -496,6 +567,7 @@ function projection(input) {
         monitoring: input.monitoring,
         failClosed: input.failClosed,
         activeRuns: input.activeRuns,
+        activity: input.activity,
         executionGroups: input.executionGroups ?? [],
         observability: input.observability,
         attention: input.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/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,16 @@ 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: ""
     }]);
 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 { 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);
+            assertInboxReceiptPreserved(existing === undefined ? undefined
+                : this.#parse(existing.payload).inbox, message.inbox);
             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);
+            assertInboxReceiptPreserved(existing === undefined ? undefined
+                : this.#parse(existing.payload).inbox, message.inbox);
             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,10 @@ 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);
+            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.7";
 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/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 !== undefined && 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([

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";

package/dist/web/assets/assetManifest.js

@@ -4,6 +4,7 @@
 import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { APP_SCRIPT, CLIENT_MODULES } from "./client/index.js";
+import { THEME_BOOTSTRAP_SCRIPT } from "./client/lib/theme.js";
 import { FONT_WOFF2_BASE64 } from "./fontData.js";
 import { DASHBOARD_HTML } from "./shell/index.js";
 import { STYLESHEETS } from "./styles/index.js";
@@ -13,6 +14,7 @@ const JS = "text/javascript; charset=utf-8";
 export const WEB_ASSETS = Object.freeze({
     ...Object.fromEntries(STYLESHEETS.map(({ name, body }) => [`/assets/css/${name}.css`, { contentType: CSS, body }])),
     ...Object.fromEntries(Object.entries(CLIENT_MODULES).map(([path, body]) => [`/assets/js/${path}.js`, { contentType: JS, body }])),
+    "/assets/theme.js": { contentType: JS, body: THEME_BOOTSTRAP_SCRIPT },
     "/assets/app.js": { contentType: JS, body: APP_SCRIPT },
     ...fontAssets(),
     "/assets/vendor/xterm.mjs": vendorAsset("@xterm/xterm/lib/xterm.mjs", JS),

package/dist/web/assets/client/app/taskView.js

@@ -154,6 +154,7 @@ function detailContext(view) {
     taskAction: deps.api.taskAction,
     inspect: api.inspect,
     list: api.list,
+    activity: api.activity,
     artifacts: api.artifacts,
     readArtifact: api.artifact,
     evidence: api.evidence,

package/dist/web/assets/client/domain/records.js

@@ -4,9 +4,77 @@ export const RECORDS_SCRIPT = String.raw `
 // never acknowledges or accepts anything.
 import { h, icon } from "/assets/js/lib/dom.js";
 import { button, jsonBlock, mono, note } from "/assets/js/ui/primitives.js";
-import { rawDisclosure } from "/assets/js/ui/containers.js";
+import { rawDisclosure, listCard, setCardCount } from "/assets/js/ui/containers.js";
 import { richText } from "/assets/js/ui/text.js";
-import { cachedExact, readExact, summaryFields } from "/assets/js/domain/context.js";
+import { cachedExact, readExact, summaryFields, entriesOf, totalOf, exactCache } from "/assets/js/domain/context.js";
+
+// Current-family counts and pages use exactly the Context current filter.
+// A changed Context revalidates already-loaded membership with one bounded
+// page. Only the family's own digest invalidates its pages, not unrelated
+// runtime events. Loading a list does not eagerly inspect its bodies.
+export function currentRecordCard(data, store, t, actions, options) {
+  const view = data.viewState;
+  exactCache(view);
+  view.openRows = view.openRows || {};
+  view.currentLists = view.currentLists || {};
+  let state = view.currentLists[store];
+  if (!state || (!state.started && state.key !== data.core.coreCursor)) {
+    state = view.currentLists[store] = {
+      key: data.core.coreCursor, items: entriesOf(data.core, store),
+      total: totalOf(data.core, store), started: false, cursor: null, error: null, pending: false
+    };
+  }
+  const revalidate = state.key !== data.core.coreCursor;
+  state.key = data.core.coreCursor;
+  const element = listCard({ id: options.id, title: options.title, icon: options.icon || "pulse", count: state.total });
+  const rows = h("div.stack"), footer = h("div.stack", { "aria-live": "polite" });
+  element.list.append(rows, footer);
+  function draw(updateRows) {
+    setCardCount(element, state.total);
+    if (updateRows !== false) {
+      rows.replaceChildren();
+      state.items.forEach(function (item) {
+        rows.append(!item.omitted && item.value && options.render ? options.render(item.value, null, item)
+          : lazyRow(item, data.task.id, t, actions, {
+            cache: view.exact,
+            openRows: view.openRows,
+            head: h("span", null, item.ref.refId + (item.summary ? " · " + item.summary : "")),
+            render: options.render
+          }));
+      });
+    }
+    footer.replaceChildren(note(t("activity.loaded") + " " + state.items.length + " / " + state.total));
+    if (!state.total) footer.append(note(t("activity.none")));
+    if (state.error) footer.append(note(state.error + " · " + t("activity.refreshHint"), "bad"));
+    if ((!state.started && state.items.length < state.total) || state.cursor) {
+      footer.append(button(t("activity.more") + " (" + Math.max(0, state.total - state.items.length) + ")", {
+        disabled: state.pending, onClick: function () { load(state.started); }
+      }));
+    }
+    footer.append(button(t("activity.refresh"), { disabled: state.pending, onClick: function () { load(false); } }));
+    element.dataset.reading = String(state.pending);
+  }
+  async function load(more) {
+    if (state.pending) return;
+    const busy = function () { return !!rows.querySelector('[data-unsent="true"], [data-reading="true"]'); };
+    if (busy()) { state.error = t("activity.busy"); draw(false); return; }
+    state.pending = true;
+    draw(false);
+    try {
+      const page = await actions.list(data.task.id, store, { view: "current", limit: 20, cursor: more ? state.cursor : null });
+      if (busy()) throw new Error(t("activity.busy"));
+      if (more || !state.started || state.digest !== page.digest) {
+        state.items = more ? state.items.concat(page.items) : page.items;
+        state.cursor = page.nextCursor;
+      }
+      state.digest = page.digest; state.total = page.total; state.started = true; state.error = null;
+    } catch (error) { state.error = error.message; }
+    finally { state.pending = false; draw(!state.error); }
+  }
+  draw();
+  if (revalidate) load(false);
+  return element;
+}
 
 // A row drawn from its exact value: synchronously when cached, otherwise the
 // summary card until the read returns and replaces it in place.