@zq-silk/yui 2.8.1 → 2.10.0

package/dist/commands/inboxCommands.js

@@ -5,9 +5,10 @@ import { createTaskWake, latestTaskWake } from "../scheduler/taskWake.js";
 import { expandTaskMessageResult } from "../message/message.js";
 import { messageAssignmentBlocker } from "../message/messageContinuation.js";
 import { globalInboxDeliveryState, inboxHandlingState, isGlobalInboxMessage, pendingGlobalInboxMessages } from "../message/inboxReceipt.js";
-import { deliveredMessageWake, isLeaderSteer, pinMessageRevisions, taskMessageInboxReceipt, unfinishedLeaderInbox } from "../message/taskInboxOwnership.js";
+import { nonReplayableMessageWake, isLeaderSteer, pinMessageRevisions, releasedNotificationWake, taskMessageInboxReceipt, unfinishedLeaderInbox } from "../message/taskInboxOwnership.js";
 import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { isTaskRecordRetired, retiredTaskRecordIds } from "../task/taskRecordRetirement.js";
+import { blocksInboxOrder, inboxEntryCategory, inboxSettled } from "../message/inboxTurn.js";
 const target = (address) => ({ kind: "role", taskId: address.taskId, roleName: address.roleName });
 const source = (address) => `inbox:${address.scope}:${address.taskId ?? ""}:${address.roleName}`;
 const pendingId = (pending) => `pending-${readDigest(pending)}`;
@@ -15,15 +16,27 @@ const sameSession = (a, b) => a.scope === b.scope && a.taskId === b.taskId
     && a.roleName === b.roleName && a.agentId === b.agentId && a.nativeSessionId === b.nativeSessionId;
 function addressOf(store, env) {
     const caller = requireManagedCaller(store, env);
+    const binding = caller.scope === "global" ? store.getGlobalRoleSessionSet(caller.roleName)?.providerBinding
+        : store.getTaskRoleSessionSet(caller.taskId, caller.roleName)?.providerBinding;
+    const turn = binding?.conversations.find(c => c.epoch === binding.currentConversationEpoch)?.conversationId === caller.nativeSessionId
+        ? binding?.run : undefined;
+    const attempt = turn && ["submitting", "accepted", "delivery-unknown"].includes(turn.status)
+        ? { attemptId: turn.attemptId } : {};
     if (caller.scope === "global") {
-        return { scope: "global", roleName: caller.roleName, agentId: caller.agentId, nativeSessionId: caller.nativeSessionId };
+        return { scope: "global", roleName: caller.roleName, agentId: caller.agentId, nativeSessionId: caller.nativeSessionId, ...attempt };
     }
     if (caller.roleName !== "leader" && caller.currentRunId === undefined) {
         throw new Error("An Assignment inbox requires its current active AgentRun.");
     }
     return { scope: "task", taskId: caller.taskId, roleName: caller.roleName,
         agentId: caller.agentId, nativeSessionId: caller.nativeSessionId,
-        ...(caller.currentRunId === undefined ? {} : { runId: caller.currentRunId }) };
+        ...(caller.currentRunId === undefined ? {} : { runId: caller.currentRunId }), ...attempt };
+}
+function currentTurn(store, address) {
+    const binding = address.scope === "global" ? store.getGlobalRoleSessionSet(address.roleName)?.providerBinding
+        : store.getTaskRoleSessionSet(address.taskId, address.roleName)?.providerBinding;
+    return binding?.conversations.find(c => c.epoch === binding.currentConversationEpoch)?.conversationId === address.nativeSessionId
+        ? binding?.run : undefined;
 }
 function ownsMessage(store, address, message) {
     if (address.roleName === "leader" && message.taskId === address.taskId && isLeaderSteer(message))
@@ -80,15 +93,15 @@ function blocker(store, address, entry) {
     if (!isWake(entry) && address.scope === "task"
         && isTaskRecordRetired(store.listEvents(address.taskId), "message", entry.id))
         return "message-retired";
-    if (entry.inbox?.ack !== undefined)
-        return "acknowledged";
+    if (inboxSettled(entry.inbox))
+        return entry.inbox?.retirement ? "retired" : "acknowledged";
     if (entry.inbox !== undefined) {
         return sameSession(entry.inbox.claim.actor, address) ? undefined : "claimed-by-previous-session";
     }
     if (isWake(entry)) {
         // Native acceptance releases transport ownership, not semantic handling.
         // The current Leader may explicitly claim the fixed delivered window.
-        if (entry.status === "consumed")
+        if (entry.status === "consumed" || releasedNotificationWake(store, entry.taskId, entry.id))
             return undefined;
         return "automatic-notification-owns-window";
     }
@@ -150,9 +163,12 @@ function checkMutation(store, address) {
 }
 function summary(store, address, entry) {
     return { id: entry.id, kind: isWake(entry) ? "notification-window" : "message",
+        category: inboxEntryCategory(entry, address, currentTurn(store, address)),
         createdAt: entry.createdAt, summary: summaryText(isWake(entry) ? entry.reasons.join(", ") : entry.body),
         blocked: blocker(store, address, entry) ?? null, inbox: summaryMetadata(entry.inbox ?? null),
         handling: inboxHandlingState(entry.inbox),
+        ...(entry.inbox !== undefined && entry.inbox.ack === undefined && !sameSession(entry.inbox.claim.actor, address)
+            ? { recovery: "Read this original and prior effects under current authority; finish handling, then inbox ack this exact entry. Retain the original claim; do not claim again or replay business." } : {}),
         delivery: isWake(entry) ? entry.status : summaryMetadata({
             control: entry.control ?? null,
             ...(address.scope === "global" ? { receipt: entry.delivery ?? null,
@@ -173,23 +189,33 @@ export function runInboxCommand(args, store, env, now = new Date()) {
     const [action, ...tail] = args;
     const address = addressOf(store, env);
     if (action === "list") {
-        const parsed = readOptions(tail);
-        if (parsed.positionals.length)
-            throw new Error("Inbox list accepts only --limit and --cursor.");
+        const parsed = readOptions(tail, ["--limit", "--cursor", "--view"]);
+        const view = parsed.values.get("--view") ?? "all";
+        if (!["all", "current", "history"].includes(view) || parsed.positionals.length) {
+            throw new Error("Inbox list accepts --view current|history|all, --limit and --cursor.");
+        }
         const retired = address.scope === "task" ? retiredTaskRecordIds(store.listEvents(address.taskId), "message") : new Set();
         const selected = address.scope === "global" ? pendingGlobalInboxMessages(store.listGlobalRoleMessages(address.roleName))
             : entries(store, address).filter(entry => (isWake(entry) || !retired.has(entry.id))
-                && inboxHandlingState(entry.inbox) !== "handled");
-        const items = selected.map(entry => summary(store, address, entry));
+                && !inboxSettled(entry.inbox));
+        const turn = currentTurn(store, address);
+        const categories = selected.map(entry => ({ entry, category: inboxEntryCategory(entry, address, turn) }));
+        const rank = { current: 0, available: 1, history: 2 };
+        categories.sort((a, b) => rank[a.category] - rank[b.category]);
+        const items = categories.filter(item => view === "all"
+            || (view === "history") === (item.category === "history")).map(({ entry }) => summary(store, address, entry));
         if (address.scope === "task" && address.roleName === "leader") {
             const mailbox = store.getWorkMailbox(target(address));
-            if (mailbox?.pending != null)
-                items.push({ id: pendingId(mailbox.pending), kind: "notification-window",
+            if (mailbox?.pending != null && view !== "history")
+                items.splice(categories.filter(item => item.category === "current").length, 0, { id: pendingId(mailbox.pending), kind: "notification-window",
+                    category: "available",
                     summary: summaryText(mailbox.pending.reasons.join(", ")),
                     blocked: mailbox.processing === null && !unfinishedLeaderInbox(store, address.taskId) ? null : "earlier-window-owned",
                     read: `yui inbox show ${pendingId(mailbox.pending)}` });
         }
-        return recordPage(items, source(address), parsed, { identity: address });
+        return recordPage(items, `${source(address)}/${view}`, parsed, { identity: address, view,
+            historyCount: categories.filter(item => item.category === "history").length,
+            note: "History lacks handling evidence; it is not unexecuted work. Inspect original effects before disposition." });
     }
     if (action === "show") {
         const parsed = readOptions(tail, ["--cursor"]);
@@ -208,8 +234,8 @@ export function runInboxCommand(args, store, env, now = new Date()) {
             ? expandTaskMessageResult(entry, (task, run) => store.getRun(task, run)) : entry;
         return boundedDocument(value, `${source(address)}/${id}`, parsed.cursor);
     }
-    if (action !== "claim" && action !== "ack")
-        throw new Error("Inbox commands: list, show, claim, ack.");
+    if (action !== "claim" && action !== "ack" && action !== "retire")
+        throw new Error("Inbox commands: list, show, claim, ack, retire.");
     const parsed = readOptions(tail, ["--request-id", "--reason"]);
     const ids = parsed.positionals;
     const requestId = parsed.values.get("--request-id");
@@ -220,7 +246,7 @@ export function runInboxCommand(args, store, env, now = new Date()) {
     if (!ids.length || ids.length > 16 || new Set(ids).size !== ids.length) {
         throw new Error("Select 1..16 distinct exact inbox entries; no wildcard acknowledgement.");
     }
-    if (action === "ack" && (!reason?.trim() || Buffer.byteLength(reason) > 2048)) {
+    if (action !== "claim" && (!reason?.trim() || Buffer.byteLength(reason) > 2048)) {
         throw new Error("Acknowledgement requires --reason describing handling or why no action remains (up to 2048 bytes).");
     }
     if (action === "claim" && reason !== undefined)
@@ -251,7 +277,7 @@ export function runInboxCommand(args, store, env, now = new Date()) {
                     continue;
                 const message = tx.listMessages(current.taskId).find(message => message.id === ref.id);
                 if (message !== undefined && (taskMessageInboxReceipt(tx, message) !== undefined
-                    || deliveredMessageWake(tx, message) !== undefined)
+                    || nonReplayableMessageWake(tx, message) !== undefined)
                     || message?.interruptThen !== undefined
                     || message?.control !== undefined && message.control.outcome !== "rejected"
                     || message?.inputControl?.expectedSessionId !== undefined
@@ -274,7 +300,36 @@ export function runInboxCommand(args, store, env, now = new Date()) {
         }
         else {
             entry = getEntry(tx, current, id);
-            if (action === "claim") {
+            if (action === "retire") {
+                if (current.scope !== "global" || isWake(entry)) {
+                    throw new Error("Task input retirement uses the Leader's existing task message retire operation.");
+                }
+                const message = entry;
+                if (message.inbox?.retirement) {
+                    const saved = message.inbox.retirement;
+                    if (saved.requestId !== requestId || saved.reason !== reason || !sameSession(saved.actor, current)) {
+                        throw new Error("Conflicting retirement; original disposition retained.");
+                    }
+                    return receipt(entry);
+                }
+                // A retained attempt in an older conversation is still evidence of
+                // submission; changing the active Session cannot erase that boundary.
+                const turn = tx.getGlobalRoleSessionSet(current.roleName)?.providerBinding?.run;
+                const foreignTarget = message.deliveryTarget && (message.deliveryTarget.agentId !== current.agentId
+                    || message.deliveryTarget.nativeSessionId !== current.nativeSessionId)
+                    || message.inputControl?.expectedSessionId !== undefined
+                        && message.inputControl.expectedSessionId !== current.nativeSessionId;
+                if (message.inbox?.ack || message.delivery !== undefined || message.interruptThen !== undefined
+                    || message.control !== undefined && message.control.outcome !== "rejected"
+                    || turn?.attemptId === `global-input:${current.roleName}/${message.id}`
+                    || !foreignTarget && message.notDelivered === undefined) {
+                    throw new Error("Retirement requires obsolete, proven-unsubmitted input; unknown/accepted/interrupt-owned input must retain its exact handling path.");
+                }
+                entry = { ...message, inbox: { ...message.inbox,
+                        claim: message.inbox?.claim ?? { requestId, actor: current, at: now.toISOString() },
+                        retirement: { requestId, actor: current, at: now.toISOString(), reason: reason } } };
+            }
+            else if (action === "claim") {
                 if (entry.inbox !== undefined) {
                     if (!sameSession(entry.inbox.claim.actor, current))
                         throw new Error("Claim belongs to a previous Session; read the original and prior effects, then explicitly acknowledge only after finishing its handling.");
@@ -285,7 +340,7 @@ export function runInboxCommand(args, store, env, now = new Date()) {
                 const blocked = blocker(tx, current, entry);
                 if (blocked !== undefined)
                     throw new Error(`Inbox entry cannot be claimed: ${blocked}.`);
-                if (isWake(entry) && !acceptedInput(entry)) {
+                if (isWake(entry) && !acceptedInput(entry) && !releasedNotificationWake(tx, entry.taskId, entry.id)) {
                     for (const ref of entry.refs ?? []) {
                         if (ref.type !== "message")
                             continue;
@@ -299,7 +354,7 @@ export function runInboxCommand(args, store, env, now = new Date()) {
                 for (const previous of entries(tx, current)) {
                     if (previous.id === entry.id)
                         break;
-                    if (isWake(previous) || previous.inbox?.ack !== undefined)
+                    if (!blocksInboxOrder(previous, current, currentTurn(tx, current)))
                         continue;
                     if (current.scope === "task"
                         && isTaskRecordRetired(tx.listEvents(current.taskId), "message", previous.id))
@@ -315,11 +370,13 @@ export function runInboxCommand(args, store, env, now = new Date()) {
             else {
                 if (!entry.inbox)
                     throw new Error("Claim the exact entry before handling and acknowledgement.");
+                if (entry.inbox.retirement)
+                    throw new Error("Retirement is not acknowledgement; original disposition retained.");
                 // Ack settles already-owned handling; it never submits or retargets
                 // the original. The current rightful successor may settle a claim
                 // acquired by the exact selected Session, retaining both identities.
                 const claimant = entry.inbox.claim.actor;
-                if (isWake(entry) && !acceptedInput(entry)) {
+                if (isWake(entry) && !acceptedInput(entry) && !releasedNotificationWake(tx, entry.taskId, entry.id)) {
                     const messageIds = new Set(entry.refs?.filter(ref => ref.type === "message").map(ref => ref.id));
                     for (const message of tx.listMessages(current.taskId)) {
                         if (messageIds.has(message.id))

package/dist/commands/projectCommands.js

@@ -1,12 +1,13 @@
 import { existsSync } from "node:fs";
 import { readdir, rename, rm } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { CliError, usageError } from "../errors/cliError.js";
+import { usageError } from "../errors/cliError.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
 import { boundedDocument, readOptions, recordPage } from "../output/boundedRead.js";
 import { healCheckoutSwap, restoreCheckoutSwap, swapManagedCheckout } from "../repository/checkoutSwap.js";
-import { GitWorkspaceRefreshError, NodeGitWorkspace } from "../repository/gitWorkspace.js";
+import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
 import { acquireProjectMaintenanceLock } from "../repository/projectMaintenanceLock.js";
+import { refreshRegisteredProject } from "../repository/projectRefresh.js";
 import { addProjectKnowledge, addKnowledgeProposal, assertProjectActive, decideKnowledgeProposal, createProject, findKnowledgeProposal, findKnowledgeProposalByFingerprint, knowledgeEvidenceDigest, knowledgeProposalFingerprint, managedProjectPath, planKnowledgeAcceptance, retireProject, retireProjectKnowledge, resolveProject, updateProjectKnowledge, updateProjectMetadata, validateProject, validateProjectName } from "../repository/project.js";
 import { managedWorkspacesRoot } from "../storage/homeLayout.js";
 import { projectActor } from "../task/taskAuthority.js";
@@ -90,37 +91,7 @@ async function refreshProject(args, store, options) {
         throw usageError("Project refresh usage: yui project refresh <project>.");
     }
     const project = requireProject(store, args[0]);
-    assertProjectActive(project, "refresh");
-    if (project.remoteUrl === undefined) {
-        throw usageError(`Project refresh requires a remote URL: ${project.id}.`);
-    }
-    if (project.stableBranch !== project.developmentBranch) {
-        throw usageError(`Project refresh requires matching stable and development branches: ${project.id}.`);
-    }
-    // RFC Phase 1: hold the per-Project maintenance fence for the whole refresh
-    // so Task workspace preparation and other maintenance cannot interleave
-    // with the canonical branch/working-tree move.
-    const releaseMaintenance = await acquireProjectMaintenanceLock(store.rootDirectory(), project.id, { signal: options.signal });
-    try {
-        const current = requireUnchangedMaintenanceProject(store, project, "refresh");
-        const refreshed = await (options.git ?? new NodeGitWorkspace()).refresh({
-            repositoryPath: current.path,
-            remoteUrl: current.remoteUrl,
-            stableRef: current.stableBranch
-        });
-        return { project: current, ...refreshed };
-    }
-    catch (error) {
-        if (error instanceof GitWorkspaceRefreshError) {
-            throw new CliError("RUNTIME_ERROR", error.message, undefined, {
-                projectId: project.id, refresh: error.result
-            });
-        }
-        throw error;
-    }
-    finally {
-        releaseMaintenance();
-    }
+    return refreshRegisteredProject(store, project.id, options);
 }
 /**
  * RFC Phase 1: diagnose a managed Project's divergence without mutating it.

package/dist/commands/scheduleCommands.js

@@ -0,0 +1,45 @@
+import { usageError } from "../errors/cliError.js";
+import { callFileTaskController } from "../controller/clientRuntime.js";
+import { resolveJobCaller } from "../task/taskAuthority.js";
+export async function runScheduleCommand(args, options) {
+    const [op, ...rest] = args;
+    if (op === undefined || !["create", "list", "show", "update", "enable", "disable"].includes(op)) {
+        throw usageError("Schedule command must be create, list, show, update, enable, or disable.");
+    }
+    const flags = new Map();
+    for (let i = 0; i < rest.length; i++) {
+        const flag = rest[i];
+        if (!["--global", "--task", "--schedule", "--job", "--rule", "--revision"].includes(flag) || flags.has(flag)) {
+            throw usageError(`Unknown or repeated Schedule flag: ${flag}.`);
+        }
+        if (flag === "--global") {
+            flags.set(flag, "true");
+            continue;
+        }
+        const value = rest[++i];
+        if (value === undefined || value.startsWith("--"))
+            throw usageError(`Missing value: ${flag}.`);
+        flags.set(flag, value);
+    }
+    if (flags.has("--global") === flags.has("--task"))
+        throw usageError("Choose exactly one of --global or --task.");
+    const taskId = flags.get("--task");
+    let rule;
+    if (flags.has("--rule")) {
+        try {
+            rule = JSON.parse(flags.get("--rule"));
+        }
+        catch {
+            throw usageError("--rule must be JSON.");
+        }
+    }
+    const result = await callFileTaskController(options.home, "schedule.control", {
+        op, scope: taskId === undefined ? { kind: "global" } : { kind: "task", taskId },
+        caller: resolveJobCaller(options.environment, taskId ?? ""),
+        ...(flags.has("--schedule") ? { id: flags.get("--schedule") } : {}),
+        ...(flags.has("--job") ? { jobId: flags.get("--job") } : {}),
+        ...(rule === undefined ? {} : { rule }),
+        ...(flags.has("--revision") ? { expectedRevision: Number(flags.get("--revision")) } : {})
+    }, { environment: options.environment });
+    return result;
+}

package/dist/commands/taskActivationCommands.js

@@ -6,6 +6,7 @@ import { currentManagedRuntime } from "../runtime/managedCaller.js";
 import { describeEnvironmentPlan } from "../task/taskActivation.js";
 import { cancelTaskActivation, requestTaskActivation, taskActivationOperationRef } from "../task/taskActivationService.js";
 import { taskLocalActor } from "../task/taskAuthority.js";
+import { taskPhase } from "../context/taskPhase.js";
 /**
  * Explicit Activation requests.
  *
@@ -20,7 +21,7 @@ export function runTaskActivationCommand(args, store, options) {
     switch (command) {
         case "request": return requestActivation(rest, store, options);
         case "cancel": return cancelActivation(rest, store, options);
-        case "show": return showActivation(rest, store);
+        case "show": return store.readTransaction((reader) => showActivation(rest, reader));
         default:
             throw usageError(command === undefined
                 ? "Task activation command is required."
@@ -28,7 +29,8 @@ export function runTaskActivationCommand(args, store, options) {
     }
 }
 const REQUEST_USAGE = "Task activation request usage: yui task activation request <task> "
-    + "--request-id <id> --environment <empty|scratch|local:<resource>:<read|write>>.";
+    + "--request-id <id> --environment <empty|scratch|local:<resource>:<read|write>> "
+    + "[--source-message <message-id> | --source-text <exact-input>].";
 /**
  * Records the request and returns its reference immediately.
  *
@@ -39,19 +41,26 @@ const REQUEST_USAGE = "Task activation request usage: yui task activation reques
  * current then.
  */
 function requestActivation(args, store, options) {
-    const parsed = parseTail(args, new Set(["--request-id", "--environment"]), REQUEST_USAGE);
+    const parsed = parseTail(args, new Set(["--request-id", "--environment", "--source-message", "--source-text"]), REQUEST_USAGE);
     exactPositionals(parsed.positionals, 1, REQUEST_USAGE);
     const taskId = parsed.positionals[0];
     const requestId = requiredOption(parsed.options, "--request-id", REQUEST_USAGE);
     const environmentPlan = parseEnvironmentPlan(requiredOption(parsed.options, "--environment", REQUEST_USAGE), REQUEST_USAGE);
     const now = options.now?.() ?? new Date();
     const caller = activationCaller(store, options, taskId);
+    const sourceMessageId = parsed.options.get("--source-message");
+    const sourceText = parsed.options.get("--source-text");
+    if (caller.actorId.startsWith("task:") && sourceMessageId === undefined && sourceText === undefined) {
+        throw usageError("Leader activation requires --source-message or --source-text with the exact new user input. Read the original; do not substitute a Brief summary.", REQUEST_USAGE);
+    }
     const result = attempt(REQUEST_USAGE, () => requestTaskActivation(store, {
         taskId,
         requestId,
         actorId: caller.actorId,
         authorityRef: caller.authorityRef,
         environmentPlan,
+        sourceMessageId, sourceText,
+        sourceNativeSessionId: caller.nativeSessionId,
         ...(caller.planningRunId === undefined ? {} : { callerRunId: caller.planningRunId })
     }, now));
     // An immediate request has nothing left to wait for, so ask the Controller to
@@ -64,12 +73,14 @@ function requestActivation(args, store, options) {
         void options.runtime?.notifyMailboxChanged({ kind: "task", taskId });
     }
     const request = result.request;
+    const source = taskPhase(store, { ...requireTask(store, taskId), activationRequest: request }).activation?.source;
     const lines = [
         `${result.created ? "Requested" : "Existing"} activation ${result.operationRef}`,
         `Task: ${taskId} (draft)`,
         `Start: ${result.startMode}${result.afterPlanningRun === undefined ? "" : ` after ${taskId}/${result.afterPlanningRun}`}`,
         `Environment: ${describeEnvironmentPlan(request.environmentPlan)}`,
         `Disposition: ${request.disposition}`,
+        ...(source?.read === undefined ? [] : [`Source: yui ${source.read}`]),
         result.startMode === "after-planning-turn"
             ? "This reference is returned now; the request is adopted after the planning Turn ends."
             : `Adopt it with: yui task activate ${taskId}`
@@ -81,7 +92,8 @@ function requestActivation(args, store, options) {
         ...(result.afterPlanningRun === undefined
             ? {}
             : { afterPlanningRun: result.afterPlanningRun }),
-        request
+        request,
+        source
     });
 }
 /** A cancelled request is never adopted, even if the same id is retried. */
@@ -139,7 +151,8 @@ function showActivation(args, store) {
         `Requested at: ${request.requestedAt}`,
         ...settledLines
     ];
-    return output(`${lines.join("\n")}\n`, { task, request, settledRequests: settled });
+    return output(`${lines.join("\n")}\n`, { task, request, settledRequests: settled,
+        phase: taskPhase(store, task) });
 }
 /**
  * Resolves who is requesting, and whether they are running inside this Task's
@@ -161,6 +174,7 @@ function activationCaller(store, options, taskId) {
             : store.getRun(taskId, runtime.currentRunId);
         return {
             actorId: `task:${taskId}/role:${SYSTEM_LEADER_ROLE}`,
+            nativeSessionId: runtime.nativeSessionId,
             // Non-secret binding fingerprint of the live Session, matching the Job
             // boundary: reattaching the same Session keeps it, replacing it does not.
             authorityRef: fingerprint([

package/dist/commands/taskCommands.js

@@ -83,6 +83,7 @@ import { assertTaskOpen, clock, exactPositionals, leaderActionEventPayload, lead
 import { assertTaskCompletionPublishedTreeProof } from "./taskCompletionGate.js";
 import { runTaskContextCommand, taskRecordList } from "./taskContextCommand.js";
 import { taskBriefCommand, taskDecisionCommand, taskEventCommand, taskMilestoneCommand } from "./taskFactCommands.js";
+import { taskProjectDeliveryCommand } from "./taskProjectDeliveryCommand.js";
 import { taskUsageCommand } from "./taskUsageCommand.js";
 import { openInputRequestCount, runTaskInputCommand } from "./taskInputCommands.js";
 import { runTaskNextActionCommand } from "./taskNextActionCommand.js";
@@ -456,6 +457,8 @@ function assertCandidateReviewRoleIsolation(producerRoles, reviewerRoleName, lan
 }
 function taskProjectCommand(args, store, options) {
     const [command, ...rest] = args;
+    if (command === "delivery")
+        return taskProjectDeliveryCommand(rest, store, options);
     if (command === "list") {
         exactPositionals(rest, 1, "Task project list usage: yui task project list <task>.");
         const task = requireTask(store, rest[0]);
@@ -665,6 +668,7 @@ function routeUserSubmission(tx, task, actor, body, intent, now, submissionKey,
                 requestId: `submit-${message.id}`,
                 actorId: identity.actorId,
                 authorityRef: identity.authorityRef,
+                sourceMessageId: message.id,
                 environmentPlan: routing.environmentPlan
             }, now);
             activationRef = taskActivationOperationRef(task.id, `submit-${message.id}`);
@@ -1879,7 +1883,9 @@ function steerTaskInput(taskId, input, store, options) {
         if (saved === undefined || requestId === undefined || taskMessageInboxReceipt(tx, saved) !== undefined)
             return false;
         tx.updateMessage(result.task.id, recordTaskMessageControlOutcome(saved, {
-            requestId, receiptId, outcome: "pending", observedAt: clock(options)
+            requestId, receiptId, outcome: "pending", observedAt: clock(options),
+            target: { agentId: resolution.target.agentId, nativeSessionId: resolution.target.nativeSessionId,
+                attemptId: resolution.target.attemptId }
         }));
         return true;
     });
@@ -7008,7 +7014,7 @@ function taskWakeInspectionCommand(args, store) {
         const windowEvents = allEvents.filter((e) => inWindow(e.createdAt) || referenced("event", e.id) || reasonEvent(e));
         const events = history ? windowEvents : windowEvents.filter(e => referenced("event", e.id)
             || reasonEvent(e) || ["run.completed", "run.failed", "run.cancelled"].includes(e.type));
-        const messages = wakeMessages(wake, store.listMessages(task.id));
+        const messages = wakeMessages(wake, store.listMessages(task.id), history);
         const allRuns = store.listRuns(task.id);
         const referencedRunIds = new Set(referencedWakeRunIds(allRuns, allEvents, events));
         for (const run of allRuns)

package/dist/commands/taskFactCommands.js

@@ -1,5 +1,5 @@
 import { createTaskBrief, updateTaskBrief } from "../brief/taskBrief.js";
-import { assertContextRecordReadable } from "../context/taskContext.js";
+import { assertContextRecordReadable, resolveContextReader } from "../context/taskContext.js";
 import { taskRecordList } from "./taskContextCommand.js";
 import { materialize } from "../context/taskContext.js";
 import { enqueueWork } from "../coordination/workMailboxQueue.js";
@@ -8,15 +8,22 @@ import { dataError, usageError } from "../errors/cliError.js";
 import { createMilestone } from "../milestone/milestone.js";
 import { assertTaskOpen, clock, exactPositionals, leaderActionEventPayload, leaderMailbox, notifyMailbox, output, parseMultiValueTail, parseTail, presentTime, recordTaskEvent, requiredOption, requiredText, requireTask, taskActor, taskMailbox, taskRef } from "./taskCommandSupport.js";
 import { failureCapabilitiesCommand } from "../runtime/agentFailureContext.js";
+import { taskBriefGuard, taskPhase } from "../context/taskPhase.js";
 export function taskBriefCommand(args, store, options) {
     const [command, ...rest] = args;
     if (command === "show") {
         exactPositionals(rest, 1, "Task brief show usage: yui task brief show <task>.");
-        const task = requireTask(store, rest[0]);
-        assertContextRecordReadable(store, task.id, "task-brief", task.id, options.environment);
-        const brief = store.getTaskBrief(task.id);
+        const { task, brief, writeGuard, phase } = store.readTransaction(reader => {
+            const task = requireTask(reader, rest[0]);
+            assertContextRecordReadable(reader, task.id, "task-brief", task.id, options.environment);
+            const caller = resolveContextReader(reader, options.environment ?? {});
+            const shared = caller === undefined || caller.roleName === "leader";
+            return { task, brief: reader.getTaskBrief(task.id),
+                writeGuard: shared ? taskBriefGuard(reader, task) : undefined,
+                phase: shared ? taskPhase(reader, task) : undefined };
+        });
         if (brief === null) {
-            return output(`Task ${task.id} has no brief.\n`, { taskId: task.id, brief: null });
+            return output(`Task ${task.id} has no brief.\n${writeGuard === undefined ? "" : `Write guard: ${writeGuard}\n`}`, { taskId: task.id, brief: null, writeGuard, phase });
         }
         const timeZone = store.getConfig().timeZone;
         const working = task.status === "draft" || task.status === "active";
@@ -32,12 +39,13 @@ export function taskBriefCommand(args, store, options) {
             `${working ? "Current focus" : "Last working focus"}: ${brief.currentFocus}`,
             `${working ? "Leader summary" : "Last working summary"}: ${brief.leaderSummary}`,
             `Updated by: ${brief.updatedBy}`,
-            `Updated at: ${presentTime(brief.updatedAt, timeZone)}`
-        ].join("\n").concat("\n"), { taskId: task.id, brief });
+            `Updated at: ${presentTime(brief.updatedAt, timeZone)}`,
+            ...(writeGuard === undefined ? [] : [`Write guard: ${writeGuard}`])
+        ].join("\n").concat("\n"), { taskId: task.id, brief, writeGuard, phase });
     }
     if (command === "update") {
-        const usage = "Task brief update usage: yui task brief update <task> [--objective <text>] [--boundary <text> ...] [--approach <text>] [--focus <text>] [--leader-summary <text>].";
-        const parsed = parseMultiValueTail(rest, new Set(["--objective", "--approach", "--focus", "--leader-summary"]), new Set(["--boundary"]), usage);
+        const usage = "Task brief update usage: yui task brief update <task> --if-current <writeGuard> [--objective <text>] [--boundary <text> ...] [--approach <text>] [--focus <text>] [--leader-summary <text>].";
+        const parsed = parseMultiValueTail(rest, new Set(["--objective", "--approach", "--focus", "--leader-summary", "--if-current"]), new Set(["--boundary"]), usage);
         exactPositionals(parsed.positionals, 1, usage);
         const hasObjective = parsed.options.has("--objective");
         const hasApproach = parsed.options.has("--approach");
@@ -53,6 +61,9 @@ export function taskBriefCommand(args, store, options) {
             assertTaskOpen(task);
             const existing = tx.getTaskBrief(task.id);
             const updatedBy = taskActor(tx, options, task.id);
+            if (parsed.options.get("--if-current") !== taskBriefGuard(tx, task)) {
+                throw usageError(`Task context or Brief changed, or --if-current is missing; read task brief show ${task.id}, reconcile new input, then retry with its writeGuard.`);
+            }
             const brief = existing === null
                 ? createTaskBrief({
                     objective: requiredText(parsed.options.get("--objective"), "--objective"),
@@ -244,9 +255,10 @@ export function taskEventCommand(args, store, options = {}) {
         exactPositionals(rest, 2, "Task event show usage: yui task event show <task> <event>.");
         const task = requireTask(store, rest[0]);
         assertContextRecordReadable(store, task.id, "task-event", rest[1], options.environment);
-        const events = store.listEvents(task.id);
-        const event = events.find((e) => e.id === rest[1]) ?? null;
-        if (event === null)
+        const event = store.queryContextRecords(task.id, {
+            family: "task-event", ids: [rest[1]], limit: 1
+        }).records[0]?.value;
+        if (event === undefined)
             throw dataError(`Event not found: ${rest[1]}.`);
         const timeZone = store.getConfig().timeZone;
         const capabilitiesCommand = event.type === "runtime.agent-error" && event.payload.roleName

package/dist/commands/taskProjectDeliveryCommand.js

@@ -0,0 +1,56 @@
+import { readTaskAuthorizationMessage, taskAuthorizationSource } from "../grant/taskAuthorization.js";
+import { assertTaskDeliveryAuthority } from "../task/taskAuthority.js";
+import { PROJECT_DELIVERY_DECIDED_EVENT, projectDeliveryDecision } from "../task/projectDeliveryScope.js";
+import { enqueueWork } from "../coordination/workMailboxQueue.js";
+import { usageError } from "../errors/cliError.js";
+import { clock, exactPositionals, leaderMailbox, notifyMailbox, output, parseTail, recordTaskEvent, requiredOption, requireTask, taskMailbox, taskRef } from "./taskCommandSupport.js";
+export function taskProjectDeliveryCommand(args, store, options) {
+    const usage = "yui task project delivery <task> <project-id> --requirement <required|excluded> "
+        + "--reason <text> --source-message <message-id> --purpose <exact-quote> --if-current <event-id|none>";
+    const parsed = parseTail(args, new Set([
+        "--requirement", "--reason", "--source-message", "--purpose", "--if-current"
+    ]), usage);
+    exactPositionals(parsed.positionals, 2, usage);
+    const requirement = requiredOption(parsed.options, "--requirement");
+    if (requirement !== "required" && requirement !== "excluded")
+        throw usageError(usage);
+    const reason = requiredOption(parsed.options, "--reason");
+    const sourceMessage = requiredOption(parsed.options, "--source-message");
+    const purpose = requiredOption(parsed.options, "--purpose");
+    const guard = requiredOption(parsed.options, "--if-current");
+    const now = clock(options);
+    const result = store.transaction(tx => {
+        const task = requireTask(tx, parsed.positionals[0]);
+        const actor = assertTaskDeliveryAuthority(tx, options.environment, task.id);
+        if (!["active", "completed"].includes(task.status) || task.executionGate.state !== "enabled") {
+            throw usageError("Delivery scope requires an active or completed, unarchived Task with execution enabled; it does not reopen or resume work.");
+        }
+        const projectId = parsed.positionals[1];
+        if (!task.projectBindings.some(binding => binding.projectId === projectId)) {
+            throw usageError(`Project is not bound to this Task: ${projectId}.`);
+        }
+        const source = actor === "leader"
+            ? taskAuthorizationSource(tx, task.id, options.environment ?? {}, sourceMessage, purpose)
+            : readTaskAuthorizationMessage(tx, task.id, sourceMessage, purpose);
+        const previous = projectDeliveryDecision(tx.listEventsByType(task.id, [PROJECT_DELIVERY_DECIDED_EVENT]), task.id, projectId);
+        if (guard !== (previous?.id ?? "none")) {
+            throw usageError("Project delivery scope changed; read task remote-delivery and reconcile before retrying with its scopeDecision.id (or none).");
+        }
+        const event = recordTaskEvent(tx, task.id, PROJECT_DELIVERY_DECIDED_EVENT, {
+            projectId, requirement, reason, by: actor,
+            sourceMessageId: source.messageId, sourceDigest: source.digest, purpose: source.purpose,
+            ...("nativeSessionId" in source && typeof source.nativeSessionId === "string"
+                ? { nativeSessionId: source.nativeSessionId } : {}),
+            ...(previous === null ? {} : { supersedes: previous.id })
+        }, now);
+        enqueueWork(tx, taskMailbox(task.id), "project-delivery-decided", now, [taskRef(task.id)]);
+        if (task.status === "active" && actor !== "leader") {
+            enqueueWork(tx, leaderMailbox(task.id), "project-delivery-decided", now, [taskRef(task.id)]);
+        }
+        return { task, event };
+    });
+    notifyMailbox(options.runtime, taskMailbox(result.task.id));
+    if (result.task.status === "active")
+        notifyMailbox(options.runtime, leaderMailbox(result.task.id));
+    return output(`Recorded Project delivery requirement (${requirement}); merge facts and cleanup authority are unchanged.\n`, result.event);
+}

package/dist/commands/taskPublicationCommands.js

@@ -35,7 +35,7 @@ export function runPublicationCommand(args, store, options) {
     }
 }
 function upsertPublication(args, store, options) {
-    const usage = "Task publication upsert usage: yui task publication upsert <task> --project <project> --provider <github|gitlab> --repository <owner/name> --kind <pull-request|merge-request> --id <external-id> [--url <url>] [--title <text>] [--source-branch <branch>] [--target-branch <branch>] [--local-commit <sha>] [--head-commit <sha>] [--remote-commit <sha>] [--state <open|merged|closed>] [--reported|--verified] [--evidence <text>] [--merged-at <iso-timestamp>].";
+    const usage = "Task publication upsert usage: yui task publication upsert <task> --project <project> --provider <github|gitlab> --repository <owner/name> --kind <pull-request|merge-request> --id <external-id> [--url <url>] [--title <text>] [--source-branch <branch>] [--target-branch <branch>] [--local-commit <sha>] [--head-commit <sha>] [--remote-commit <sha>] [--state <open|merged|closed>] [--reported] [--evidence <text>] [--merged-at <iso-timestamp>].";
     const parsed = parseUpsertArgs(args, usage);
     exactPositionals(parsed.positionals, 1, usage);
     const task = requireTask(store, parsed.positionals[0]);
@@ -173,8 +173,9 @@ function parseVerification(parsed, usage) {
     if (parsed.flags.has("--reported") && parsed.flags.has("--verified")) {
         throw usageError("--reported and --verified are mutually exclusive.", usage);
     }
-    if (parsed.flags.has("--verified"))
-        return "verified";
+    if (parsed.flags.has("--verified")) {
+        throw usageError("Use task publication verify with a provider read or --observation tool evidence; upsert cannot assert --verified.");
+    }
     if (parsed.flags.has("--reported"))
         return "reported";
     return undefined;
@@ -210,6 +211,8 @@ function inheritPublicationInput(existing, input) {
             && normalizeCommitForComparison(input.headCommit) !== existing.headCommit)
         || input.projectId !== existing.projectId
         || input.externalKind !== existing.externalKind
+        || (input.externalUrl !== undefined && input.externalUrl !== existing.externalUrl)
+        || (input.targetBranch !== undefined && input.targetBranch !== existing.targetBranch)
         || stateChanged
         || remoteCommitChanged
         || evidenceChanged