@zq-silk/yui 2.8.1 → 2.10.0

package/dist/job/durableJob.js

@@ -11,6 +11,9 @@ export const DURABLE_JOB_TERMINAL_STATUSES = [
     "cancelled",
     "unknown-needs-attention"
 ];
+export function executionNamespace(run) {
+    return "taskId" in run ? run.taskId : "global";
+}
 export function isDurableJobTerminal(status) {
     return DURABLE_JOB_TERMINAL_STATUSES.includes(status);
 }
@@ -22,6 +25,9 @@ export function createDurableJob(input, now) {
     return validateDurableJob({
         schemaVersion: CURRENT_DURABLE_JOB_SCHEMA_VERSION,
         id: input.id,
+        definitionId: input.definitionId ?? input.id,
+        definitionRevision: input.definitionRevision ?? 1,
+        trigger: input.trigger ?? { source: "manual", key: input.operation.requestId },
         taskId: input.taskId,
         owner: input.owner,
         projectId: input.projectId,
@@ -233,50 +239,26 @@ export function validateDurableJob(job) {
         throw new Error(`DurableJob must use schemaVersion ${CURRENT_DURABLE_JOB_SCHEMA_VERSION}.`);
     }
     validateOperationFacts(job.operation);
-    validateTaskRecordReference({
-        taskId: job.taskId,
-        localId: job.id
-    }, "durableJob");
-    validateDurableJobOwner(job.owner, job.taskId);
-    requireIdentity(job.projectId, "DurableJob project id");
-    requireCommit(job.head, "DurableJob head");
-    requireText(job.workspace, "DurableJob workspace");
-    if (!job.workspace.startsWith("/")) {
-        throw new Error("DurableJob workspace must be an absolute path.");
-    }
-    validateEnvMap(job.env);
-    if (!Array.isArray(job.steps) || job.steps.length === 0) {
-        throw new Error("DurableJob requires at least one step.");
-    }
-    const stepNames = new Set();
-    for (const step of job.steps) {
-        const name = requireText(step.name, "DurableJob step name");
-        if (stepNames.has(name)) {
-            throw new Error(`DurableJob step names must be unique: ${name}.`);
-        }
-        stepNames.add(name);
-        requireText(step.command, `DurableJob step command (${name})`);
-        if (step.argv !== undefined) {
-            if (!Array.isArray(step.argv) || step.argv.length === 0) {
-                throw new Error(`DurableJob step argv must be a non-empty array (${name}).`);
-            }
-            for (const value of step.argv) {
-                requireText(value, `DurableJob step argv (${name})`);
-            }
-        }
-        if (step.cwd !== undefined) {
-            requireText(step.cwd, `DurableJob step cwd (${name})`);
-            if (!step.cwd.startsWith("/")) {
-                throw new Error(`DurableJob step cwd must be absolute (${name}).`);
-            }
-        }
-        if (step.env !== undefined) {
-            validateEnvMap(step.env);
-        }
-        if (step.timeoutMs !== undefined) {
-            requirePositiveInteger(step.timeoutMs, `DurableJob step timeout (${name})`);
-        }
-    }
+    requireIdentity(job.definitionId, "Job definition id");
+    requirePositiveInteger(job.definitionRevision, "Job definition revision");
+    requireText(job.trigger?.key, "Job trigger key");
+    if (!["manual", "retry", "schedule", "integration", "migration"].includes(job.trigger.source)) {
+        throw new Error("Invalid JobRun trigger source.");
+    }
+    if ("taskId" in job) {
+        validateTaskRecordReference({ taskId: job.taskId, localId: job.id }, "durableJob");
+        validateDurableJobOwner(job.owner, job.taskId);
+        requireIdentity(job.projectId, "DurableJob project id");
+    }
+    else {
+        if (job.scope !== "global")
+            throw new Error("Invalid global JobRun scope.");
+        requireIdentity(job.id, "JobRun id");
+        requireText(job.action, "JobRun builtin action");
+        if (job.projectId !== undefined)
+            requireIdentity(job.projectId, "JobRun Project id");
+    }
+    validateJobExecutionConfiguration(job);
     requireText(job.idempotencyKey, "DurableJob idempotency key");
     if (!/^[a-f0-9]{64}$/u.test(job.idempotencyKey)) {
         throw new Error("DurableJob idempotency key is invalid.");
@@ -321,7 +303,10 @@ export function validateDurableJob(job) {
         normalizeDurableJobResult(job.result);
     }
     if (job.retryOf !== undefined) {
-        validateTaskRecordReference({ taskId: job.taskId, localId: job.retryOf }, "durableJob");
+        if ("taskId" in job)
+            validateTaskRecordReference({ taskId: job.taskId, localId: job.retryOf }, "durableJob");
+        else
+            requireIdentity(job.retryOf, "JobRun retryOf");
     }
     if (job.cancelRequestedAt !== undefined) {
         requireTimestamp(job.cancelRequestedAt, "DurableJob cancelRequestedAt");
@@ -345,14 +330,18 @@ export function validateDurableJob(job) {
 }
 export function validDurableJobTransition(before, after) {
     if (before.id !== after.id
-        || before.taskId !== after.taskId
+        || before.definitionId !== after.definitionId
+        || before.definitionRevision !== after.definitionRevision
+        || !isDeepStrictEqual(before.trigger, after.trigger)
+        || before.retryOf !== after.retryOf
+        || executionNamespace(before) !== executionNamespace(after)
         || before.projectId !== after.projectId
         || before.head !== after.head
         || before.workspace !== after.workspace
         || before.idempotencyKey !== after.idempotencyKey
         || before.artifactsLocator !== after.artifactsLocator
         || before.createdAt !== after.createdAt
-        || !isDeepStrictEqual(before.owner, after.owner)
+        || !isDeepStrictEqual("owner" in before ? before.owner : [before.action, before.actionInput], "owner" in after ? after.owner : [after.action, after.actionInput])
         || !isDeepStrictEqual(before.env, after.env)
         || !isDeepStrictEqual(before.steps, after.steps)
         || before.operation.requestId !== after.operation.requestId
@@ -374,7 +363,10 @@ export function validDurableJobTransition(before, after) {
         const wakeupFlip = before.wakeupNotified !== true && after.wakeupNotified === true;
         const acknowledgeFlip = before.acknowledgedAt === undefined
             && after.acknowledgedAt !== undefined;
-        return before.status === after.status
+        const { wakeupNotified: _beforeWake, acknowledgedAt: _beforeAck, updatedAt: _beforeTime, ...beforeFacts } = before;
+        const { wakeupNotified: _afterWake, acknowledgedAt: _afterAck, updatedAt: _afterTime, ...afterFacts } = after;
+        return isDeepStrictEqual(beforeFacts, afterFacts)
+            && before.status === after.status
             && isDeepStrictEqual(before.result, after.result)
             && isDeepStrictEqual(before.operation, after.operation)
             && before.terminalAt === after.terminalAt
@@ -398,7 +390,7 @@ export function validDurableJobTransition(before, after) {
     };
     return (allowed[before.status] ?? []).includes(after.status);
 }
-function validateDurableJobOwner(owner, taskId) {
+export function validateDurableJobOwner(owner, taskId) {
     if (owner.kind === "integration-attempt") {
         validateTaskRecordReference({ taskId, localId: owner.integrationAttemptId }, "integrationAttempt");
     }
@@ -409,6 +401,37 @@ function validateDurableJobOwner(owner, taskId) {
         throw new Error(`DurableJob owner kind is invalid: ${String(owner.kind)}.`);
     }
 }
+export function validateJobExecutionConfiguration(job) {
+    requireCommit(job.head, "DurableJob head");
+    requireText(job.workspace, "DurableJob workspace");
+    if (!job.workspace.startsWith("/"))
+        throw new Error("DurableJob workspace must be an absolute path.");
+    validateEnvMap(job.env);
+    if (!Array.isArray(job.steps) || job.steps.length === 0) {
+        throw new Error("DurableJob requires at least one step.");
+    }
+    const names = new Set();
+    for (const step of job.steps) {
+        const name = requireText(step.name, "DurableJob step name");
+        if (names.has(name))
+            throw new Error(`DurableJob step names must be unique: ${name}.`);
+        names.add(name);
+        requireText(step.command, `DurableJob step command (${name})`);
+        if (step.argv !== undefined) {
+            if (!Array.isArray(step.argv) || step.argv.length === 0)
+                throw new Error("Step argv must be nonempty.");
+            for (const value of step.argv)
+                requireText(value, `DurableJob step argv (${name})`);
+        }
+        if (step.cwd !== undefined && !requireText(step.cwd, "Step cwd").startsWith("/")) {
+            throw new Error("DurableJob step cwd must be absolute.");
+        }
+        if (step.env !== undefined)
+            validateEnvMap(step.env);
+        if (step.timeoutMs !== undefined)
+            requirePositiveInteger(step.timeoutMs, "Step timeout");
+    }
+}
 function validateEnvMap(env) {
     if (typeof env !== "object" || env === null || Array.isArray(env)) {
         throw new Error("DurableJob env must be a map.");

package/dist/job/jobDefinition.js

@@ -0,0 +1,68 @@
+import { requireIdentity, requireKnownFields, requirePositiveInteger, requireText, requireTimestamp } from "../domain/validation.js";
+import { validateJobExecutionConfiguration, validateDurableJobOwner } from "./durableJob.js";
+export function jobScopeKey(scope) {
+    if (scope.kind === "global")
+        return "global";
+    requireIdentity(scope.taskId, "Job Task id");
+    if (!/^task-\d+$/u.test(scope.taskId))
+        throw new Error("Invalid Job Task id.");
+    return scope.taskId;
+}
+export function validateJobDefinition(job) {
+    requireKnownFields(job, ["schemaVersion", "id", "scope", "title", "revision", "configuration", "createdAt", "updatedAt"], "Job");
+    if (job.schemaVersion !== 1)
+        throw new Error("Job schemaVersion must be 1.");
+    requireIdentity(job.id, "Job id");
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/u.test(job.id))
+        throw new Error("Invalid Job definition id.");
+    requireText(job.title, "Job title");
+    requirePositiveInteger(job.revision, "Job revision");
+    requireTimestamp(job.createdAt, "Job createdAt");
+    requireTimestamp(job.updatedAt, "Job updatedAt");
+    if (job.scope.kind !== "task" && job.scope.kind !== "global")
+        throw new Error("Invalid Job scope.");
+    requireKnownFields(job.scope, job.scope.kind === "task" ? ["kind", "taskId"] : ["kind"], "Job scope");
+    jobScopeKey(job.scope);
+    const config = job.configuration;
+    if (job.scope.kind === "global") {
+        if (config.kind !== "builtin")
+            throw new Error("Global Jobs require a controlled builtin action.");
+        requireKnownFields(config, ["kind", "action", "projectId", "input"], "Builtin Job");
+        requireText(config.action, "Builtin action");
+        if (config.projectId !== undefined)
+            requireIdentity(config.projectId, "Job Project id");
+        if (config.input === undefined)
+            throw new Error("Builtin Job input is required.");
+    }
+    else {
+        if (config.kind !== "shell")
+            throw new Error("Task Jobs require a managed shell configuration.");
+        requireKnownFields(config, ["kind", "owner", "projectId", "head", "workspace", "env", "steps"], "Task Job");
+        requireIdentity(config.projectId, "Job Project id");
+        validateDurableJobOwner(config.owner, job.scope.taskId);
+        validateJobExecutionConfiguration(config);
+    }
+    return job;
+}
+export function createJobDefinition(input, now) {
+    return validateJobDefinition({
+        schemaVersion: 1, ...structuredClone(input), revision: 1,
+        createdAt: now.toISOString(), updatedAt: now.toISOString()
+    });
+}
+export function reviseJobDefinition(job, input, now) {
+    return validateJobDefinition({
+        ...job, title: input.title, configuration: structuredClone(input.configuration),
+        revision: job.revision + 1, updatedAt: now.toISOString()
+    });
+}
+/** Old execution IDs are preserved one-to-one; command equality never merges history. */
+export function definitionFromTaskRun(run) {
+    return createJobDefinition({
+        id: run.definitionId, scope: { kind: "task", taskId: run.taskId }, title: run.steps[0].name,
+        configuration: {
+            kind: "shell", owner: run.owner, projectId: run.projectId, head: run.head,
+            workspace: run.workspace, env: run.env, steps: run.steps
+        }
+    }, new Date(run.createdAt));
+}

package/dist/job/jobRunner.js

@@ -267,7 +267,8 @@ function readSpec(specPath) {
     if (typeof spec.jobId !== "string" || spec.jobId.length === 0) {
         throw new Error("DurableJob spec is missing jobId.");
     }
-    if (typeof spec.taskId !== "string" || spec.taskId.length === 0) {
+    if (spec.scope === "global" ? spec.taskId !== undefined
+        : typeof spec.taskId !== "string" || spec.taskId.length === 0) {
         throw new Error("DurableJob spec is missing taskId.");
     }
     if (typeof spec.workspace !== "string" || !spec.workspace.startsWith("/")) {

package/dist/job/projectRefreshRunner.js

@@ -0,0 +1,48 @@
+/**
+ * Controlled Project domain action invoked by the artifact-only Job runner.
+ * Its catalog connection is read-only; only the shared domain service writes Git.
+ */
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { SqliteTaskStore } from "../storage/sqliteStore.js";
+import { authorizeGlobalJobStart } from "../controller/jobDefinitionControl.js";
+import { refreshRegisteredProject } from "../repository/projectRefresh.js";
+import { projectRefreshDigest } from "./builtinJob.js";
+import { CliError } from "../errors/cliError.js";
+export async function runProjectRefresh(home, runId) {
+    const store = new SqliteTaskStore(home, { readonly: true });
+    try {
+        const run = store.getGlobalJobRun(runId);
+        if (!run || run.action !== "project.refresh" || !["queued", "running"].includes(run.status)
+            || run.operation.effect !== "possible" || run.cancelRequestedAt) {
+            throw new Error("No active admitted project.refresh Run.");
+        }
+        authorizeGlobalJobStart(store, run);
+        const result = await refreshRegisteredProject(store, run.projectId, {
+            automatic: true,
+            expectedDigest: projectRefreshDigest({
+                kind: "builtin", action: run.action, projectId: run.projectId, input: run.actionInput
+            }),
+            beforeRefresh: () => {
+                const current = store.getGlobalJobRun(runId);
+                if (!current || !["queued", "running"].includes(current.status) || current.cancelRequestedAt) {
+                    throw new Error("Project refresh Run stopped while waiting for maintenance.");
+                }
+                authorizeGlobalJobStart(store, current);
+            }
+        });
+        process.stdout.write(JSON.stringify({ action: run.action, projectId: run.projectId,
+            trigger: run.trigger, outcome: "succeeded", observedAt: new Date().toISOString(),
+            remoteCheck: { status: "verified", commit: result.toCommit }, refresh: result }) + "\n");
+    }
+    finally {
+        store.close();
+    }
+}
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    runProjectRefresh(process.argv[2], process.argv[3]).catch(error => {
+        process.stderr.write(JSON.stringify({ outcome: "failed", reason: error instanceof Error ? error.message : String(error),
+            ...(error instanceof CliError ? { details: error.details } : {}) }) + "\n");
+        process.exitCode = 1;
+    });
+}

package/dist/message/globalInboxRecovery.js

@@ -0,0 +1,44 @@
+import { createHash } from "node:crypto";
+import { createGlobalRoleMessage } from "./message.js";
+import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { currentProviderConversation } from "../runtime/providerRuntimeIdentity.js";
+import { INBOX_CHECK_PREFIX } from "./inboxTurn.js";
+const requestId = (agentId, nativeSessionId) => `${INBOX_CHECK_PREFIX}recovery:${createHash("sha256").update(JSON.stringify([agentId, nativeSessionId])).digest("hex")}`;
+/** Derive a single initialization notice from existing retained claims. New
+ * Sessions are created only by the existing authorized lifecycle path. A
+ * restart can finish notice creation, but cannot select or replace a Session. */
+export function globalInboxRecovery(store, roleName, now) {
+    return store.transaction(tx => {
+        const sessions = tx.getGlobalRoleSessionSet(roleName);
+        const session = sessions?.sessions[sessions.activeAgentId];
+        const binding = sessions?.providerBinding;
+        if (!session || session.status !== "active" || !session.nativeSessionId || !binding
+            || binding.authority.owner !== "controller"
+            || currentProviderConversation(binding).conversationId !== session.nativeSessionId
+            || binding.run && ["submitting", "accepted", "delivery-unknown"].includes(binding.run.status)
+            || hasRuntimeCleanupObligation(tx.getWorkMailbox(runtimeLifecycleTarget({ scope: "global", roleName }))))
+            return;
+        if (tx.queryGlobalRoleMessages(roleName, { handling: true, handlingExceptSession: {
+                agentId: session.agentId, nativeSessionId: session.nativeSessionId
+            }, limit: 0 }).count === 0)
+            return;
+        const id = requestId(session.agentId, session.nativeSessionId);
+        const existing = tx.queryGlobalRoleMessages(roleName, { requestId: id, limit: 1 }).messages[0];
+        if (existing)
+            return existing;
+        const notice = {
+            ...createGlobalRoleMessage(tx.nextGlobalRoleMessageId(), roleName, [
+                "Yui-Summary: This successor has retained inbox handling obligations; inspect original evidence before settlement.",
+                "Read current Session Context and yui inbox list --view history --json. Read the exact original, original claim and prior effects.",
+                "This is initialization only: do not replay old input, retarget its delivery, or infer business completion.",
+                "After handling under current authority, explicitly acknowledge the original entry without replacing its claim.",
+                "Uncertain external effects require verification or a real user decision. New queued input remains separate."
+            ].join("\n"), "system", { type: "system" }, now, {
+                inputControl: { action: "queue", requestId: id, expectedSessionId: session.nativeSessionId }
+            }),
+            deliveryTarget: { agentId: session.agentId, nativeSessionId: session.nativeSessionId }
+        };
+        tx.saveGlobalRoleMessage(notice);
+        return notice;
+    });
+}

package/dist/message/globalInterrupt.js

@@ -11,7 +11,7 @@ export function recordGlobalSteerResult(store, roleName, messageId, receipt) {
         const now = new Date();
         const outcome = receipt.state === "steered" ? "accepted"
             : receipt.state === "steer-unknown" ? "delivery-unknown" : "rejected";
-        const updated = { ...message, control: {
+        const updated = { ...message, control: { ...message.control,
                 requestId: source.requestId, receiptId: `steer:${roleName}/${messageId}`,
                 outcome, observedAt: now.toISOString()
             } };

package/dist/message/inboxReceipt.js

@@ -3,7 +3,8 @@ 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";
+    return receipt?.retirement !== undefined ? "retired" : receipt?.ack !== undefined ? "handled"
+        : receipt !== undefined ? "claimed-unacknowledged" : "unclaimed";
 }
 export function isGlobalInboxMessage(message) {
     return message.inputControl !== undefined || message.interruptThen !== undefined;
@@ -11,7 +12,8 @@ export function isGlobalInboxMessage(message) {
 /** 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");
+    return messages.filter(message => isGlobalInboxMessage(message)
+        && !["handled", "retired"].includes(inboxHandlingState(message.inbox)));
 }
 /** Original message evidence only. A missing receipt is not proof of
  * non-submission; admission additionally inspects the exact native attempt. */
@@ -22,20 +24,22 @@ export function globalInboxDeliveryState(message) {
 export function validateInboxReceipt(receipt) {
     if (receipt === undefined)
         return;
-    requireKnownFields(receipt, ["claim", "ack"], "Inbox receipt");
+    requireKnownFields(receipt, ["claim", "ack", "retirement"], "Inbox receipt");
+    if (receipt.ack && receipt.retirement)
+        throw new Error("Inbox disposition cannot be both acknowledgement and retirement.");
     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");
+        requireKnownFields(actor, ["scope", "taskId", "roleName", "agentId", "nativeSessionId", "runId", "attemptId"], "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")
+        if (kind !== "claim")
             requireText(entry.reason, "Inbox disposition");
     }
     if (!receipt.claim)
@@ -45,7 +49,8 @@ export function validateInboxReceipt(receipt) {
  * 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))) {
+        || previous.ack !== undefined && !isDeepStrictEqual(previous.ack, next?.ack)
+        || previous.retirement !== undefined && !isDeepStrictEqual(previous.retirement, next?.retirement))) {
         throw new Error("Inbox handling ownership changed; reread the original instead of overwriting its receipt.");
     }
 }
@@ -55,6 +60,9 @@ export function assertInboxReceiptPreserved(previous, next) {
  */
 export function assertInboxOriginalPreserved(previous, next) {
     assertInboxReceiptPreserved(previous?.inbox, next.inbox);
+    if (previous?.control?.target !== undefined && !isDeepStrictEqual(previous.control.target, next.control?.target)) {
+        throw new Error("The exact admitted control target cannot be replaced or erased.");
+    }
     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/inboxTurn.js

@@ -0,0 +1,86 @@
+import { globalInboxDeliveryState } from "./inboxReceipt.js";
+export const INBOX_CHECK_PREFIX = "inbox-check:";
+export const INBOX_CHECK_REASON = "inbox-handling-missing";
+export const isInboxWake = (entry) => "fromCursor" in entry;
+export const isHandlingReminder = (entry) => isInboxWake(entry)
+    ? entry.reasons.every(reason => reason === INBOX_CHECK_REASON)
+    : entry.kind === "system" && entry.inputControl?.requestId.startsWith(INBOX_CHECK_PREFIX) === true;
+/** Correlation uses existing input identities, not timestamps, output text or
+ * Task state. Active consumption adds only the exact attempt to its claim. */
+export function belongsToInboxTurn(entry, actor, turn) {
+    if (!turn)
+        return false;
+    const claim = entry.inbox?.claim.actor;
+    if (claim?.attemptId === turn.attemptId && claim.scope === actor.scope && claim.taskId === actor.taskId
+        && claim.roleName === actor.roleName && claim.agentId === actor.agentId
+        && claim.nativeSessionId === actor.nativeSessionId)
+        return true;
+    if (isInboxWake(entry))
+        return actor.scope === "task" && actor.roleName === "leader"
+            && entry.taskId === actor.taskId && (turn.input?.kind === "wake" && turn.input.wakeId === entry.id
+            && turn.input.taskId === entry.taskId
+            || turn.attemptId.startsWith(`notification:${entry.taskId}/${entry.id}/`));
+    if ("roleName" in entry) {
+        if (actor.scope !== "global" || entry.roleName !== actor.roleName)
+            return false;
+        if (entry.deliveryTarget && (entry.deliveryTarget.agentId !== actor.agentId
+            || entry.deliveryTarget.nativeSessionId !== actor.nativeSessionId))
+            return false;
+        if (turn.input?.kind === "message" && turn.input.roleName === actor.roleName
+            && turn.input.messageId === entry.id || turn.attemptId === `global-input:${actor.roleName}/${entry.id}`)
+            return true;
+    }
+    else {
+        if (actor.scope !== "task" || entry.taskId !== actor.taskId)
+            return false;
+        if (turn.runId !== undefined && entry.recipient?.roleName === actor.roleName
+            && entry.continuation?.runId === turn.runId)
+            return true;
+    }
+    const target = entry.control?.target;
+    return entry.control?.outcome === "accepted" && target?.agentId === actor.agentId
+        && target.nativeSessionId === actor.nativeSessionId && target.attemptId === turn.attemptId;
+}
+/** Historical absence of ACK is not fresh work. Current unsubmitted input
+ * remains discoverable, but never steals an unsettled transport owner. */
+export function inboxEntryCategory(entry, actor, turn) {
+    if (belongsToInboxTurn(entry, actor, turn))
+        return "current";
+    if (entry.inbox !== undefined)
+        return "history";
+    if (isInboxWake(entry))
+        return "history";
+    if ("roleName" in entry) {
+        if (entry.delivery !== undefined || entry.notDelivered !== undefined
+            || entry.deliveryTarget && (entry.deliveryTarget.agentId !== actor.agentId
+                || entry.deliveryTarget.nativeSessionId !== actor.nativeSessionId))
+            return "history";
+    }
+    else if (entry.continuation?.runId !== undefined)
+        return "history";
+    if (entry.inputControl?.expectedSessionId !== undefined
+        && entry.inputControl.expectedSessionId !== actor.nativeSessionId)
+        return "history";
+    if (entry.control?.outcome === "accepted")
+        return "history";
+    return "available";
+}
+export function inboxSettled(receipt) {
+    return receipt?.ack !== undefined || receipt?.retirement !== undefined;
+}
+export function missingTurnHandling(entries, actor, turn) {
+    return entries.filter(entry => !inboxSettled(entry.inbox) && !isHandlingReminder(entry)
+        && belongsToInboxTurn(entry, actor, turn));
+}
+/** Accepted historical input and explicit nondelivery do not impose an input
+ * order on independent new messages. Unknown delivery still does. */
+export function blocksInboxOrder(entry, actor, turn) {
+    if (isInboxWake(entry) || inboxSettled(entry.inbox))
+        return false;
+    if ("roleName" in entry && (globalInboxDeliveryState(entry) === "accepted" || entry.notDelivered !== undefined))
+        return false;
+    if (entry.control?.outcome === "accepted")
+        return false;
+    return inboxEntryCategory(entry, actor, turn) !== "history"
+        || entry.control !== undefined && ["pending", "delivery-unknown"].includes(entry.control.outcome);
+}

package/dist/message/message.js

@@ -147,6 +147,7 @@ export function recordTaskMessageControlOutcome(message, record) {
             requestId: requireSafeIdentity(record.requestId, "Message control requestId"),
             receiptId: requireText(record.receiptId, "Message control receiptId"),
             outcome: record.outcome,
+            ...(existing?.target ?? record.target ? { target: existing?.target ?? record.target } : {}),
             observedAt: record.observedAt.toISOString()
         }
     };
@@ -282,6 +283,7 @@ export function validateTaskMessage(message) {
         }
     }
     if (message.control !== undefined) {
+        validateControlTarget(message.control);
         requireSafeIdentity(message.control.requestId, "Message control requestId");
         requireText(message.control.receiptId, "Message control receiptId");
         if (!TASK_MESSAGE_INPUT_CONTROL_OUTCOMES.includes(message.control.outcome)) {
@@ -408,6 +410,7 @@ export function validateGlobalRoleMessage(message) {
         requireText(message.deliveryTarget.nativeSessionId, "Global input Session");
     }
     if (message.control !== undefined) {
+        validateControlTarget(message.control);
         requireSafeIdentity(message.control.requestId, "Global input requestId");
         requireText(message.control.receiptId, "Global input receiptId");
         if (!TASK_MESSAGE_INPUT_CONTROL_OUTCOMES.includes(message.control.outcome)
@@ -479,6 +482,14 @@ export function validateGlobalRoleMessage(message) {
         throw new Error("Message createdAt is invalid.");
     }
 }
+function validateControlTarget(control) {
+    if (control.target === undefined)
+        return;
+    requireKnownFields(control.target, ["agentId", "nativeSessionId", "attemptId"], "Control target");
+    requireText(control.target.agentId, "Control target Agent");
+    requireText(control.target.nativeSessionId, "Control target Session");
+    requireText(control.target.attemptId, "Control target attempt");
+}
 /** A Global message local id is `global-message-<n>`; it carries no Task id. */
 export function validateGlobalRoleMessageId(localId) {
     const normalized = requireSafeIdentity(localId, "Global message id");

package/dist/message/taskInboxOwnership.js

@@ -26,10 +26,15 @@ export function isLeaderSteer(message) {
 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");
+/** Acceptance or explicit no-replay release suppresses repeat notification,
+ * never handling. The original fixed window stays in the own inbox. */
+export function nonReplayableMessageWake(store, message) {
+    return messageRevisionWakes(store, message).find(wake => wake.status === "consumed" || releasedNotificationWake(store, message.taskId, wake.id));
+}
+/** Operational release is not acceptance. Keep its originals out of automatic
+ * delivery while permitting explicit inspection and settlement in the inbox. */
+export function releasedNotificationWake(store, taskId, wakeId) {
+    return store.listEventsByType(taskId, ["notification.resolved"]).some(event => event.payload.wakeId === wakeId && event.payload.outcome === "released-without-replay");
 }
 function messageRevisionWakes(store, message) {
     const revision = latestMessageUpdate(store, message);
@@ -37,7 +42,16 @@ function messageRevisionWakes(store, message) {
         && 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)
+    const sessions = store.getTaskRoleSessionSet(taskId, "leader");
+    const binding = sessions?.providerBinding;
+    const turn = binding?.run;
+    const nativeSessionId = binding?.conversations.find(c => c.epoch === binding.currentConversationEpoch)?.conversationId;
+    const active = (receipt) => receipt !== undefined && receipt.ack === undefined
+        && (receipt.claim.actor.attemptId === undefined || turn?.attemptId === receipt.claim.actor.attemptId
+            && receipt.claim.actor.agentId === sessions?.activeAgentId
+            && receipt.claim.actor.nativeSessionId === nativeSessionId
+            && ["submitting", "accepted", "delivery-unknown"].includes(turn.status));
+    return store.listTaskWakes(taskId).some(wake => active(wake.inbox))
         || operationalTaskRecords(store.listMessages(taskId), store.listEvents(taskId), "message").some(message => isLeaderSteer(message)
-            && message.inbox !== undefined && message.inbox.ack === undefined);
+            && active(message.inbox));
 }