@zq-silk/yui 0.15.7 → 0.15.8

package/dist/scheduler/taskObservabilityProjection.js

@@ -8,9 +8,9 @@ export function buildTaskObservabilityProjection(input) {
     const dag = projectDag(input.workItems);
     const workItems = input.workItems.map((item) => {
         const groups = item.executionGroups;
-        const itemCost = projectWorkItemCost(groups, input.turns, now);
-        const itemContext = projectContext(groups, input.turns, input.contextSnapshots);
-        const producerObservability = projectWorkItemProducerObservability(item, input.turns);
+        const itemCost = projectWorkItemCost(groups, input.runs, now);
+        const itemContext = projectContext(groups, input.runs, input.contextSnapshots);
+        const producerObservability = projectWorkItemProducerObservability(item, input.runs);
         return Object.freeze({
             workItemId: item.id,
             title: item.title,
@@ -21,8 +21,8 @@ export function buildTaskObservabilityProjection(input) {
             resultCount: producerObservability?.resultCount ?? null
         });
     });
-    const cost = projectCost(input.executionGroups, input.turns, input.events, now);
-    const context = projectContext(input.executionGroups, input.turns, input.contextSnapshots);
+    const cost = projectCost(input.executionGroups, input.runs, input.events, now);
+    const context = projectContext(input.executionGroups, input.runs, input.contextSnapshots);
     return Object.freeze({
         dag,
         workItems,
@@ -31,21 +31,21 @@ export function buildTaskObservabilityProjection(input) {
         sessionTokens: Object.freeze([...(input.sessionTokens ?? [])])
     });
 }
-function projectWorkItemProducerObservability(item, turns) {
+function projectWorkItemProducerObservability(item, runs) {
     const successfulLanes = item.executionGroups.flatMap((group) => group.lanes.flatMap((lane) => (lane.disposition === "succeeded" ? [{ group, lane }] : [])));
     let resultCount = 0;
     for (const { group, lane } of successfulLanes) {
-        const turn = lane.successfulTurnId === undefined
+        const run = lane.successfulRunId === undefined
             ? undefined
-            : turns.find(({ id }) => id === lane.successfulTurnId);
-        if (turn === undefined
-            || turn.result === undefined
-            || turn.status !== "completed"
-            || turn.taskId !== item.taskId
-            || turn.workItemId !== item.id
-            || turn.executionGroupId !== group.id
-            || turn.executionLaneId !== lane.id
-            || turn.roleName !== lane.roleName)
+            : runs.find(({ id }) => id === lane.successfulRunId);
+        if (run === undefined
+            || run.result === undefined
+            || run.status !== "completed"
+            || run.taskId !== item.taskId
+            || run.workItemId !== item.id
+            || run.executionGroupId !== group.id
+            || run.executionLaneId !== lane.id
+            || run.roleName !== lane.roleName)
             return null;
         resultCount += 1;
     }
@@ -69,7 +69,7 @@ function projectDag(workItems) {
         const unresolved = item.dependsOn.filter((dependency) => {
             return !dependencySatisfied(dependency, byId);
         });
-        const projectedStatus = item.status === "pending"
+        const projectedStatus = item.status === "open"
             ? unresolved.length === 0 ? "ready" : "blocked"
             : item.status;
         return Object.freeze({
@@ -110,13 +110,13 @@ function rootCauses(id, byId) {
         }
         const unresolved = item.dependsOn.filter((dependency) => !dependencySatisfied(dependency, byId));
         if (unresolved.length === 0) {
-            if (item.status === "failed" || item.status === "awaiting_acceptance")
+            if (item.status === "open" && item.currentCandidateId !== undefined)
                 result.push(item.id);
             return;
         }
         for (const dependency of unresolved) {
             const target = byId.get(dependency);
-            if (target?.status === "failed" || target?.status === "awaiting_acceptance")
+            if (target?.status === "open" && target.currentCandidateId !== undefined)
                 result.push(target.id);
             else
                 visit(dependency);
@@ -126,7 +126,7 @@ function rootCauses(id, byId) {
     return [...new Set(result)];
 }
 function dependencySatisfied(id, byId) {
-    return byId.get(id)?.status === "completed";
+    return byId.get(id)?.status === "accepted";
 }
 function dependencyEdgeStatus(id, byId) {
     const target = byId.get(id);
@@ -136,14 +136,14 @@ function dependencyEdgeStatus(id, byId) {
         return "satisfied";
     if (target.status === "retired")
         return "dead";
-    if (target.status === "failed" || target.status === "awaiting_acceptance")
-        return "failed-open";
+    if (target.status === "open" && target.currentCandidateId !== undefined)
+        return "active";
     return "active";
 }
-function projectCost(groups, turns, _events, now) {
+function projectCost(groups, runs, _events, now) {
     const uniqueGroups = [...new Map(groups.map((group) => [group.id, group])).values()];
     const groupIds = new Set(uniqueGroups.map(({ id }) => id));
-    const attempts = turns.filter(({ executionGroupId }) => (executionGroupId !== undefined && groupIds.has(executionGroupId)));
+    const attempts = runs.filter(({ executionGroupId }) => (executionGroupId !== undefined && groupIds.has(executionGroupId)));
     const laneCount = uniqueGroups.reduce((total, group) => total + group.lanes.length, 0);
     return Object.freeze({
         tokens: 0,
@@ -158,9 +158,9 @@ function projectCost(groups, turns, _events, now) {
         marginalValueStatus: "unavailable"
     });
 }
-function projectWorkItemCost(groups, turns, now) {
+function projectWorkItemCost(groups, runs, now) {
     const groupIds = new Set(groups.map(({ id }) => id));
-    const attempts = turns.filter(({ executionGroupId }) => (executionGroupId !== undefined && groupIds.has(executionGroupId)));
+    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")
@@ -184,15 +184,15 @@ function projectWorkItemCost(groups, turns, now) {
         marginalValueStatus: "unavailable"
     });
 }
-function projectContext(groups, turns, snapshots) {
+function projectContext(groups, runs, snapshots) {
     const refs = new Map();
     for (const group of groups) {
         const ref = group.assignment.contextSnapshotRef;
         if (ref !== undefined)
             refs.set(ref.id, ref);
     }
-    for (const turn of turns) {
-        const ref = turn.inputs[0].input.contextSnapshotRef;
+    for (const run of runs) {
+        const ref = run.inputs[0].input.contextSnapshotRef;
         if (ref !== undefined)
             refs.set(ref.id, ref);
     }

package/dist/scheduler/taskWake.js

@@ -1,5 +1,6 @@
 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 function createTaskWake(input) {
     const wake = {
@@ -8,16 +9,22 @@ export function createTaskWake(input) {
         taskId: requireIdentity(input.taskId, "Task id"),
         seq: wakeSequence(input.id),
         reasons: Object.freeze(input.reasons.map((reason) => requireText(reason, "Wake reason"))),
+        ...(input.refs === undefined ? {} : { refs: Object.freeze(input.refs.map(copyRef)) }),
         fromCursor: requireTimestamp(input.fromCursor, "Wake fromCursor"),
         toCursor: requireTimestamp(input.toCursor, "Wake toCursor"),
         status: "dispatched",
-        turnId: requireIdentity(input.turnId, "Wake Turn id"),
+        ...(input.runId === undefined ? {} : { runId: requireIdentity(input.runId, "Wake AgentRun id") }),
         createdAt: input.now.toISOString()
     };
     validateTaskWake(wake);
     return wake;
 }
 export function validateTaskWake(wake) {
+    if (wake.refs !== undefined) {
+        if (!Array.isArray(wake.refs))
+            throw new Error("Wake references must be an array.");
+        wake.refs.forEach(copyRef);
+    }
     if (wake.schemaVersion !== CURRENT_TASK_WAKE_SCHEMA_VERSION) {
         throw new Error(`Task wake ${wake.id} must use schemaVersion ${CURRENT_TASK_WAKE_SCHEMA_VERSION}.`);
     }
@@ -55,12 +62,12 @@ export function latestTaskWake(wakes) {
     return latest;
 }
 /**
- * The delta lower bound for a Task's first wake: the last Leader Turn's
+ * 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 Turn exists, the Task's own creation time bounds the window.
+ * Leader AgentRun exists, the Task's own creation time bounds the window.
  */
 export function fallbackWakeCursor(input) {
-    return input.leaderTurnCreatedAt ?? input.taskCreatedAt;
+    return input.leaderRunCreatedAt ?? input.taskCreatedAt;
 }
 function wakeSequence(id) {
     const prefix = `${TASK_RECORD_ID_PREFIXES.taskWake}-`;

package/dist/scheduler/wakeReason.js

@@ -8,7 +8,7 @@
  * queue — the wake layer owns the meaning of its tags.
  *
  * Tag wire format: `<kind>` or `<kind>:<ref>`. The ref is an exact record
- * identifier (InputRequest id, Turn id, ...) or, for `force-wake`, the
+ * identifier (InputRequest id, AgentRun id, ...) or, for `force-wake`, the
  * operator-supplied text. Unknown kinds parse losslessly so a newer producer
  * can never wedge an older reader.
  */
@@ -17,6 +17,7 @@ export const WAKE_REASON_KINDS = Object.freeze([
     "input-timeout",
     "role-turn-stalled",
     "agent-error",
+    "activation-failed",
     "agent-session-recovery",
     "review-failed",
     "task-reopened",
@@ -27,6 +28,13 @@ export const WAKE_REASON_KINDS = Object.freeze([
     "force-wake"
 ]);
 const IMMEDIATE_KINDS = new Set([
+    "operator-input",
+    "user-message",
+    "task-created",
+    "execution-started",
+    "session-replaced",
+    "force-wake",
+    "activation-failed",
     "task-reopened",
     "leader-turn-failed",
     "role-turn-failed"

package/dist/setup/setupCommand.js

@@ -60,6 +60,7 @@ export async function runSetupCommand(args, env, executor, io = {}) {
             `Leader configuration: ${roleStatus.leader}.`,
             `Tmux: ${tmuxBin}.`,
             "Setup did not configure Review, Worker, Profiles, or shell completion.",
+            "Provider login and native key/initialization confirmations remain with the Provider; setup did not call a model.",
             "Run `yui operator enter` to continue, or `yui config show` to inspect configuration."
         ].join("\n")}\n`;
     }

package/dist/storage/migrations/agentRunContract.js

@@ -0,0 +1,159 @@
+import { createContextSnapshot, contextContentDigest } from "../../context/contextSnapshot.js";
+/** Storage 12 -> 13 only. Text, native identities and opaque record/receipt ids
+ * are never renamed. Ordinary runtime stores do not interpret old payloads.
+ * v13 also introduces optional Message recipient/continuation/handovers.
+ * Existing messages have no recipient and remain informational/Leader wakes;
+ * migration never guesses an owner or causes historical messages to execute.
+ */
+export function migrateAgentRunContract(db) {
+    // T08 already stored real planning executions. Use that frozen evidence,
+    // never the Task's current status, to classify their shared Session snapshots.
+    const planningLaunches = new Set();
+    for (const row of db.prepare("SELECT task_id, payload FROM turns").all()) {
+        const run = JSON.parse(row.payload);
+        if (run.purpose === "planning") {
+            planningLaunches.add(`${row.task_id}:${contextContentDigest(run.effective)}`);
+        }
+    }
+    const snapshotDigests = new Map();
+    const renameKey = (key) => {
+        if (key === "turn")
+            return "run";
+        if (key === "turns")
+            return "runs";
+        if (key === "turnId")
+            return "runId";
+        if (key === "turnIds")
+            return "runIds";
+        if (/NativeTurn|ProviderTurn|CompletedTurn|nativeTurn|providerTurn/.test(key))
+            return key;
+        return key.replaceAll("Turn", "Run").replace(/^turn(?=[A-Z])/, "run")
+            .replaceAll("TURN_", "RUN_").replaceAll("_TURN", "_RUN");
+    };
+    const untouched = new Set(["advanced", "metadata", "environment", "raw", "output", "body",
+        "description", "summary", "directive", "config"]);
+    const migrate = (value, taskId, purpose) => {
+        if (Array.isArray(value))
+            return value.map((entry) => migrate(entry, taskId, purpose));
+        if (value === null || typeof value !== "object")
+            return value;
+        const input = value;
+        const ownerTaskId = typeof input.taskId === "string" ? input.taskId : taskId;
+        const executionPurpose = typeof input.purpose === "string" ? input.purpose : purpose;
+        const result = {};
+        for (const [key, child] of Object.entries(input)) {
+            let next = untouched.has(key) ? child : migrate(child, ownerTaskId, executionPurpose);
+            if ((key === "type" || key === "recordKind" || key === "store") && child === "turn")
+                next = "run";
+            if (key === "type" && typeof child === "string" && child.startsWith("turn.")
+                && typeof input.id === "string" && input.id.startsWith("event-") && input.createdAt !== undefined) {
+                next = child.replace(/^turn\./, "run.");
+            }
+            if (key === "store" && child === "source-turn")
+                next = "source-run";
+            // Runtime envelopes are structured evidence encoded inside Task Events,
+            // not free-form Provider output.
+            if (key === "observation" && typeof child === "string") {
+                const parsed = JSON.parse(child);
+                next = JSON.stringify(migrate(parsed, ownerTaskId));
+            }
+            result[renameKey(key)] = next;
+        }
+        if (typeof input.digest === "string" && typeof input.id === "string"
+            && input.id.startsWith("context-snapshot-") && typeof input.sequence === "number") {
+            result.digest = snapshotDigests.get(input.digest) ?? input.digest;
+        }
+        // A Run has its own authoritative purpose. Session copies are classified
+        // by the exact planning launch they retain; activation never upgrades them.
+        if (input.schemaVersion === 3 && typeof input.agentId === "string"
+            && typeof input.sourceDesiredRevision === "number" && input.workspace !== undefined
+            && input.context !== undefined && input.permission !== undefined) {
+            result.executionAuthority = executionPurpose === "planning"
+                || (ownerTaskId !== undefined && planningLaunches.has(`${ownerTaskId}:${contextContentDigest(input)}`))
+                ? "planning" : "delivery";
+        }
+        return result;
+    };
+    const snapshots = db.prepare("SELECT rowid, payload FROM context_snapshots")
+        .all();
+    const originals = new Map(snapshots.map((row) => {
+        const snapshot = JSON.parse(row.payload);
+        return [`${snapshot.taskId}/${snapshot.id}`, { ...row, snapshot }];
+    }));
+    const visiting = new Set();
+    const completed = new Set();
+    const migrateSnapshot = (key) => {
+        if (completed.has(key))
+            return;
+        const row = originals.get(key);
+        if (row === undefined)
+            return; // Preserve unresolved historical references as references.
+        if (visiting.has(key))
+            throw new Error("Context Snapshot references contain a cycle.");
+        visiting.add(key);
+        const original = row.snapshot;
+        // Dependency order, not wall-clock order: async callers can freeze with
+        // an earlier pass timestamp while referencing an already committed parent.
+        const visitReferences = (value) => {
+            if (value === null || typeof value !== "object")
+                return;
+            if (Array.isArray(value)) {
+                value.forEach(visitReferences);
+                return;
+            }
+            const ref = value;
+            if (typeof ref.id === "string" && ref.id.startsWith("context-snapshot-")
+                && typeof ref.taskId === "string" && typeof ref.digest === "string"
+                && typeof ref.sequence === "number")
+                migrateSnapshot(`${ref.taskId}/${ref.id}`);
+            for (const [field, child] of Object.entries(ref)) {
+                if (!untouched.has(field))
+                    visitReferences(child);
+            }
+        };
+        visitReferences(original.parentRef);
+        visitReferences(original.resources);
+        const current = migrate(original);
+        const resources = current.resources.map((entry) => ({
+            ...entry, ref: { ...entry.ref, digest: contextContentDigest(entry.value) }
+        }));
+        const refs = current.refs.map((ref) => resources.find((entry) => entry.ref.layer === ref.layer && entry.ref.store === ref.store && entry.ref.refId === ref.refId)?.ref ?? ref);
+        const snapshot = createContextSnapshot({ ...current, resources, refs, frozenAt: new Date(current.frozenAt) });
+        snapshotDigests.set(original.digest, snapshot.digest);
+        db.prepare("UPDATE context_snapshots SET payload = ?, digest = ? WHERE rowid = ?")
+            .run(JSON.stringify(snapshot), snapshot.digest, row.rowid);
+        visiting.delete(key);
+        completed.add(key);
+    };
+    for (const key of originals.keys())
+        migrateSnapshot(key);
+    const tables = [
+        "config", "agent_profiles", "global_roles", "global_role_session_sets",
+        "task_records", "task_roles", "role_session_sets", "work_items", "work_item_candidates",
+        "turns", "active_turns", "review_rounds", "change_sets", "integration_attempts",
+        "messages", "input_requests", "decisions", "milestones", "events", "task_projections",
+        "durable_jobs", "integration_queue", "task_wakes", "telemetry", "telemetry_aggregate"
+    ];
+    const rewriteColumn = (table, column) => {
+        const columns = db.prepare(`PRAGMA table_info("${table}")`).all();
+        if (!columns.some((entry) => entry.name === column))
+            return;
+        const keys = columns.filter((entry) => entry.pk > 0).sort((a, b) => a.pk - b.pk).map((entry) => entry.name);
+        if (!keys.length)
+            throw new Error(`Migration requires the primary key of ${table}.`);
+        const quote = (value) => `"${value.replaceAll('"', '""')}"`;
+        const rows = db.prepare(`SELECT * FROM ${quote(table)} WHERE ${quote(column)} IS NOT NULL`)
+            .all();
+        const update = db.prepare(`UPDATE ${quote(table)} SET ${quote(column)} = ? WHERE ${keys.map((key) => `${quote(key)} = ?`).join(" AND ")}`);
+        for (const row of rows) {
+            update.run(JSON.stringify(migrate(JSON.parse(row[column]), typeof row.task_id === "string" ? row.task_id : undefined)), ...keys.map((key) => row[key]));
+        }
+    };
+    for (const table of tables) {
+        rewriteColumn(table, "payload");
+    }
+    for (const column of ["pending", "processing"]) {
+        rewriteColumn("mailboxes", column);
+    }
+    db.prepare("UPDATE id_sequences SET kind = 'run' WHERE kind = 'turn'").run();
+}

package/dist/storage/migrations/removeRuntimeGeneration.js

@@ -0,0 +1,207 @@
+import { createHash } from "node:crypto";
+/** Storage 3 -> 4. Frozen migration; runtime code must not depend on this module. */
+export const REMOVE_RUNTIME_GENERATION_SQL = `
+-- data-transform: remove-runtime-generation-records-v1
+DROP TRIGGER telemetry_ai;
+DROP TRIGGER telemetry_au;
+DROP INDEX idx_telemetry_turn;
+ALTER TABLE telemetry RENAME TO telemetry_v3;
+ALTER TABLE telemetry_aggregate RENAME TO telemetry_aggregate_v3;
+CREATE TABLE telemetry (
+  task_id TEXT NOT NULL, role_name TEXT NOT NULL, turn_id TEXT NOT NULL,
+  progress_id TEXT NOT NULL, sequence INTEGER, payload TEXT NOT NULL,
+  received_at TEXT NOT NULL,
+  PRIMARY KEY (task_id, role_name, turn_id, progress_id)
+) WITHOUT ROWID;
+CREATE INDEX idx_telemetry_turn ON telemetry(task_id, turn_id);
+INSERT INTO telemetry
+SELECT task_id, role_name, turn_id, progress_id, sequence, payload, received_at
+FROM (
+  SELECT *, ROW_NUMBER() OVER (
+    PARTITION BY task_id, role_name, turn_id, progress_id
+    ORDER BY received_at DESC, COALESCE(sequence, -1) DESC, generation DESC
+  ) AS rank FROM telemetry_v3
+) WHERE rank = 1;
+CREATE TABLE telemetry_aggregate (
+  task_id TEXT NOT NULL, role_name TEXT NOT NULL, turn_id TEXT NOT NULL,
+  first_at TEXT NOT NULL, last_at TEXT NOT NULL, count INTEGER NOT NULL,
+  max_sequence INTEGER, error_count INTEGER NOT NULL DEFAULT 0, updated_at TEXT NOT NULL,
+  PRIMARY KEY (task_id, role_name, turn_id)
+) WITHOUT ROWID;
+INSERT INTO telemetry_aggregate
+SELECT task_id, role_name, turn_id, MIN(first_at), MAX(last_at), SUM(count),
+  MAX(max_sequence), SUM(error_count), MAX(updated_at)
+FROM telemetry_aggregate_v3 GROUP BY task_id, role_name, turn_id;
+DROP TABLE telemetry_v3;
+DROP TABLE telemetry_aggregate_v3;
+CREATE TRIGGER telemetry_ai AFTER INSERT ON telemetry
+BEGIN
+  INSERT INTO telemetry_aggregate
+    (task_id, role_name, turn_id, first_at, last_at, count, max_sequence, error_count, updated_at)
+  VALUES (NEW.task_id, NEW.role_name, NEW.turn_id, NEW.received_at, NEW.received_at,
+    1, NEW.sequence,
+    CASE WHEN json_valid(NEW.payload)
+      AND (COALESCE(json_extract(NEW.payload, '$.error'), '') <> ''
+        OR COALESCE(json_extract(NEW.payload, '$.errorKind'), '') <> '')
+      THEN 1 ELSE 0 END, NEW.received_at)
+  ON CONFLICT(task_id, role_name, turn_id) DO UPDATE SET
+    first_at = MIN(telemetry_aggregate.first_at, excluded.first_at),
+    last_at = MAX(telemetry_aggregate.last_at, excluded.last_at),
+    count = telemetry_aggregate.count + 1,
+    max_sequence = CASE WHEN excluded.max_sequence IS NOT NULL
+      AND (telemetry_aggregate.max_sequence IS NULL OR excluded.max_sequence > telemetry_aggregate.max_sequence)
+      THEN excluded.max_sequence ELSE telemetry_aggregate.max_sequence END,
+    error_count = telemetry_aggregate.error_count + excluded.error_count,
+    updated_at = excluded.updated_at;
+END;
+CREATE TRIGGER telemetry_au AFTER UPDATE ON telemetry
+BEGIN
+  UPDATE telemetry_aggregate SET
+    last_at = MAX(last_at, NEW.received_at),
+    max_sequence = CASE WHEN NEW.sequence IS NOT NULL
+      AND (max_sequence IS NULL OR NEW.sequence > max_sequence) THEN NEW.sequence ELSE max_sequence END,
+    updated_at = NEW.received_at
+  WHERE task_id = NEW.task_id AND role_name = NEW.role_name AND turn_id = NEW.turn_id;
+END;
+
+DROP INDEX idx_session_owners_task;
+ALTER TABLE session_owners RENAME TO session_owners_v3;
+CREATE TABLE session_owners (
+  process_key TEXT PRIMARY KEY, scope TEXT NOT NULL CHECK(scope IN ('task','global')),
+  task_id TEXT, role_name TEXT NOT NULL, agent_id TEXT NOT NULL, native_session_id TEXT,
+  provider_root_pid INTEGER, payload TEXT NOT NULL, recorded_at TEXT NOT NULL
+);
+INSERT INTO session_owners
+SELECT process_key, scope, task_id, role_name, agent_id, native_session_id,
+  provider_root_pid, payload, recorded_at
+FROM (
+  SELECT *,
+    CAST(provider_root_pid AS TEXT) || '-' || json_extract(payload, '$.providerRoot.startIdentity') AS process_key,
+    ROW_NUMBER() OVER (
+      PARTITION BY provider_root_pid, json_extract(payload, '$.providerRoot.startIdentity')
+      ORDER BY recorded_at DESC, launch_id DESC
+    ) AS rank
+  FROM session_owners_v3
+) WHERE rank = 1;
+DROP TABLE session_owners_v3;
+CREATE INDEX idx_session_owners_task ON session_owners(task_id, role_name);
+
+DROP INDEX idx_runtime_session_cleanup_required;
+ALTER TABLE runtime_session_candidates RENAME TO runtime_session_candidates_v3;
+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, session_updated_at TEXT NOT NULL,
+  PRIMARY KEY(scope, task_id, role_name),
+  CHECK((scope = 'task' AND length(task_id) > 0) OR (scope = 'global' AND task_id = ''))
+);
+INSERT INTO runtime_session_candidates
+SELECT scope, task_id, role_name, agent_id, adapter_id, native_session_id, session_updated_at
+FROM runtime_session_candidates_v3;
+DROP TABLE runtime_session_candidates_v3;
+
+-- Retire only obsolete launch bookkeeping; preserve pending intent and cleanup requests.
+UPDATE mailboxes SET processing = NULL
+WHERE target_kind IN ('role-runtime','global-role-runtime')
+  AND json_extract(processing, '$.owner') = 'runtime-lifecycle'
+  AND json_extract(processing, '$.batch.reasons') = '["runtime-launch-reserved"]';
+`;
+export function removeRuntimeGenerationRecords(db) {
+    const object = (value) => (value !== null && typeof value === "object" && !Array.isArray(value));
+    const obsolete = new Set([
+        "runtimeGenerationId", "hostActivationId", "activationId", "continuationGeneration"
+    ]);
+    // Accepted Jobs retain exactly the Session authority they already had.
+    // Never refresh a revoked/stale binding to the currently active Session.
+    for (const row of db.prepare("SELECT task_id, job_id, payload FROM durable_jobs").all()) {
+        const job = JSON.parse(row.payload);
+        if (!object(job.operation) || typeof job.operation.actorId !== "string")
+            continue;
+        const prefix = `task:${row.task_id}/role:`;
+        if (!job.operation.actorId.startsWith(prefix))
+            continue;
+        const roleName = job.operation.actorId.slice(prefix.length);
+        const roleRow = db.prepare("SELECT payload FROM task_roles WHERE task_id = ? AND role_name = ?")
+            .get(row.task_id, roleName);
+        const sessionsRow = db.prepare("SELECT payload FROM role_session_sets WHERE task_id = ? AND role_name = ?")
+            .get(row.task_id, roleName);
+        if (roleRow === undefined || sessionsRow === undefined)
+            continue;
+        const role = JSON.parse(roleRow.payload);
+        const sessions = JSON.parse(sessionsRow.payload);
+        const session = sessions.sessions?.[sessions.activeAgentId];
+        if (session?.status !== "active" || role.activeAgentId !== sessions.activeAgentId)
+            continue;
+        const key = db.prepare("SELECT hash FROM job_caller_key_hashes WHERE task_id = ? AND role_name = ? AND agent_id = ?")
+            .get(row.task_id, roleName, session.agentId);
+        if (key === undefined)
+            continue;
+        const identity = [session.agentId, session.adapterId, session.nativeSessionId];
+        const prior = createHash("sha256").update(JSON.stringify([key.hash, ...identity])).digest("hex");
+        if (job.operation.authorityRef !== prior)
+            continue;
+        job.operation.authorityRef = createHash("sha256").update(JSON.stringify(identity)).digest("hex");
+        db.prepare("UPDATE durable_jobs SET payload = ? WHERE task_id = ? AND job_id = ?")
+            .run(JSON.stringify(job), row.task_id, row.job_id);
+    }
+    db.exec("DROP TABLE job_caller_key_hashes");
+    const clean = (value) => {
+        if (Array.isArray(value))
+            return value.map(clean);
+        if (!object(value))
+            return value;
+        const next = {};
+        for (const [key, child] of Object.entries(value)) {
+            if (obsolete.has(key))
+                continue;
+            if (key === "activations" && typeof value.providerNamespace === "string"
+                && Array.isArray(value.conversations))
+                continue;
+            if (key === "generation" && typeof value.continuationId === "string")
+                continue;
+            if (key === "generation" && value.kind === "yui-task-runtime-isolation")
+                continue;
+            next[key] = clean(child);
+        }
+        if (typeof next.providerNamespace === "string" && Array.isArray(next.conversations)
+            && object(next.authority) && next.authority.owner === "controller") {
+            next.authority.holderId = "controller";
+        }
+        if (next.authorityOwner === "controller" && typeof next.holderId === "string") {
+            next.holderId = "controller";
+        }
+        if (next.kind === "yui-task-runtime-isolation" && object(next.roots)) {
+            next.roots.runtime = next.roots.generation;
+            delete next.roots.generation;
+        }
+        return next;
+    };
+    // These are system-owned record families, not arbitrary user documents or Job outputs.
+    for (const table of ["role_session_sets", "global_role_session_sets", "turns", "session_owners", "events"]) {
+        const columns = db.prepare(`PRAGMA table_info("${table}")`).all();
+        const keys = columns.filter((column) => column.pk > 0).sort((a, b) => a.pk - b.pk).map((c) => c.name);
+        const rows = db.prepare(`SELECT * FROM "${table}"`).all();
+        const where = keys.map((key) => `"${key}" = ?`).join(" AND ");
+        const update = db.prepare(`UPDATE "${table}" SET payload = ?${table === "events" ? ", type = ?" : ""} WHERE ${where}`);
+        for (const row of rows) {
+            const raw = JSON.parse(row.payload);
+            const migrated = clean(raw);
+            if (table === "events" && object(migrated.payload)
+                && typeof migrated.payload.observation === "string"
+                && typeof migrated.type === "string" && migrated.type.startsWith("runtime.")) {
+                const observation = JSON.parse(migrated.payload.observation);
+                const current = clean(observation);
+                if (typeof current.kind === "string" && current.kind.startsWith("activation.")) {
+                    // Keep the historical fact, but it is no longer a current lifecycle event.
+                    migrated.type = "runtime.historical-attachment-observed";
+                }
+                if (typeof current.stopReceiptId === "string") {
+                    current.stopRequested = true;
+                    delete current.stopReceiptId;
+                }
+                migrated.payload.observation = JSON.stringify(current);
+            }
+            update.run(JSON.stringify(migrated), ...(table === "events" ? [migrated.type] : []), ...keys.map((key) => row[key]));
+        }
+    }
+}