@zq-silk/yui 0.15.12 → 0.16.0

package/dist/scheduler/roleRunStall.js

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

package/dist/scheduler/taskExecutionProjection.js

@@ -14,22 +14,24 @@ import { projectSessionTokenMetrics, resolveSessionTokenIdentity } from "../runt
  * aggregate. This function only reads; it never starts a Controller, queues a
  * wake, writes a Message, or mutates any record.
  */
-export function buildTaskExecutionProjection(store, taskId, taskOverride, now = new Date()) {
-    const task = store.getTask?.(taskId) ?? taskOverride ?? null;
+export function buildTaskExecutionProjection(store, taskId, now = new Date()) {
+    const task = store.getTask(taskId);
     if (task === null)
         return null;
-    const roles = store.listRoles?.(taskId) ?? [];
-    const events = store.listEvents?.(taskId) ?? [];
-    const usageRuns = store.listRuns?.(taskId) ?? [];
+    const roles = store.listRoles(taskId);
+    const events = store.listEvents(taskId);
+    const usageRuns = store.listRuns(taskId);
+    const workItems = store.listWorkItems(taskId);
+    const reviewRounds = store.listReviewRounds(taskId);
     const runs = operationalTaskRecords(usageRuns, events, "run");
-    const leaderMailbox = store.getWorkMailbox?.({
+    const leaderMailbox = store.getWorkMailbox({
         kind: "role",
         taskId,
         roleName: "leader"
-    }) ?? null;
+    });
     const roleSessions = roles.flatMap((role) => {
-        const session = store.getRoleSession?.(taskId, role.name);
-        return session === null || session === undefined
+        const session = store.getRoleSession(taskId, role.name);
+        return session === null
             ? []
             : [{ roleName: role.name, ...session }];
     });
@@ -39,38 +41,28 @@ export function buildTaskExecutionProjection(store, taskId, taskOverride, now =
         runs,
         usageRuns,
         providerRetries: roles.flatMap(role => {
-            const retry = providerRetryProjection(store.getTaskRoleSessionSet?.(taskId, role.name)?.providerBinding);
+            const retry = providerRetryProjection(store.getTaskRoleSessionSet(taskId, role.name)?.providerBinding);
             return retry === null ? [] : [retry];
         }),
         runDelivery: Object.fromEntries(runs.map((run) => {
-            const observed = store.getTaskRoleSessionSet?.(taskId, run.roleName)?.providerBinding?.run;
+            const observed = store.getTaskRoleSessionSet(taskId, run.roleName)?.providerBinding?.run;
             return [run.id, observed?.runId === run.id ? observed.status : "unobserved"];
         })),
-        executionGroups: store.listWorkItems === undefined && store.listReviewRounds === undefined
-            ? []
-            : collectExecutionGroups(store.listWorkItems?.(taskId) ?? [], store.listReviewRounds?.(taskId) ?? [], runs),
-        workItems: store.listWorkItems?.(taskId) ?? [],
-        ...(store.listContextSnapshots === undefined
-            ? {}
-            : { contextSnapshots: store.listContextSnapshots(taskId) }),
-        inputRequests: store.listInputRequests?.(taskId) ?? [],
-        ...(store.listReviewRounds === undefined
-            ? {}
-            : { reviewRounds: store.listReviewRounds(taskId) }),
-        ...(store.listChangeSets === undefined
-            ? {}
-            : { changeSets: store.listChangeSets(taskId) }),
-        ...(store.listIntegrationAttempts === undefined
-            ? {}
-            : { integrations: store.listIntegrationAttempts(taskId) }),
-        ...(store.listEvents === undefined ? {} : { events }),
-        ...(store.getTaskBrief === undefined ? {} : { brief: store.getTaskBrief(taskId) }),
-        pendingWakeup: store.getPendingWakeup?.(taskId) ?? null,
+        executionGroups: collectExecutionGroups(workItems, reviewRounds, runs),
+        workItems,
+        contextSnapshots: store.listContextSnapshots(taskId),
+        inputRequests: store.listInputRequests(taskId),
+        reviewRounds,
+        changeSets: store.listChangeSets(taskId),
+        integrations: store.listIntegrationAttempts(taskId),
+        events,
+        brief: store.getTaskBrief(taskId),
+        pendingWakeup: store.getPendingWakeup(taskId),
         leaderMailbox,
-        leaderFailure: store.getLeaderFailure?.(taskId) ?? null,
+        leaderFailure: store.getLeaderFailure(taskId),
         roleSessions,
         now,
-        runtimeHealthPolicy: resolveRuntimeHealth(store.getConfig?.().runtimeHealth)
+        runtimeHealthPolicy: resolveRuntimeHealth(store.getConfig().runtimeHealth)
     });
 }
 /**

package/dist/scheduler/taskObservabilityProjection.js

@@ -60,7 +60,6 @@ function projectDag(workItems) {
     const edges = [];
     for (const item of workItems) {
         for (const dependency of item.dependsOn) {
-            const target = byId.get(dependency);
             const status = dependencyEdgeStatus(dependency, byId);
             edges.push({ from: dependency, to: item.id, status });
             dependents.get(dependency)?.push(item.id);

package/dist/scheduler/taskWake.js

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

package/dist/scheduler/wakeReason.js

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

package/dist/scheduler/wakeupQueue.js

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

package/dist/setup/setupCommand.js

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

package/dist/storage/contextRecords.js

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

package/dist/storage/currentTaskStore.js

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

package/dist/storage/homeLayout.js

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

package/dist/storage/migrations/agentFailureContext.js

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

package/dist/storage/migrations/currentInputContract.js

@@ -0,0 +1,86 @@
+/** Frozen 33→34 boundary. An old immediate request without origin was not
+ * auto-adoptable. Its owner must activate or cancel it with the old release;
+ * an upgrade cannot make that choice, even while execution is stopped. */
+export function preflightCurrentInputContract(db) {
+    const blocked = db.prepare(`SELECT task_id FROM task_records
+    WHERE json_extract(payload,'$.status')='draft'
+      AND json_type(payload,'$.retiredAt') IS NULL
+      AND json_extract(payload,'$.activationRequest.startMode')='immediate'
+      AND json_extract(payload,'$.activationRequest.disposition')='pending'
+      AND json_type(payload,'$.activationRequest.origin') IS NULL LIMIT 1`)
+        .get();
+    if (blocked !== undefined) {
+        throw new Error(`Input contract cutover requires explicit activation or cancellation of the origin-less pending request: ${blocked.task_id}. Preserve the request and resolve it with the old release before upgrading.`);
+    }
+}
+/** Preserve original representations as audit Events, not runtime alternatives.
+ * All interpretation of wakePolicy/origin ends at this migration. */
+export function migrateCurrentInputContract(db) {
+    preflightCurrentInputContract(db);
+    const highWater = db.prepare(`SELECT max(
+    coalesce((SELECT high_water FROM id_sequences WHERE task_id=? AND kind='event'),0),
+    coalesce((SELECT max(CAST(substr(event_id,7) AS INTEGER)) FROM events WHERE task_id=?),0)
+  ) AS value`);
+    const saveEvent = db.prepare("INSERT INTO events(task_id,event_id,type,occurred_at,payload) VALUES(?,?,?,?,?)");
+    const saveCounter = db.prepare(`INSERT INTO id_sequences(task_id,kind,high_water) VALUES(?,'event',?)
+    ON CONFLICT(task_id,kind) DO UPDATE SET high_water=max(high_water,excluded.high_water)`);
+    const at = new Date().toISOString();
+    const archive = (taskId, type, record) => {
+        const seq = highWater.get(taskId, taskId).value + 1;
+        const event = { schemaVersion: 2, id: `event-${seq}`, taskId, type, createdAt: at,
+            payload: { record, disposition: "audit-only" } };
+        saveEvent.run(taskId, event.id, type, at, JSON.stringify(event));
+        saveCounter.run(taskId, seq);
+    };
+    const messages = db.prepare("SELECT task_id,message_id,payload FROM messages ORDER BY task_id,seq")
+        .all();
+    const saveMessage = db.prepare("UPDATE messages SET payload=? WHERE task_id=? AND message_id=?");
+    for (const row of messages) {
+        const message = JSON.parse(row.payload);
+        const user = message.kind === "user" || message.kind === "operator";
+        const hasPolicy = Object.hasOwn(message, "wakePolicy");
+        if (message.schemaVersion !== 3 || message.id !== row.message_id || message.taskId !== row.task_id
+            || (hasPolicy && (!user || !["leader", "none"].includes(message.wakePolicy)))
+            || (message.intent !== undefined && (!user || !["record", "discuss", "develop"].includes(message.intent)))
+            || (hasPolicy && message.intent !== undefined
+                && (message.wakePolicy === "none") !== (message.intent === "record"))) {
+            throw new Error(`Invalid historical Message input: ${row.task_id}/${row.message_id}. Preserve it for diagnosis.`);
+        }
+        if (!hasPolicy && (!user || message.intent !== undefined))
+            continue;
+        archive(row.task_id, "message.input-contract-retired", row.payload);
+        if (user && message.intent === undefined) {
+            message.intent = message.wakePolicy === "none" ? "record" : "discuss";
+        }
+        delete message.wakePolicy;
+        saveMessage.run(JSON.stringify(message), row.task_id, row.message_id);
+    }
+    const tasks = db.prepare("SELECT task_id,payload FROM task_records ORDER BY task_id")
+        .all();
+    const saveTask = db.prepare("UPDATE task_records SET payload=? WHERE task_id=?");
+    for (const row of tasks) {
+        const task = JSON.parse(row.payload);
+        const requests = [
+            ...(task.activationRequest === undefined ? [] : [task.activationRequest]),
+            ...(task.settledActivationRequests ?? [])
+        ];
+        let changed = false;
+        for (const request of requests) {
+            if (request === null || typeof request !== "object" || request.schemaVersion !== 1
+                || request.operation?.targetId !== row.task_id
+                || !["immediate", "after-planning-turn"].includes(request.startMode)
+                || !["pending", "failed", "cancelled", "adopted"].includes(request.disposition)
+                || (Object.hasOwn(request, "origin") && !["explicit", "submit-develop"].includes(request.origin))) {
+                throw new Error(`Invalid historical activation request: ${row.task_id}. Preserve it for diagnosis.`);
+            }
+            if (Object.hasOwn(request, "origin")) {
+                changed = true;
+                delete request.origin;
+            }
+        }
+        if (changed) {
+            archive(row.task_id, "task.activation-origin-retired", row.payload);
+            saveTask.run(JSON.stringify(task), row.task_id);
+        }
+    }
+}