@zq-silk/yui 2.6.0 → 2.8.0

package/dist/doctor/doctor.js

@@ -1,6 +1,6 @@
 import { accessSync, constants, existsSync, lstatSync, realpathSync } from "node:fs";
 import { isAbsolute, join } from "node:path";
-import Database from "better-sqlite3";
+import Database, { selectSqliteDriver } from "../sqlite/driver.js";
 import { inspectPty } from "./ptyProbe.js";
 import { gitVersionSupport } from "../repository/gitCompatibility.js";
 import { resolveExecutable } from "../external/pinnedCommandRunner.js";
@@ -31,6 +31,7 @@ import { CommandExecutionError } from "../tmux/commandExecutor.js";
  * and never block an update.
  */
 export const STORAGE_DOCTOR_CHECK_NAMES = Object.freeze([
+    "sqlite driver",
     "storage schema",
     "storage compatibility",
     "storage state"
@@ -38,7 +39,7 @@ export const STORAGE_DOCTOR_CHECK_NAMES = Object.freeze([
 /**
  * Classify the storage checks into a machine-readable health verdict. This is the
  * canonical, parseable signal the update post-verify consumes (P1-3): storage is
- * healthy only when schema, compatibility, and state are all `ok`. Any
+ * healthy only when driver, schema, compatibility, and state are all `ok`. Any
  * `unsupported` (version mismatch / needs-new-version), `invalid` (corrupted /
  * unreadable), or `missing` (uninitialized) storage check is blocking — even
  * and the machine-readable command exits non-zero.
@@ -119,6 +120,7 @@ export async function getDoctorChecks(env, executor) {
 async function inspectDoctor(env, executor) {
     const home = resolveYuiHome(env);
     const homeCheck = checkHome(home);
+    const driverCheck = checkSqliteDriver();
     const schema = readSchema(home);
     const compatibility = inspectCompatibility(home, homeCheck, schema);
     const schemaCheck = checkSchema(schema);
@@ -135,6 +137,7 @@ async function inspectDoctor(env, executor) {
     return {
         checks: [
             homeCheck,
+            driverCheck,
             schemaCheck,
             compatibility.check,
             storage.check,
@@ -148,6 +151,26 @@ async function inspectDoctor(env, executor) {
         review: review.report
     };
 }
+export function checkSqliteDriver() {
+    try {
+        const selected = selectSqliteDriver();
+        return {
+            name: "sqlite driver",
+            status: "ok",
+            detail: `${selected.name}@${selected.version}; SQLite ${selected.sqliteVersion}; `
+                + (selected.fallbackReason === undefined
+                    ? "no fallback"
+                    : `fallback: ${selected.fallbackReason}`)
+                + ". Isolated native connection probe; does not validate Home data."
+        };
+    }
+    catch (error) {
+        return {
+            name: "sqlite driver", status: "invalid",
+            detail: `Native driver probe failed (not a Home diagnosis): ${error instanceof Error ? error.message : String(error)}`
+        };
+    }
+}
 /** Query the authenticated Controller endpoint without starting it. */
 export async function checkController(home, probe = callController) {
     try {

package/dist/executor/effectiveLaunch.js

@@ -2,7 +2,7 @@ import { isDeepStrictEqual } from "node:util";
 import { validateExecutionEnvironmentSnapshot } from "../resources/projectResource.js";
 import { validateManagedWorkspace } from "../worktree/managedWorkspace.js";
 import { resolveAgentAdapter } from "./agentAdapter.js";
-import { compileRoleSessionContext, roleSessionKind } from "../context/roleSessionContext.js";
+import { loadYuiSkillContexts, roleSessionKind, roleSkillIds } from "../context/roleSessionContext.js";
 import { validateSkillPackageRef } from "../context/skillPackage.js";
 import { isAgentAdapterId } from "../agent/adapterCatalog.js";
 import { adapterIdForExecutionComponent, isAgentExecutionComponentId, resolveAgentExecutionComponent } from "../agent/executionComponents.js";
@@ -24,7 +24,7 @@ export function resolveEffectiveLaunch(input) {
     const continuing = existing?.status === "active";
     const skillPackages = continuing ? existing.effective.skillPackages
         : home === undefined ? undefined
-            : compileRoleSessionContext(home, input.role, "taskId" in input.role ? { scope: "task", taskId: input.role.taskId } : { scope: "global" }, { purpose: input.purpose }).skills.map(skill => skill.package);
+            : loadYuiSkillContexts(home, roleSkillIds(input.role, roleSessionKind(input.role, "taskId" in input.role ? { scope: "task", taskId: input.role.taskId } : { scope: "global" }, input.purpose))).map(skill => skill.package);
     return snapshotFromConfig({
         executionAuthority: input.executionAuthority ?? (input.purpose === "planning" ? "planning" : "delivery"),
         sourceDesiredRevision: input.role.launchRevision,

package/dist/executor/fileRoleLaunchPlanner.js

@@ -259,15 +259,10 @@ export class FileRoleLaunchPlanner {
         const existingSession = owner.scope === "task"
             ? this.store.getTaskRoleSessionSet(owner.taskId, role.name)?.sessions[input.agentId]
             : this.store.getGlobalRoleSessionSet(role.name)?.sessions[input.agentId];
-        // A resume carries the Session's recorded generation forward unchanged. This
-        // planner runs in the Controller, which after an upgrade is already the new
-        // code, so it cannot speak for the still-running Agent Host that owns the
-        // Session: rejecting here would end live Sessions on Controller upgrade,
-        // while rewriting to current code would silently move a Session onto code it
-        // never started on. The Host that actually executes the implementation makes
-        // the decision — a reused live Host accepts its own generation, and a newly
-        // started Host running different code fails closed
-        // (`agentEndpointOwnership.pin` -> `requireBuiltinAgentEndpointImplementation`).
+        // Retain original launch provenance. The Host reports its actually loaded
+        // build separately and checks adapter/native identity, not build equality.
+        // A compatible new Host can resume this exact Session after safe release;
+        // this planner never silently replaces a live Host or native conversation.
         const endpointImplementation = input.mode === "resume"
             ? validateAgentEndpointImplementation(existingSession.endpointImplementation)
             : builtinAgentEndpointImplementation(binding.adapterId);
@@ -337,12 +332,10 @@ export class FileRoleLaunchPlanner {
         Object.assign(launchEnvironment, runtimeIsolation === undefined
             ? {}
             : taskRuntimeIsolationEnvironment(runtimeIsolation));
-        const skillPackages = input.mode === "resume"
-            ? existingSession?.effective.skillPackages : effective.skillPackages;
-        if (skillPackages === undefined) {
-            throw new Error("This launch has no frozen Skill package evidence (pre-1.5 or externally recorded Session). Create a new Session from current Role configuration; historical Skill versions cannot be reconstructed.");
-        }
-        const baseSessionContext = compileRoleSessionContext(this.home, launchRole, owner, { ...sessionPolicy, skillPackages });
+        // Frozen packages describe historical materialization, not Session identity
+        // or current instruction availability. Never require or reconstruct them
+        // when reconnecting a valid old Session.
+        const baseSessionContext = compileRoleSessionContext(this.home, launchRole, owner, sessionPolicy);
         const bootstrap = materializeSessionBootstrap({
             yuiHome: this.home,
             role: launchRole,

package/dist/interaction/notificationPresentation.js

@@ -69,7 +69,7 @@ export function taskNotificationPresentation(wake, store) {
         ...(messages.length > 4 ? [`${messages.length - 4} more messages in the fixed wake.`] : []),
         `Refresh: yui task context ${wake.taskId} --json`,
         `Read inputs/results: yui task wake show ${wake.taskId} ${wake.id} --json`,
-        "Apply yui-leader (from the current Manifest); read relevant originals in full and advance authorized work."
+        "Check current Skills each turn: yui session skills --json. Apply current yui-leader; read relevant originals in full and advance authorized work."
     ].join("\n");
 }
 export function globalMessagePresentation(roleName, messageId, message) {
@@ -80,6 +80,6 @@ export function globalMessagePresentation(roleName, messageId, message) {
         ...(summary === undefined ? [] : [`Author summary (message-body): ${JSON.stringify(summary)}`]),
         "Refresh Session Context using the current Manifest's loadCommand.",
         `Read original: yui role message show ${roleName} ${messageId} --json`,
-        `Apply ${roleName === "operator" ? "yui-operator" : "yui-runtime"} from the current Manifest within existing authority.`
+        `The Global loadCommand checks current Skill versions each turn. Apply current ${roleName === "operator" ? "yui-operator" : "yui-runtime"} within existing authority.`
     ].join("\n");
 }

package/dist/interaction/operatorPresentation.js

@@ -10,7 +10,7 @@ export function createOperatorBatchPresentation(batchId, items) {
         receiptId: `operator-batch:${batchId}`,
         text: [
             "[Yui updates]",
-            "Apply yui-operator from the current Manifest: inspect these originals and present material changes or decisions.",
+            "Check current Skills each turn via the Global Manifest's loadCommand. Apply current yui-operator; inspect these originals and present material changes or decisions.",
             ...items.flatMap(renderItem)
         ].join("\n")
     };

package/dist/message/globalInputBacklog.js

@@ -0,0 +1,69 @@
+import { providerRetryPending } from "../runtime/providerRetry.js";
+import { hasRuntimeCleanupObligation } from "../runtime/lifecycleReservation.js";
+/** Bounded, derived diagnostics only; never an acknowledgement or recovery authority. */
+export function globalInputBacklog(pending, sessions, now = new Date(), mailboxes = {}) {
+    const first = pending[0];
+    const run = sessions?.providerBinding?.run;
+    const session = sessions?.sessions[sessions.activeAgentId];
+    const authority = sessions?.providerBinding?.authority;
+    const batches = [mailboxes.attention?.pending, mailboxes.attention?.processing?.batch]
+        .filter(batch => batch != null);
+    const coalescedFactCount = batches.reduce((count, batch) => count + batch.requestCount, 0);
+    let reason = "ready";
+    let recovery = "The Controller delivers at the next legal opportunity; do not duplicate the input.";
+    if (first === undefined && coalescedFactCount === 0)
+        reason = "empty";
+    else if (hasRuntimeCleanupObligation(mailboxes.lifecycle ?? null)) {
+        reason = "lifecycle-cleanup";
+        recovery = "Complete the existing exact-owner stop/replacement; queued input cannot revive the Session.";
+    }
+    else if (session?.status !== "active") {
+        reason = session === undefined ? "session-unavailable" : "session-stopped";
+        recovery = "Inspect Session lifecycle. Explicit stop/replacement is not undone by background delivery.";
+    }
+    else if (authority?.owner !== "controller") {
+        reason = "external-or-unknown-writer";
+        recovery = "Resolve the current writer/authority explicitly; no background takeover is allowed.";
+    }
+    else if (providerRetryPending(sessions?.providerBinding)) {
+        reason = "provider-retry";
+        recovery = "The existing bounded Provider retry owns this input; inspect session retry before intervening.";
+    }
+    else if (run && ["submitting", "accepted", "delivery-unknown"].includes(run.status)) {
+        reason = run.status === "accepted" ? "in-flight-or-unobserved-terminal" : run.status;
+        recovery = "Age does not prove a stalled Turn. Periodic reconciliation asks only the original Host for exact retained terminal evidence. Inspect recent runtime-attention Messages if the Host is unobservable; never resend unknown input.";
+    }
+    else if (first?.inbox) {
+        reason = "agent-inbox-handling";
+        recovery = "Read the exact inbox original and prior handling claim; explicitly acknowledge after processing. No automatic replay or timeout release.";
+    }
+    else if (first?.control && first.control.outcome !== "rejected") {
+        reason = "message-acceptance-unresolved";
+        recovery = "Inspect this original Message's exact control receipt; do not replay or bypass uncertain input.";
+    }
+    else if (first?.interruptThen) {
+        reason = "reserved-interrupt-then";
+        recovery = "Only the original Session, authority and exact terminal release the reserved continuation.";
+    }
+    else if (first?.deliveryTarget && (first.deliveryTarget.agentId !== sessions?.activeAgentId
+        || first.deliveryTarget.nativeSessionId !== session.nativeSessionId)) {
+        reason = "stale-target";
+        recovery = "Unsubmitted stale messages are retained with a nondelivery reason; no cross-Session input copy.";
+    }
+    const oldestCreatedAt = [...pending.map(message => message.createdAt), ...batches.map(batch => batch.firstQueuedAt)]
+        .reduce((oldest, at) => oldest === null || at < oldest ? at : oldest, null);
+    return {
+        pendingCount: pending.length, coalescedFactCount, oldestCreatedAt,
+        oldestAgeMs: oldestCreatedAt === null ? null : Math.max(0, now.getTime() - Date.parse(oldestCreatedAt)),
+        reason, recovery,
+        target: session === undefined ? null : {
+            agentId: session.agentId, nativeSessionId: session.nativeSessionId,
+            authority: authority ?? null, attemptId: run?.attemptId ?? null, nativeTurnId: run?.nativeTurnId ?? null
+        },
+        messages: pending.slice(0, 8).map(message => ({
+            id: message.id, createdAt: message.createdAt, deliveryTarget: message.deliveryTarget ?? null,
+            control: message.control ?? null, interruptThen: message.interruptThen ?? null
+        })),
+        omittedMessages: Math.max(0, pending.length - 8)
+    };
+}

package/dist/message/globalMessageQuery.js

@@ -0,0 +1 @@
+export {};

package/dist/message/inboxReceipt.js

@@ -0,0 +1,62 @@
+import { requireKnownFields, requireText, requireTimestamp } from "../domain/validation.js";
+import { isDeepStrictEqual } from "node:util";
+/** Semantic handling and transport delivery are independent facts. Projections
+ * must not infer handling from delivery, a native terminal, or an empty queue. */
+export function inboxHandlingState(receipt) {
+    return receipt?.ack !== undefined ? "handled" : receipt !== undefined ? "claimed-unacknowledged" : "unclaimed";
+}
+export function isGlobalInboxMessage(message) {
+    return message.inputControl !== undefined || message.interruptThen !== undefined;
+}
+/** Unhandled own-role input, including accepted and unknown delivery. This is
+ * NOT the scheduler's deliverable queue; selecting it never authorizes replay. */
+export function pendingGlobalInboxMessages(messages) {
+    return messages.filter(message => isGlobalInboxMessage(message) && inboxHandlingState(message.inbox) !== "handled");
+}
+/** Original message evidence only. A missing receipt is not proof of
+ * non-submission; admission additionally inspects the exact native attempt. */
+export function globalInboxDeliveryState(message) {
+    return message.control?.outcome ?? (message.delivery?.via === "provider" ? "accepted"
+        : message.delivery === undefined ? "unobserved" : "delivery-unknown");
+}
+export function validateInboxReceipt(receipt) {
+    if (receipt === undefined)
+        return;
+    requireKnownFields(receipt, ["claim", "ack"], "Inbox receipt");
+    for (const [kind, entry] of Object.entries(receipt)) {
+        requireKnownFields(entry, kind === "claim" ? ["requestId", "actor", "at"]
+            : ["requestId", "actor", "at", "reason"], "Inbox action");
+        requireText(entry.requestId, "Inbox request id");
+        requireTimestamp(entry.at, "Inbox timestamp");
+        const actor = entry.actor;
+        requireKnownFields(actor, ["scope", "taskId", "roleName", "agentId", "nativeSessionId", "runId"], "Inbox actor");
+        if (!["task", "global"].includes(actor.scope)
+            || (actor.scope === "task") !== (actor.taskId !== undefined))
+            throw new Error("Inbox actor scope is invalid.");
+        for (const value of Object.values(actor))
+            requireText(value, "Inbox actor identity");
+        if (kind === "ack")
+            requireText(entry.reason, "Inbox disposition");
+    }
+    if (!receipt.claim)
+        throw new Error("Inbox receipt requires its original claim.");
+}
+/** A stale automatic writer cannot erase an active claim between its read and
+ * Host admission. The original claim and any ack are immutable audit facts. */
+export function assertInboxReceiptPreserved(previous, next) {
+    if (previous !== undefined && (!isDeepStrictEqual(previous.claim, next?.claim)
+        || previous.ack !== undefined && !isDeepStrictEqual(previous.ack, next?.ack))) {
+        throw new Error("Inbox handling ownership changed; reread the original instead of overwriting its receipt.");
+    }
+}
+/** A receipt cannot silently acknowledge different content under the same ID.
+ * Operational delivery/Assignment fields may evolve with their existing
+ * guards, but handled originals must be submitted as new Messages to change.
+ */
+export function assertInboxOriginalPreserved(previous, next) {
+    assertInboxReceiptPreserved(previous?.inbox, next.inbox);
+    if (previous?.inbox !== undefined && (previous.body !== next.body || previous.kind !== next.kind
+        || !isDeepStrictEqual(previous.author, next.author) || !isDeepStrictEqual(previous.inputControl, next.inputControl))) {
+        throw new Error("Inbox receipt binds the exact original Message; submit changed content as a new Message.");
+    }
+}

package/dist/message/message.js

@@ -1,5 +1,6 @@
 import { validateTaskRecordReference } from "../task/taskRecordReference.js";
 import { requireKnownFields } from "../domain/validation.js";
+import { validateInboxReceipt } from "./inboxReceipt.js";
 export const TASK_MESSAGE_KINDS = ["user", "operator", "role-result", "system"];
 /**
  * How a user/operator submission asks its Task to react (task-32 Requirement A).
@@ -207,8 +208,9 @@ export function validateTaskMessage(message) {
         throw new Error("Task Message must use schemaVersion 1.");
     requireKnownFields(message, [
         "schemaVersion", "id", "taskId", "kind", "author", "body", "intent", "submissionKey", "submissionReceipt",
-        "inputControl", "interruptThen", "control", "runId", "resultRef", "workItemId", "recipient", "continuation", "handovers", "createdAt"
+        "inputControl", "interruptThen", "control", "runId", "resultRef", "workItemId", "recipient", "continuation", "handovers", "createdAt", "inbox"
     ], "Task Message");
+    validateInboxReceipt(message.inbox);
     validateTaskRecordReference({ taskId: message.taskId, localId: message.id }, "message");
     requireText(message.body, "Message body");
     validateKindAndAuthor(message.kind, message.author);
@@ -394,6 +396,7 @@ export function createGlobalRoleMessage(id, roleName, body, kind, author, now, c
     return message;
 }
 export function validateGlobalRoleMessage(message) {
+    validateInboxReceipt(message.inbox);
     if (message.schemaVersion !== 1)
         throw new Error("Global Role Message must use schemaVersion 1.");
     validateGlobalRoleMessageId(message.id);
@@ -517,6 +520,8 @@ export function markGlobalRoleMessageDelivered(message, now, via = "provider") {
  * keeps resolving to this same Message and never creates a second input.
  */
 export function claimGlobalRoleMessageInterruptThen(message, claim) {
+    if (message.inbox !== undefined)
+        throw new Error("Agent inbox handling already owns this Message; it cannot be replayed through interrupt-then.");
     const { inputControl, notDelivered: _priorNondelivery, ...rest } = message;
     const claimed = {
         ...rest,

package/dist/message/messageContinuation.js

@@ -10,6 +10,7 @@ import { validateExactRunReviewRound } from "../lifecycle/exactRunTerminalizatio
 import { sourceRunContextValue } from "../context/sourceRunContext.js";
 import { requireManagedTaskCaller } from "../runtime/managedCaller.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
+import { isTaskRecordRetired, operationalTaskRecords } from "../task/taskRecordRetirement.js";
 export function resolveMessageRecipient(store, taskId, roleName, scope) {
     if (scope.reviewRoundId !== undefined) {
         const round = store.getReviewRound(taskId, scope.reviewRoundId);
@@ -28,8 +29,11 @@ export function resolveMessageRecipient(store, taskId, roleName, scope) {
         throw new Error("No existing Dispatch owns this Role and work scope.");
     return { roleName, ownerRunId: previous.id, ...scope };
 }
-/** Bounded diagnosis, not automatic ownership repair. */
-export function messageContinuationBlocker(store, message) {
+/** Current Assignment authority, independent of eligibility to start a new Run.
+ * A Reviewer still owns its frozen clarification when Task main advances. */
+export function messageAssignmentBlocker(store, message) {
+    if (isTaskRecordRetired(store.listEvents(message.taskId), "message", message.id))
+        return "message-retired";
     const target = message.recipient;
     if (target?.ownerRunId === undefined)
         return "recipient-assignment-missing";
@@ -78,22 +82,29 @@ export function messageContinuationBlocker(store, message) {
         && latest.inputs[0]?.input.source.channel !== "message-continuation")
         return "assignment-changed";
     if (target.reviewRoundId !== undefined) {
-        const round = store.getReviewRound(message.taskId, target.reviewRoundId);
-        if (round === null)
-            return "review-round-missing";
+        const validation = validateExactRunReviewRound(store, latest ?? owner, { allowTerminal: true });
+        if (validation.disposition !== "applied")
+            return validation.reason ?? "review-candidate-stale";
+    }
+    return undefined;
+}
+/** Starting another Run additionally requires the reviewed candidate to remain current. */
+export function messageContinuationBlocker(store, message) {
+    const invalid = messageAssignmentBlocker(store, message);
+    if (invalid !== undefined)
+        return invalid;
+    const reviewRoundId = message.recipient?.reviewRoundId;
+    if (reviewRoundId !== undefined) {
+        const round = store.getReviewRound(message.taskId, reviewRoundId);
         if (round.scope === "task") {
+            const task = store.getTask(message.taskId);
             if (round.taskCandidate?.projects.some((project) => task.projectBindings.find((binding) => binding.projectId === project.projectId)?.currentCommit !== project.commit)) {
                 return "review-candidate-stale";
             }
         }
-        else {
-            const item = store.getWorkItem(message.taskId, round.workItemId);
-            if (item?.candidates.at(-1)?.id !== round.candidateId)
-                return "review-candidate-stale";
+        else if (store.getWorkItem(message.taskId, round.workItemId)?.candidates.at(-1)?.id !== round.candidateId) {
+            return "review-candidate-stale";
         }
-        const validation = validateExactRunReviewRound(store, latest ?? owner, { allowTerminal: true });
-        if (validation.disposition !== "applied")
-            return validation.reason ?? "review-candidate-stale";
     }
     return undefined;
 }
@@ -189,7 +200,11 @@ export function interruptThenTerminalState(store, message) {
  * remain the pending authority; Mailbox is only the existing scheduling hint.
  * Reserving inputs and creating the next Run is one atomic effect. */
 export function prepareMessageContinuations(store, taskId, now, roleName) {
-    const pending = store.listMessages(taskId).filter((message) => message.recipient?.roleName === roleName && message.recipient.ownerRunId !== undefined
+    const messages = operationalTaskRecords(store.listMessages(taskId), store.listEvents(taskId), "message");
+    const claims = messages.filter(message => message.recipient?.roleName === roleName
+        && message.inbox !== undefined && message.inbox.ack === undefined);
+    const pending = messages.filter((message) => message.recipient?.roleName === roleName && message.recipient.ownerRunId !== undefined
+        && message.inbox === undefined
         && message.continuation?.runId === undefined
         // A steer targets the exact current native turn, never a queued next Run.
         // If its live attempt did not submit, the message stays saved for the
@@ -197,6 +212,12 @@ export function prepareMessageContinuations(store, taskId, now, roleName) {
         && message.inputControl?.action !== "steer");
     for (const message of pending) {
         const recipient = message.recipient;
+        // Retain ordering within the claimed Assignment, not across unrelated
+        // work owned by the same Role. Only ack or explicit retirement settles a
+        // claim's scheduling obligation; neither time nor a failed Run does.
+        if (claims.some(claim => claim.recipient?.workItemId === recipient.workItemId
+            && claim.recipient?.reviewRoundId === recipient.reviewRoundId))
+            continue;
         const blocker = messageContinuationBlocker(store, message);
         if (blocker !== undefined) {
             markNotDelivered(store, message, blocker);

package/dist/message/taskInboxOwnership.js

@@ -0,0 +1,43 @@
+import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
+/** Pin mutable originals by their existing event identity, not wall-clock time.
+ * Both automatic notification and active consumption use the same fixed refs. */
+export function pinMessageRevisions(store, taskId, refs) {
+    const pinned = [...refs];
+    for (const ref of refs) {
+        if (ref.type !== "message" || ref.taskId !== taskId)
+            continue;
+        const message = store.listMessages(taskId).find(message => message.id === ref.id);
+        const revision = message === undefined ? undefined : latestMessageUpdate(store, message);
+        if (revision !== undefined && !pinned.some(ref => ref.type === "event" && ref.id === revision.id)) {
+            pinned.push({ type: "event", taskId, id: revision.id });
+        }
+    }
+    return pinned;
+}
+export function latestMessageUpdate(store, message) {
+    return store.listEvents(message.taskId).filter(event => event.type === "message.updated" && event.payload.messageId === message.id).at(-1);
+}
+/** Leader steer has no Assignment recipient; ordinary Task records are not
+ * private inbox messages. Queued Leader inputs remain fixed wake windows. */
+export function isLeaderSteer(message) {
+    return message.recipient === undefined && message.inputControl?.action === "steer";
+}
+/** Derive ownership from original receipts, never from disposable mailboxes. */
+export function taskMessageInboxReceipt(store, message) {
+    return message.inbox ?? messageRevisionWakes(store, message).find(wake => wake.inbox !== undefined)?.inbox;
+}
+/** Delivery suppresses repeat notification of that revision, but remains
+ * distinct from handling. The original fixed window stays in the own inbox. */
+export function deliveredMessageWake(store, message) {
+    return messageRevisionWakes(store, message).find(wake => wake.status === "consumed");
+}
+function messageRevisionWakes(store, message) {
+    const revision = latestMessageUpdate(store, message);
+    return store.listTaskWakes(message.taskId).filter(wake => (revision === undefined || wake.refs?.some(ref => ref.type === "event" && ref.taskId === message.taskId && ref.id === revision.id))
+        && wake.refs?.some(ref => ref.type === "message" && ref.taskId === message.taskId && ref.id === message.id));
+}
+export function unfinishedLeaderInbox(store, taskId) {
+    return store.listTaskWakes(taskId).some(wake => wake.inbox !== undefined && wake.inbox.ack === undefined)
+        || operationalTaskRecords(store.listMessages(taskId), store.listEvents(taskId), "message").some(message => isLeaderSteer(message)
+            && message.inbox !== undefined && message.inbox.ack === undefined);
+}