@zq-silk/yui 0.15.12 → 0.16.0

package/dist/commands/taskCompletionGate.js

@@ -2,8 +2,8 @@ import { usageError } from "../errors/cliError.js";
 import { GitIntegrationService } from "../integration/gitIntegrationService.js";
 import { createIntegrationAttempt } from "../integration/integrationAttempt.js";
 import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
-import { publicationExternalKey } from "../task/publicationReference.js";
 import { isCompletedTaskReviewEvidence } from "../review/reviewAcceptance.js";
+import { publicationExternalKey } from "../task/publicationReference.js";
 import { workspaceProjectEntry } from "../worktree/managedWorkspace.js";
 /**
  * Verify the one supported ancestry waiver before `task complete` mutates any

package/dist/commands/taskExecutionCommands.js

@@ -6,7 +6,7 @@ import { finishReviewRound, updateReviewExecutionGroup } from "../review/reviewR
 import { failRun } from "../agentRun/agentRun.js";
 import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
 import { startTaskExecution, stopTaskExecution } from "../task/task.js";
-import { taskActor } from "./taskActor.js";
+import { taskActor } from "../task/taskAuthority.js";
 export function parseTaskExecutionStopRequest(args) {
     const taskId = args[0];
     if (taskId === undefined || taskId.startsWith("--")) {

package/dist/commands/taskFactCommands.js

@@ -0,0 +1,325 @@
+import { createTaskBrief, updateTaskBrief } from "../brief/taskBrief.js";
+import { assertContextRecordReadable, contextRecordReader } from "../context/taskContext.js";
+import { enqueueWork } from "../coordination/workMailboxQueue.js";
+import { createDecision, supersedeDecision } from "../decision/decision.js";
+import { dataError, usageError } from "../errors/cliError.js";
+import { createMilestone } from "../milestone/milestone.js";
+import { defaultTableWidth, renderTable } from "../output/table.js";
+import { assertTaskOpen, clock, exactPositionals, leaderActionEventPayload, leaderMailbox, notifyMailbox, optionalNonEmptyOption, output, parseMultiValueTail, parseTail, presentTime, recordTaskEvent, requiredOption, requiredText, requireTask, taskActor, taskMailbox, taskRef } from "./taskCommandSupport.js";
+import { failureCapabilitiesCommand } from "../runtime/agentFailureContext.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);
+        if (brief === null) {
+            return output(`Task ${task.id} has no brief.\n`, { taskId: task.id, brief: null });
+        }
+        const timeZone = store.getConfig().timeZone;
+        return output([
+            `Task: ${task.id}`,
+            `Objective: ${brief.objective}`,
+            `Boundaries:`,
+            ...(brief.boundaries.length === 0 ? ["  (none)"] : brief.boundaries.map((b) => `  - ${b}`)),
+            `Technical approach: ${brief.technicalApproach || "(not defined)"}`,
+            `Current focus: ${brief.currentFocus}`,
+            `Leader summary: ${brief.leaderSummary}`,
+            `Updated by: ${brief.updatedBy}`,
+            `Updated at: ${presentTime(brief.updatedAt, timeZone)}`
+        ].join("\n").concat("\n"), { taskId: task.id, brief });
+    }
+    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);
+        exactPositionals(parsed.positionals, 1, usage);
+        const hasObjective = parsed.options.has("--objective");
+        const hasApproach = parsed.options.has("--approach");
+        const hasFocus = parsed.options.has("--focus");
+        const hasSummary = parsed.options.has("--leader-summary");
+        const boundaries = parsed.multiOptions.get("--boundary") ?? [];
+        if (!hasObjective && !hasApproach && !hasFocus && !hasSummary && boundaries.length === 0) {
+            throw usageError("At least one brief field is required.", usage);
+        }
+        const now = clock(options);
+        const result = store.transaction((tx) => {
+            const task = requireTask(tx, parsed.positionals[0]);
+            assertTaskOpen(task);
+            const existing = tx.getTaskBrief(task.id);
+            const updatedBy = taskActor(tx, options, task.id);
+            const brief = existing === null
+                ? createTaskBrief({
+                    objective: requiredText(parsed.options.get("--objective"), "--objective"),
+                    boundaries,
+                    ...(hasApproach
+                        ? { technicalApproach: requiredText(parsed.options.get("--approach"), "--approach") }
+                        : {}),
+                    currentFocus: requiredText(parsed.options.get("--focus"), "--focus"),
+                    leaderSummary: requiredText(parsed.options.get("--leader-summary"), "--leader-summary"),
+                    updatedBy
+                }, now)
+                : updateTaskBrief(existing, {
+                    ...(hasObjective ? { objective: parsed.options.get("--objective") } : {}),
+                    ...(boundaries.length > 0 ? { boundaries } : {}),
+                    ...(hasApproach
+                        ? { technicalApproach: parsed.options.get("--approach") }
+                        : {}),
+                    ...(hasFocus ? { currentFocus: parsed.options.get("--focus") } : {}),
+                    ...(hasSummary ? { leaderSummary: parsed.options.get("--leader-summary") } : {})
+                }, updatedBy, now);
+            tx.saveTaskBrief(task.id, brief);
+            recordTaskEvent(tx, task.id, "brief.updated", {
+                updatedBy,
+                previous: JSON.stringify(existing), current: JSON.stringify(brief)
+            }, now);
+            enqueueWork(tx, taskMailbox(task.id), "brief-updated", now, [taskRef(task.id)]);
+            if (task.status === "active" && updatedBy !== "leader") {
+                enqueueWork(tx, leaderMailbox(task.id), "brief-updated", now, [taskRef(task.id)]);
+            }
+            return { task, brief };
+        });
+        notifyMailbox(options.runtime, taskMailbox(result.task.id));
+        if (result.task.status === "active") {
+            notifyMailbox(options.runtime, leaderMailbox(result.task.id));
+        }
+        return output(`Updated brief for ${result.task.id}\n`, { taskId: result.task.id, brief: result.brief });
+    }
+    throw usageError(command === undefined
+        ? "Task brief command is required."
+        : `Unknown command: task brief ${command}`);
+}
+export function taskDecisionCommand(args, store, options) {
+    const [command, ...rest] = args;
+    if (command === "record") {
+        const usage = "Task decision record usage: yui task decision record <task> --title <text> --rationale <text>.";
+        const parsed = parseTail(rest, new Set(["--title", "--rationale"]), usage);
+        exactPositionals(parsed.positionals, 1, usage);
+        const title = requiredOption(parsed.options, "--title");
+        const rationale = requiredOption(parsed.options, "--rationale");
+        const now = clock(options);
+        const result = store.transaction((tx) => {
+            const task = requireTask(tx, parsed.positionals[0]);
+            assertTaskOpen(task);
+            const actor = taskActor(tx, options, task.id);
+            const decision = createDecision(tx.nextDecisionId(task.id), task.id, title, rationale, now);
+            tx.saveDecision(task.id, decision);
+            recordTaskEvent(tx, task.id, "decision.recorded", {
+                decisionId: decision.id,
+                title,
+                ...leaderActionEventPayload(tx, task.id, options)
+            }, now);
+            enqueueWork(tx, taskMailbox(task.id), "decision-recorded", now, [taskRef(task.id)]);
+            if (task.status === "active" && actor !== "leader") {
+                enqueueWork(tx, leaderMailbox(task.id), "decision-recorded", now, [taskRef(task.id)]);
+            }
+            return { task, decision };
+        });
+        notifyMailbox(options.runtime, taskMailbox(result.task.id));
+        if (result.task.status === "active")
+            notifyMailbox(options.runtime, leaderMailbox(result.task.id));
+        return output(`Recorded decision ${result.decision.id} for ${result.task.id}\n`);
+    }
+    if (command === "list") {
+        const usage = "Task decision list usage: yui task decision list <task> [--status active|superseded].";
+        const parsed = parseTail(rest, new Set(["--status"]), usage);
+        exactPositionals(parsed.positionals, 1, usage);
+        const task = requireTask(store, parsed.positionals[0]);
+        const readable = contextRecordReader(store, task.id, options.environment);
+        let decisions = store.listDecisions(task.id).filter(record => readable("task-decision", record.id));
+        const status = parsed.options.get("--status");
+        if (status !== undefined) {
+            if (status !== "active" && status !== "superseded") {
+                throw usageError("--status must be active or superseded.", usage);
+            }
+            decisions = decisions.filter((d) => d.status === status);
+        }
+        if (decisions.length === 0) {
+            return output(`No decisions found for ${task.id}.\n`, { taskId: task.id, decisions: [] });
+        }
+        const timeZone = store.getConfig().timeZone;
+        return output(`${renderTable(`Decisions: ${task.id}`, [
+            { header: "Decision", minWidth: 8, maxWidth: 18 },
+            { header: "Status", minWidth: 6, maxWidth: 12 },
+            { header: "Title", minWidth: 8, maxWidth: 64 },
+            { header: "Created", minWidth: 10, maxWidth: 28 }
+        ], decisions.map((d) => [d.id, d.status, d.title, presentTime(d.createdAt, timeZone)]), defaultTableWidth())}\n`, { taskId: task.id, decisions });
+    }
+    if (command === "show") {
+        exactPositionals(rest, 2, "Task decision show usage: yui task decision show <task> <decision>.");
+        const task = requireTask(store, rest[0]);
+        assertContextRecordReadable(store, task.id, "task-decision", rest[1], options.environment);
+        const decision = store.getDecision(task.id, rest[1]);
+        if (decision === null)
+            throw dataError(`Decision not found: ${rest[1]}.`);
+        const timeZone = store.getConfig().timeZone;
+        return output([
+            `Decision: ${decision.id}`,
+            `Task: ${task.id}`,
+            `Title: ${decision.title}`,
+            `Rationale: ${decision.rationale}`,
+            `Status: ${decision.status}`,
+            ...(decision.supersededReason === undefined ? [] : [`Superseded reason: ${decision.supersededReason}`]),
+            ...(decision.supersededAt === undefined ? [] : [`Superseded at: ${presentTime(decision.supersededAt, timeZone)}`]),
+            `Created: ${presentTime(decision.createdAt, timeZone)}`,
+            `Updated: ${presentTime(decision.updatedAt, timeZone)}`
+        ].join("\n").concat("\n"), { taskId: task.id, decision });
+    }
+    if (command === "supersede") {
+        const usage = "Task decision supersede usage: yui task decision supersede <task> <decision> --reason <text>.";
+        const parsed = parseTail(rest, new Set(["--reason"]), usage);
+        exactPositionals(parsed.positionals, 2, usage);
+        const reason = requiredOption(parsed.options, "--reason");
+        const now = clock(options);
+        const result = store.transaction((tx) => {
+            const task = requireTask(tx, parsed.positionals[0]);
+            assertTaskOpen(task);
+            const actor = taskActor(tx, options, task.id);
+            const existing = tx.getDecision(task.id, parsed.positionals[1]);
+            if (existing === null)
+                throw dataError(`Decision not found: ${parsed.positionals[1]}.`);
+            const decision = supersedeDecision(existing, reason, now);
+            tx.saveDecision(task.id, decision);
+            recordTaskEvent(tx, task.id, "decision.superseded", {
+                decisionId: decision.id,
+                reason,
+                ...leaderActionEventPayload(tx, task.id, options)
+            }, now);
+            enqueueWork(tx, taskMailbox(task.id), "decision-superseded", now, [taskRef(task.id)]);
+            if (task.status === "active" && actor !== "leader") {
+                enqueueWork(tx, leaderMailbox(task.id), "decision-superseded", now, [taskRef(task.id)]);
+            }
+            return { task, decision };
+        });
+        notifyMailbox(options.runtime, taskMailbox(result.task.id));
+        if (result.task.status === "active")
+            notifyMailbox(options.runtime, leaderMailbox(result.task.id));
+        return output(`Superseded decision ${result.decision.id} for ${result.task.id}\n`);
+    }
+    throw usageError(command === undefined
+        ? "Task decision command is required."
+        : `Unknown command: task decision ${command}`);
+}
+export function taskMilestoneCommand(args, store, options) {
+    const [command, ...rest] = args;
+    if (command === "add") {
+        const usage = "Task milestone add usage: yui task milestone add <task> --title <text> --summary <text>.";
+        const parsed = parseTail(rest, new Set(["--title", "--summary"]), usage);
+        exactPositionals(parsed.positionals, 1, usage);
+        const title = requiredOption(parsed.options, "--title");
+        const summary = requiredOption(parsed.options, "--summary");
+        const now = clock(options);
+        const result = store.transaction((tx) => {
+            const task = requireTask(tx, parsed.positionals[0]);
+            assertTaskOpen(task);
+            const actor = taskActor(tx, options, task.id);
+            const milestone = createMilestone(tx.nextMilestoneId(task.id), task.id, title, summary, actor, now);
+            tx.saveMilestone(task.id, milestone);
+            recordTaskEvent(tx, task.id, "milestone.added", {
+                milestoneId: milestone.id,
+                title,
+                ...leaderActionEventPayload(tx, task.id, options)
+            }, now);
+            enqueueWork(tx, taskMailbox(task.id), "milestone-added", now, [taskRef(task.id)]);
+            return { task, milestone };
+        });
+        notifyMailbox(options.runtime, taskMailbox(result.task.id));
+        return output(`Added milestone ${result.milestone.id} for ${result.task.id}\n`);
+    }
+    if (command === "list") {
+        exactPositionals(rest, 1, "Task milestone list usage: yui task milestone list <task>.");
+        const task = requireTask(store, rest[0]);
+        const readable = contextRecordReader(store, task.id, options.environment);
+        const milestones = store.listMilestones(task.id).filter(record => readable("task-milestone", record.id));
+        if (milestones.length === 0) {
+            return output(`No milestones found for ${task.id}.\n`, { taskId: task.id, milestones: [] });
+        }
+        const timeZone = store.getConfig().timeZone;
+        return output(`${renderTable(`Milestones: ${task.id}`, [
+            { header: "Milestone", minWidth: 9, maxWidth: 18 },
+            { header: "Title", minWidth: 8, maxWidth: 64 },
+            { header: "Created", minWidth: 10, maxWidth: 28 }
+        ], milestones.map((m) => [m.id, m.title, presentTime(m.createdAt, timeZone)]), defaultTableWidth())}\n`, { taskId: task.id, milestones });
+    }
+    if (command === "show") {
+        exactPositionals(rest, 2, "Task milestone show usage: yui task milestone show <task> <milestone>.");
+        const task = requireTask(store, rest[0]);
+        assertContextRecordReadable(store, task.id, "task-milestone", rest[1], options.environment);
+        const milestone = store.getMilestone(task.id, rest[1]);
+        if (milestone === null)
+            throw dataError(`Milestone not found: ${rest[1]}.`);
+        const timeZone = store.getConfig().timeZone;
+        return output([
+            `Milestone: ${milestone.id}`,
+            `Task: ${task.id}`,
+            `Title: ${milestone.title}`,
+            `Summary: ${milestone.summary}`,
+            `Created by: ${milestone.createdBy}`,
+            `Created: ${presentTime(milestone.createdAt, timeZone)}`
+        ].join("\n").concat("\n"), { taskId: task.id, milestone });
+    }
+    throw usageError(command === undefined
+        ? "Task milestone command is required."
+        : `Unknown command: task milestone ${command}`);
+}
+export function taskEventCommand(args, store, options = {}) {
+    const [command, ...rest] = args;
+    if (command === "list") {
+        const eventListUsage = "Task event list usage: yui task event list <task> [--after <timestamp>] [--limit <n>].";
+        const parsed = parseTail(rest, new Set(["--after", "--limit"]), eventListUsage);
+        exactPositionals(parsed.positionals, 1, eventListUsage);
+        const task = requireTask(store, parsed.positionals[0]);
+        const readable = contextRecordReader(store, task.id, options.environment);
+        let events = store.listEvents(task.id).filter(record => readable("task-event", record.id));
+        const after = optionalNonEmptyOption(parsed.options, "--after");
+        if (after !== undefined) {
+            const afterMs = Date.parse(after);
+            if (!Number.isFinite(afterMs))
+                throw usageError("--after must be a valid timestamp.", eventListUsage);
+            events = events.filter((e) => Date.parse(e.createdAt) > afterMs);
+        }
+        const limit = optionalNonEmptyOption(parsed.options, "--limit");
+        if (limit !== undefined) {
+            const n = Number(limit);
+            if (!Number.isSafeInteger(n) || n <= 0)
+                throw usageError("--limit must be a positive integer.", eventListUsage);
+            events = events.slice(-n);
+        }
+        if (events.length === 0) {
+            return output(`No events found for ${task.id}.\n`, { taskId: task.id, events: [] });
+        }
+        const timeZone = store.getConfig().timeZone;
+        return output(`${renderTable(`Events: ${task.id}`, [
+            { header: "Event", minWidth: 8, maxWidth: 18 },
+            { header: "Type", minWidth: 8, maxWidth: 28 },
+            { header: "Created", minWidth: 10, maxWidth: 28 }
+        ], events.map((e) => [e.id, e.type, presentTime(e.createdAt, timeZone)]), defaultTableWidth())}\n`, { taskId: task.id, events });
+    }
+    if (command === "show") {
+        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)
+            throw dataError(`Event not found: ${rest[1]}.`);
+        const timeZone = store.getConfig().timeZone;
+        const capabilitiesCommand = event.type === "runtime.agent-error" && event.payload.roleName
+            ? failureCapabilitiesCommand(task.id, event.payload.roleName, event.id) : undefined;
+        return output([
+            `Event: ${event.id}`,
+            `Task: ${task.id}`,
+            `Type: ${event.type}`,
+            `Created: ${presentTime(event.createdAt, timeZone)}`,
+            ...(capabilitiesCommand === undefined ? [] : [`Inspect capabilities: ${capabilitiesCommand}`]),
+            `Payload:`,
+            ...(Object.keys(event.payload).length === 0
+                ? ["  (none)"]
+                : Object.entries(event.payload).map(([k, v]) => `  ${k}: ${v}`))
+        ].join("\n").concat("\n"), { taskId: task.id, event,
+            ...(capabilitiesCommand === undefined ? {} : { diagnostics: { capabilitiesCommand } }) });
+    }
+    throw usageError(command === undefined
+        ? "Task event command is required."
+        : `Unknown command: task event ${command}`);
+}

package/dist/commands/taskInputCommands.js

@@ -1,12 +1,11 @@
+import { enqueueWork } from "../coordination/workMailboxQueue.js";
 import { dataError, roleNotFound, taskNotFound, usageError } from "../errors/cliError.js";
 import { createTaskEvent } from "../event/taskEvent.js";
-import { activeLiveRoleAgentSession } from "../executor/agentExecutor.js";
 import { answerInputRequest, cancelInputRequest, createInputRequest } from "../input/inputRequest.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
 import { formatTimestamp } from "../output/timePresentation.js";
-import { enqueueWork } from "../coordination/workMailboxQueue.js";
+import { requireManagedTaskCaller, requireManagedGlobalCaller } from "../runtime/managedCaller.js";
 import { isRoleRunStalled, RUN_RECOVERED_EVENT } from "../scheduler/roleRunStall.js";
-import { requireManagedTaskCaller } from "../runtime/managedCaller.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
 const LEADER_ROLE = "leader";
 export function runTaskInputCommand(args, store, options) {
@@ -84,7 +83,7 @@ function createRequest(args, store, options) {
         }, now);
         return created;
     });
-    notifyMailbox(options, { kind: "operator" }, request.taskId);
+    notifyMailbox(options, { kind: "operator" });
     return output(`Created input request ${request.id} for ${request.taskId}\n`, { request });
 }
 function listRequests(args, store) {
@@ -165,7 +164,7 @@ function answerRequest(args, store, options) {
         enqueueWork(tx, { kind: "role", taskId: task.id, roleName: LEADER_ROLE }, `input-answered:${answered.id}`, now, [{ type: "input", taskId: task.id, id: answered.id }]);
         return answered;
     });
-    notifyMailbox(options, { kind: "role", taskId: request.taskId, roleName: LEADER_ROLE }, request.taskId);
+    notifyMailbox(options, { kind: "role", taskId: request.taskId, roleName: LEADER_ROLE });
     return output(`Answered input request ${request.id} for ${request.taskId}\n`, { request });
 }
 function cancelRequest(args, store, options) {
@@ -195,7 +194,7 @@ function cancelRequest(args, store, options) {
         enqueueWork(tx, { kind: "role", taskId: task.id, roleName: LEADER_ROLE }, `input-cancelled:${cancelled.id}`, now, [{ type: "input", taskId: task.id, id: cancelled.id }]);
         return cancelled;
     });
-    notifyMailbox(options, { kind: "role", taskId: request.taskId, roleName: LEADER_ROLE }, request.taskId);
+    notifyMailbox(options, { kind: "role", taskId: request.taskId, roleName: LEADER_ROLE });
     return output(`Cancelled input request ${request.id} for ${request.taskId}\n`, { request });
 }
 function requireLeaderInputOrigin(store, taskId, environment) {
@@ -237,27 +236,13 @@ export function isCurrentGlobalOperator(store, environment) {
         || (environment.YUI_ROLE !== undefined && environment.YUI_ROLE !== "operator")
         || environment.YUI_TASK_ID !== undefined)
         return false;
-    const role = store.getGlobalRole("operator");
-    if (role === null)
-        return false;
-    const binding = role.agentBindings[role.activeAgentId];
-    if (binding === undefined)
-        return false;
-    const sessions = store.getGlobalRoleSessionSet(role.name);
-    const session = activeLiveRoleAgentSession(sessions);
-    if (sessions === null || session === null || sessions.activeAgentId !== role.activeAgentId) {
+    try {
+        requireManagedGlobalCaller(store, { ...environment, YUI_SESSION_SCOPE: "global", YUI_ROLE: "operator" });
+        return true;
+    }
+    catch {
         return false;
     }
-    // The provider's conversation survives Host restarts and entry-point changes.
-    // Prefer its command-time identity over a launch-time environment snapshot.
-    // A launch reservation alone is not a registered Operator conversation.
-    const nativeSessionId = exactIdentity(binding.adapterId === "codex"
-        ? environment.CODEX_THREAD_ID ?? environment.YUI_NATIVE_SESSION_ID
-        : environment.YUI_NATIVE_SESSION_ID);
-    return binding.agentId === session.agentId
-        && binding.adapterId === session.adapterId
-        && nativeSessionId !== undefined
-        && nativeSessionId === session.nativeSessionId;
 }
 function inputAnswerer(environment) {
     const env = environment ?? {};
@@ -400,16 +385,6 @@ function requiredText(value, label) {
         throw usageError(`${label} is required.`);
     return normalized;
 }
-function trimmed(value) {
-    const normalized = value?.trim();
-    return normalized === undefined || normalized.length === 0 ? undefined : normalized;
-}
-function exactIdentity(value) {
-    if (value === undefined || value.includes("\0"))
-        return undefined;
-    const normalized = value.trim();
-    return normalized.length === 0 || normalized !== value ? undefined : normalized;
-}
 function timeoutAfter(now, value) {
     if (!/^[1-9][0-9]*$/.test(value)) {
         throw usageError("--timeout-seconds must be a positive integer.");
@@ -487,11 +462,6 @@ function parseMultiValueTail(args, valueOptions, repeatOptions, usage) {
     }
     return { positionals, options, multiOptions };
 }
-function notifyMailbox(options, target, compatibilityTaskId) {
-    if (options.runtime?.notifyMailboxChanged !== undefined) {
-        options.runtime.notifyMailboxChanged(target);
-    }
-    else {
-        options.runtime?.notifyStateChanged(compatibilityTaskId);
-    }
+function notifyMailbox(options, target) {
+    options.runtime?.notifyMailboxChanged(target);
 }

package/dist/commands/taskIntegrationCommands.js

@@ -1,15 +1,15 @@
-import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
-import { assertProjectActive, resolveProject } from "../repository/project.js";
-import { workspaceProjectEntry } from "../worktree/managedWorkspace.js";
+import { parseRepeatable } from "../cli/parseRepeatable.js";
 import { usageError } from "../errors/cliError.js";
-import { defaultTableWidth, renderTable } from "../output/table.js";
-import { createIntegrationAttempt, recordResolutionDecision, supersedeIntegration } from "../integration/integrationAttempt.js";
 import { GitIntegrationService } from "../integration/gitIntegrationService.js";
+import { createIntegrationAttempt, recordResolutionDecision, supersedeIntegration } from "../integration/integrationAttempt.js";
+import { defaultTableWidth, renderTable } from "../output/table.js";
+import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
+import { assertProjectActive, resolveProject } from "../repository/project.js";
 import { FileTaskWorkspacePreparer } from "../repository/taskWorkspacePreparer.js";
-import { runTaskIntegrationQueueCommand } from "./taskIntegrationQueueCommands.js";
-import { assertTaskDeliveryAuthority as taskLocalActor } from "./taskActor.js";
+import { assertTaskDeliveryAuthority as taskLocalActor } from "../task/taskAuthority.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
 import { governingWorkItemCandidate } from "../workItem/workItem.js";
+import { workspaceProjectEntry } from "../worktree/managedWorkspace.js";
 export async function runTaskIntegrationCommand(args, store, home, options = {}) {
     const now = options.now ?? (() => new Date());
     const [command, ...rest] = args;
@@ -33,9 +33,6 @@ export async function runTaskIntegrationCommand(args, store, home, options = {})
         return list(rest, store);
     if (command === "show")
         return show(rest, store, options.environment);
-    if (command === "queue") {
-        return runTaskIntegrationQueueCommand(rest, store, home, options);
-    }
     throw usageError(command === undefined
         ? "Task Integration command is required."
         : `Unknown command: task integration ${command}`);
@@ -78,8 +75,8 @@ async function cleanupIntegration(args, store, home, environment) {
     };
 }
 async function start(args, store, home, now, options) {
-    const usage = "Task Integration start usage: yui task integration start <task> --work-item <id> --strategy <ff|cherry-pick|merge|manual> [--project <project>] [--target <ref>] [--check <command> ...].";
-    const parsed = parseRepeatable(args, new Set(["--check"]), new Set(["--work-item", "--strategy", "--project", "--target"]), usage);
+    const usage = "Task Integration start usage: yui task integration start <task> --work-item <id> --strategy <ff|cherry-pick|merge|manual> [--project <project>] [--target <ref>] [--check <command> ...] [--rerun-checks].";
+    const parsed = parseRepeatable(args, new Set(["--check"]), new Set(["--work-item", "--strategy", "--project", "--target"]), usage, new Set(["--rerun-checks"]));
     if (parsed.positionals.length !== 1)
         throw usageError(usage);
     let task = store.getTask(parsed.positionals[0]);
@@ -156,7 +153,8 @@ async function start(args, store, home, now, options) {
                 resultCommit,
                 strategy
             },
-            checkCommands: parsed.many.get("--check") ?? []
+            checkCommands: parsed.many.get("--check") ?? [],
+            rerunChecks: parsed.one.has("--rerun-checks")
         }, now());
         tx.saveIntegrationAttempt(task.id, created);
         return created;
@@ -193,7 +191,7 @@ async function runIntegration(store, home, integration, now, options) {
                     : `Integration ${result.attempt.id} failed; inspect its target and preserved evidence\n`;
     return { output, data: result };
 }
-function resolveDecision(args, store, now, environment, home) {
+function resolveDecision(args, store, now, environment, _home) {
     const usage = "Task Integration resolve usage: yui task integration resolve <task>/<integration> --option <manual-resolution|reject> --rationale <text>.";
     const parsed = parseRepeatable(args, new Set(), new Set(["--option", "--rationale"]), usage);
     if (parsed.positionals.length !== 1)
@@ -239,7 +237,7 @@ async function abortIntegration(args, store, now, options, home) {
         data: { integration: settled }
     };
 }
-function supersedeIntegrationCommand(args, store, now, environment, home) {
+function supersedeIntegrationCommand(args, store, now, environment, _home) {
     const usage = "Task Integration supersede usage: yui task integration supersede <task>/<integration> --reason <text>.";
     const parsed = parseRepeatable(args, new Set(), new Set(["--reason"]), usage);
     if (parsed.positionals.length !== 1)
@@ -255,17 +253,6 @@ function supersedeIntegrationCommand(args, store, now, environment, home) {
     // Superseding a committed Integration rewrites delivery-baseline evidence
     // and audit history, so it remains an explicit Task-control decision.
     taskLocalActor(store, environment, integration.taskId);
-    // A queue-backed committed Attempt cannot be superseded: the queue entry
-    // would remain in its current status while its Attempt becomes "superseded",
-    // leaving contradictory terminal records that never converge. This covers
-    // the crash window where the entry is still "running" or "conflicted" after
-    // the Attempt committed.
-    const queueBacked = store.listIntegrationQueueEntries(integration.taskId)
-        .some((entry) => entry.integrationAttemptId === integration.id);
-    if (queueBacked) {
-        throw usageError(`Integration ${integration.id} is backed by a queue entry; `
-            + "reconcile the queue entry instead of superseding its Attempt.");
-    }
     return store.transaction((tx) => {
         const current = tx.getIntegrationAttempt(integration.taskId, integration.id);
         if (current === null) {
@@ -330,6 +317,9 @@ function show(args, store, environment) {
             `Candidate: ${integration.candidateCommit ?? "-"}`,
             `After commit: ${integration.afterCommit ?? "-"}`,
             `Job: ${integration.jobId ?? "-"}`,
+            `Check execution: ${integration.rerunChecks ? "explicit rerun"
+                : integration.checkCommands.length > 0 ? "explicit check commands"
+                    : "reuse exact successful evidence when available"}`,
             `Source: ${integrationSourceLabel(integration)}`,
             `Status: ${integration.status}`,
             `Summary: ${integration.summary ?? "-"}`,
@@ -353,9 +343,7 @@ function integrationSourceLabel(integration) {
     if (integration.source.kind === "work-item") {
         return `work-item:${integration.source.workItemId}@${integration.source.resultCommit.slice(0, 12)}`;
     }
-    return integration.source.kind === "upstream"
-        ? `upstream:${integration.source.branch}@${integration.source.remoteCommit.slice(0, 12)}`
-        : `historical:${integration.source.changeSetIds.join(",")}`;
+    return `upstream:${integration.source.branch}@${integration.source.remoteCommit.slice(0, 12)}`;
 }
 function requireIntegration(store, value, environment) {
     let reference;
@@ -375,31 +363,3 @@ function requireIntegration(store, value, environment) {
     }
     return attempt;
 }
-export function parseRepeatable(args, repeatable, singular, usage) {
-    const positionals = [];
-    const many = new Map();
-    const one = new Map();
-    for (let index = 0; index < args.length; index += 1) {
-        const value = args[index];
-        if (!value.startsWith("--")) {
-            positionals.push(value);
-            continue;
-        }
-        if (!repeatable.has(value) && !singular.has(value)) {
-            throw usageError(`Unsupported option: ${value}.`, usage);
-        }
-        if (singular.has(value) && one.has(value)) {
-            throw usageError(`Option may only be specified once: ${value}.`, usage);
-        }
-        const optionValue = args[index + 1];
-        if (optionValue === undefined || optionValue.startsWith("--")) {
-            throw usageError(`${value} is required.`, usage);
-        }
-        if (repeatable.has(value))
-            many.set(value, [...(many.get(value) ?? []), optionValue]);
-        else
-            one.set(value, optionValue);
-        index += 1;
-    }
-    return { positionals, many, one };
-}

package/dist/commands/taskNextActionCommand.js

@@ -1,11 +1,12 @@
 import { taskNotFound, usageError } from "../errors/cliError.js";
-import { projectNextAction } from "../task/nextAction.js";
-import { projectCompletionReadiness } from "../task/completionReadiness.js";
 import { projectTaskOrchestration } from "../observability/orchestrationMetrics.js";
-import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
-import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
 import { projectReviewDecision } from "../review/reviewDecision.js";
-import { projectTaskRemoteDeliveryFromStore, renderTaskRemoteDelivery } from "./taskRemoteDeliveryCommand.js";
+import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
+import { projectCompletionReadiness } from "../task/completionReadiness.js";
+import { projectNextAction } from "../task/nextAction.js";
+import { projectTaskRemoteDeliveryFromStore } from "../task/remoteDeliveryService.js";
+import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
+import { renderTaskRemoteDelivery } from "./taskRemoteDeliveryCommand.js";
 /**
  * Issue 07 (Leader convergence): read-only `yui task next-action <task>`.
  * Folds the existing durable records into exactly one protocol-level next
@@ -34,7 +35,7 @@ export function runTaskNextActionCommand(args, store, currentTaskReviewCandidate
         const facts = reader.readNextActionFacts(taskId);
         if (facts === null)
             throw taskNotFound(taskId);
-        const execution = buildTaskExecutionProjection(reader, taskId, undefined, now);
+        const execution = buildTaskExecutionProjection(reader, taskId, now);
         if (execution === null)
             throw taskNotFound(taskId);
         const actionFacts = {

package/dist/commands/taskPublicationAdoptCommand.js

@@ -1,15 +1,15 @@
 import { createHash } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
+import { parseRepeatable } from "../cli/parseRepeatable.js";
 import { contextContentDigest } from "../context/contextSnapshot.js";
-import { createTaskEvent } from "../event/taskEvent.js";
 import { usageError } from "../errors/cliError.js";
+import { createTaskEvent } from "../event/taskEvent.js";
 import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
 import { PUBLICATION_ADOPTED_EVENT, publicationAdoption } from "../task/publicationAdoption.js";
 import { publicationExternalKey } from "../task/publicationReference.js";
 import { commitMap, completionEvent } from "../task/remoteDelivery.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
-import { assertTaskDeliveryAuthority, taskActor } from "./taskActor.js";
-import { parseRepeatable } from "./taskIntegrationCommands.js";
+import { assertTaskDeliveryAuthority, taskActor } from "../task/taskAuthority.js";
 /** Local read -> explicit semantic adoption of those exact bytes. No Git writes,
  * provider reads, completion rewrite or implicit acceptance of Integration. */
 export async function runTaskPublicationAdoptCommand(args, store, options = {}) {