@zq-silk/yui 0.6.8 → 0.6.10

package/dist/storage/sqliteStore.js

@@ -12,10 +12,9 @@
  *                                    the write transaction; conflict ->
  *                                    StorageConflictError (transactionWithRevisionCas).
  *   - Atomic durable write ........ WAL + synchronous=FULL; COMMIT == fsync.
- *   - Mailbox per-target ordering . mailboxes.next_sequence + mailbox_signals
- *                                    (mailbox_id, sequence) primary key.
+ *   - Mailbox per-target ordering . WorkMailbox v2 sequence/cursors in one row.
  *   - Exactly-once terminal state . conditional updates + UNIQUE(request_id)
- *                                    on outbox / mailbox_signals.
+ *                                    on the durable outbox.
  *   - Crash recovery .............. WAL rollback of uncommitted transactions;
  *                                    outbox replay of committed-but-unacked effects.
  *   - Record family versioning .... full record (incl. schemaVersion) in payload.
@@ -39,8 +38,7 @@ import { existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import Database from "better-sqlite3";
-import { mailboxTargetKey } from "../coordination/workMailbox.js";
-import { validatePendingTurnCompletion } from "../executor/turnCompletion.js";
+import { consumePendingBatch, mailboxTargetKey, pendingLane, validateWorkMailbox } from "../coordination/workMailbox.js";
 import { compareRuntimeSessionCandidates, projectRuntimeSessionCandidate } from "../runtime/runtimeSessionCandidate.js";
 import { validateReviewFinding } from "../review/reviewFinding.js";
 import { generateHomeIdentity, validateHomeIdentity } from "../repository/homeIdentity.js";
@@ -90,17 +88,18 @@ function isUniqueConstraint(error) {
 }
 /** Project a leader-role work mailbox's pending batch to a PendingWakeup (mirrors taskStore.ts). */
 function pendingWakeupProjection(mailbox) {
+    const pending = mailbox === null ? null : pendingLane(mailbox, "normal");
     if (mailbox === null || mailbox.target.kind !== "role" || mailbox.target.roleName !== "leader"
-        || mailbox.pending === null) {
+        || pending === null) {
         return null;
     }
     return {
         schemaVersion: CURRENT_PENDING_WAKEUP_SCHEMA_VERSION,
         taskId: mailbox.target.taskId,
-        reasons: [...mailbox.pending.reasons],
-        requestCount: mailbox.pending.requestCount,
-        firstRequestedAt: mailbox.pending.firstQueuedAt,
-        lastRequestedAt: mailbox.pending.lastQueuedAt
+        reasons: [...pending.reasons],
+        requestCount: pending.requestCount,
+        firstRequestedAt: pending.firstQueuedAt,
+        lastRequestedAt: pending.lastQueuedAt
     };
 }
 export class SqliteTaskStore {
@@ -915,7 +914,6 @@ export class SqliteTaskStore {
             this.#db.prepare(`INSERT INTO role_session_sets (task_id, role_name, payload, updated_at) VALUES (?, ?, ?, ?)
          ON CONFLICT(task_id, role_name) DO UPDATE SET payload = excluded.payload, updated_at = excluded.updated_at`).run(sessions.owner.taskId, sessions.owner.roleName, this.#json(sessions), this.#now());
             this.#saveRuntimeSessionCandidate(sessions);
-            this.#savePendingRuntimeTurnCompletion(sessions);
         });
     }
     removeTaskRole(taskId, name) {
@@ -1104,33 +1102,6 @@ export class SqliteTaskStore {
             && row.session_updated_at === candidate.sessionUpdatedAt
             && row.cleanup_required === (candidate.cleanupRequired ? 1 : 0);
     }
-    listPendingRuntimeTurnCompletions(taskIds) {
-        const selectedTaskIds = taskIds === undefined
-            ? undefined
-            : [...new Set(taskIds)].sort(numericCompare);
-        if (selectedTaskIds?.length === 0)
-            return [];
-        const where = selectedTaskIds === undefined
-            ? ""
-            : ` WHERE task_id IN (${selectedTaskIds.map(() => "?").join(", ")})`;
-        const rows = this.#db.prepare(`SELECT task_id, role_name, schema_version, agent_id, native_session_id,
-              turn_id, run_id, summary, observed_at, due_at
-       FROM pending_runtime_turn_completions${where}`).all(...(selectedTaskIds ?? []));
-        return rows.map((row) => validatePendingTurnCompletion({
-            schemaVersion: row.schema_version,
-            taskId: row.task_id,
-            roleName: row.role_name,
-            agentId: row.agent_id,
-            nativeSessionId: row.native_session_id,
-            turnId: row.turn_id,
-            runId: row.run_id,
-            summary: row.summary,
-            observedAt: row.observed_at,
-            dueAt: row.due_at
-        })).sort((left, right) => (numericCompare(left.taskId, right.taskId)
-            || numericCompare(left.roleName, right.roleName)
-            || numericCompare(left.runId, right.runId)));
-    }
     saveRoleSessionSet(sessions) {
         const taskId = sessions.owner.taskId;
         this.#requireTask(taskId);
@@ -1138,7 +1109,6 @@ export class SqliteTaskStore {
             this.#db.prepare(`INSERT INTO role_session_sets (task_id, role_name, payload, updated_at) VALUES (?, ?, ?, ?)
          ON CONFLICT(task_id, role_name) DO UPDATE SET payload = excluded.payload, updated_at = excluded.updated_at`).run(taskId, sessions.owner.roleName, this.#json(sessions), this.#now());
             this.#saveRuntimeSessionCandidate(sessions);
-            this.#savePendingRuntimeTurnCompletion(sessions);
         });
     }
     saveTaskRoleSessionSet(sessions) {
@@ -1175,32 +1145,6 @@ export class SqliteTaskStore {
         this.#db.prepare(`DELETE FROM runtime_session_candidates
        WHERE scope = ? AND task_id = ? AND role_name = ?`).run(owner.scope, owner.scope === "task" ? owner.taskId : "", owner.roleName);
     }
-    /** Maintain the independent pending-Turn projection in the same write txn. */
-    #savePendingRuntimeTurnCompletion(sessions) {
-        const owner = sessions.owner;
-        const pending = sessions.pendingTurnCompletion;
-        if (pending === null) {
-            this.#db.prepare("DELETE FROM pending_runtime_turn_completions WHERE task_id = ? AND role_name = ?").run(owner.taskId, owner.roleName);
-            return;
-        }
-        const normalized = validatePendingTurnCompletion(pending);
-        if (normalized.taskId !== owner.taskId || normalized.roleName !== owner.roleName) {
-            throw new StorageRecordError(`Pending Turn completion owner does not match Role session: ${owner.taskId}/${owner.roleName}.`);
-        }
-        this.#db.prepare(`INSERT INTO pending_runtime_turn_completions (
-         task_id, role_name, schema_version, agent_id, native_session_id,
-         turn_id, run_id, summary, observed_at, due_at
-       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-       ON CONFLICT(task_id, role_name) DO UPDATE SET
-         schema_version = excluded.schema_version,
-         agent_id = excluded.agent_id,
-         native_session_id = excluded.native_session_id,
-         turn_id = excluded.turn_id,
-         run_id = excluded.run_id,
-         summary = excluded.summary,
-         observed_at = excluded.observed_at,
-         due_at = excluded.due_at`).run(normalized.taskId, normalized.roleName, normalized.schemaVersion, normalized.agentId, normalized.nativeSessionId, normalized.turnId, normalized.runId, normalized.summary, normalized.observedAt, normalized.dueAt);
-    }
     // -- work items -------------------------------------------------------------
     nextWorkItemId(taskId) { return this.#nextTaskRecordId(taskId, "workItem"); }
     getWorkItem(taskId, workItemId) {
@@ -1776,13 +1720,14 @@ export class SqliteTaskStore {
     }
     #rowToMailbox(row) {
         const target = this.#targetFromCols(row.target_kind, row.task_id, row.role_name);
-        return {
-            schemaVersion: 1,
+        return validateWorkMailbox({
+            schemaVersion: CURRENT_WORK_MAILBOX_SCHEMA_VERSION,
             target,
             nextSequence: row.next_sequence,
             processing: row.processing === null ? null : this.#parse(row.processing),
-            pending: row.pending === null ? null : this.#parse(row.pending)
-        };
+            pending: this.#parse(row.pending),
+            inputDelivery: row.input_delivery === null ? null : this.#parse(row.input_delivery)
+        });
     }
     #targetFromCols(kind, taskId, roleName) {
         switch (kind) {
@@ -1796,27 +1741,31 @@ export class SqliteTaskStore {
     }
     getWorkMailbox(target) {
         const cols = this.#mailboxCols(target);
-        const row = this.#db.prepare("SELECT target_kind, task_id, role_name, next_sequence, processing, pending FROM mailboxes WHERE target_key = ?").get(cols.targetKey);
+        const row = this.#db.prepare("SELECT target_kind, task_id, role_name, next_sequence, processing, pending, input_delivery FROM mailboxes WHERE target_key = ?").get(cols.targetKey);
         return row === undefined ? null : this.#rowToMailbox(row);
     }
     listWorkMailboxes() {
-        const rows = this.#db.prepare("SELECT target_kind, task_id, role_name, next_sequence, processing, pending FROM mailboxes ORDER BY target_key").all();
+        const rows = this.#db.prepare("SELECT target_kind, task_id, role_name, next_sequence, processing, pending, input_delivery FROM mailboxes ORDER BY target_key").all();
         return rows.map((row) => this.#rowToMailbox(row));
     }
     listReadyWorkMailboxes() {
-        const rows = this.#db.prepare(`SELECT target_kind, task_id, role_name, next_sequence, processing, pending
+        const rows = this.#db.prepare(`SELECT target_kind, task_id, role_name, next_sequence, processing, pending, input_delivery
        FROM mailboxes
-       WHERE processing IS NOT NULL OR pending IS NOT NULL
+       WHERE processing IS NOT NULL
+          OR input_delivery IS NOT NULL
+          OR json_type(pending, '$.normal') <> 'null'
+          OR json_type(pending, '$.userCorrection') <> 'null'
        ORDER BY target_key`).all();
         return rows.map((row) => this.#rowToMailbox(row));
     }
     saveWorkMailbox(mailbox) {
         const cols = this.#mailboxCols(mailbox.target);
         this.#mutate(() => {
-            this.#db.prepare(`INSERT INTO mailboxes (target_kind, task_id, role_name, target_key, next_sequence, processing, pending)
-         VALUES (?, ?, ?, ?, ?, ?, ?)
+            this.#db.prepare(`INSERT INTO mailboxes (target_kind, task_id, role_name, target_key, next_sequence, processing, pending, input_delivery)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)
          ON CONFLICT(target_key) DO UPDATE SET next_sequence = excluded.next_sequence,
-           processing = excluded.processing, pending = excluded.pending`).run(cols.targetKind, cols.taskId, cols.roleName, cols.targetKey, mailbox.nextSequence, mailbox.processing === null ? null : this.#json(mailbox.processing), mailbox.pending === null ? null : this.#json(mailbox.pending));
+           processing = excluded.processing, pending = excluded.pending,
+           input_delivery = excluded.input_delivery`).run(cols.targetKind, cols.taskId, cols.roleName, cols.targetKey, mailbox.nextSequence, mailbox.processing === null ? null : this.#json(mailbox.processing), this.#json(mailbox.pending), mailbox.inputDelivery === null ? null : this.#json(mailbox.inputDelivery));
         });
     }
     removeWorkMailbox(target) {
@@ -1832,28 +1781,6 @@ export class SqliteTaskStore {
      * single writer connection serializes enqueues, so sequences stay gapless per
      * mailbox. `(mailbox_id, sequence)` is the exactly-once key.
      */
-    enqueueMailboxSignal(target, input) {
-        return this.#mutate(() => {
-            const cols = this.#mailboxCols(target);
-            let mailboxId;
-            let sequence;
-            const existing = this.#db.prepare("SELECT mailbox_id, next_sequence FROM mailboxes WHERE target_key = ?").get(cols.targetKey);
-            if (existing === undefined) {
-                const result = this.#db.prepare(`INSERT INTO mailboxes (target_kind, task_id, role_name, target_key, next_sequence, processing, pending)
-           VALUES (?, ?, ?, ?, 1, NULL, NULL)`).run(cols.targetKind, cols.taskId, cols.roleName, cols.targetKey);
-                mailboxId = Number(result.lastInsertRowid);
-                sequence = 1;
-            }
-            else {
-                mailboxId = existing.mailbox_id;
-                sequence = existing.next_sequence;
-            }
-            this.#db.prepare(`INSERT INTO mailbox_signals (mailbox_id, sequence, reason, ref_type, ref_task_id, ref_id, occurred_at, request_id)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(mailboxId, sequence, input.reason, input.ref?.type ?? null, input.ref && "taskId" in input.ref ? input.ref.taskId : null, input.ref?.id ?? null, this.#now(), input.requestId);
-            this.#db.prepare("UPDATE mailboxes SET next_sequence = ? WHERE mailbox_id = ?").run(sequence + 1, mailboxId);
-            return sequence;
-        });
-    }
     // -- scheduler projections -----------------------------------------------------
     #getProjection(taskId, kind) {
         const row = this.#db.prepare("SELECT payload FROM task_projections WHERE task_id = ? AND kind = ?").get(taskId, kind);
@@ -1908,32 +1835,47 @@ export class SqliteTaskStore {
         const target = { kind: "role", taskId: value.taskId, roleName: "leader" };
         this.transaction((store) => {
             const existing = store.getWorkMailbox(target);
-            if (existing !== null && existing.pending !== null
-                && value.requestCount <= existing.pending.requestCount) {
+            const existingPending = existing === null ? null : pendingLane(existing, "normal");
+            if (existingPending !== null
+                && value.requestCount <= existingPending.requestCount) {
                 throw new StorageRecordError(`Pending wakeup is stale: ${value.taskId}`);
             }
-            const fromSequence = existing?.pending?.fromSequence ?? existing?.nextSequence ?? 1;
+            const fromSequence = existingPending?.fromSequence ?? existing?.nextSequence ?? 1;
             const toSequence = fromSequence + value.requestCount - 1;
             store.saveWorkMailbox({
                 schemaVersion: CURRENT_WORK_MAILBOX_SCHEMA_VERSION,
                 target,
                 nextSequence: Math.max(existing?.nextSequence ?? 1, toSequence + 1),
                 processing: existing?.processing ?? null,
+                inputDelivery: existing?.inputDelivery ?? null,
                 pending: {
-                    ...existing?.pending,
-                    fromSequence,
-                    toSequence,
-                    reasons: [...value.reasons],
-                    refs: existing?.pending?.refs ?? [],
-                    requestCount: value.requestCount,
-                    firstQueuedAt: value.firstRequestedAt,
-                    lastQueuedAt: value.lastRequestedAt
+                    normal: {
+                        fromSequence,
+                        toSequence,
+                        reasons: [...value.reasons],
+                        refs: existingPending?.refs ?? [],
+                        requestCount: value.requestCount,
+                        firstQueuedAt: value.firstRequestedAt,
+                        lastQueuedAt: value.lastRequestedAt,
+                        sources: existingPending?.sources ?? ["pending-wakeup-projection"],
+                        dedupeKeys: existingPending?.dedupeKeys ?? [
+                            `pending-wakeup:${value.taskId}:${fromSequence}-${toSequence}`
+                        ],
+                        deliveryModes: existingPending?.deliveryModes ?? ["followup"]
+                    },
+                    userCorrection: existing?.pending.userCorrection ?? null,
+                    cursors: existing?.pending.cursors ?? { normal: 0, userCorrection: 0 },
+                    recentDedupeKeys: existing?.pending.recentDedupeKeys ?? []
                 }
             });
         });
     }
     clearPendingWakeup(taskId) {
-        this.removeWorkMailbox({ kind: "role", taskId, roleName: "leader" });
+        const target = { kind: "role", taskId, roleName: "leader" };
+        const mailbox = this.getWorkMailbox(target);
+        if (mailbox === null || mailbox.pending.normal === null)
+            return;
+        this.saveWorkMailbox(consumePendingBatch(mailbox, "normal"));
     }
     // -- telemetry (§4.4) -----------------------------------------------------------
     /**

package/dist/storage/storageVersions.js

@@ -15,4 +15,4 @@
  */
 export const CURRENT_STORAGE_LAYOUT_VERSION = 7;
 /** Version of the authoritative aggregate stored in `state.json`. */
-export const CURRENT_AGGREGATE_SCHEMA_VERSION = 19;
+export const CURRENT_AGGREGATE_SCHEMA_VERSION = 20;

package/dist/storage/storeRpc.js

@@ -69,7 +69,6 @@ const READ_ONLY_STORE_METHODS = new Set([
     "getTaskRoleSessionSet",
     "listRoleSessionSets",
     "listRuntimeSessionCandidates",
-    "listPendingRuntimeTurnCompletions",
     "getRoleSession",
     "getWorkItem",
     "listWorkItems",

package/dist/storage/taskStore.js

@@ -7,10 +7,9 @@ import { validateCapabilityGrant } from "../grant/capabilityGrant.js";
 import { validateReleaseWorkflow } from "../release/releaseWorkflow.js";
 import { reconciliationIntervalMilliseconds, resolveLeaderNextActionMode, resolveResourcesGcAutoQuarantine, resolveResourcesGcMode } from "../config/yuiConfig.js";
 import { resolveTimeZone } from "../output/timePresentation.js";
-import { mailboxTargetKey, validateWorkMailbox } from "../coordination/workMailbox.js";
+import { mailboxBatches, consumePendingBatch, mailboxHasWork, mailboxTargetKey, pendingLane, validateWorkMailbox } from "../coordination/workMailbox.js";
 import { validateInputRequest } from "../input/inputRequest.js";
 import { validateRoleSessionSet } from "../executor/agentExecutor.js";
-import { validatePendingTurnCompletion } from "../executor/turnCompletion.js";
 import { validateTaskMessage } from "../message/message.js";
 import { validateAgentRun } from "../run/agentRun.js";
 import { compareRuntimeSessionCandidates, projectRuntimeSessionCandidate } from "../runtime/runtimeSessionCandidate.js";
@@ -71,7 +70,7 @@ export const CURRENT_MILESTONE_SCHEMA_VERSION = 1;
 export const CURRENT_EVENT_SCHEMA_VERSION = 2;
 export const CURRENT_CAPABILITY_GRANT_SCHEMA_VERSION = 1;
 export const CURRENT_RELEASE_WORKFLOW_SCHEMA_VERSION = 1;
-export const CURRENT_WORK_MAILBOX_SCHEMA_VERSION = 1;
+export const CURRENT_WORK_MAILBOX_SCHEMA_VERSION = 2;
 export const CURRENT_ROLE_AGENT_SESSION_SCHEMA_VERSION = 3;
 export const CURRENT_PENDING_WAKEUP_SCHEMA_VERSION = 1;
 const STORAGE_LOCK_DIRECTORY = ".state.lock";
@@ -111,7 +110,7 @@ export const CURRENT_STORED_TASK_SCHEMA_VERSION = 16;
  * Keep these named at the storage boundary so the upgrade record-axis map can
  * assert it is classifying the same bytes the store reads and writes.
  */
-export const CURRENT_TASK_ROLE_SESSION_SET_SCHEMA_VERSION = 4;
+export const CURRENT_TASK_ROLE_SESSION_SET_SCHEMA_VERSION = 5;
 /**
  * v7 combines optional Issue 04 retry/receipt fields and Issue 05 Leader
  * actionability fields. All are optional, so the v6→v7 migration is a
@@ -779,27 +778,6 @@ export class FileTaskStore {
             .filter((candidate) => !query.cleanupRequiredOnly || candidate.cleanupRequired)
             .sort(compareRuntimeSessionCandidates);
     }
-    listPendingRuntimeTurnCompletions(taskIds) {
-        const selectedTaskIds = taskIds === undefined
-            ? undefined
-            : [...new Set(taskIds)].sort(numericCompare);
-        if (selectedTaskIds?.length === 0)
-            return [];
-        const taskAggregates = selectedTaskIds === undefined
-            ? Object.values(this.#state().tasks)
-            : selectedTaskIds.flatMap((taskId) => {
-                const aggregate = this.#state().tasks[taskId];
-                return aggregate === undefined ? [] : [aggregate];
-            });
-        return taskAggregates.flatMap((aggregate) => (Object.values(aggregate.roleSessionSets).flatMap((sessions) => {
-            const pending = sessions.pendingTurnCompletion;
-            return pending === null || pending === undefined
-                ? []
-                : [validatePendingTurnCompletion(pending)];
-        }))).sort((left, right) => (numericCompare(left.taskId, right.taskId)
-            || numericCompare(left.roleName, right.roleName)
-            || numericCompare(left.runId, right.runId)));
-    }
     saveRoleSessionSet(sessions) {
         const stored = taskSessions(sessions);
         const taskId = stored.owner.taskId;
@@ -1484,7 +1462,7 @@ export class FileTaskStore {
         // in-memory aggregate while preserving the indexed SQLite contract's
         // target-key order; production layout 7 uses the bounded SQLite query.
         return Object.entries(this.#state().mailboxes)
-            .filter(([, mailbox]) => mailbox.processing !== null || mailbox.pending !== null)
+            .filter(([, mailbox]) => mailboxHasWork(mailbox))
             .sort(([left], [right]) => left.localeCompare(right))
             .map(([, mailbox]) => clone(mailbox));
     }
@@ -1520,32 +1498,47 @@ export class FileTaskStore {
         const target = { kind: "role", taskId: wakeup.taskId, roleName: "leader" };
         this.transaction(() => {
             const existing = this.getWorkMailbox(target);
-            if (existing !== null && existing.pending !== null
-                && wakeup.requestCount <= existing.pending.requestCount) {
+            const existingPending = existing === null ? null : pendingLane(existing, "normal");
+            if (existingPending !== null
+                && wakeup.requestCount <= existingPending.requestCount) {
                 throw new StorageRecordError(`Pending wakeup is stale: ${wakeup.taskId}`);
             }
-            const fromSequence = existing?.pending?.fromSequence ?? existing?.nextSequence ?? 1;
+            const fromSequence = existingPending?.fromSequence ?? existing?.nextSequence ?? 1;
             const toSequence = fromSequence + wakeup.requestCount - 1;
             this.saveWorkMailbox({
                 schemaVersion: CURRENT_WORK_MAILBOX_SCHEMA_VERSION,
                 target,
                 nextSequence: Math.max(existing?.nextSequence ?? 1, toSequence + 1),
                 processing: existing?.processing ?? null,
+                inputDelivery: existing?.inputDelivery ?? null,
                 pending: {
-                    ...existing?.pending,
-                    fromSequence,
-                    toSequence,
-                    reasons: [...wakeup.reasons],
-                    refs: existing?.pending?.refs ?? [],
-                    requestCount: wakeup.requestCount,
-                    firstQueuedAt: wakeup.firstRequestedAt,
-                    lastQueuedAt: wakeup.lastRequestedAt
+                    normal: {
+                        fromSequence,
+                        toSequence,
+                        reasons: [...wakeup.reasons],
+                        refs: existingPending?.refs ?? [],
+                        requestCount: wakeup.requestCount,
+                        firstQueuedAt: wakeup.firstRequestedAt,
+                        lastQueuedAt: wakeup.lastRequestedAt,
+                        sources: existingPending?.sources ?? ["pending-wakeup-projection"],
+                        dedupeKeys: existingPending?.dedupeKeys ?? [
+                            `pending-wakeup:${wakeup.taskId}:${fromSequence}-${toSequence}`
+                        ],
+                        deliveryModes: existingPending?.deliveryModes ?? ["followup"]
+                    },
+                    userCorrection: existing?.pending.userCorrection ?? null,
+                    cursors: existing?.pending.cursors ?? { normal: 0, userCorrection: 0 },
+                    recentDedupeKeys: existing?.pending.recentDedupeKeys ?? []
                 }
             });
         });
     }
     clearPendingWakeup(taskId) {
-        this.removeWorkMailbox({ kind: "role", taskId, roleName: "leader" });
+        const target = { kind: "role", taskId, roleName: "leader" };
+        const mailbox = this.getWorkMailbox(target);
+        if (mailbox === null || mailbox.pending.normal === null)
+            return;
+        this.saveWorkMailbox(consumePendingBatch(mailbox, "normal"));
     }
     getLeaderFailure(taskId) { return optional(this.#state().tasks[taskId]?.leaderFailure ?? undefined); }
     saveLeaderFailure(value) { this.#saveSingleton(value.taskId, "leaderFailure", value, "Leader failure"); }
@@ -2912,17 +2905,18 @@ function values(records, identity) {
 }
 function numericCompare(left, right) { return left.localeCompare(right, undefined, { numeric: true }); }
 export function pendingWakeupProjection(mailbox) {
+    const pending = mailbox === null ? null : pendingLane(mailbox, "normal");
     if (mailbox === null || mailbox.target.kind !== "role" || mailbox.target.roleName !== "leader"
-        || mailbox.pending === null) {
+        || pending === null) {
         return null;
     }
     return {
         schemaVersion: CURRENT_PENDING_WAKEUP_SCHEMA_VERSION,
         taskId: mailbox.target.taskId,
-        reasons: [...mailbox.pending.reasons],
-        requestCount: mailbox.pending.requestCount,
-        firstRequestedAt: mailbox.pending.firstQueuedAt,
-        lastRequestedAt: mailbox.pending.lastQueuedAt
+        reasons: [...pending.reasons],
+        requestCount: pending.requestCount,
+        firstRequestedAt: pending.firstQueuedAt,
+        lastRequestedAt: pending.lastQueuedAt
     };
 }
 function validateMailboxReferences(state, mailbox) {
@@ -2939,12 +2933,11 @@ function validateMailboxReferences(state, mailbox) {
     }
     const refs = [];
     if (mailbox.processing !== null) {
-        refs.push(...mailbox.processing.batch.refs);
         if (mailbox.processing.executionRef !== undefined)
             refs.push(mailbox.processing.executionRef);
     }
-    if (mailbox.pending !== null)
-        refs.push(...mailbox.pending.refs);
+    for (const batch of mailboxBatches(mailbox))
+        refs.push(...batch.refs);
     for (const ref of refs) {
         if (!mailboxReferenceExists(state, ref)) {
             const identity = "taskId" in ref ? `${ref.taskId}/${ref.id}` : ref.id;
@@ -3012,13 +3005,6 @@ function validateCanonicalTaskReferences(state, aggregate) {
                 throw new StorageRecordError(`Task Role in-flight Run is invalid: ${taskId}/${roleName}.`);
             }
         }
-        if (sessions.pendingTurnCompletion !== null) {
-            const completion = sessions.pendingTurnCompletion;
-            const run = aggregate.agentRuns[completion.runId];
-            if (completion.taskId !== taskId || run === undefined || run.roleName !== roleName) {
-                throw new StorageRecordError(`Task Role pending completion Run is invalid: ${taskId}/${roleName}.`);
-            }
-        }
     }
     for (const run of Object.values(aggregate.agentRuns)) {
         if (run.workItemId !== undefined && aggregate.workItems[run.workItemId] === undefined) {
@@ -3316,6 +3302,7 @@ function mailboxReferenceExists(state, ref) {
             case "work-item": return aggregate.workItems[ref.id] !== undefined;
             case "input": return aggregate.inputRequests[ref.id] !== undefined;
             case "message": return aggregate.messages[ref.id] !== undefined;
+            case "event": return aggregate.events[ref.id] !== undefined;
         }
     }
     switch (ref.type) {

package/dist/storage/upgrade/sqliteStateMigration.js

@@ -49,7 +49,6 @@ export function copySqlitePassthroughState(home, sourceDatabaseFilename, targetD
         target.transaction(() => {
             mergeGlobalSequences(source, target);
             copyTableRows(source, target, "outbox");
-            copyMailboxSignals(source, target);
             copyTableRows(source, target, "work_item_candidates");
             copyTableRows(source, target, "review_findings");
             copyTableRows(source, target, "telemetry");
@@ -78,26 +77,6 @@ function mergeGlobalSequences(source, target) {
     for (const row of rows)
         merge.run(row.name, row.high_water);
 }
-function copyMailboxSignals(source, target) {
-    if (!sqliteTableExists(source, "mailbox_signals"))
-        return;
-    const rows = source.prepare(`SELECT m.target_key, s.sequence, s.reason, s.ref_type, s.ref_task_id,
-            s.ref_id, s.occurred_at, s.request_id
-       FROM mailbox_signals s
-       JOIN mailboxes m ON m.mailbox_id = s.mailbox_id
-      ORDER BY m.target_key, s.sequence`).iterate();
-    const findMailbox = target.prepare("SELECT mailbox_id FROM mailboxes WHERE target_key = ?");
-    const insert = target.prepare(`INSERT INTO mailbox_signals
-       (mailbox_id, sequence, reason, ref_type, ref_task_id, ref_id, occurred_at, request_id)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
-    for (const row of rows) {
-        const mailbox = findMailbox.get(row.target_key);
-        if (mailbox === undefined) {
-            throw new Error(`SQLite migration cannot preserve signals for missing mailbox ${row.target_key}.`);
-        }
-        insert.run(mailbox.mailbox_id, row.sequence, row.reason, row.ref_type, row.ref_task_id, row.ref_id, row.occurred_at, row.request_id);
-    }
-}
 function copyTableRows(source, target, table) {
     if (!sqliteTableExists(source, table) || !sqliteTableExists(target, table))
         return;

package/dist/task/nextAction.js

@@ -244,7 +244,7 @@ export function projectNextAction(facts) {
                 },
                 {
                     kind: "native-subagent",
-                    reason: "Use one native implementer subagent when one bounded implementation pass benefits from parallel attention.",
+                    reason: "Use native implementer subagents when bounded work benefits from specialist attention or parallel fan-out inside the Leader Session.",
                     refs
                 }
             ],

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

@@ -47,7 +47,7 @@ const state = {
   detail: null,
   detailKey: null
 };
-const VALID_FILTERS = ["all", "active", "draft", "completed", "archived"];
+const VALID_FILTERS = ["all", "active", "draft", "completed", "retired", "archived"];
 let terminalSession = null;
 let terminalStateKey = "terminal.closed";