@zq-silk/yui 0.13.8 → 0.13.9

package/dist/storage/migration/productionRegistry.js

@@ -51,6 +51,8 @@ const AGENT_RUN_CONTEXT_PROTOCOL_FROM_VERSION = 7;
 const AGENT_RUN_CONTEXT_PROTOCOL_TO_VERSION = 8;
 const AGENT_RUN_RETRY_EPISODE_FROM_VERSION = 8;
 const AGENT_RUN_RETRY_EPISODE_TO_VERSION = 9;
+const AGENT_RUN_ERROR_FACTS_FROM_VERSION = 9;
+const AGENT_RUN_ERROR_FACTS_TO_VERSION = 10;
 const MESSAGE_WAKE_POLICY_FROM_VERSION = 2;
 const MESSAGE_WAKE_POLICY_TO_VERSION = 3;
 const REVIEW_ROUND_FROM_VERSION = 2;
@@ -99,6 +101,8 @@ const RELEASE_WORKFLOW_FROM_VERSION = 0;
 const RELEASE_WORKFLOW_TO_VERSION = 1;
 const WORK_MAILBOX_FROM_VERSION = 1;
 const WORK_MAILBOX_TO_VERSION = 2;
+const HOST_OWNED_WORK_MAILBOX_FROM_VERSION = 2;
+const HOST_OWNED_WORK_MAILBOX_TO_VERSION = 3;
 const TASK_ROLE_FROM_VERSION = 3;
 const TASK_ROLE_TO_VERSION = 4;
 const TASK_ROLE_SESSION_SET_FROM_VERSION = 4;
@@ -107,12 +111,18 @@ const STRUCTURED_PROVIDER_SESSION_SET_FROM_VERSION = 5;
 const STRUCTURED_PROVIDER_SESSION_SET_TO_VERSION = 6;
 const AGENT_FIRST_SESSION_SET_FROM_VERSION = 6;
 const AGENT_FIRST_SESSION_SET_TO_VERSION = 7;
+const UNIFIED_TASK_SESSION_SET_FROM_VERSION = 7;
+const UNIFIED_TASK_SESSION_SET_TO_VERSION = 8;
+const UNIFIED_GLOBAL_SESSION_SET_FROM_VERSION = 3;
+const UNIFIED_GLOBAL_SESSION_SET_TO_VERSION = 4;
 const PUBLICATION_REFERENCE_FROM_VERSION = 0;
 const PUBLICATION_REFERENCE_TO_VERSION = 1;
 const CONFIG_FROM_VERSION = 1;
 const CONFIG_TO_VERSION = 2;
 const CONFIG_REVIEW_CONTROLS_FROM_VERSION = 2;
 const CONFIG_REVIEW_CONTROLS_TO_VERSION = 3;
+const CONFIG_AGENT_RECOVERY_FROM_VERSION = 3;
+const CONFIG_AGENT_RECOVERY_TO_VERSION = 4;
 /**
  * Build the authoritative production graph. Transition intent and executable
  * transforms are registered together here; compatible loading and offline
@@ -163,6 +173,7 @@ export function createProductionStorageRegistry() {
         .registerOfflineMigration(projectOwnershipStep())
         .registerOfflineMigration(configV2Step())
         .registerOfflineMigration(configReviewControlsRemovalStep())
+        .registerOfflineMigration(configAgentRecoveryStep())
         .registerCompatible(projectKnowledgeProposalsStep())
         .registerCompatible(projectLifecycleStep())
         .registerOfflineMigration(taskWorkspaceIdentityStep())
@@ -183,6 +194,7 @@ export function createProductionStorageRegistry() {
         .registerOfflineMigration(recordFamilyStep("agentRun", AGENT_RUN_OPTIONAL_FIELDS_FROM_VERSION, AGENT_RUN_OPTIONAL_FIELDS_TO_VERSION, "agentRuns"))
         .registerOfflineMigration(agentRunContextProtocolStep())
         .registerOfflineMigration(agentRunRetryEpisodeStep())
+        .registerOfflineMigration(agentRunErrorFactsStep())
         .registerOfflineMigration(messageWakePolicyStep())
         .registerOfflineMigration(recordFamilyStep("reviewRound", REVIEW_ROUND_FROM_VERSION, REVIEW_ROUND_TO_VERSION, "reviewRounds"))
         .registerOfflineMigration(recordFamilyStep("reviewRound", REVIEW_ROUND_GIT_SNAPSHOT_FROM_VERSION, REVIEW_ROUND_GIT_SNAPSHOT_TO_VERSION, "reviewRounds"))
@@ -207,10 +219,13 @@ export function createProductionStorageRegistry() {
         .registerOfflineMigration(capabilityGrantIntroductionStep())
         .registerOfflineMigration(releaseWorkflowIntroductionStep())
         .registerOfflineMigration(workMailboxV2Step())
+        .registerOfflineMigration(hostOwnedWorkMailboxStep())
         .registerOfflineMigration(agentRunOwnedTaskRoleStep())
         .registerOfflineMigration(taskRoleSessionSetV5Step())
         .registerOfflineMigration(structuredProviderSessionSetV6Step())
         .registerOfflineMigration(agentFirstSessionSetV7Step())
+        .registerOfflineMigration(unifiedTaskSessionSetStep())
+        .registerOfflineMigration(unifiedGlobalSessionSetStep())
         .registerOfflineMigration(publicationReferenceIntroductionStep());
     assertRegistryCoversBaselineToCurrent(registry);
     return registry;
@@ -379,6 +394,53 @@ function migrateConfigV2ToV3(snapshot) {
         }
     };
 }
+/** Removes Core-owned Provider retry policy; recovery is chosen from AgentError facts. */
+function configAgentRecoveryStep() {
+    return {
+        axis: "record",
+        recordKind: "config",
+        fromVersion: CONFIG_AGENT_RECOVERY_FROM_VERSION,
+        toVersion: CONFIG_AGENT_RECOVERY_TO_VERSION,
+        preconditions: requireConfigV3,
+        transform: migrateConfigV3ToV4,
+        declaredEffects: []
+    };
+}
+function requireConfigV3(snapshot) {
+    const versions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    if (versions.config !== CONFIG_AGENT_RECOVERY_FROM_VERSION) {
+        throw new Error(`Record config migration requires manifest version ${CONFIG_AGENT_RECOVERY_FROM_VERSION}.`);
+    }
+    if (snapshot.state === null)
+        return;
+    const config = asObject(snapshot.state.config, "Yui config");
+    if (config.schemaVersion !== CONFIG_AGENT_RECOVERY_FROM_VERSION) {
+        throw new Error(`Yui config must use schemaVersion ${CONFIG_AGENT_RECOVERY_FROM_VERSION} before migration.`);
+    }
+}
+function migrateConfigV3ToV4(snapshot) {
+    requireConfigV3(snapshot);
+    const versions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: { ...versions, config: CONFIG_AGENT_RECOVERY_TO_VERSION }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const config = asObject(snapshot.state.config, "Yui config");
+    const { providerRetryMode: _mode, providerRetryAdapters: _adapters, providerRetryDelaysSeconds: _delays, providerRetryMaxWindowSeconds: _window, ...retained } = config;
+    void _mode;
+    void _adapters;
+    void _delays;
+    void _window;
+    return {
+        schemaManifest,
+        state: {
+            ...snapshot.state,
+            config: { ...retained, schemaVersion: CONFIG_AGENT_RECOVERY_TO_VERSION }
+        }
+    };
+}
 function workItemExecutionGroupHistoryStep() {
     return {
         axis: "record",
@@ -2245,6 +2307,46 @@ function migrateAgentRunsToRetryEpisodes(snapshot) {
     }
     return { schemaManifest, state: { ...snapshot.state, tasks: nextTasks } };
 }
+/** Deletes the retired retry episode; an AgentRun now records scheduling only. */
+function agentRunErrorFactsStep() {
+    return {
+        axis: "record",
+        recordKind: "agentRun",
+        fromVersion: AGENT_RUN_ERROR_FACTS_FROM_VERSION,
+        toVersion: AGENT_RUN_ERROR_FACTS_TO_VERSION,
+        preconditions: (snapshot) => requireRecordFamilyVersion(snapshot, "agentRun", AGENT_RUN_ERROR_FACTS_FROM_VERSION, "agentRuns"),
+        transform: migrateAgentRunsToErrorFacts,
+        declaredEffects: []
+    };
+}
+function migrateAgentRunsToErrorFacts(snapshot) {
+    requireRecordFamilyVersion(snapshot, "agentRun", AGENT_RUN_ERROR_FACTS_FROM_VERSION, "agentRuns");
+    const versions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: { ...versions, agentRun: AGENT_RUN_ERROR_FACTS_TO_VERSION }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    const nextTasks = {};
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const task = asObject(rawTask, `Task aggregate ${taskId}`);
+        const records = asObject(task.agentRuns ?? {}, `agentRun map ${taskId}`);
+        const nextRecords = {};
+        for (const [runId, rawRecord] of Object.entries(records)) {
+            const record = asObject(rawRecord, `agentRun ${taskId}/${runId}`);
+            const { providerRetry: _retry, ...retained } = record;
+            void _retry;
+            nextRecords[runId] = {
+                ...retained,
+                schemaVersion: AGENT_RUN_ERROR_FACTS_TO_VERSION
+            };
+        }
+        nextTasks[taskId] = { ...task, agentRuns: nextRecords };
+    }
+    return { schemaManifest, state: { ...snapshot.state, tasks: nextTasks } };
+}
 function requiredMigrationPositiveInteger(value, label) {
     if (!Number.isSafeInteger(value) || value < 1) {
         throw new Error(`${label} must be a positive integer.`);
@@ -2683,6 +2785,77 @@ function migrateWorkMailboxV1ToV2(snapshot) {
         state: { ...snapshot.state, mailboxes: nextMailboxes }
     };
 }
+/** A Host launch reservation belongs to the Role owner and launchId, never a Run. */
+function hostOwnedWorkMailboxStep() {
+    return {
+        axis: "record",
+        recordKind: "workMailbox",
+        fromVersion: HOST_OWNED_WORK_MAILBOX_FROM_VERSION,
+        toVersion: HOST_OWNED_WORK_MAILBOX_TO_VERSION,
+        preconditions: requireWorkMailboxV2Family,
+        transform: migrateWorkMailboxV2ToV3,
+        declaredEffects: []
+    };
+}
+function requireWorkMailboxV2Family(snapshot) {
+    const versions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    if (versions.workMailbox !== HOST_OWNED_WORK_MAILBOX_FROM_VERSION) {
+        throw new Error(`Record workMailbox migration requires manifest version ${HOST_OWNED_WORK_MAILBOX_FROM_VERSION}.`);
+    }
+    if (snapshot.state === null)
+        return;
+    const mailboxes = asObject(snapshot.state.mailboxes, "state mailboxes");
+    for (const [key, rawMailbox] of Object.entries(mailboxes)) {
+        const mailbox = asObject(rawMailbox, `WorkMailbox ${key}`);
+        if (mailbox.schemaVersion !== HOST_OWNED_WORK_MAILBOX_FROM_VERSION) {
+            throw new Error(`WorkMailbox ${key} must use schemaVersion ${HOST_OWNED_WORK_MAILBOX_FROM_VERSION}.`);
+        }
+    }
+}
+function migrateWorkMailboxV2ToV3(snapshot) {
+    requireWorkMailboxV2Family(snapshot);
+    const versions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: { ...versions, workMailbox: HOST_OWNED_WORK_MAILBOX_TO_VERSION }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const mailboxes = asObject(snapshot.state.mailboxes, "state mailboxes");
+    const nextMailboxes = {};
+    for (const [key, rawMailbox] of Object.entries(mailboxes)) {
+        const mailbox = asObject(rawMailbox, `WorkMailbox ${key}`);
+        const target = asObject(mailbox.target, `WorkMailbox ${key} target`);
+        const processing = mailbox.processing === null
+            ? null
+            : asObject(mailbox.processing, `WorkMailbox ${key} processing`);
+        const batch = processing === null
+            ? null
+            : asObject(processing.batch, `WorkMailbox ${key} processing batch`);
+        const lifecycleReservation = (target.kind === "role-runtime"
+            || target.kind === "global-role-runtime")
+            && Array.isArray(batch?.reasons)
+            && batch.reasons.includes("runtime-launch-reserved");
+        const nextProcessing = processing === null
+            ? null
+            : lifecycleReservation
+                ? (() => {
+                    const { executionRef: _run, ...retained } = processing;
+                    void _run;
+                    return retained;
+                })()
+                : processing;
+        nextMailboxes[key] = {
+            ...mailbox,
+            schemaVersion: HOST_OWNED_WORK_MAILBOX_TO_VERSION,
+            processing: nextProcessing
+        };
+    }
+    return {
+        schemaManifest,
+        state: { ...snapshot.state, mailboxes: nextMailboxes }
+    };
+}
 /**
  * v1 used `processing` for both internal/initial dispatch ownership and later
  * model input.  A crashed later input may already have reached the provider;
@@ -2861,6 +3034,165 @@ function migrateTaskRoleSessionSetV6ToV7(snapshot) {
     }
     return { schemaManifest, state: { ...snapshot.state, tasks: nextTasks } };
 }
+/** Session stores existence only; Host readiness and Turn activity are runtime facts. */
+function unifiedTaskSessionSetStep() {
+    return {
+        axis: "record",
+        recordKind: "taskRoleSessionSet",
+        fromVersion: UNIFIED_TASK_SESSION_SET_FROM_VERSION,
+        toVersion: UNIFIED_TASK_SESSION_SET_TO_VERSION,
+        preconditions: requireTaskRoleSessionSetV7Family,
+        transform: migrateTaskRoleSessionSetV7ToV8,
+        declaredEffects: []
+    };
+}
+function requireTaskRoleSessionSetV7Family(snapshot) {
+    const versions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    if (versions.taskRoleSessionSet !== UNIFIED_TASK_SESSION_SET_FROM_VERSION) {
+        throw new Error(`Record taskRoleSessionSet migration requires manifest version ${UNIFIED_TASK_SESSION_SET_FROM_VERSION}.`);
+    }
+    if (snapshot.state === null)
+        return;
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    for (const [taskId, rawAggregate] of Object.entries(tasks)) {
+        const aggregate = asObject(rawAggregate, `Task aggregate ${taskId}`);
+        const sets = asObject(aggregate.roleSessionSets, `Task Role session sets ${taskId}`);
+        for (const [roleName, rawSet] of Object.entries(sets)) {
+            const set = asObject(rawSet, `Task Role session set ${taskId}/${roleName}`);
+            if (set.schemaVersion !== UNIFIED_TASK_SESSION_SET_FROM_VERSION) {
+                throw new Error(`Task Role session set ${taskId}/${roleName} must use schemaVersion ${UNIFIED_TASK_SESSION_SET_FROM_VERSION}.`);
+            }
+        }
+    }
+}
+function migrateTaskRoleSessionSetV7ToV8(snapshot) {
+    requireTaskRoleSessionSetV7Family(snapshot);
+    const versions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: {
+            ...versions,
+            taskRoleSessionSet: UNIFIED_TASK_SESSION_SET_TO_VERSION
+        }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    const nextTasks = {};
+    for (const [taskId, rawAggregate] of Object.entries(tasks)) {
+        const aggregate = asObject(rawAggregate, `Task aggregate ${taskId}`);
+        const sets = asObject(aggregate.roleSessionSets, `Task Role session sets ${taskId}`);
+        const nextSets = {};
+        for (const [roleName, rawSet] of Object.entries(sets)) {
+            const set = asObject(rawSet, `Task Role session set ${taskId}/${roleName}`);
+            const sessions = migrateRoleAgentSessionMap(set.sessions, `Task Role sessions ${taskId}/${roleName}`);
+            const history = set.history === undefined
+                ? undefined
+                : migrateRoleAgentSessionArray(set.history, `Task Role session history ${taskId}/${roleName}`);
+            nextSets[roleName] = {
+                ...set,
+                schemaVersion: UNIFIED_TASK_SESSION_SET_TO_VERSION,
+                sessions,
+                ...(history === undefined ? {} : { history })
+            };
+        }
+        nextTasks[taskId] = { ...aggregate, roleSessionSets: nextSets };
+    }
+    return { schemaManifest, state: { ...snapshot.state, tasks: nextTasks } };
+}
+function unifiedGlobalSessionSetStep() {
+    return {
+        axis: "record",
+        recordKind: "globalRoleSessionSet",
+        fromVersion: UNIFIED_GLOBAL_SESSION_SET_FROM_VERSION,
+        toVersion: UNIFIED_GLOBAL_SESSION_SET_TO_VERSION,
+        preconditions: requireGlobalRoleSessionSetV3Family,
+        transform: migrateGlobalRoleSessionSetV3ToV4,
+        declaredEffects: []
+    };
+}
+function requireGlobalRoleSessionSetV3Family(snapshot) {
+    const versions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    if (versions.globalRoleSessionSet !== UNIFIED_GLOBAL_SESSION_SET_FROM_VERSION) {
+        throw new Error(`Record globalRoleSessionSet migration requires manifest version ${UNIFIED_GLOBAL_SESSION_SET_FROM_VERSION}.`);
+    }
+    if (snapshot.state === null)
+        return;
+    const sets = asObject(snapshot.state.globalRoleSessionSets, "Global Role session sets");
+    for (const [roleName, rawSet] of Object.entries(sets)) {
+        const set = asObject(rawSet, `Global Role session set ${roleName}`);
+        if (set.schemaVersion !== UNIFIED_GLOBAL_SESSION_SET_FROM_VERSION) {
+            throw new Error(`Global Role session set ${roleName} must use schemaVersion ${UNIFIED_GLOBAL_SESSION_SET_FROM_VERSION}.`);
+        }
+    }
+}
+function migrateGlobalRoleSessionSetV3ToV4(snapshot) {
+    requireGlobalRoleSessionSetV3Family(snapshot);
+    const versions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: {
+            ...versions,
+            globalRoleSessionSet: UNIFIED_GLOBAL_SESSION_SET_TO_VERSION
+        }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const sets = asObject(snapshot.state.globalRoleSessionSets, "Global Role session sets");
+    const nextSets = {};
+    for (const [roleName, rawSet] of Object.entries(sets)) {
+        const set = asObject(rawSet, `Global Role session set ${roleName}`);
+        const history = set.history === undefined
+            ? undefined
+            : migrateRoleAgentSessionMap(set.history, `Global Role session history ${roleName}`);
+        nextSets[roleName] = {
+            ...set,
+            schemaVersion: UNIFIED_GLOBAL_SESSION_SET_TO_VERSION,
+            sessions: migrateRoleAgentSessionMap(set.sessions, `Global Role sessions ${roleName}`),
+            ...(history === undefined ? {} : { history })
+        };
+    }
+    return {
+        schemaManifest,
+        state: { ...snapshot.state, globalRoleSessionSets: nextSets }
+    };
+}
+function migrateRoleAgentSessionMap(value, label) {
+    const sessions = asObject(value, label);
+    return Object.fromEntries(Object.entries(sessions).map(([key, session]) => [
+        key,
+        migrateRoleAgentSessionV3(session, `${label}/${key}`)
+    ]));
+}
+function migrateRoleAgentSessionArray(value, label) {
+    if (!Array.isArray(value))
+        throw new Error(`${label} must be an array.`);
+    return value.map((session, index) => migrateRoleAgentSessionV3(session, `${label}/${String(index)}`));
+}
+function migrateRoleAgentSessionV3(value, label) {
+    const session = asObject(value, label);
+    if (session.schemaVersion !== 3) {
+        throw new Error(`${label} must use schemaVersion 3.`);
+    }
+    const status = session.status;
+    if (status !== "reserved"
+        && status !== "ready"
+        && status !== "running"
+        && status !== "stopped"
+        && status !== "broken") {
+        throw new Error(`${label} has an invalid Session status.`);
+    }
+    const { status: _status, ...retained } = session;
+    void _status;
+    return {
+        ...retained,
+        schemaVersion: 4,
+        status: status === "stopped" || status === "broken" ? "ended" : "active",
+        ...(status === "stopped"
+            ? { endReason: "stopped" }
+            : status === "broken" ? { endReason: "failed" } : {})
+    };
+}
 function requireTaskRoleSessionSetV5Family(snapshot) {
     const versions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
     if (versions.taskRoleSessionSet !== STRUCTURED_PROVIDER_SESSION_SET_FROM_VERSION) {

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 = 17;
+export const SQLITE_SCHEMA_VERSION = 18;
 /** 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;
@@ -934,6 +934,57 @@ CREATE TABLE IF NOT EXISTS context_snapshots (
 CREATE UNIQUE INDEX IF NOT EXISTS idx_context_snapshots_scope_sequence
   ON context_snapshots(task_id, scope, COALESCE(scope_ref, ''), sequence);
 `;
+/**
+ * Migration 18: align the current-Session hot projection with Session v4.
+ *
+ * Session existence now has one lifecycle: active or ended. Ended Sessions do
+ * not belong in this bounded projection, so row presence itself means active;
+ * the projection carries no independently writable lifecycle status. Host
+ * cleanup is derived solely from whether the Session still names a Host
+ * activation. Valid earlier live rows are projected into that contract;
+ * terminal broken rows disappear with the rest of ended Session history.
+ */
+const MIGRATION_18_SQL = `
+DROP INDEX idx_runtime_session_cleanup_required;
+ALTER TABLE runtime_session_candidates RENAME TO runtime_session_candidates_v11;
+
+CREATE TABLE runtime_session_candidates (
+  scope               TEXT NOT NULL CHECK (scope IN ('task','global')),
+  task_id             TEXT NOT NULL,
+  role_name           TEXT NOT NULL,
+  agent_id            TEXT NOT NULL,
+  adapter_id          TEXT NOT NULL,
+  native_session_id   TEXT NOT NULL,
+  launch_id           TEXT,
+  session_updated_at  TEXT NOT NULL,
+  cleanup_required    INTEGER NOT NULL CHECK (cleanup_required IN (0,1)),
+  PRIMARY KEY (scope, task_id, role_name),
+  CHECK (
+    (scope = 'task' AND length(task_id) > 0)
+    OR (scope = 'global' AND task_id = '')
+  ),
+  CHECK (
+    cleanup_required = CASE WHEN launch_id IS NOT NULL THEN 1 ELSE 0 END
+  )
+);
+
+INSERT INTO runtime_session_candidates (
+  scope, task_id, role_name, agent_id, adapter_id, native_session_id,
+  launch_id, session_updated_at, cleanup_required
+)
+SELECT
+  scope, task_id, role_name, agent_id, adapter_id, native_session_id,
+  launch_id, session_updated_at,
+  CASE WHEN launch_id IS NOT NULL THEN 1 ELSE 0 END
+FROM runtime_session_candidates_v11
+WHERE status IN ('reserved','ready','running');
+
+DROP TABLE runtime_session_candidates_v11;
+
+CREATE INDEX idx_runtime_session_cleanup_required
+  ON runtime_session_candidates(scope, task_id, role_name)
+  WHERE cleanup_required = 1;
+`;
 /**
  * The single forward migration history for current SQLite Homes. New durable
  * layout, aggregate, and record changes belong here and must be expressible as
@@ -957,7 +1008,8 @@ const MIGRATIONS = [
     { 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: 17, axis: "record", recordKind: "contextSnapshot", sql: MIGRATION_17_SQL }
+    { version: 17, axis: "record", recordKind: "contextSnapshot", sql: MIGRATION_17_SQL },
+    { version: 18, axis: "layout", sql: MIGRATION_18_SQL }
 ];
 /** Current hot-path indexes whose absence would invalidate a current Home. */
 const REQUIRED_SCHEMA_INDEXES = [

package/dist/storage/sqliteStore.js

@@ -1150,7 +1150,7 @@ export class SqliteTaskStore {
             ? ""
             : ` WHERE ${predicates.join(" AND ")}`;
         const rows = this.#db.prepare(`SELECT scope, task_id, role_name, agent_id, adapter_id,
-              native_session_id, launch_id, status, session_updated_at,
+              native_session_id, launch_id, session_updated_at,
               cleanup_required
        FROM runtime_session_candidates${where}`).all(...parameters);
         const candidates = rows.map((row) => ({
@@ -1161,7 +1161,6 @@ export class SqliteTaskStore {
             adapterId: row.adapter_id,
             nativeSessionId: row.native_session_id,
             ...(row.launch_id === null ? {} : { launchId: row.launch_id }),
-            status: row.status,
             sessionUpdatedAt: row.session_updated_at,
             cleanupRequired: row.cleanup_required === 1
         })).sort(compareRuntimeSessionCandidates);
@@ -1217,14 +1216,14 @@ export class SqliteTaskStore {
            json_extract(active_session, '$.adapterId') AS adapter_id,
            json_extract(active_session, '$.nativeSessionId') AS native_session_id,
            json_extract(active_session, '$.launchId') AS launch_id,
-           json_extract(active_session, '$.status') AS status,
+           CASE
+             WHEN json_extract(active_session, '$.status') = 'active'
+             THEN 1 ELSE 0
+           END AS is_active,
            json_extract(active_session, '$.updatedAt') AS session_updated_at,
            CASE
-             WHEN json_extract(active_session, '$.status') NOT IN ('stopped','broken')
-               AND (
-                 json_extract(active_session, '$.status') = 'running'
-                 OR json_type(active_session, '$.launchId') = 'text'
-               )
+             WHEN json_extract(active_session, '$.status') = 'active'
+               AND json_type(active_session, '$.launchId') = 'text'
              THEN 1 ELSE 0
            END AS cleanup_required
          FROM active`).get(...source.parameters);
@@ -1245,7 +1244,7 @@ export class SqliteTaskStore {
             && row.adapter_id === candidate.adapterId
             && row.native_session_id === candidate.nativeSessionId
             && (row.launch_id ?? undefined) === candidate.launchId
-            && row.status === candidate.status
+            && row.is_active === 1
             && row.session_updated_at === candidate.sessionUpdatedAt
             && row.cleanup_required === (candidate.cleanupRequired ? 1 : 0);
     }
@@ -1277,16 +1276,15 @@ export class SqliteTaskStore {
         const taskId = candidate.owner.scope === "task" ? candidate.owner.taskId : "";
         this.#db.prepare(`INSERT INTO runtime_session_candidates (
          scope, task_id, role_name, agent_id, adapter_id, native_session_id,
-         launch_id, status, session_updated_at, cleanup_required
-       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         launch_id, session_updated_at, cleanup_required
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(scope, task_id, role_name) DO UPDATE SET
          agent_id = excluded.agent_id,
          adapter_id = excluded.adapter_id,
          native_session_id = excluded.native_session_id,
          launch_id = excluded.launch_id,
-         status = excluded.status,
          session_updated_at = excluded.session_updated_at,
-         cleanup_required = excluded.cleanup_required`).run(candidate.owner.scope, taskId, candidate.owner.roleName, candidate.agentId, candidate.adapterId, candidate.nativeSessionId, candidate.launchId ?? null, candidate.status, candidate.sessionUpdatedAt, candidate.cleanupRequired ? 1 : 0);
+         cleanup_required = excluded.cleanup_required`).run(candidate.owner.scope, taskId, candidate.owner.roleName, candidate.agentId, candidate.adapterId, candidate.nativeSessionId, candidate.launchId ?? null, candidate.sessionUpdatedAt, candidate.cleanupRequired ? 1 : 0);
     }
     #deleteRuntimeSessionCandidate(owner) {
         this.#db.prepare(`DELETE FROM runtime_session_candidates
@@ -1585,37 +1583,6 @@ export class SqliteTaskStore {
            payload = excluded.payload, updated_at = excluded.updated_at`).run(run.taskId, run.id, run.roleName, run.status, this.#json(run), this.#now());
         });
     }
-    /**
-     * Issue 04: SQLite-native pending retry query.  A single indexed scan
-     * replaces the adapter's per-Task in-memory sweep, so Controller deadline
-     * arming no longer materializes every Task and Run in JavaScript.
-     */
-    listPendingProviderRetries(taskIds) {
-        const selectedTaskIds = taskIds === undefined
-            ? undefined
-            : [...new Set(taskIds)].sort(numericCompare);
-        if (selectedTaskIds?.length === 0)
-            return [];
-        const taskPredicate = selectedTaskIds === undefined
-            ? ""
-            : ` 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.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.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)));
-    }
     // -- review rounds ----------------------------------------------------------
     nextReviewRoundId(taskId) { return this.#nextTaskRecordId(taskId, "reviewRound"); }
     getReviewRound(taskId, reviewRoundId) {