@zq-silk/yui 0.6.16 → 0.7.0

package/dist/storage/sqliteSchema.js

@@ -27,7 +27,7 @@ export const SQLITE_LAYOUT_VERSION = 7;
 /** The aggregate version of the normalized SQLite schema. */
 export const SQLITE_AGGREGATE_VERSION = 1;
 /** The current schema migration version. */
-export const SQLITE_SCHEMA_VERSION = 16;
+export const SQLITE_SCHEMA_VERSION = 17;
 /** Telemetry retention bounds (§4.4). Open question 3 in §11; defaults from the design. */
 export const TELEMETRY_KEEP_PER_GENERATION = 200;
 export const TELEMETRY_RUN_CAP = 50_000;
@@ -911,6 +911,25 @@ CREATE TABLE IF NOT EXISTS task_wakes (
 );
 CREATE INDEX IF NOT EXISTS idx_task_wakes_seq ON task_wakes(task_id, seq);
 `;
+/** Migration 17: immutable, Task-scoped ContextSnapshot records. */
+const MIGRATION_17_SQL = `
+CREATE TABLE IF NOT EXISTS context_snapshots (
+  task_id     TEXT NOT NULL,
+  snapshot_id TEXT NOT NULL,
+  scope       TEXT NOT NULL CHECK (scope IN ('task','workitem','stage')),
+  scope_ref   TEXT,
+  sequence    INTEGER NOT NULL CHECK (sequence > 0),
+  digest      TEXT NOT NULL CHECK (length(digest) = 64),
+  payload     TEXT NOT NULL,
+  frozen_at   TEXT NOT NULL,
+  PRIMARY KEY (task_id, snapshot_id),
+  FOREIGN KEY (task_id) REFERENCES tasks_catalog(task_id) ON DELETE CASCADE,
+  CHECK ((scope = 'task' AND scope_ref IS NULL) OR (scope <> 'task' AND scope_ref IS NOT NULL))
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_context_snapshots_scope_sequence
+  ON context_snapshots(task_id, scope, COALESCE(scope_ref, ''), sequence);
+`;
 const MIGRATIONS = [
     { version: 1, axis: "layout", sql: MIGRATION_1_SQL },
     { version: 2, axis: "record", recordKind: "durableJob+capability-grant+release-workflow", sql: MIGRATION_2_SQL },
@@ -927,7 +946,8 @@ const MIGRATIONS = [
     { version: 13, axis: "layout", sql: MIGRATION_13_SQL },
     { version: 14, axis: "record", recordKind: "workMailbox", sql: MIGRATION_14_SQL },
     { version: 15, axis: "record", recordKind: "publicationReference", sql: MIGRATION_15_SQL },
-    { version: 16, axis: "record", recordKind: "taskWake", sql: MIGRATION_16_SQL }
+    { version: 16, axis: "record", recordKind: "taskWake", sql: MIGRATION_16_SQL },
+    { version: 17, axis: "record", recordKind: "contextSnapshot", sql: MIGRATION_17_SQL }
 ];
 /** Current hot-path indexes whose absence would invalidate a current Home. */
 const REQUIRED_SCHEMA_INDEXES = [
@@ -1169,6 +1189,7 @@ export const SQLITE_SCHEMA_TABLES = [
     "role_session_sets",
     "work_items",
     "work_item_candidates",
+    "context_snapshots",
     "agent_runs",
     "active_runs",
     "review_rounds",

package/dist/storage/sqliteStore.js

@@ -39,6 +39,7 @@ import { join } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import Database from "better-sqlite3";
 import { consumePendingBatch, mailboxTargetKey, pendingLane, validateWorkMailbox } from "../coordination/workMailbox.js";
+import { validateContextSnapshot } from "../context/contextSnapshot.js";
 import { compareRuntimeSessionCandidates, projectRuntimeSessionCandidate } from "../runtime/runtimeSessionCandidate.js";
 import { validateReviewFinding } from "../review/reviewFinding.js";
 import { reviewFindingLedgerMode } from "../review/reviewFindingLedger.js";
@@ -1418,6 +1419,37 @@ export class SqliteTaskStore {
             return Object.freeze({ retained, deleted: toDelete.length });
         });
     }
+    // -- context snapshots ------------------------------------------------------
+    nextContextSnapshotId(taskId) {
+        return this.#nextTaskRecordId(taskId, "contextSnapshot");
+    }
+    getContextSnapshot(taskId, snapshotId) {
+        return this.#getPayload("context_snapshots", "task_id = ? AND snapshot_id = ?", [taskId, snapshotId]);
+    }
+    listContextSnapshots(taskId) {
+        return this.#sortById(this.#listPayload("context_snapshots", "task_id = ?", [taskId]), (snapshot) => snapshot.id);
+    }
+    saveContextSnapshot(snapshot) {
+        const stored = validateContextSnapshot(snapshot);
+        this.#requireTask(stored.taskId);
+        const existing = this.getContextSnapshot(stored.taskId, stored.id);
+        if (existing !== null) {
+            if (!isDeepStrictEqual(existing, stored)) {
+                throw new StorageRecordError(`Context Snapshot is immutable: ${stored.id}.`);
+            }
+            return;
+        }
+        const duplicate = this.#db.prepare(`SELECT snapshot_id FROM context_snapshots
+       WHERE task_id = ? AND scope = ? AND COALESCE(scope_ref, '') = COALESCE(?, '') AND sequence = ?`).get(stored.taskId, stored.scope, stored.scopeRef ?? null, stored.sequence);
+        if (duplicate !== undefined) {
+            throw new StorageRecordError(`Context Snapshot sequence already exists: ${stored.taskId}/${stored.scope}/${stored.sequence}.`);
+        }
+        this.#mutate(() => {
+            this.#db.prepare(`INSERT INTO context_snapshots
+          (task_id, snapshot_id, scope, scope_ref, sequence, digest, payload, frozen_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(stored.taskId, stored.id, stored.scope, stored.scopeRef ?? null, stored.sequence, stored.digest, this.#json(stored), stored.frozenAt);
+        });
+    }
     // -- agent runs -------------------------------------------------------------
     nextAgentRunId(taskId) { return this.#nextTaskRecordId(taskId, "agentRun"); }
     peekNextAgentRunId(taskId) { return this.#peekTaskRecordId(taskId, "agentRun"); }
@@ -1451,13 +1483,18 @@ export class SqliteTaskStore {
             ? ""
             : ` AND tc.task_id IN (${selectedTaskIds.map(() => "?").join(", ")})`;
         const rows = this.#db.prepare(`SELECT DISTINCT ar.task_id AS taskId, ar.run_id AS runId, ar.role_name AS roleName,
-              json_extract(ar.payload, '$.providerRetry.nextAttemptAt') AS nextAttemptAt
+              json_extract(ar.payload, '$.providerRetry.state') AS state,
+              CASE json_extract(ar.payload, '$.providerRetry.state')
+                WHEN 'scheduled' THEN json_extract(ar.payload, '$.providerRetry.nextAttemptAt')
+                ELSE json_extract(ar.payload, '$.providerRetry.episodeDeadlineAt')
+              END AS dueAt
        FROM tasks_catalog tc INDEXED BY idx_tasks_active
        JOIN active_runs ap ON ap.task_id = tc.task_id
        JOIN agent_runs ar ON ar.task_id = ap.task_id AND ar.run_id = ap.run_id
        WHERE tc.is_active = 1
          AND ar.status = 'active'
-         AND json_extract(ar.payload, '$.providerRetry.nextAttemptAt') IS NOT NULL${taskPredicate}`).all(...(selectedTaskIds ?? []));
+         AND json_extract(ar.payload, '$.providerRetry.state') IN
+           ('scheduled', 'dispatching', 'awaiting-progress')${taskPredicate}`).all(...(selectedTaskIds ?? []));
         return rows.sort((left, right) => (numericCompare(left.taskId, right.taskId)
             || numericCompare(left.roleName, right.roleName)
             || numericCompare(left.runId, right.runId)));

package/dist/storage/taskStore.js

@@ -9,10 +9,12 @@ import { publicationExternalKey, validatePublicationReference } from "../task/pu
 import { reconciliationIntervalMilliseconds, resolveLeaderNextActionMode, resolveResourcesGcAutoQuarantine, resolveResourcesGcMode } from "../config/yuiConfig.js";
 import { resolveTimeZone } from "../output/timePresentation.js";
 import { mailboxBatches, consumePendingBatch, mailboxHasWork, mailboxTargetKey, pendingLane, validateWorkMailbox } from "../coordination/workMailbox.js";
+import { validateContextSnapshot } from "../context/contextSnapshot.js";
 import { validateInputRequest } from "../input/inputRequest.js";
 import { validateRoleSessionSet } from "../executor/agentExecutor.js";
 import { validateTaskMessage } from "../message/message.js";
-import { validateAgentRun } from "../run/agentRun.js";
+import { agentRunDeliveryReceiptId, validateAgentRun } from "../run/agentRun.js";
+import { providerRetryWakeAt } from "../run/providerRetry.js";
 import { compareRuntimeSessionCandidates, projectRuntimeSessionCandidate } from "../runtime/runtimeSessionCandidate.js";
 import { FileSessionOwnerRegistry } from "../runtime/sessionOwnerRegistry.js";
 import { validateReviewConfig } from "../review/reviewConfig.js";
@@ -31,7 +33,7 @@ import { CURRENT_LEADER_FAILURE_SCHEMA_VERSION } from "../scheduler/leaderFailur
 import { CURRENT_OPERATOR_NOTIFICATION_SCHEMA_VERSION } from "../scheduler/operatorNotification.js";
 import { CURRENT_TASK_WAKE_SCHEMA_VERSION, validateTaskWake } from "../scheduler/taskWake.js";
 import { validateTask } from "../task/task.js";
-import { formatAgentRunReceiptId, TASK_RECORD_ID_PREFIXES, validateTaskRecordReference } from "../task/taskRecordReference.js";
+import { TASK_RECORD_ID_PREFIXES, validateTaskRecordReference } from "../task/taskRecordReference.js";
 import { workItemExecutionGroupById, validateWorkItem } from "../workItem/workItem.js";
 import { isExecutionGroupTransition, validateExecutionGroup } from "../execution/executionGroup.js";
 import { managedWorkspaceKey, validateManagedWorkspace } from "../worktree/managedWorkspace.js";
@@ -60,6 +62,7 @@ export const CURRENT_GLOBAL_ROLE_SCHEMA_VERSION = 3;
 export const CURRENT_GLOBAL_ROLE_SESSION_SET_SCHEMA_VERSION = 3;
 export const CURRENT_TASK_SCHEMA_VERSION = 4;
 export const CURRENT_TASK_BRIEF_SCHEMA_VERSION = 2;
+export const CURRENT_CONTEXT_SNAPSHOT_SCHEMA_VERSION = 1;
 export const CURRENT_TASK_ROLE_SCHEMA_VERSION = 3;
 export const CURRENT_MANAGED_WORKSPACE_SCHEMA_VERSION = 2;
 export const CURRENT_WORK_ITEM_SCHEMA_VERSION = 9;
@@ -120,7 +123,7 @@ export const CURRENT_TASK_ROLE_SESSION_SET_SCHEMA_VERSION = 5;
  * actionability fields. All are optional, so the v6→v7 migration is a
  * version-only rewrite.
  */
-export const CURRENT_AGENT_RUN_SCHEMA_VERSION = 7;
+export const CURRENT_AGENT_RUN_SCHEMA_VERSION = 9;
 export const CURRENT_INTEGRATION_QUEUE_SCHEMA_VERSION = 1;
 export class FileTaskStore {
     rootDir;
@@ -904,6 +907,38 @@ export class FileTaskStore {
             task.workItems[stored.id] = stored;
         });
     }
+    nextContextSnapshotId(taskId) {
+        return this.#nextTaskRecordId(taskId, "contextSnapshot");
+    }
+    getContextSnapshot(taskId, id) {
+        return optional(this.#state().tasks[taskId]?.contextSnapshots[id]);
+    }
+    listContextSnapshots(taskId) {
+        return values(this.#requireTask(taskId).contextSnapshots, "id");
+    }
+    saveContextSnapshot(snapshot) {
+        const stored = identified(snapshot, CURRENT_CONTEXT_SNAPSHOT_SCHEMA_VERSION, "id", snapshot.id, "Context Snapshot");
+        validateContextSnapshot(stored);
+        const aggregate = this.#requireTaskForWrite(stored.taskId);
+        const existing = aggregate.contextSnapshots[stored.id];
+        if (existing !== undefined) {
+            if (!isDeepStrictEqual(existing, stored)) {
+                throw new StorageRecordError(`Context Snapshot is immutable: ${stored.id}.`);
+            }
+            return;
+        }
+        const duplicateSequence = Object.values(aggregate.contextSnapshots).find((candidate) => (candidate.scope === stored.scope
+            && candidate.scopeRef === stored.scopeRef
+            && candidate.sequence === stored.sequence));
+        if (duplicateSequence !== undefined) {
+            throw new StorageRecordError(`Context Snapshot sequence already exists: ${stored.taskId}/${stored.scope}/${stored.sequence}.`);
+        }
+        this.#mutate((state) => {
+            const task = state.tasks[stored.taskId];
+            observeTaskRecordId(task, "contextSnapshot", stored.id);
+            task.contextSnapshots[stored.id] = stored;
+        });
+    }
     nextAgentRunId(taskId) {
         return this.#nextTaskRecordId(taskId, "agentRun");
     }
@@ -926,7 +961,9 @@ export class FileTaskStore {
             if (task.status !== "active")
                 continue;
             for (const run of this.listAgentRuns(task.id)) {
-                if (run.status === "active" && run.providerRetry?.nextAttemptAt !== undefined) {
+                if (run.status === "active"
+                    && run.providerRetry !== undefined
+                    && providerRetryWakeAt(run.providerRetry) !== null) {
                     throw new StorageRecordError("Provider retry in place requires the SQLite backend; run `yui update` to migrate this Home.");
                 }
             }
@@ -1920,6 +1957,7 @@ function emptyStoredTask(task) {
         roleSessionSets: {},
         jobCallerKeyHashes: {},
         workItems: {},
+        contextSnapshots: {},
         agentRuns: {},
         reviewRounds: {},
         activeRuns: {},
@@ -1939,6 +1977,7 @@ function emptyStoredTask(task) {
 function emptyTaskIdHighWaterMarks() {
     return {
         workItem: 0,
+        contextSnapshot: 0,
         agentRun: 0,
         reviewRound: 0,
         reviewFinding: 0,
@@ -2137,6 +2176,7 @@ function parseStoredTask(value, taskId) {
         "roleSessionSets",
         "jobCallerKeyHashes",
         "workItems",
+        "contextSnapshots",
         "agentRuns",
         "reviewRounds",
         "activeRuns",
@@ -2226,6 +2266,14 @@ function parseStoredTask(value, taskId) {
         validateWorkItem(item);
         return item;
     }, "workItems");
+    parseMap(aggregate.contextSnapshots, (record, key) => {
+        const snapshot = identified(record, CURRENT_CONTEXT_SNAPSHOT_SCHEMA_VERSION, "id", key, "Context Snapshot");
+        if (snapshot.taskId !== taskId) {
+            throw new StorageRecordError(`Context Snapshot belongs to another Task: ${snapshot.taskId}.`);
+        }
+        validateContextSnapshot(snapshot);
+        return snapshot;
+    }, "contextSnapshots");
     parseMap(aggregate.agentRuns, (record, key) => {
         const run = identified(record, CURRENT_AGENT_RUN_SCHEMA_VERSION, "id", key, "Agent run");
         if (run.taskId !== taskId) {
@@ -2357,6 +2405,7 @@ function parseStoredTask(value, taskId) {
 function validateTaskIdHighWaterCoverage(aggregate, taskId) {
     const records = {
         workItem: aggregate.workItems,
+        contextSnapshot: aggregate.contextSnapshots,
         agentRun: aggregate.agentRuns,
         reviewRound: aggregate.reviewRounds,
         // Issue 06 dbonly: review findings are SQLite-native; the file aggregate
@@ -3230,7 +3279,7 @@ function validateCanonicalTaskReferences(state, aggregate) {
         if (sessions.inFlight !== null) {
             const run = aggregate.agentRuns[sessions.inFlight.runId];
             if (run === undefined || run.roleName !== roleName
-                || sessions.inFlight.receiptId !== formatAgentRunReceiptId(taskId, run.id)) {
+                || sessions.inFlight.receiptId !== agentRunDeliveryReceiptId(run)) {
                 throw new StorageRecordError(`Task Role in-flight Run is invalid: ${taskId}/${roleName}.`);
             }
         }

package/dist/storage/upgrade/recordVersions.js

@@ -16,7 +16,7 @@
  * transform in the production migration graph.
  */
 import { CURRENT_AGGREGATE_SCHEMA_VERSION, CURRENT_STORAGE_LAYOUT_VERSION } from "../storageVersions.js";
-import { CURRENT_AGENT_RUN_SCHEMA_VERSION, CURRENT_ACTIVE_RUN_POINTER_SCHEMA_VERSION, CURRENT_AGENT_PROFILE_SCHEMA_VERSION, CURRENT_CAPABILITY_GRANT_SCHEMA_VERSION, CURRENT_CONFIG_SCHEMA_VERSION, CURRENT_CONFIGURED_AGENT_SCHEMA_VERSION, CURRENT_CHANGE_SET_SCHEMA_VERSION, CURRENT_DECISION_SCHEMA_VERSION, CURRENT_EVENT_SCHEMA_VERSION, CURRENT_GLOBAL_ROLE_SCHEMA_VERSION, CURRENT_GLOBAL_ROLE_SESSION_SET_SCHEMA_VERSION, CURRENT_INPUT_REQUEST_SCHEMA_VERSION, CURRENT_INTEGRATION_ATTEMPT_SCHEMA_VERSION, CURRENT_INTEGRATION_QUEUE_SCHEMA_VERSION, CURRENT_MANAGED_WORKSPACE_SCHEMA_VERSION, CURRENT_MESSAGE_SCHEMA_VERSION, CURRENT_MILESTONE_SCHEMA_VERSION, CURRENT_PUBLICATION_REFERENCE_SCHEMA_VERSION, CURRENT_PROJECT_SCHEMA_VERSION, CURRENT_RELEASE_WORKFLOW_SCHEMA_VERSION, CURRENT_REVIEW_ROUND_SCHEMA_VERSION, CURRENT_STORED_TASK_SCHEMA_VERSION, CURRENT_TASK_BRIEF_SCHEMA_VERSION, CURRENT_TASK_ROLE_SCHEMA_VERSION, CURRENT_TASK_ROLE_SESSION_SET_SCHEMA_VERSION, CURRENT_TASK_SCHEMA_VERSION, CURRENT_WORK_ITEM_SCHEMA_VERSION, CURRENT_WORK_MAILBOX_SCHEMA_VERSION } from "../taskStore.js";
+import { CURRENT_AGENT_RUN_SCHEMA_VERSION, CURRENT_ACTIVE_RUN_POINTER_SCHEMA_VERSION, CURRENT_AGENT_PROFILE_SCHEMA_VERSION, CURRENT_CAPABILITY_GRANT_SCHEMA_VERSION, CURRENT_CONFIG_SCHEMA_VERSION, CURRENT_CONFIGURED_AGENT_SCHEMA_VERSION, CURRENT_CHANGE_SET_SCHEMA_VERSION, CURRENT_CONTEXT_SNAPSHOT_SCHEMA_VERSION, CURRENT_DECISION_SCHEMA_VERSION, CURRENT_EVENT_SCHEMA_VERSION, CURRENT_GLOBAL_ROLE_SCHEMA_VERSION, CURRENT_GLOBAL_ROLE_SESSION_SET_SCHEMA_VERSION, CURRENT_INPUT_REQUEST_SCHEMA_VERSION, CURRENT_INTEGRATION_ATTEMPT_SCHEMA_VERSION, CURRENT_INTEGRATION_QUEUE_SCHEMA_VERSION, CURRENT_MANAGED_WORKSPACE_SCHEMA_VERSION, CURRENT_MESSAGE_SCHEMA_VERSION, CURRENT_MILESTONE_SCHEMA_VERSION, CURRENT_PUBLICATION_REFERENCE_SCHEMA_VERSION, CURRENT_PROJECT_SCHEMA_VERSION, CURRENT_RELEASE_WORKFLOW_SCHEMA_VERSION, CURRENT_REVIEW_ROUND_SCHEMA_VERSION, CURRENT_STORED_TASK_SCHEMA_VERSION, CURRENT_TASK_BRIEF_SCHEMA_VERSION, CURRENT_TASK_ROLE_SCHEMA_VERSION, CURRENT_TASK_ROLE_SESSION_SET_SCHEMA_VERSION, CURRENT_TASK_SCHEMA_VERSION, CURRENT_WORK_ITEM_SCHEMA_VERSION, CURRENT_WORK_MAILBOX_SCHEMA_VERSION } from "../taskStore.js";
 import { CURRENT_LEADER_FAILURE_SCHEMA_VERSION } from "../../scheduler/leaderFailure.js";
 import { CURRENT_OPERATOR_NOTIFICATION_SCHEMA_VERSION } from "../../scheduler/operatorNotification.js";
 import { CURRENT_TASK_WAKE_SCHEMA_VERSION } from "../../scheduler/taskWake.js";
@@ -44,6 +44,7 @@ const EXPECTED_DIRECT_RECORD_LOCATORS = Object.freeze({
     managedWorkspace: "state.json#/tasks/*/managedWorkspaces",
     taskRoleSessionSet: "state.json#/tasks/*/roleSessionSets",
     workItem: "state.json#/tasks/*/workItems",
+    contextSnapshot: "state.json#/tasks/*/contextSnapshots",
     agentRun: "state.json#/tasks/*/agentRuns",
     reviewRound: "state.json#/tasks/*/reviewRounds",
     changeSet: "state.json#/tasks/*/changeSets",
@@ -99,6 +100,7 @@ function getCurrentRecordDescriptors() {
             managedWorkspace: descriptor(CURRENT_MANAGED_WORKSPACE_SCHEMA_VERSION, "state.json#/tasks/*/managedWorkspaces"),
             taskRoleSessionSet: descriptor(CURRENT_TASK_ROLE_SESSION_SET_SCHEMA_VERSION, "state.json#/tasks/*/roleSessionSets"),
             workItem: descriptor(CURRENT_WORK_ITEM_SCHEMA_VERSION, "state.json#/tasks/*/workItems"),
+            contextSnapshot: descriptor(CURRENT_CONTEXT_SNAPSHOT_SCHEMA_VERSION, "state.json#/tasks/*/contextSnapshots"),
             agentRun: descriptor(CURRENT_AGENT_RUN_SCHEMA_VERSION, "state.json#/tasks/*/agentRuns"),
             reviewRound: descriptor(CURRENT_REVIEW_ROUND_SCHEMA_VERSION, "state.json#/tasks/*/reviewRounds"),
             changeSet: descriptor(CURRENT_CHANGE_SET_SCHEMA_VERSION, "state.json#/tasks/*/changeSets"),

package/dist/storage/upgrade/sqliteStateMigration.js

@@ -176,6 +176,7 @@ function asStoredTask(value) {
         managedWorkspaces: asObjectMap(record.managedWorkspaces),
         roleSessionSets: asObjectMap(record.roleSessionSets),
         workItems: asObjectMap(record.workItems),
+        contextSnapshots: asObjectMap(record.contextSnapshots),
         agentRuns: asObjectMap(record.agentRuns),
         reviewRounds: asObjectMap(record.reviewRounds),
         changeSets: asObjectMap(record.changeSets),
@@ -271,6 +272,9 @@ export function populateSqliteFromState(home, state, databaseFilename) {
                 for (const item of Object.values(stored.workItems)) {
                     store.saveWorkItem(taskId, item);
                 }
+                for (const snapshot of Object.values(stored.contextSnapshots)) {
+                    store.saveContextSnapshot(snapshot);
+                }
                 for (const run of Object.values(stored.agentRuns)) {
                     store.saveAgentRun(run);
                 }
@@ -451,6 +455,7 @@ export function computeStateFamilyChecksums(state) {
     const workspaces = [];
     const roleSessionSets = [];
     const workItems = [];
+    const contextSnapshots = [];
     const agentRuns = [];
     const reviewRounds = [];
     const changeSets = [];
@@ -478,6 +483,7 @@ export function computeStateFamilyChecksums(state) {
         workspaces.push(...Object.values(stored.managedWorkspaces));
         roleSessionSets.push(...Object.values(stored.roleSessionSets));
         workItems.push(...Object.values(stored.workItems));
+        contextSnapshots.push(...Object.values(stored.contextSnapshots));
         agentRuns.push(...Object.values(stored.agentRuns));
         reviewRounds.push(...Object.values(stored.reviewRounds));
         changeSets.push(...Object.values(stored.changeSets));
@@ -517,6 +523,7 @@ export function computeStateFamilyChecksums(state) {
     checksums.managedWorkspace = hashRecords(workspaces);
     checksums.taskRoleSessionSet = hashRecords(roleSessionSets);
     checksums.workItem = hashRecords(workItems);
+    checksums.contextSnapshot = hashRecords(contextSnapshots);
     checksums.agentRun = hashRecords(agentRuns);
     checksums.reviewRound = hashRecords(reviewRounds);
     checksums.changeSet = hashRecords(changeSets);
@@ -605,6 +612,7 @@ export function computeDbFamilyChecksums(home, databaseFilename) {
         checksums.managedWorkspace = hashPayloadTable(db, "SELECT payload FROM managed_workspaces");
         checksums.taskRoleSessionSet = hashPayloadTable(db, "SELECT payload FROM role_session_sets");
         checksums.workItem = hashPayloadTable(db, "SELECT payload FROM work_items");
+        checksums.contextSnapshot = hashPayloadTable(db, "SELECT payload FROM context_snapshots");
         checksums.agentRun = hashPayloadTable(db, "SELECT payload FROM agent_runs");
         checksums.reviewRound = hashPayloadTable(db, "SELECT payload FROM review_rounds");
         checksums.changeSet = hashPayloadTable(db, "SELECT payload FROM change_sets");
@@ -733,6 +741,7 @@ export function readStateFromSqlite(home) {
                 managedWorkspaces: {},
                 roleSessionSets: {},
                 workItems: {},
+                contextSnapshots: {},
                 agentRuns: {},
                 reviewRounds: {},
                 changeSets: {},
@@ -760,6 +769,7 @@ export function readStateFromSqlite(home) {
         loadTaskPayloadMap(db, "managed_workspaces", tasks, "managedWorkspaces", (record) => managedWorkspaceKey(record.owner));
         loadTaskPayloadMap(db, "role_session_sets", tasks, "roleSessionSets", (record) => record.owner.roleName);
         loadTaskPayloadMap(db, "work_items", tasks, "workItems", (record) => record.id);
+        loadTaskPayloadMap(db, "context_snapshots", tasks, "contextSnapshots", (record) => record.id);
         loadTaskPayloadMap(db, "agent_runs", tasks, "agentRuns", (record) => record.id);
         loadTaskPayloadMap(db, "review_rounds", tasks, "reviewRounds", (record) => record.id);
         loadTaskPayloadMap(db, "change_sets", tasks, "changeSets", (record) => record.id);

package/dist/task/taskRecordReference.js

@@ -1,6 +1,7 @@
 import { requireIdentity } from "../domain/validation.js";
 export const TASK_RECORD_ID_PREFIXES = {
     workItem: "work-item",
+    contextSnapshot: "context-snapshot",
     agentRun: "agent-run",
     reviewRound: "review-round",
     reviewFinding: "review-finding",

package/dist/tmux/tmuxManager.js

@@ -483,7 +483,7 @@ export class TmuxManager {
         try {
             output = this.run([
                 "list-panes", "-s", "-t", this.sessionName(taskId), "-F",
-                `#{window_name}${formatSeparator}#{pane_dead}${formatSeparator}#{pane_pid}${formatSeparator}#{pane_current_command}`
+                `#{window_name}${formatSeparator}#{pane_dead}${formatSeparator}#{pane_dead_status}${formatSeparator}#{pane_pid}${formatSeparator}#{pane_current_command}`
             ]);
         }
         catch (error) {
@@ -495,9 +495,10 @@ export class TmuxManager {
             if (line.length === 0)
                 return [];
             const separator = line.includes(encodedSeparator) ? encodedSeparator : formatSeparator;
-            const [roleName, deadText, pidText, currentCommand, ...extra] = line.split(separator);
+            const [roleName, deadText, deadStatusText, pidText, currentCommand, ...extra] = line.split(separator);
             if (roleName === undefined
                 || deadText === undefined
+                || deadStatusText === undefined
                 || pidText === undefined
                 || currentCommand === undefined
                 || extra.length > 0
@@ -505,11 +506,13 @@ export class TmuxManager {
                 throw runtimeError(`Tmux returned an invalid Task Role pane state for ${taskId}.`);
             }
             const pid = Number(pidText);
+            const deadStatus = Number(deadStatusText);
             return [{
                     taskId,
                     roleName,
                     target: this.target(taskId, roleName),
                     dead: deadText === "1",
+                    ...(Number.isSafeInteger(deadStatus) && deadStatus >= 0 ? { deadStatus } : {}),
                     ...(Number.isSafeInteger(pid) && pid > 0 ? { pid } : {}),
                     currentCommand
                 }];
@@ -532,6 +535,7 @@ export class TmuxManager {
                     "#{session_name}",
                     "#{window_name}",
                     "#{pane_dead}",
+                    "#{pane_dead_status}",
                     "#{pane_pid}",
                     "#{pane_current_command}"
                 ].join(formatSeparator)
@@ -546,10 +550,11 @@ export class TmuxManager {
             if (line.length === 0)
                 return [];
             const separator = line.includes(encodedSeparator) ? encodedSeparator : formatSeparator;
-            const [sessionName, roleName, deadText, pidText, currentCommand, ...extra] = line.split(separator);
+            const [sessionName, roleName, deadText, deadStatusText, pidText, currentCommand, ...extra] = line.split(separator);
             if (sessionName === undefined
                 || roleName === undefined
                 || deadText === undefined
+                || deadStatusText === undefined
                 || pidText === undefined
                 || currentCommand === undefined
                 || extra.length > 0
@@ -563,11 +568,13 @@ export class TmuxManager {
                 throw runtimeError("Tmux returned an invalid Yui Role pane identity.");
             }
             const pid = Number(pidText);
+            const deadStatus = Number(deadStatusText);
             return [{
                     taskId,
                     roleName,
                     target: this.target(taskId, roleName),
                     dead: deadText === "1",
+                    ...(Number.isSafeInteger(deadStatus) && deadStatus >= 0 ? { deadStatus } : {}),
                     ...(Number.isSafeInteger(pid) && pid > 0 ? { pid } : {}),
                     currentCommand
                 }];
@@ -585,6 +592,7 @@ export class TmuxManager {
                     "#{session_name}",
                     "#{window_name}",
                     "#{pane_dead}",
+                    "#{pane_dead_status}",
                     "#{pane_pid}",
                     "#{pane_current_command}"
                 ].join(formatSeparator)
@@ -1059,10 +1067,11 @@ function parseRolePaneInventory(output, formatSeparator, encodedSeparator, sessi
         if (line.length === 0)
             return [];
         const separator = line.includes(encodedSeparator) ? encodedSeparator : formatSeparator;
-        const [sessionName, roleName, deadText, pidText, currentCommand, ...extra] = line.split(separator);
+        const [sessionName, roleName, deadText, deadStatusText, pidText, currentCommand, ...extra] = line.split(separator);
         if (sessionName === undefined
             || roleName === undefined
             || deadText === undefined
+            || deadStatusText === undefined
             || pidText === undefined
             || currentCommand === undefined
             || extra.length > 0
@@ -1076,11 +1085,13 @@ function parseRolePaneInventory(output, formatSeparator, encodedSeparator, sessi
             throw runtimeError("Tmux returned an invalid Yui Role pane identity.");
         }
         const pid = Number(pidText);
+        const deadStatus = Number(deadStatusText);
         return [{
                 taskId,
                 roleName,
                 target: target(taskId, roleName),
                 dead: deadText === "1",
+                ...(Number.isSafeInteger(deadStatus) && deadStatus >= 0 ? { deadStatus } : {}),
                 ...(Number.isSafeInteger(pid) && pid > 0 ? { pid } : {}),
                 currentCommand
             }];

package/dist/web/assets/client/components.js

@@ -509,7 +509,7 @@ export function runCard(run, t, locale) {
   idRow.append(node("time", "", formatDateTime(run.endedAt || run.updatedAt, locale)));
   card.append(idRow);
 
-  card.append(richText(t("detail.instruction"), run.input, t, { className: "execute-io", threshold: 320 }));
+  card.append(richText(t("detail.instruction"), run.assignment?.directive || run.assignment?.action || "-", t, { className: "execute-io", threshold: 320 }));
   if (run.summary) {
     card.append(richText(t("detail.outcome"), run.summary, t, { className: "execute-io outcome", threshold: 320 }));
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zq-silk/yui",
-  "version": "0.6.16",
+  "version": "0.7.0",
   "description": "Local control plane for long-running native agent CLI sessions backed by tmux.",
   "license": "MIT",
   "private": false,

package/skills/yui-leader/SKILL.md

@@ -5,6 +5,10 @@ description: Lead one Yui Task from the user's core outcome by reasoning from fi
 
 # Yui Leader
 
+Follow `yui-runtime` first and load the exact current Run Context Pack before
+making Task decisions. Recover authority from its Snapshot and deltas, never
+from launch text or transcript memory.
+
 Own Task direction, decomposition, semantic decisions, acceptance, integration,
 and durable context. Yui has one work model: every bounded outcome is a
 WorkItem. Choose one of three execution paths for each WorkItem:
@@ -213,11 +217,11 @@ yui task wake show <task-id> <wake-id>
 ```
 
 For a fresh generation (no native history), or when the envelope indicates a
-major change, start with the complete Task projection, then follow its Project
-Policy references:
+major change, start with the exact Run Context Pack loaded through
+`yui-runtime`, expand only its authorized Task and Project Policy refs, then
+inspect Project-owned records as needed:
 
 ```sh
-yui task context <task-id>
 yui project show <project>
 yui project knowledge list <project>
 ```
@@ -361,7 +365,7 @@ yui task work update <work-id> done \
 Use `failed` with recovery context when it cannot be completed. Do not mark
 work done before checking its acceptance criteria. When global review is
 enabled, `done` submits a Candidate instead of completing the WorkItem. Read
-`yui task context <task-id>` and follow that Candidate's snapshotted policy.
+the exact Run Context Pack and follow that Candidate's snapshotted policy.
 
 ## Create a native subagent
 
@@ -488,7 +492,8 @@ delivers evidence and moves the WorkItem to Leader review; it is not acceptance.
 ## Review, retry, capture, and integrate
 
 After any Candidate is submitted, inspect its exact policy, Run result,
-ReviewRounds, checks, and workspace through `task context`.
+ReviewRounds, checks, and workspace through the exact Run Context Pack and its
+authorized expansions.
 
 - `always`: wait for the automatically requested ReviewRound to become
   terminal. Never bypass an active round.

package/skills/yui-operator/SKILL.md

@@ -5,6 +5,10 @@ description: Route multi-project user requests into Yui Tasks, preserve durable
 
 # Yui Operator
 
+Follow `yui-runtime` for every routed managed Run. Load only the exact
+authorized Context Pack; do not infer Task authority from a prompt, process, or
+workspace.
+
 Be the task-neutral user entry point. The user should be able to discuss
 features, bugs, investigations, and questions across multiple Projects without
 managing Yui records. Route each request to the correct Project and Task; leave

package/skills/yui-reviewer/SKILL.md

@@ -5,6 +5,10 @@ description: Review the exact frozen WorkItem Candidate or Task-final Integratio
 
 # Yui Reviewer
 
+Follow `yui-runtime` first and load the exact current Run Context Pack. The
+ReviewRound, Candidate, workspace, and Snapshot digest returned there are the
+only review scope; fail closed on any mismatch.
+
 Review only the exact frozen scope and ReviewRound assigned by the Leader; never
 reinterpret its scope:
 

package/skills/yui-runtime/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: yui-runtime
+description: Load and use the exact authorized context for every Yui-managed Leader, Worker, Reviewer, Operator, or custom Role Run, and complete that Run through its bounded control-plane protocol.
+---
+
+# Yui Runtime
+
+Treat the Session Manifest and Run Bootstrap Envelope as pointers, never as the
+Task brief. Do not infer Task facts from the launch command, process list,
+workspace layout, native transcript, or an earlier Run.
+
+For every managed Task Run:
+
+1. Read the exact Run identity from the newest Bootstrap Envelope.
+2. Before acting, load its authorized pack with the exact Session CLI:
+
+   ```sh
+   "$YUI_SESSION_CLI" task run context "$YUI_TASK_ID/<run-id>" --json
+   ```
+
+3. Verify that the returned Task, Run, Role, purpose, Snapshot digest, workspace,
+   and Adapter match the Envelope and Session Manifest. Stop and report a
+   context-load failure if the pack is missing, stale, unauthorized, malformed,
+   or mismatched. Never request an inline/full-prompt fallback.
+4. Use pack summaries and pointers first. Expand only an authorized ref when
+   its full value is needed:
+
+   ```sh
+   "$YUI_SESSION_CLI" task run context expand "$YUI_TASK_ID/<run-id>" <ref-id> --mode full --json
+   ```
+
+5. On a later wake, request only the declared delta after the last pack cursor.
+   If no cursor is available, reload the exact pack; do not reconstruct state
+   from transcript memory.
+
+The pack's authority view and writable Project IDs are hard boundaries. A
+native subagent inherits the parent Run's refs and authority; it does not gain a
+new Yui actor, Run, Session, or cross-Task read permission.
+
+For a global Operator or custom GlobalRole Session, load the stable exact view
+before routing or acting:
+
+```sh
+"$YUI_SESSION_CLI" role context "$YUI_ROLE" --json
+```
+
+Global context grants no Task implementation workspace. Read a Task only after
+the Operator has routed to its public/task-authorized context command; never
+invent a Task Run identity for a GlobalRole.
+
+Provider acceptance, Context load, and workflow completion are separate facts.
+Do not treat a live pane, process output, final response, or completed Provider
+Turn as a Yui yield. For a managed Task Run, use the exact current Run's
+supported checkpoint/yield command as the final control-plane action, then stop
+immediately. If that direct command is denied or stale, report the blocker once
+and stop; do not wrap, retry, broaden permissions, or target another Run.
+
+For a transient Provider retry Envelope, continue the failed Turn in the same
+native Session. Do not replay the original Assignment or reload unrelated Task
+content. Process/child replacement does not by itself authorize a new Yui
+generation or native conversation.