@zq-silk/yui 0.15.11 → 0.16.0

package/dist/scheduler/roleRunStall.js

@@ -178,9 +178,8 @@ export function currentRoleRunProgressAt(store, taskId, roleName, run) {
     return { progressAt: run.createdAt };
 }
 /**
- * Computes the current semantic progress fence for an exact AgentRun. The optional
- * related-record readers add Work/Review/Integration evidence to the AgentRun and
- * event facts used by on-demand projections.
+ * Computes the current semantic progress fence for an exact AgentRun from
+ * required Work/Review/Integration readers and the AgentRun's event facts.
  */
 export function latestRunDurableProgressAt(store, taskId, roleName, runId, precomputed) {
     const run = store.getRun(taskId, runId);
@@ -204,20 +203,16 @@ export function latestRunDurableProgressAt(store, taskId, roleName, runId, preco
     if (run.workItemId === undefined) {
         return { progressAt: baseline };
     }
-    const workItem = store.getWorkItem?.(taskId, run.workItemId) ?? null;
-    const reviewRounds = store.listReviewRounds?.(taskId)
-        .filter(({ workItemId }) => workItemId === run.workItemId)
-        ?? [];
-    const changeSets = store.listChangeSets?.(taskId)
-        .filter(({ workItemId }) => workItemId === run.workItemId)
-        ?? [];
-    const integrations = store.listIntegrationAttempts?.(taskId)
-        .filter(({ source }) => (source.kind === "work-item" && source.workItemId === run.workItemId))
-        ?? [];
-    const inputProgress = store.listInputRequests?.(taskId)
+    const workItem = store.getWorkItem(taskId, run.workItemId);
+    const reviewRounds = store.listReviewRounds(taskId)
+        .filter(({ workItemId }) => workItemId === run.workItemId);
+    const changeSets = store.listChangeSets(taskId)
+        .filter(({ workItemId }) => workItemId === run.workItemId);
+    const integrations = store.listIntegrationAttempts(taskId)
+        .filter(({ source }) => (source.kind === "work-item" && source.workItemId === run.workItemId));
+    const inputProgress = store.listInputRequests(taskId)
         .filter((request) => (request.requester.runId === run.id
-        || request.blockedRefs.some((ref) => ref.type === "run" && ref.id === run.id)))
-        ?? [];
+        || request.blockedRefs.some((ref) => ref.type === "run" && ref.id === run.id)));
     const related = [
         workItem?.updatedAt,
         ...reviewRounds.map(({ endedAt, createdAt }) => endedAt ?? createdAt),
@@ -433,8 +428,6 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
     // existing mailbox work without manufacturing another episode.
     if (selection !== undefined && !selection.full)
         return [];
-    if (store.recordRoleRunStall === undefined)
-        return [];
     // A Draft planning Turn can stall exactly like any other admitted Turn, so it
     // is selected here too; the episode stays diagnostic-only either way.
     const candidates = selectedActiveSchedulerTasks(store, selection, {
@@ -455,7 +448,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
         const existing = eventsByTask.get(taskId);
         if (existing !== undefined)
             return existing;
-        const events = store.listEvents?.(taskId) ?? [];
+        const events = store.listEvents(taskId);
         eventsByTask.set(taskId, events);
         return events;
     };
@@ -469,7 +462,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
     const diagnosticStartedAt = now.toISOString();
     const finishDiagnostics = (outcome) => {
         for (const { task, role, run } of stallCandidates) {
-            store.recordRoleRunDiagnostic?.({
+            store.recordRoleRunDiagnostic({
                 taskId: task.id,
                 roleName: role.name,
                 runId: run.id,
@@ -676,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?.({
+            store.recordRoleRunProgress({
                 taskId: candidate.task.id,
                 roleName: candidate.role.name,
                 runId: candidate.run.id,
@@ -745,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?.({
+            store.recordRoleRunProgress({
                 taskId: candidate.task.id,
                 roleName: candidate.role.name,
                 runId: candidate.run.id,
@@ -827,7 +820,7 @@ function latestLeaderActionProgressAt(store, taskId, runId, startedAt, batch, no
         return "";
     let latest = startedAt;
     let latestMs = startedMs;
-    for (const event of store.listEvents?.(taskId) ?? []) {
+    for (const event of store.listEvents(taskId)) {
         if (!LEADER_ACTION_PROGRESS_TYPES.has(event.type))
             continue;
         if (event.payload.taskId !== undefined && event.payload.taskId !== taskId)

package/dist/scheduler/taskExecutionProjection.js

@@ -1,5 +1,6 @@
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
+import { providerRetryProjection } from "../runtime/providerRetry.js";
 import { taskOwnsManagedWorkspace } from "../task/task.js";
 import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
 import { mailboxBatches } from "../coordination/workMailbox.js";
@@ -13,21 +14,24 @@ 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, taskOverride, now = new Date()) {
-    const task = store.getTask?.(taskId) ?? taskOverride ?? null;
+export function buildTaskExecutionProjection(store, taskId, now = new Date()) {
+    const task = store.getTask(taskId);
     if (task === null)
         return null;
-    const roles = store.listRoles?.(taskId) ?? [];
-    const events = store.listEvents?.(taskId) ?? [];
-    const runs = operationalTaskRecords(store.listRuns?.(taskId) ?? [], events, "run");
-    const leaderMailbox = store.getWorkMailbox?.({
+    const roles = store.listRoles(taskId);
+    const events = store.listEvents(taskId);
+    const usageRuns = store.listRuns(taskId);
+    const workItems = store.listWorkItems(taskId);
+    const reviewRounds = store.listReviewRounds(taskId);
+    const runs = operationalTaskRecords(usageRuns, events, "run");
+    const leaderMailbox = store.getWorkMailbox({
         kind: "role",
         taskId,
         roleName: "leader"
-    }) ?? null;
+    });
     const roleSessions = roles.flatMap((role) => {
-        const session = store.getRoleSession?.(taskId, role.name);
-        return session === null || session === undefined
+        const session = store.getRoleSession(taskId, role.name);
+        return session === null
             ? []
             : [{ roleName: role.name, ...session }];
     });
@@ -35,35 +39,30 @@ export function buildTaskExecutionProjection(store, taskId, taskOverride, now =
         task,
         roles,
         runs,
+        usageRuns,
+        providerRetries: roles.flatMap(role => {
+            const retry = providerRetryProjection(store.getTaskRoleSessionSet(taskId, role.name)?.providerBinding);
+            return retry === null ? [] : [retry];
+        }),
         runDelivery: Object.fromEntries(runs.map((run) => {
-            const observed = store.getTaskRoleSessionSet?.(taskId, run.roleName)?.providerBinding?.run;
+            const observed = store.getTaskRoleSessionSet(taskId, run.roleName)?.providerBinding?.run;
             return [run.id, observed?.runId === run.id ? observed.status : "unobserved"];
         })),
-        executionGroups: store.listWorkItems === undefined && store.listReviewRounds === undefined
-            ? []
-            : collectExecutionGroups(store.listWorkItems?.(taskId) ?? [], store.listReviewRounds?.(taskId) ?? [], runs),
-        workItems: store.listWorkItems?.(taskId) ?? [],
-        ...(store.listContextSnapshots === undefined
-            ? {}
-            : { contextSnapshots: store.listContextSnapshots(taskId) }),
-        inputRequests: store.listInputRequests?.(taskId) ?? [],
-        ...(store.listReviewRounds === undefined
-            ? {}
-            : { reviewRounds: store.listReviewRounds(taskId) }),
-        ...(store.listChangeSets === undefined
-            ? {}
-            : { changeSets: store.listChangeSets(taskId) }),
-        ...(store.listIntegrationAttempts === undefined
-            ? {}
-            : { integrations: store.listIntegrationAttempts(taskId) }),
-        ...(store.listEvents === undefined ? {} : { events }),
-        ...(store.getTaskBrief === undefined ? {} : { brief: store.getTaskBrief(taskId) }),
-        pendingWakeup: store.getPendingWakeup?.(taskId) ?? null,
+        executionGroups: collectExecutionGroups(workItems, reviewRounds, runs),
+        workItems,
+        contextSnapshots: store.listContextSnapshots(taskId),
+        inputRequests: store.listInputRequests(taskId),
+        reviewRounds,
+        changeSets: store.listChangeSets(taskId),
+        integrations: store.listIntegrationAttempts(taskId),
+        events,
+        brief: store.getTaskBrief(taskId),
+        pendingWakeup: store.getPendingWakeup(taskId),
         leaderMailbox,
-        leaderFailure: store.getLeaderFailure?.(taskId) ?? null,
+        leaderFailure: store.getLeaderFailure(taskId),
         roleSessions,
         now,
-        runtimeHealthPolicy: resolveRuntimeHealth(store.getConfig?.().runtimeHealth)
+        runtimeHealthPolicy: resolveRuntimeHealth(store.getConfig().runtimeHealth)
     });
 }
 /**
@@ -79,6 +78,7 @@ export function projectTaskExecutionFromFacts(facts) {
     return projectTaskExecution({
         ...facts,
         runs,
+        usageRuns: facts.usageRuns ?? facts.runs,
         executionGroups
     });
 }
@@ -107,9 +107,10 @@ export function projectTaskExecution(facts) {
         });
     });
     const observability = buildTaskObservabilityProjection({
+        task,
         workItems,
         executionGroups: observabilityGroups,
-        runs,
+        runs: facts.usageRuns ?? runs,
         events,
         contextSnapshots: facts.contextSnapshots,
         sessionTokens,
@@ -206,8 +207,12 @@ export function projectTaskExecution(facts) {
     const hasPendingLeaderWork = pendingWakeup !== null
         || leaderMailbox?.pending !== null;
     const recoveryPending = isRecoveryPending(pendingWakeup, leaderMailbox, leaderFailure);
-    const failedWork = workItems.some((item) => item.status === "open"
-        && runs.filter((run) => run.workItemId === item.id).at(-1)?.status === "failed");
+    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)));
+    const failedWork = workItems.some((item) => {
+        const last = runs.filter((run) => run.workItemId === item.id).at(-1);
+        return item.status === "open" && last?.status === "failed" && !recoveringRunIds.has(last.id);
+    });
     const candidateReady = workItems.some((item) => (item.status === "open" && item.currentCandidateId !== undefined));
     const blockedIntegration = integrations.some((attempt) => attempt.status === "blocked");
     const conflictedIntegration = integrations.find((attempt) => attempt.status === "conflicted");
@@ -258,7 +263,7 @@ export function projectTaskExecution(facts) {
             pendingWakeup
         });
     }
-    if (laneRecovery !== undefined) {
+    if (laneRecovery !== undefined && (laneRecovery.runId === undefined || !recoveringRunIds.has(laneRecovery.runId))) {
         return render({
             task,
             status: laneRecovery.runtimeHealth === "confirmed-dead"
@@ -306,6 +311,14 @@ export function projectTaskExecution(facts) {
             pendingWakeup
         });
     }
+    if (providerRecoveries.length > 0 && healthyActiveRuns.length === 0) {
+        return render({
+            task, status: "recovering", owner: "none", action: "none",
+            summary: `${providerRecoveries.length} Provider recovery chain(s) are cooling down or awaiting their exact result; existing work is preserved. Do not dispatch a duplicate.`,
+            reason: "provider-recovery", monitoring, failClosed: false,
+            activeRuns: activeRunViews, attention, blockers, pendingWakeup
+        });
+    }
     if (recoveryPending) {
         return render({
             task,

package/dist/scheduler/taskObservabilityProjection.js

@@ -1,3 +1,4 @@
+import { projectTaskUsageMetrics } from "../runtime/taskUsageMetrics.js";
 /**
  * Build the read-only DAG, execution, cost, and context view consumed by CLI
  * and Web. It deliberately derives every value from existing Task records and
@@ -8,7 +9,7 @@ export function buildTaskObservabilityProjection(input) {
     const dag = projectDag(input.workItems);
     const workItems = input.workItems.map((item) => {
         const groups = item.executionGroups;
-        const itemCost = projectWorkItemCost(groups, input.runs, now);
+        const itemCost = projectCost({ ...input, now }, groups, item.id);
         const itemContext = projectContext(groups, input.runs, input.contextSnapshots);
         const producerObservability = projectWorkItemProducerObservability(item, input.runs);
         return Object.freeze({
@@ -21,7 +22,7 @@ export function buildTaskObservabilityProjection(input) {
             resultCount: producerObservability?.resultCount ?? null
         });
     });
-    const cost = projectCost(input.executionGroups, input.runs, input.events, now);
+    const cost = projectCost({ ...input, now }, input.executionGroups);
     const context = projectContext(input.executionGroups, input.runs, input.contextSnapshots);
     return Object.freeze({
         dag,
@@ -59,7 +60,6 @@ function projectDag(workItems) {
     const edges = [];
     for (const item of workItems) {
         for (const dependency of item.dependsOn) {
-            const target = byId.get(dependency);
             const status = dependencyEdgeStatus(dependency, byId);
             edges.push({ from: dependency, to: item.id, status });
             dependents.get(dependency)?.push(item.id);
@@ -140,17 +140,13 @@ function dependencyEdgeStatus(id, byId) {
         return "active";
     return "active";
 }
-function projectCost(groups, runs, _events, now) {
+function projectCost(input, groups, workItemId) {
     const uniqueGroups = [...new Map(groups.map((group) => [group.id, group])).values()];
     const groupIds = new Set(uniqueGroups.map(({ id }) => id));
-    const attempts = runs.filter(({ executionGroupId }) => (executionGroupId !== undefined && groupIds.has(executionGroupId)));
+    const attempts = input.runs.filter(({ executionGroupId }) => (executionGroupId !== undefined && groupIds.has(executionGroupId)));
     const laneCount = uniqueGroups.reduce((total, group) => total + group.lanes.length, 0);
     return Object.freeze({
-        tokens: 0,
-        toolCalls: 0,
-        wallClockSeconds: uniqueGroups.reduce((total, group) => total + groupDurationSeconds(group, now), 0),
-        tokensObservable: false,
-        toolCallsObservable: false,
+        ...projectTaskUsageMetrics({ ...input, workItemId }),
         laneCount,
         groupCount: uniqueGroups.length,
         retryCount: Math.max(0, attempts.length - laneCount),
@@ -158,32 +154,6 @@ function projectCost(groups, runs, _events, now) {
         marginalValueStatus: "unavailable"
     });
 }
-function projectWorkItemCost(groups, runs, now) {
-    const groupIds = new Set(groups.map(({ id }) => id));
-    const attempts = runs.filter(({ executionGroupId }) => (executionGroupId !== undefined && groupIds.has(executionGroupId)));
-    const wallClockSeconds = groups.reduce((total, group) => {
-        const started = Date.parse(group.createdAt);
-        const ended = group.lanes.some(({ disposition }) => disposition === "open")
-            ? now.getTime()
-            : Date.parse(group.updatedAt);
-        return total + (Number.isFinite(started) && Number.isFinite(ended)
-            ? Math.max(0, Math.floor((ended - started) / 1_000))
-            : 0);
-    }, 0);
-    const laneCount = groups.reduce((total, group) => total + group.lanes.length, 0);
-    return Object.freeze({
-        tokens: 0,
-        toolCalls: 0,
-        wallClockSeconds,
-        tokensObservable: false,
-        toolCallsObservable: false,
-        laneCount,
-        groupCount: groups.length,
-        retryCount: Math.max(0, attempts.length - laneCount),
-        marginalValuePercent: null,
-        marginalValueStatus: "unavailable"
-    });
-}
 function projectContext(groups, runs, snapshots) {
     const refs = new Map();
     for (const group of groups) {
@@ -223,12 +193,3 @@ function projectContext(groups, runs, snapshots) {
         compressionStatus: "unavailable"
     });
 }
-function groupDurationSeconds(group, now) {
-    const started = Date.parse(group.createdAt);
-    const ended = group.lanes.some(({ disposition }) => disposition === "open")
-        ? now.getTime()
-        : Date.parse(group.updatedAt);
-    return Number.isFinite(started) && Number.isFinite(ended)
-        ? Math.max(0, Math.floor((ended - started) / 1_000))
-        : 0;
-}

package/dist/scheduler/taskWake.js

@@ -1,8 +1,10 @@
 import { requireIdentity, requirePositiveInteger, requireText, requireTimestamp } from "../domain/validation.js";
 import { TASK_RECORD_ID_PREFIXES } from "../task/taskRecordReference.js";
 import { copyRef } from "../coordination/workMailbox.js";
-export const CURRENT_TASK_WAKE_SCHEMA_VERSION = 1;
+export const CURRENT_TASK_WAKE_SCHEMA_VERSION = 2;
 export function createTaskWake(input) {
+    if (Object.hasOwn(input, "runId"))
+        throw new Error("A notification wake cannot dispatch an AgentRun.");
     const wake = {
         schemaVersion: CURRENT_TASK_WAKE_SCHEMA_VERSION,
         id: requireIdentity(input.id, "Task wake id"),
@@ -13,13 +15,14 @@ export function createTaskWake(input) {
         fromCursor: requireTimestamp(input.fromCursor, "Wake fromCursor"),
         toCursor: requireTimestamp(input.toCursor, "Wake toCursor"),
         status: "dispatched",
-        ...(input.runId === undefined ? {} : { runId: requireIdentity(input.runId, "Wake AgentRun id") }),
         createdAt: input.now.toISOString()
     };
     validateTaskWake(wake);
     return wake;
 }
 export function validateTaskWake(wake) {
+    if (Object.hasOwn(wake, "runId"))
+        throw new Error("Run-backed wakes are not current notification records.");
     if (wake.refs !== undefined) {
         if (!Array.isArray(wake.refs))
             throw new Error("Wake references must be an array.");
@@ -61,14 +64,6 @@ export function latestTaskWake(wakes) {
     }
     return latest;
 }
-/**
- * The delta lower bound for a Task's first wake: the last Leader AgentRun's
- * creation time, preserving the pre-ledger watermark semantics. When no
- * Leader AgentRun exists, the Task's own creation time bounds the window.
- */
-export function fallbackWakeCursor(input) {
-    return input.leaderRunCreatedAt ?? input.taskCreatedAt;
-}
 function wakeSequence(id) {
     const prefix = `${TASK_RECORD_ID_PREFIXES.taskWake}-`;
     if (!id.startsWith(prefix)) {

package/dist/scheduler/wakeReason.js

@@ -25,6 +25,7 @@ export const WAKE_REASON_KINDS = Object.freeze([
     "role-turn-failed",
     "job-finished",
     "published-tree-authorized",
+    "notification-retry",
     "force-wake"
 ]);
 const IMMEDIATE_KINDS = new Set([
@@ -34,6 +35,7 @@ const IMMEDIATE_KINDS = new Set([
     "execution-started",
     "session-replaced",
     "force-wake",
+    "notification-retry",
     "activation-failed",
     "task-reopened",
     "leader-turn-failed",

package/dist/scheduler/wakeupQueue.js

@@ -1,10 +1,8 @@
 import { mergePendingWakeup } from "./pendingWakeup.js";
+/** The caller's TaskStore transaction owns this read/merge/write operation. */
 export function queueLeaderWakeup(store, taskId, reason, now) {
-    if (store.getTask?.(taskId)?.status === "archived")
+    if (store.getTask(taskId)?.status === "archived")
         return null;
-    if (store.enqueueLeaderWakeup !== undefined) {
-        return store.enqueueLeaderWakeup(taskId, reason, now);
-    }
     const pending = mergePendingWakeup(taskId, reason, now, store.getPendingWakeup(taskId));
     store.savePendingWakeup(pending);
     return pending;

package/dist/setup/setupCommand.js

@@ -5,10 +5,10 @@ import { configuredAgentToDefinition, createConfiguredAgent } from "../agent/age
 import { assertRoleRuntimeMutationAllowed } from "../commands/roleRuntimeGuard.js";
 import { resolveTmuxBin } from "../config/yuiConfig.js";
 import { usageError } from "../errors/cliError.js";
-import { managedGlobalRoleWorkspace } from "../storage/homeLayout.js";
 import { createGlobalRole, createRoleAgentBinding, updateGlobalRole } from "../role/role.js";
 import { SYSTEM_LEADER_ROLE, SYSTEM_OPERATOR_ROLE } from "../role/systemRoles.js";
 import { initializeCurrentTaskStore } from "../storage/currentTaskStore.js";
+import { managedGlobalRoleWorkspace } from "../storage/homeLayout.js";
 import { ensureYuiHome, resolveYuiHome } from "../storage/taskStore.js";
 const BUILTIN_AGENTS = Object.freeze([
     Object.freeze({

package/dist/storage/contextRecords.js

@@ -0,0 +1,106 @@
+import { validateStoredRecord } from "./recordValidation.js";
+import { validateWorkItemCandidate } from "../workItem/workItem.js";
+/** Read-only projections of existing tables, not a new Context index or Store. */
+const FAMILIES = {
+    "work-item": ["work_items", "work_item_id"],
+    "candidate": ["work_items", "work_item_id"],
+    "environment-preparation": ["environment_preparations", "id"],
+    "managed-workspace": ["managed_workspaces", "owner_id"],
+    "change-set": ["change_sets", "change_set_id"],
+    "task-message": ["messages", "message_id"],
+    "run": ["turns", "turn_id"],
+    "review-round": ["review_rounds", "review_round_id"],
+    "input-request": ["input_requests", "input_id"],
+    "task-decision": ["decisions", "decision_id"],
+    "task-milestone": ["milestones", "milestone_id"],
+    "job": ["durable_jobs", "job_id"],
+    "publication": ["publication_references", "publication_id"],
+    "task-event": ["events", "event_id"]
+};
+/** Only identities cross this query: shared user intent and the exact live
+ * Assignment's steers augment frozen read refs without loading other messages.
+ */
+export function contextInputReferences(db, taskId, scope) {
+    const shared = `json_extract(m.payload, '$.kind') IN ('user','operator')
+    AND json_extract(m.payload, '$.recipient') IS NULL
+    AND json_extract(m.payload, '$.workItemId') IS NULL
+    AND json_extract(m.payload, '$.runId') IS NULL`;
+    const steer = `(COALESCE(json_extract(m.payload, '$.inputControl.action'), '') = 'steer'
+    OR COALESCE(json_extract(m.payload, '$.interruptThen.reusedInput.action'), '') = 'steer')`;
+    const matches = `m.task_id = @taskId AND (
+    ((${shared}) AND NOT ${steer}) OR (${steer}
+      AND json_extract(m.payload, '$.recipient.roleName') = @roleName
+      AND json_extract(m.payload, '$.recipient.workItemId') IS @workItemId
+      AND json_extract(m.payload, '$.recipient.reviewRoundId') IS @reviewRoundId))`;
+    const params = { taskId, roleName: scope.roleName,
+        workItemId: scope.workItemId ?? null, reviewRoundId: scope.reviewRoundId ?? null };
+    const ids = `SELECT m.message_id FROM messages m WHERE ${matches}`;
+    const messages = db.prepare(ids).all(params).map(row => row.message_id);
+    const events = db.prepare(`SELECT event_id FROM events
+    WHERE task_id = @taskId AND type GLOB 'message.*'
+      AND json_extract(payload, '$.payload.messageId') IN (${ids})`).all(params).map(row => row.event_id);
+    return { messages, events };
+}
+export function queryContextRecords(db, taskId, query) {
+    const family = FAMILIES[query.family];
+    if (family === undefined || !Number.isSafeInteger(query.limit) || query.limit < 0 || query.limit > 256
+        || !Number.isSafeInteger(query.offset ?? 0) || (query.offset ?? 0) < 0) {
+        throw new Error("Context record query exceeds its bounded contract.");
+    }
+    const [table, key] = family;
+    const candidate = query.family === "candidate";
+    const payload = candidate ? "candidate.value" : "r.payload";
+    const id = candidate ? `r.${key} || '/' || json_extract(candidate.value, '$.id')` : `r.${key}`;
+    const from = `${table} r${candidate ? ", json_each(r.payload, '$.candidates') candidate" : ""}`;
+    const where = ["r.task_id = @taskId"];
+    const params = { taskId };
+    if (query.ids !== undefined) {
+        where.push(`${id} IN (SELECT value FROM json_each(@ids))`);
+        params.ids = JSON.stringify(query.ids);
+    }
+    for (const [label, statuses, not] of [
+        ["statuses", query.statuses, ""],
+        ["excludeStatuses", query.excludeStatuses, "NOT"]
+    ]) {
+        if (statuses !== undefined) {
+            where.push(`json_extract(${payload}, '$.status') ${not} IN (SELECT value FROM json_each(@${label}))`);
+            params[label] = JSON.stringify(statuses);
+        }
+    }
+    const sequence = `CAST(substr(r.${key}, length(r.${key}) - length(ltrim(r.${key}, 'abcdefghijklmnopqrstuvwxyz-')) + 1) AS INTEGER)`;
+    // Task-local numeric IDs are the stable historical order, not lexical 1,10,2.
+    if (query.family === "task-event") {
+        if (query.eventTypes !== undefined) {
+            where.push("r.type IN (SELECT value FROM json_each(@types))");
+            params.types = JSON.stringify(query.eventTypes);
+        }
+        for (const [key, value, comparison] of [
+            ["after", query.afterSequence, ">"], ["through", query.throughSequence, "<="]
+        ]) {
+            if (value !== undefined) {
+                if (!Number.isSafeInteger(value) || value < 0)
+                    throw new Error("Invalid event cursor.");
+                where.push(`${sequence} ${comparison} @${key}`);
+                params[key] = value;
+            }
+        }
+    }
+    const condition = where.join(" AND ");
+    const count = db.prepare(`SELECT count(*) AS n FROM ${from} WHERE ${condition}`).get(params).n;
+    if (query.limit === 0 || count === 0)
+        return { count, records: [] };
+    const direction = query.descending ? "DESC" : "ASC";
+    const order = query.family === "work-item" || candidate
+        ? `r.updated_at DESC, ${sequence} ASC${candidate ? ", candidate.key DESC" : ""}`
+        : query.family === "managed-workspace" ? `r.${key} ${direction}` : `${sequence} ${direction}, r.${key} ${direction}`;
+    const rows = db.prepare(`SELECT ${id} AS id, ${payload} AS payload
+    FROM ${from} WHERE ${condition} ORDER BY ${order} LIMIT @limit OFFSET @offset`).all({ ...params, limit: query.limit, offset: query.offset ?? 0 });
+    return { count, records: rows.map(row => {
+            const value = JSON.parse(row.payload);
+            if (candidate)
+                validateWorkItemCandidate(value);
+            else
+                validateStoredRecord(table, value);
+            return { id: row.id, value };
+        }) };
+}

package/dist/storage/currentTaskStore.js

@@ -40,7 +40,7 @@ export function readCurrentHomeIdentity(home) {
 export function validateCurrentTaskStore(home) {
     const store = openCurrentTaskStore(home);
     try {
-        store.getConfig();
+        store.validateCurrentRecords();
     }
     finally {
         store.close();

package/dist/storage/homeLayout.js

@@ -1,4 +1,5 @@
 import { isAbsolute, join, relative, resolve } from "node:path";
+import { createHash } from "node:crypto";
 /**
  * The single authority for every Yui self-managed path derived from a Home.
  *
@@ -10,7 +11,7 @@ import { isAbsolute, join, relative, resolve } from "node:path";
  * single canonical YUI_HOME contains all self-managed data, with only the
  * approved short-path IPC sockets (Controller, tmux, Agent Host, integration
  * runtime) remaining outside it for the `sockaddr_un` length budget. Within the
- * managed workspace root, storage v20 further collapses the former
+ * managed workspace root, storage v25 further collapses the former
  * physical-worktree/symlink-view split into a single layer of real worktrees
  * under `tasks/` (see {@link managedTaskRoot}).
  *
@@ -27,33 +28,21 @@ function homeRoot(home) {
     return resolved;
 }
 /**
- * Root that contains every managed Git workspace. Since storage v20 this holds a
+ * Root that contains every managed Git workspace. Since storage v25 this holds a
  * single layer of real worktrees under `tasks/` (plus the legacy `worktree/`
- * root, preserved by the 19->20 migration as its rollback anchor). A single
+ * root, preserved by the 24->25 migration as its rollback anchor). A single
  * parent keeps the managed families adjacent and lets the storage migrations
  * relocate them as one subtree.
  */
 export function managedWorkspacesRoot(home) {
     return join(homeRoot(home), "workspaces");
 }
-/**
- * LEGACY physical worktree root: `<home>/workspaces/worktree`. Before storage
- * v20 every managed clone/linked worktree lived here under a per-Project subtree,
- * surfaced to each Task through a symlink view under `tasks/`. The 19->20
- * migration collapses those into real worktrees under `tasks/` and PRESERVES this
- * tree as the rollback anchor, so this path survives only for that migration's
- * inline layout and for post-upgrade cleanup — no current runtime code derives a
- * live worktree path from it.
- */
-export function managedWorktreeRoot(home) {
-    return join(managedWorkspacesRoot(home), "worktree");
-}
 /**
  * Managed Git worktrees, one real worktree per Task owner and Project at
  * `<home>/workspaces/tasks/<taskId>/<owner>/<projectDirectory>` (owner being
  * `main`, `work-items/<id>`, `reviews/<name>`, `integrations/<id>`, or
- * `execution-lanes/<g>/<l>`). Before storage v20 these were symlink views over
- * the physical `worktree/` root; the 19->20 migration makes them the worktrees
+ * `execution-lanes/<g>/<l>`). Before storage v25 these were symlink views over
+ * the physical `worktree/` root; the 24->25 migration makes them the worktrees
  * themselves, so the logical entry path and the physical Git worktree coincide.
  */
 export function managedTaskRoot(home) {
@@ -79,6 +68,13 @@ export function managedRuntimeRoot(home) {
 export function managedIntegrationRuntimeRoot(home) {
     return join(homeRoot(home), "runtime", "integration-runtimes");
 }
+/** The shared Home-scoped short IPC directory; ordinary integration data stays
+ * inside Home. A fixture that owns the whole Home may remove this when empty. */
+export function integrationTmuxSocketRoot(home) {
+    const uid = typeof process.getuid === "function" ? process.getuid() : 0;
+    const homeDigest = createHash("sha256").update(homeRoot(home)).digest("hex").slice(0, 16);
+    return join("/tmp", `yi-${uid.toString(36)}-${homeDigest}`);
+}
 /**
  * Disposable staging prefix for `yui update`'s side-by-side package install
  * (an upgrade artifact): `<home>/runtime/update-staging`. Kept under Home so a

package/dist/storage/migrations/agentFailureContext.js

@@ -0,0 +1,22 @@
+/** Historical errors have no trustworthy launch snapshot. Preserve their raw
+ * payloads and explicitly record that fact; never infer it from today's Role. */
+export function migrateAgentFailureContext(db) {
+    const archive = db.prepare(`INSERT INTO storage_migration_archive
+    (migration_version,family,record_key,payload,content) VALUES(36,'agent-error',?,?,NULL)`);
+    const update = db.prepare("UPDATE events SET payload=? WHERE task_id=? AND event_id=?");
+    const rows = db.prepare("SELECT task_id,event_id,payload FROM events WHERE type='runtime.agent-error'").all();
+    for (const row of rows) {
+        const event = JSON.parse(row.payload);
+        if (!event || event.schemaVersion !== 2 || event.type !== "runtime.agent-error" || event.taskId !== row.task_id
+            || event.id !== row.event_id || !event.payload || typeof event.payload !== "object"
+            || Array.isArray(event.payload) || Object.values(event.payload).some(value => typeof value !== "string")
+            || Object.hasOwn(event.payload, "capabilityContext")) {
+            throw new Error(`Invalid pre-context Agent error: ${row.task_id}/${row.event_id}.`);
+        }
+        archive.run(JSON.stringify([row.task_id, row.event_id]), row.payload);
+        event.payload.capabilityContext = JSON.stringify({
+            status: "unavailable", reason: "Launch configuration was not recorded by this historical error producer."
+        });
+        update.run(JSON.stringify(event), row.task_id, row.event_id);
+    }
+}