@zq-silk/yui 2.17.0 → 2.18.0

package/dist/message/globalInboxRecovery.js

@@ -4,28 +4,39 @@ import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/
 import { currentProviderConversation } from "../runtime/providerRuntimeIdentity.js";
 import { INBOX_CHECK_PREFIX } from "./inboxTurn.js";
 const requestId = (agentId, nativeSessionId) => `${INBOX_CHECK_PREFIX}recovery:${createHash("sha256").update(JSON.stringify([agentId, nativeSessionId])).digest("hex")}`;
+function recoveryCandidate(store, roleName) {
+    const sessions = store.getGlobalRoleSessionSet(roleName);
+    const session = sessions?.sessions[sessions.activeAgentId];
+    const binding = sessions?.providerBinding;
+    if (!session || session.status !== "active" || !session.nativeSessionId || !binding
+        || binding.authority.owner !== "controller"
+        || currentProviderConversation(binding).conversationId !== session.nativeSessionId
+        || binding.run && ["submitting", "accepted", "delivery-unknown"].includes(binding.run.status)
+        || hasRuntimeCleanupObligation(store.getWorkMailbox(runtimeLifecycleTarget({ scope: "global", roleName }))))
+        return;
+    if (store.queryGlobalRoleMessages(roleName, { handling: true, handlingExceptSession: {
+            agentId: session.agentId, nativeSessionId: session.nativeSessionId
+        }, limit: 0 }).count === 0)
+        return;
+    const id = requestId(session.agentId, session.nativeSessionId);
+    return { id, agentId: session.agentId, nativeSessionId: session.nativeSessionId,
+        existing: store.queryGlobalRoleMessages(roleName, { requestId: id, limit: 1 }).messages[0] };
+}
 /** Derive a single initialization notice from existing retained claims. New
  * Sessions are created only by the existing authorized lifecycle path. A
  * restart can finish notice creation, but cannot select or replace a Session. */
 export function globalInboxRecovery(store, roleName, now) {
+    // The common idle/already-notified path must not reserve SQLite's writer.
+    // This snapshot is only a preflight; creation rechecks all authority, cleanup
+    // and retained-claim facts in the original atomic transaction.
+    const candidate = store.readTransaction(tx => recoveryCandidate(tx, roleName));
+    if (!candidate || candidate.existing)
+        return candidate?.existing;
     return store.transaction(tx => {
-        const sessions = tx.getGlobalRoleSessionSet(roleName);
-        const session = sessions?.sessions[sessions.activeAgentId];
-        const binding = sessions?.providerBinding;
-        if (!session || session.status !== "active" || !session.nativeSessionId || !binding
-            || binding.authority.owner !== "controller"
-            || currentProviderConversation(binding).conversationId !== session.nativeSessionId
-            || binding.run && ["submitting", "accepted", "delivery-unknown"].includes(binding.run.status)
-            || hasRuntimeCleanupObligation(tx.getWorkMailbox(runtimeLifecycleTarget({ scope: "global", roleName }))))
-            return;
-        if (tx.queryGlobalRoleMessages(roleName, { handling: true, handlingExceptSession: {
-                agentId: session.agentId, nativeSessionId: session.nativeSessionId
-            }, limit: 0 }).count === 0)
-            return;
-        const id = requestId(session.agentId, session.nativeSessionId);
-        const existing = tx.queryGlobalRoleMessages(roleName, { requestId: id, limit: 1 }).messages[0];
-        if (existing)
-            return existing;
+        const latest = recoveryCandidate(tx, roleName);
+        if (!latest || latest.existing)
+            return latest?.existing;
+        const { id, agentId, nativeSessionId } = latest;
         const notice = {
             ...createGlobalRoleMessage(tx.nextGlobalRoleMessageId(), roleName, [
                 "Yui-Summary: This successor has retained inbox handling obligations; inspect original evidence before settlement.",
@@ -34,9 +45,9 @@ export function globalInboxRecovery(store, roleName, now) {
                 "After handling under current authority, explicitly acknowledge the original entry without replacing its claim.",
                 "Uncertain external effects require verification or a real user decision. New queued input remains separate."
             ].join("\n"), "system", { type: "system" }, now, {
-                inputControl: { action: "queue", requestId: id, expectedSessionId: session.nativeSessionId }
+                inputControl: { action: "queue", requestId: id, expectedSessionId: nativeSessionId }
             }),
-            deliveryTarget: { agentId: session.agentId, nativeSessionId: session.nativeSessionId }
+            deliveryTarget: { agentId, nativeSessionId }
         };
         tx.saveGlobalRoleMessage(notice);
         return notice;

package/dist/message/globalProviderRetry.js

@@ -2,6 +2,12 @@ import { markGlobalRoleMessageNotDelivered } from "./message.js";
 /** Settle the original queue entry when recovery ends with exact nondelivery.
  * Cancellation of a submitted/unknown request is not negative Provider proof. */
 export function settleGlobalRetryInput(store, roleName, binding, now) {
+    const settlement = globalRetryInputSettlement(store, roleName, binding, now);
+    if (settlement !== undefined)
+        store.updateGlobalRoleMessage(settlement);
+}
+/** Read-only proposal; callers applying it must recheck under their transaction. */
+export function globalRetryInputSettlement(store, roleName, binding, now) {
     const retry = binding?.retry;
     if (retry === undefined || retry.input.kind !== "message" || retry.input.roleName !== roleName
         || !["cancelled", "exhausted", "needs-attention"].includes(retry.status)
@@ -11,5 +17,5 @@ export function settleGlobalRetryInput(store, roleName, binding, now) {
     const message = store.listGlobalRoleMessages(roleName).find(m => m.id === messageId);
     if (message === undefined || message.delivery !== undefined || message.notDelivered !== undefined)
         return;
-    store.updateGlobalRoleMessage(markGlobalRoleMessageNotDelivered(message, `provider-retry-${retry.status}: ${retry.reason ?? retry.failureRef}`, now));
+    return markGlobalRoleMessageNotDelivered(message, `provider-retry-${retry.status}: ${retry.reason ?? retry.failureRef}`, now);
 }

package/dist/runtime/builtinAgentErrorMappers.js

@@ -30,6 +30,10 @@ export function mapCodexAgentError(input) {
 }
 function mapCodexDisplayError(input) {
     const text = `${input.message}\n${input.raw}`;
+    if (/Codex Session availability is systemError; no input was submitted\./u.test(text)) {
+        return { category: "session", code: "provider.session-system-error",
+            inputDisposition: "not-accepted", sessionDisposition: "unknown" };
+    }
     if (/^server_error$/iu.test(input.message)) {
         return recoverable("availability", "provider.server-error");
     }

package/dist/runtime/globalSessionHealth.js

@@ -0,0 +1,39 @@
+import { currentProviderConversation } from "./providerRuntimeIdentity.js";
+import { providerRetrySummary } from "./providerRetry.js";
+/** Read-only provenance. Writer selection is not live Host/transport health. */
+export function globalSessionHealth(role, sessions) {
+    const session = sessions?.sessions[role.activeAgentId];
+    const binding = sessions?.providerBinding;
+    const matches = session !== undefined && binding != null
+        && sessions?.activeAgentId === role.activeAgentId
+        && currentProviderConversation(binding).conversationId === session.nativeSessionId;
+    // Conversation replacement retains the terminal Turn as audit evidence while
+    // advancing writer authority. Matching the new conversation alone is insufficient.
+    const turnMatches = matches && binding.run?.authorityEpoch === binding.authority.epoch;
+    const turn = turnMatches ? binding.run : null;
+    const retry = matches && binding.retry?.nativeSessionId === session?.nativeSessionId
+        && binding.retry?.authorityEpoch === binding.authority.epoch
+        ? providerRetrySummary(binding) : null;
+    const failure = turn?.status === "failed" || turn?.status === "rejected" ? turn.failure : undefined;
+    return {
+        desiredRevision: role.launchRevision,
+        effectiveRevision: session?.effective.sourceDesiredRevision ?? null,
+        configurationDrift: session === undefined ? null
+            : session.effective.sourceDesiredRevision !== role.launchRevision,
+        nativeSessionId: session?.nativeSessionId ?? null,
+        nativeTurn: turn == null ? null : {
+            attemptId: turn.attemptId, nativeTurnId: turn.nativeTurnId, status: turn.status
+        },
+        currentFailure: failure === undefined ? null : {
+            ref: failure.ref, source: failure.error.source, phase: failure.error.phase,
+            category: failure.error.category, code: failure.error.code,
+            inputDisposition: failure.error.inputDisposition,
+            sessionDisposition: failure.error.sessionDisposition
+        },
+        retry,
+        historicalBinding: binding != null && (!matches || (binding.run !== null && !turnMatches)),
+        hostObservation: "unobserved",
+        note: "Selected/active writer state is not delivery or terminal-observation health. "
+            + "Inspect exact Host capabilities and runtime diagnostics; Controller restart does not refresh a live Host."
+    };
+}

package/dist/scheduler/roleRunStall.js

@@ -460,9 +460,9 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
     if (stallCandidates.length === 0)
         return [];
     const diagnosticStartedAt = now.toISOString();
-    const finishDiagnostics = (outcome) => {
+    const finishDiagnostics = async (outcome) => {
         for (const { task, role, run } of stallCandidates) {
-            store.recordRoleRunDiagnostic({
+            await store.recordRoleRunDiagnostic({
                 taskId: task.id,
                 roleName: role.name,
                 runId: run.id,
@@ -523,7 +523,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
             // Health inspection is advisory. Unknown host state must leave the exact
             // AgentRun/Session fence untouched. Closing this window schedules the next
             // bounded diagnostic thirty minutes later instead of hot-looping.
-            finishDiagnostics("observation-error");
+            await finishDiagnostics("observation-error");
             return [];
         }
     }
@@ -535,7 +535,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
         catch {
             // A malformed/partial provider snapshot is not evidence of a stall.
             // Leave all fences untouched and let the next full pass retry.
-            finishDiagnostics("observation-error");
+            await finishDiagnostics("observation-error");
             return [];
         }
     }
@@ -550,7 +550,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
         let live;
         try {
             if (liveStatuses !== undefined && !liveStatuses.has(key)) {
-                finishDiagnostics("observation-error");
+                await finishDiagnostics("observation-error");
                 return [];
             }
             live = liveStatuses !== undefined
@@ -571,7 +571,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
             // Without a complete live snapshot, especially for downstream AgentRuns,
             // Leader classification would be unsafe. Treat the whole advisory pass
             // as unknown instead of escalating a false stall.
-            finishDiagnostics("observation-error");
+            await finishDiagnostics("observation-error");
             return [];
         }
         // A missing process is handled by the existing fenced liveness pass. This
@@ -669,7 +669,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
             // A new semantic progress point closes the previous episode first. It
             // may itself already be older than the window, in which case the same
             // pass records the next AgentRun+progressAt episode below.
-            store.recordRoleRunProgress({
+            await store.recordRoleRunProgress({
                 taskId: candidate.task.id,
                 roleName: candidate.role.name,
                 runId: candidate.run.id,
@@ -702,7 +702,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
         // diagnostic context, not duplicated as another Task-level alert.
         if (previous?.progressAt === progressAt)
             continue;
-        const persisted = store.recordRoleRunStall({
+        const persisted = await store.recordRoleRunStall({
             taskId: candidate.task.id,
             roleName: candidate.role.name,
             runId: candidate.run.id,
@@ -738,7 +738,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
         const previous = store.getRunProgressFacts(candidate.task.id, candidate.run.id)?.latestStall;
         if (previous !== undefined
             && Date.parse(progressAt) > Date.parse(previous.progressAt)) {
-            store.recordRoleRunProgress({
+            await store.recordRoleRunProgress({
                 taskId: candidate.task.id,
                 roleName: candidate.role.name,
                 runId: candidate.run.id,
@@ -748,7 +748,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
             });
         }
     }
-    finishDiagnostics("observed");
+    await finishDiagnostics("observed");
     return raised;
 }
 function isStallCandidate(run, now, windowMs, lastDiagnosticFinishedAt, latestProgressAt) {

package/dist/storage/persistenceWorker.js

@@ -33,6 +33,8 @@
 import { runRpcWorker } from "../core/boundedRpc.js";
 import { SqliteTaskStore } from "./sqliteStore.js";
 import { StorageRecordError } from "./taskStore.js";
+import { randomUUID } from "node:crypto";
+import { ControllerWorkObserver, compactWorkObservation } from "../core/controllerTelemetry.js";
 // -- method invocation -------------------------------------------------------
 function invokeMethod(target, method, args) {
     const fn = target[method];
@@ -41,6 +43,13 @@ function invokeMethod(target, method, args) {
     }
     return fn.apply(target, args);
 }
+const workerInstance = randomUUID();
+const work = new ControllerWorkObserver();
+function observation() {
+    return { instance: workerInstance, work: compactWorkObservation(work),
+        database: state.writer?.storageObservationMetrics() ?? null,
+        reads: state.observer?.compactReadObservationMetrics?.() ?? null };
+}
 /**
  * Sentinel returned by a handler when the durable outbox already records the
  * request's effect (§5.4). The host's `result` builder maps it to an
@@ -80,7 +89,10 @@ async function handleInit(request) {
         state.observer = {
             invoke(method, args) {
                 return invokeMethod(host, method, args);
-            }
+            },
+            ...(host.compactReadObservationMetrics === undefined ? {} : {
+                compactReadObservationMetrics: () => host.compactReadObservationMetrics()
+            })
         };
     }
 }
@@ -162,21 +174,31 @@ runRpcWorker({
     },
     init: (request) => handleInit(request),
     handle: async (request) => {
-        switch (request.kind) {
-            case "call":
-                return handleCall(request);
-            case "transaction":
-                return handleTransaction(request);
-            case "observer":
-                return handleObserver(request);
-            case "telemetry":
-                if (state.writer === undefined)
-                    throw new Error("Worker not initialized.");
-                return state.writer.flushTelemetry(request.entries, request.runCap);
-            case "init":
-            case "cancel":
-            case "shutdown":
-                throw new Error(`Unexpected request kind for handle: ${request.kind}`);
+        const finish = work.start(request.kind, "requestId" in request ? request.requestId : undefined);
+        try {
+            switch (request.kind) {
+                case "call":
+                    return await handleCall(request);
+                case "transaction":
+                    return await handleTransaction(request);
+                case "observer":
+                    return await handleObserver(request);
+                case "telemetry":
+                    if (state.writer === undefined)
+                        throw new Error("Worker not initialized.");
+                    return state.writer.flushTelemetry(request.entries, request.runCap);
+                case "init":
+                case "cancel":
+                case "shutdown":
+                    throw new Error(`Unexpected request kind for handle: ${request.kind}`);
+            }
+        }
+        catch (error) {
+            finish(true);
+            throw error;
+        }
+        finally {
+            finish();
         }
     },
     cancel: (requestId) => {
@@ -196,7 +218,7 @@ runRpcWorker({
     },
     ready: () => ({ kind: "ready" }),
     result: (requestId, value) => (value === ALREADY_APPLIED
-        ? { kind: "already-applied", requestId }
-        : { kind: "result", requestId, result: value }),
-    error: (requestId, error) => ({ kind: "error", requestId, error })
+        ? { kind: "already-applied", requestId, observation: observation() }
+        : { kind: "result", requestId, result: value, observation: observation() }),
+    error: (requestId, error) => ({ kind: "error", requestId, error, observation: observation() })
 });

package/dist/storage/sqliteSchema.js

@@ -5,6 +5,7 @@ import { migrateTaskMainWorkspaces } from "./upgrade/taskMainWorkspaceMigration.
 import { migrateProjectKnowledge } from "./upgrade/projectKnowledgeMigration.js";
 import { JOB_SCHEMA_SQL } from "./jobSchema.js";
 import { AGENT_JOB_SCHEMA_SQL } from "./agentJobSchema.js";
+import { TASK_READ_REVISION_SCHEMA_SQL } from "./taskReadRevisionSchema.js";
 import { SCHEDULE_SCHEMA_SQL } from "./scheduleSchema.js";
 import { GLOBAL_SESSION_TABLE_SQL, SESSION_HISTORY_UPGRADE_SQL } from "./sessionHistorySchema.js";
 import { migrateJobDefinitions } from "./upgrade/jobDefinitionMigration.js";
@@ -13,7 +14,7 @@ import { migrateScheduleDispatch } from "./upgrade/scheduleDispatchMigration.js"
 import { migrateProjectSyncClock } from "./upgrade/projectSyncClockMigration.js";
 import { CURRENT_STORAGE_VERSION, MIN_SUPPORTED_STORAGE_VERSION, STORAGE_FORMAT, isMinorStorageUpgrade, isStorageVersion, storageVersionParts } from "./storageVersions.js";
 export { BASELINE_SCHEMA_SQL };
-export const SQLITE_SCHEMA_TABLES = [...BASELINE_SCHEMA_TABLES, "job_definitions", "global_job_runs", "schedules", "agent_job_runs"];
+export const SQLITE_SCHEMA_TABLES = [...BASELINE_SCHEMA_TABLES, "job_definitions", "global_job_runs", "schedules", "agent_job_runs", "task_read_revisions"];
 export const TELEMETRY_KEEP_PER_RUN = 200;
 export const TELEMETRY_RUN_CAP = 50_000;
 export const BASELINE_SCHEMA_CHECKSUM = createHash("sha256").update(BASELINE_SCHEMA_SQL).digest("hex");
@@ -23,7 +24,9 @@ export const SCHEDULE_SCHEMA_CHECKSUM = createHash("sha256").update(SCHEDULE_SCH
 // Fresh Homes create the final layout directly; published baseline SQL stays immutable.
 const SESSION_SCHEMA_SQL = SCHEDULE_SCHEMA_SQL_COMPLETE.replace(/CREATE TABLE global_role_session_sets \([\s\S]*?\n\);/, GLOBAL_SESSION_TABLE_SQL);
 const SESSION_SCHEMA_CHECKSUM = createHash("sha256").update(SESSION_SCHEMA_SQL).digest("hex");
-export const CURRENT_SCHEMA_SQL = SESSION_SCHEMA_SQL + AGENT_JOB_SCHEMA_SQL;
+export const PRE_READ_REVISION_SCHEMA_SQL = SESSION_SCHEMA_SQL + AGENT_JOB_SCHEMA_SQL;
+const PRE_READ_REVISION_SCHEMA_CHECKSUM = createHash("sha256").update(PRE_READ_REVISION_SCHEMA_SQL).digest("hex");
+export const CURRENT_SCHEMA_SQL = PRE_READ_REVISION_SCHEMA_SQL + TASK_READ_REVISION_SCHEMA_SQL;
 export const CURRENT_SCHEMA_CHECKSUM = createHash("sha256").update(CURRENT_SCHEMA_SQL).digest("hex");
 export class SqliteSchemaError extends Error {
     code;
@@ -230,7 +233,7 @@ const MINOR_UPGRADES = Object.freeze([{
         name: "job-agent-execution",
         introducedIn: "next",
         sourceChecksum: SESSION_SCHEMA_CHECKSUM,
-        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        targetChecksum: PRE_READ_REVISION_SCHEMA_CHECKSUM,
         // Existing records and immutable artifacts remain byte-for-byte unchanged.
         // Declares Agent definitions/Runs and optional Job ownership of a non-Task Role.
         sql: AGENT_JOB_SCHEMA_SQL
@@ -239,8 +242,8 @@ const MINOR_UPGRADES = Object.freeze([{
         toVersion: "1.21",
         name: "project-sync-clock",
         introducedIn: "next",
-        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
-        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        sourceChecksum: PRE_READ_REVISION_SCHEMA_CHECKSUM,
+        targetChecksum: PRE_READ_REVISION_SCHEMA_CHECKSUM,
         sql: "",
         dataMigration: "project-sync-clock"
     }, {
@@ -248,11 +251,31 @@ const MINOR_UPGRADES = Object.freeze([{
         toVersion: "1.22",
         name: "role-profile-availability",
         introducedIn: "next",
-        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
-        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        sourceChecksum: PRE_READ_REVISION_SCHEMA_CHECKSUM,
+        targetChecksum: PRE_READ_REVISION_SCHEMA_CHECKSUM,
         // Optional enabled flag; absence means enabled. Preserve all historical
         // Role/Profile bytes, frozen contexts and Session snapshots.
         sql: ""
+    }, {
+        fromVersion: "1.22",
+        toVersion: "1.23",
+        name: "global-shell-scripts",
+        introducedIn: "next",
+        sourceChecksum: PRE_READ_REVISION_SCHEMA_CHECKSUM,
+        targetChecksum: PRE_READ_REVISION_SCHEMA_CHECKSUM,
+        // Additive global Shell definitions with revisioned script text and exact
+        // Run snapshots. Historical definitions/Runs stay byte-for-byte unchanged.
+        sql: ""
+    }, {
+        fromVersion: "1.23",
+        toVersion: "1.24",
+        name: "task-read-revisions",
+        introducedIn: "next",
+        sourceChecksum: PRE_READ_REVISION_SCHEMA_CHECKSUM,
+        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        // No payload rewriting or historical revision invention. A newly opened
+        // reader starts empty; zero is the initial token until the first mutation.
+        sql: TASK_READ_REVISION_SCHEMA_SQL
     }]);
 export function storageMinorUpgradePlan(from) {
     if (from === CURRENT_STORAGE_VERSION)
@@ -282,10 +305,11 @@ export function validateSqliteSchemaObjects(db, version = CURRENT_STORAGE_VERSIO
     const checksum = version === CURRENT_STORAGE_VERSION
         ? CURRENT_SCHEMA_CHECKSUM : storageMinorUpgradePlan(version)?.[0]?.sourceChecksum;
     const sql = checksum === CURRENT_SCHEMA_CHECKSUM ? CURRENT_SCHEMA_SQL
-        : checksum === SESSION_SCHEMA_CHECKSUM ? SESSION_SCHEMA_SQL
-            : checksum === SCHEDULE_SCHEMA_CHECKSUM ? SCHEDULE_SCHEMA_SQL_COMPLETE
-                : checksum === JOB_SCHEMA_CHECKSUM ? BASELINE_SCHEMA_SQL + JOB_SCHEMA_SQL
-                    : checksum === BASELINE_SCHEMA_CHECKSUM ? BASELINE_SCHEMA_SQL : undefined;
+        : checksum === PRE_READ_REVISION_SCHEMA_CHECKSUM ? PRE_READ_REVISION_SCHEMA_SQL
+            : checksum === SESSION_SCHEMA_CHECKSUM ? SESSION_SCHEMA_SQL
+                : checksum === SCHEDULE_SCHEMA_CHECKSUM ? SCHEDULE_SCHEMA_SQL_COMPLETE
+                    : checksum === JOB_SCHEMA_CHECKSUM ? BASELINE_SCHEMA_SQL + JOB_SCHEMA_SQL
+                        : checksum === BASELINE_SCHEMA_CHECKSUM ? BASELINE_SCHEMA_SQL : undefined;
     if (sql === undefined || checksum === undefined)
         throw new SqliteSchemaError(`unsupported schema definition for storage ${version}.`);
     let expectedObjects = schemaObjectsByChecksum.get(checksum);

package/dist/storage/sqliteStore.js

@@ -34,6 +34,7 @@ import { validateAgentJobRun, assertAgentJobRunTransition } from "../job/agentJo
  * in-process contract or deferred validation phase.
  */
 import Database from "../sqlite/driver.js";
+import { ControllerWorkObserver, compactWorkObservation } from "../core/controllerTelemetry.js";
 import { findNativeSessionSets } from "./nativeSessionLookup.js";
 import { existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
@@ -141,10 +142,37 @@ function assertRunAdmission(task, run) {
     }
 }
 export class SqliteTaskStore {
+    #payloadReads = new ControllerWorkObserver();
+    #transactions = {
+        "write-lock": new ControllerWorkObserver(),
+        "write-body": new ControllerWorkObserver(),
+        "transaction-commit": new ControllerWorkObserver()
+    };
+    storageObservationMetrics() {
+        return {
+            lock: compactWorkObservation(this.#transactions["write-lock"]),
+            body: compactWorkObservation(this.#transactions["write-body"]),
+            commit: compactWorkObservation(this.#transactions["transaction-commit"]),
+            payloadReads: compactWorkObservation(this.#payloadReads)
+        };
+    }
+    #observeTransaction(phase, action) {
+        const finish = this.#transactions[phase].start(phase);
+        try {
+            const result = action();
+            finish();
+            return result;
+        }
+        catch (error) {
+            finish(true);
+            throw error;
+        }
+    }
     #db;
     #rootDir;
     #openedSchemaHead;
     #inTransaction = false;
+    #writeTransaction = false;
     #dirty = false;
     constructor(rootDir, _options = {}) {
         this.#rootDir = rootDir;
@@ -261,6 +289,13 @@ export class SqliteTaskStore {
     listEventsByType(taskId, types) {
         return this.#sortById(this.#listPayload("events", "task_id = ? AND type IN (SELECT value FROM json_each(?))", [taskId, JSON.stringify(types)]), event => event.id);
     }
+    hasRuntimeObservation(taskId, identity) {
+        const byEvent = "eventId" in identity;
+        return this.#db.prepare(`SELECT 1 FROM events WHERE task_id = ?
+      AND type = 'runtime.observation'
+      AND json_extract(payload, '${byEvent ? "$.payload.eventId" : "$.payload.semanticKey"}') = ?
+      LIMIT 1`).get(taskId, byEvent ? identity.eventId : identity.semanticKey) !== undefined;
+    }
     readTaskUsageFacts(taskId) {
         // Bounded source selection, not a scan/deserialization of Task history.
         // Strip result bodies before they cross the SQLite boundary.
@@ -348,13 +383,15 @@ export class SqliteTaskStore {
         writeTelemetryBatch(this.#db, entries, runCap);
     }
     #begin() {
-        this.#db.exec("BEGIN IMMEDIATE");
+        this.#observeTransaction("write-lock", () => this.#db.exec("BEGIN IMMEDIATE"));
         this.#inTransaction = true;
+        this.#writeTransaction = true;
         this.#dirty = false;
     }
     #commit() {
-        this.#db.exec("COMMIT");
+        this.#observeTransaction("transaction-commit", () => this.#db.exec("COMMIT"));
         this.#inTransaction = false;
+        this.#writeTransaction = false;
         this.#dirty = false;
     }
     #rollback() {
@@ -363,6 +400,7 @@ export class SqliteTaskStore {
         }
         catch { /* already closed */ }
         this.#inTransaction = false;
+        this.#writeTransaction = false;
         this.#dirty = false;
     }
     /** Verify the SQLite schema head at the single write boundary. */
@@ -393,7 +431,7 @@ export class SqliteTaskStore {
         this.#begin();
         try {
             this.#prepareWrite();
-            const result = fn();
+            const result = this.#observeTransaction("write-body", fn);
             this.#bumpRevision();
             this.#commit();
             return result;
@@ -413,7 +451,7 @@ export class SqliteTaskStore {
             // This prevents a long-lived Store from executing SQL after the database
             // schema head has changed underneath it.
             this.#prepareWrite();
-            const result = run(this);
+            const result = this.#observeTransaction("write-body", () => run(this));
             if (this.#dirty) {
                 if (options?.requestId !== undefined) {
                     this.#insertOutbox(options.requestId, options.outboxCommand ?? null);
@@ -438,7 +476,7 @@ export class SqliteTaskStore {
         this.#begin();
         try {
             this.#prepareWrite();
-            const result = await execute(this);
+            const result = await this.#transactions["write-body"].observe("write-body", undefined, () => execute(this));
             if (this.#dirty)
                 this.#bumpRevision();
             this.#commit();
@@ -472,7 +510,7 @@ export class SqliteTaskStore {
             if (current !== expectedRevision) {
                 throw new StorageConflictError(`Storage revision conflict (expected ${expectedRevision}, found ${current}).`, current);
             }
-            const result = execute(this);
+            const result = this.#observeTransaction("write-body", () => execute(this));
             if (this.#dirty) {
                 this.#prepareWrite();
                 if (options?.requestId !== undefined) {
@@ -496,6 +534,13 @@ export class SqliteTaskStore {
         return row.revision;
     }
     getStateRevision() { return this.getRevision(); }
+    getTaskReadRevision(taskId) {
+        // Uncommitted writes have no durable cache identity, even if rolled back.
+        if (this.#writeTransaction)
+            return Number.NaN;
+        return this.#db.prepare("SELECT revision FROM task_read_revisions WHERE task_id = ?")
+            .get(taskId)?.revision ?? 0;
+    }
     /**
      * Run an ordered command batch inside one `BEGIN IMMEDIATE … COMMIT`, yielding
      * to the event loop between commands so a cancellation signal can interrupt
@@ -656,8 +701,19 @@ export class SqliteTaskStore {
         return row === undefined ? null : this.#validateTaskPayload(table, row.payload);
     }
     #listPayload(table, where, params) {
-        const rows = this.#db.prepare(`SELECT payload FROM ${table} WHERE ${where}`).all(...params);
-        return rows.map((row) => this.#validateTaskPayload(table, row.payload));
+        // Table names are fixed internal callers; no SQL, parameters or payload
+        // text enters diagnostics. Include parsing/validation, not only SQLite IO.
+        const finish = this.#payloadReads.start(`list-${table}`);
+        try {
+            const rows = this.#db.prepare(`SELECT payload FROM ${table} WHERE ${where}`).all(...params);
+            const values = rows.map((row) => this.#validateTaskPayload(table, row.payload));
+            finish();
+            return values;
+        }
+        catch (error) {
+            finish(true);
+            throw error;
+        }
     }
     #validateTaskPayload(table, payload) {
         const record = this.#parse(payload);
@@ -1019,6 +1075,17 @@ export class SqliteTaskStore {
         OR json_extract(payload, '$.interruptThen') IS NOT NULL)`);
         if (query.interruptThen)
             where.push("json_extract(payload, '$.interruptThen') IS NOT NULL");
+        if (query.reservedThen !== undefined) {
+            where.push(`json_extract(payload, '$.delivery') IS NULL
+        AND json_extract(payload, '$.notDelivered') IS NULL
+        AND json_extract(payload, '$.interruptThen.targetNativeSessionId') = @thenSession
+        AND json_extract(payload, '$.interruptThen.targetAgentId') = @thenAgent
+        AND json_extract(payload, '$.interruptThen.targetAuthorityEpoch') = @thenEpoch
+        AND json_extract(payload, '$.interruptThen.targetAuthorityHolderId') = @thenHolder`);
+            Object.assign(params, { thenSession: query.reservedThen.nativeSessionId,
+                thenAgent: query.reservedThen.agentId, thenEpoch: query.reservedThen.authorityEpoch,
+                thenHolder: query.reservedThen.holderId });
+        }
         if (query.operatorNotice)
             where.push("json_extract(payload, '$.inputControl.requestId') LIKE 'operator-notice:%'");
         if (query.afterSequence !== undefined) {
@@ -1335,6 +1402,17 @@ export class SqliteTaskStore {
     listJobDefinitions(scope) {
         return this.#listPayload("job_definitions", "scope_key=?", [jobScopeKey(scope)]);
     }
+    listJobScopeSummaries() {
+        const rows = this.#db.prepare(`SELECT scope_key, SUM(definitions) AS definitions, SUM(schedules) AS schedules,
+        SUM(enabled) AS enabled FROM (
+          SELECT scope_key, 1 AS definitions, 0 AS schedules, 0 AS enabled FROM job_definitions
+          UNION ALL SELECT scope_key, 0, 1, CASE WHEN state='enabled' THEN 1 ELSE 0 END FROM schedules)
+      GROUP BY scope_key`).all();
+        return rows.map(row => ({
+            scope: row.scope_key === "global" ? { kind: "global" } : { kind: "task", taskId: row.scope_key },
+            definitions: Number(row.definitions), schedules: Number(row.schedules), enabledSchedules: Number(row.enabled)
+        }));
+    }
     saveGlobalJobRun(run) {
         validateDurableJob(run);
         if ("taskId" in run || run.scope !== "global")

package/dist/storage/storageVersions.js

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