@zq-silk/yui 0.12.4 → 0.13.0

package/dist/commands/taskCommands.js

@@ -30,7 +30,7 @@ import { buildDeltaRecheckDispatchContext, verifyDeltaRecheckDiff } from "../rev
 import { isAcceptedTaskReviewBaseline } from "../review/reviewAcceptance.js";
 import { projectReviewerAvailability } from "../review/reviewerAvailability.js";
 import { buildTaskFinalReviewFindingContext, dispositionReviewFinding, planRepairGroups, reconcileReviewFindings, reconcileReviewFindingsAfterReview } from "../review/reviewFindingLedger.js";
-import { LEADER_FINDING_DISPOSITIONS } from "../review/reviewFinding.js";
+import { TASK_CONTROL_FINDING_DISPOSITIONS } from "../review/reviewFinding.js";
 import { createTaskBrief, updateTaskBrief } from "../brief/taskBrief.js";
 import { createDecision, supersedeDecision } from "../decision/decision.js";
 import { createMilestone } from "../milestone/milestone.js";
@@ -42,7 +42,6 @@ import { blockingProviderContinuations, projectProviderContinuations, runOwnsBlo
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { addTaskProjectBinding, archiveTask, completeTask, createTask, retireTask, reopenTask, updateTaskMetadata } from "../task/task.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
-import { TASK_COMPLETION_PUBLISHED_TREE_AUTHORIZED_EVENT } from "../task/publicationReference.js";
 import { projectCompletionReadiness } from "../task/completionReadiness.js";
 import { assertProjectActive, resolveProject } from "../repository/project.js";
 import { acquireProjectMaintenanceLocks } from "../repository/projectMaintenanceLock.js";
@@ -203,9 +202,6 @@ export function preflightTaskCompletion(taskId, store, options = {}, request = {
         .filter((entry) => entry.run !== null);
     const leaderEntry = activeRuns.find(({ role }) => role.name === LEADER_ROLE);
     if (leaderEntry !== undefined) {
-        if (actor !== "leader") {
-            throw usageError(`Task ${task.id} has an active Leader run.`);
-        }
         if (leaderEntry.run.workItemId !== undefined) {
             throw usageError(`Task ${task.id} has running work: ${leaderEntry.run.workItemId}.`);
         }
@@ -381,9 +377,7 @@ function taskProjectCommand(args, store, options) {
     const updated = store.transaction((tx) => {
         const task = requireTask(tx, parsed.positionals[0]);
         assertTaskOpen(task);
-        if (task.status === "active" && taskActor(tx, options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may add a Project to an active Task.");
-        }
+        taskActor(tx, options, task.id);
         const project = resolveProject(tx.listProjects(), parsed.positionals[1]);
         if (project === null)
             throw usageError(`Project not found: ${parsed.positionals[1]}.`);
@@ -723,8 +717,7 @@ function completeTaskCommand(args, store, options) {
                 changed: false,
                 runtimeCleanupTargets: [],
                 completionAdvisories: [],
-                finalReview: undefined,
-                publishedTreeAuthorization: undefined
+                finalReview: undefined
             };
         }
         const taskFinalContract = preflight.taskFinalReviewContract;
@@ -734,28 +727,6 @@ function completeTaskCommand(args, store, options) {
         const publishedTreeProof = request.acceptedPublishedTreePublicationId === undefined
             ? undefined
             : assertTaskCompletionPublishedTreeProof(tx, task, request.acceptedPublishedTreePublicationId, options.completionPublishedTreeProof, actualTaskCandidate);
-        const requiresContractHandoff = publishedTreeProof !== undefined
-            && taskFinalContract !== undefined;
-        if (requiresContractHandoff && actor !== "leader") {
-            const existing = matchingPublishedTreeAuthorization(tx, publishedTreeProof);
-            const event = existing ?? recordTaskEventRecord(tx, task.id, TASK_COMPLETION_PUBLISHED_TREE_AUTHORIZED_EVENT, publishedTreeAuthorizationPayload(actor, publishedTreeProof), now);
-            enqueueWork(tx, leaderMailbox(task.id), wakeReason("published-tree-authorized", event.id), now, [eventRef(task.id, event.id)]);
-            return {
-                task,
-                changed: false,
-                runtimeCleanupTargets: [],
-                completionAdvisories: [],
-                finalReview: undefined,
-                publishedTreeAuthorization: {
-                    event,
-                    proof: publishedTreeProof,
-                    created: existing === undefined
-                }
-            };
-        }
-        if (publishedTreeProof !== undefined && actor === "leader") {
-            requirePublishedTreeAuthorization(tx, publishedTreeProof);
-        }
         const roles = tx.listRoles(task.id);
         const activeRuns = roles
             .map((role) => ({ role, run: tx.getActiveAgentRun(task.id, role.name) }))
@@ -766,9 +737,6 @@ function completeTaskCommand(args, store, options) {
         // the post-Review readiness fence below.
         const leaderEntry = activeRuns.find(({ role }) => role.name === LEADER_ROLE);
         if (leaderEntry !== undefined) {
-            if (actor !== "leader") {
-                throw usageError(`Task ${task.id} has an active Leader run.`);
-            }
             if (leaderEntry.run.workItemId !== undefined) {
                 throw usageError(`Task ${task.id} has running work: ${leaderEntry.run.workItemId}.`);
             }
@@ -799,7 +767,6 @@ function completeTaskCommand(args, store, options) {
                 runtimeCleanupTargets: [],
                 completionAdvisories: [],
                 finalReview,
-                publishedTreeAuthorization: undefined
             };
         }
         // Issue 06: re-validate the full completion readiness inside the
@@ -863,21 +830,9 @@ function completeTaskCommand(args, store, options) {
             changed: true,
             runtimeCleanupTargets,
             completionAdvisories: readiness.advisories,
-            finalReview: undefined,
-            publishedTreeAuthorization: undefined
+            finalReview: undefined
         };
     });
-    if (result.publishedTreeAuthorization !== undefined) {
-        notifyMailbox(options.runtime, leaderMailbox(result.task.id), result.task.id);
-        const authorization = result.publishedTreeAuthorization;
-        return output(authorization.created
-            ? `Authorized published-tree completion for ${result.task.id} as ${authorization.event.id}; exact Task Leader completion is required.\n`
-            : `Published-tree completion is already authorized for ${result.task.id} as ${authorization.event.id}; exact Task Leader completion is required.\n`, {
-            task: result.task,
-            authorizationEvent: authorization.event,
-            publishedTreeProof: authorization.proof
-        });
-    }
     if (result.changed) {
         for (const target of result.runtimeCleanupTargets) {
             // Cleanup owns an independent lifecycle lane. Never fall back to the
@@ -1147,10 +1102,7 @@ export function parseTaskArchiveArguments(args) {
 export function validateTaskArchiveRequest(args, store, options = {}) {
     const request = parseTaskArchiveArguments(args);
     const task = requireTask(store, request.taskId);
-    const actor = taskActor(store, options, task.id);
-    if (actor === "leader") {
-        throw usageError("Only the global Operator may archive a Task from a managed Session.");
-    }
+    taskActor(store, options, task.id);
     if (task.status !== "archived"
         && task.status !== "completed"
         && task.status !== "retired") {
@@ -1954,9 +1906,7 @@ function updateWorkScope(args, store, options) {
     const updated = store.transaction((tx) => {
         const item = requireWorkItem(tx, parsed.positionals[0], options);
         const task = requireTask(tx, item.taskId);
-        if (taskActor(tx, options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may change a Work Item Project scope.");
-        }
+        taskActor(tx, options, task.id);
         if (tx.getActiveAgentRun(task.id, item.assignee ?? "") !== null) {
             throw usageError(`Stop the active Work Item Run before changing scope: ${item.id}.`);
         }
@@ -2004,9 +1954,7 @@ function updateWork(args, store, options) {
         const task = requireTask(tx, current.taskId);
         assertTaskOpen(task);
         if (current.assignee === undefined) {
-            if (taskActor(tx, options, task.id) !== "leader") {
-                throw usageError(`Only the Task Leader may update unassigned Work Item execution: ${current.id}.`);
-            }
+            taskActor(tx, options, task.id);
             if (status === "running") {
                 assertWorkItemDependenciesCompleted(tx, current);
             }
@@ -2199,9 +2147,8 @@ function dispatchWork(args, store, options) {
                 + `The Task Leader must run "yui task work update ${item.id} running", `
                 + "then execute it directly or create native subagents in the Leader Session.");
         }
-        if (expanding && taskActor(tx, options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may expand a running ExecutionGroup.");
-        }
+        if (expanding)
+            taskActor(tx, options, task.id);
         assertWorkItemDependenciesCompleted(tx, item);
         const workspace = tx.getWorkItemWorkspace(task.id, item.id);
         if (workspace?.owner.type === "work-item"
@@ -2581,9 +2528,7 @@ function resolveWorkExecutionGroup(args, store, options) {
         const task = requireTask(tx, item.taskId);
         if (task.status !== "active")
             throw usageError(inactiveTaskMessage(task, "resolving an ExecutionGroup"));
-        if (taskActor(tx, options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may resolve an ExecutionGroup.");
-        }
+        taskActor(tx, options, task.id);
         let group = currentWorkItemExecutionGroup(item);
         if (group === undefined
             || (group.stage === undefined
@@ -2815,9 +2760,7 @@ function acceptWork(args, store, options) {
         if (task.status !== "active") {
             throw usageError(`Task is not active: ${task.id}/${task.status}.`);
         }
-        if (taskActor(tx, options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may accept a Work Item.");
-        }
+        const actor = taskActor(tx, options, task.id);
         if (item.status !== "awaiting_acceptance") {
             throw usageError(`Work Item is not awaiting acceptance: ${item.id}/${item.status}.`);
         }
@@ -2876,9 +2819,9 @@ function acceptWork(args, store, options) {
             ...(candidate.source.type === "run"
                 ? { runId: candidate.source.runId }
                 : { workItemRevision: String(candidate.workItemRevision) }),
-            acceptedBy: "leader",
+            acceptedBy: actor,
             summary,
-            ...leaderActionEventPayload(tx, item.taskId, options)
+            ...(actor === "leader" ? leaderActionEventPayload(tx, item.taskId, options) : {})
         }, now);
         return completed;
     });
@@ -2938,9 +2881,7 @@ function rejectWork(args, store, options) {
         if (task.status !== "active") {
             throw usageError(`Task is not active: ${task.id}/${task.status}.`);
         }
-        if (taskActor(tx, options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may reject a Work Item.");
-        }
+        const actor = taskActor(tx, options, task.id);
         if (item.status !== "awaiting_acceptance") {
             throw usageError(`Work Item is not awaiting acceptance: ${item.id}/${item.status}.`);
         }
@@ -2954,7 +2895,7 @@ function rejectWork(args, store, options) {
         recordTaskEvent(tx, item.taskId, "work.rejected", {
             workItemId: item.id,
             candidateId: candidate.id,
-            rejectedBy: "leader",
+            rejectedBy: actor,
             summary
         }, now);
         return failed;
@@ -3097,9 +3038,7 @@ function reviewWork(args, store, options) {
         if (task.status !== "active") {
             throw usageError(`Task is not active: ${task.id}/${task.status}.`);
         }
-        if (taskActor(tx, options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may request a Work Item review.");
-        }
+        const requestedBy = taskActor(tx, options, task.id);
         if (item.status !== "awaiting_acceptance") {
             throw usageError(`Work Item is not awaiting acceptance: ${item.id}/${item.status}.`);
         }
@@ -3126,7 +3065,7 @@ function reviewWork(args, store, options) {
             }
             throw usageError(`ReviewRound is already active: ${activeRound.id}/${activeRound.status}.`);
         }
-        const queued = queueReviewRound(tx, item, config, "leader", now);
+        const queued = queueReviewRound(tx, item, config, requestedBy, now);
         return { ...queued, resumed: false };
     });
     if (result.run !== null) {
@@ -3140,7 +3079,7 @@ function reviewWork(args, store, options) {
         : output(`Review requested as ${result.round.id}\n`, { reviewRound: result.round });
 }
 /**
- * Leader-controlled recovery for a failed Task-final ReviewRound that never
+ * Task-control recovery for a failed Task-final ReviewRound that never
  * created a Reviewer Run. This is deliberately separate from `task run retry`:
  * that command requires an exact failed Agent Run and remains the only retry
  * path for a failed provider execution. Here the old terminal Round is an
@@ -3290,9 +3229,7 @@ function resolveReviewExecutionGroup(args, store, options) {
         const task = requireTask(tx, round.taskId);
         if (task.status !== "active")
             throw usageError(inactiveTaskMessage(task, "resolving a Review ExecutionGroup"));
-        if (taskActor(tx, options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may resolve a Reviewer ExecutionGroup.");
-        }
+        taskActor(tx, options, task.id);
         const group = round.executionGroup;
         if (group === undefined
             || (group.lanes.length < 2 && group.strategy.mode !== "adaptive")) {
@@ -3411,7 +3348,7 @@ function disposeReviewFindingCommand(args, store, options) {
     const parsed = parseTail(args, new Set(["--disposition", "--work-item", "--commit", "--verification", "--note", "--superseded-by"]), usage);
     exactPositionals(parsed.positionals, 1, usage);
     const disposition = requiredOption(parsed.options, "--disposition");
-    if (!LEADER_FINDING_DISPOSITIONS.includes(disposition)) {
+    if (!TASK_CONTROL_FINDING_DISPOSITIONS.includes(disposition)) {
         throw usageError(`Review finding disposition is invalid: ${disposition}.`);
     }
     const now = clock(options);
@@ -3423,12 +3360,12 @@ function disposeReviewFindingCommand(args, store, options) {
         const task = requireTask(tx, reference.taskId);
         if (task.status !== "active")
             throw usageError(inactiveTaskMessage(task, "dispositioning a review finding"));
-        if (taskActor(tx, options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may disposition a review finding.");
-        }
+        const actor = taskActor(tx, options, task.id);
         const command = {
             disposition,
-            by: taskLeaderActionRunId(tx, task.id, options.environment, options.yuiHome) ?? "leader",
+            by: actor === "leader"
+                ? taskLeaderActionRunId(tx, task.id, options.environment, options.yuiHome) ?? actor
+                : actor,
             ...(parsed.options.get("--note") === undefined ? {} : { note: parsed.options.get("--note") }),
             ...(parsed.options.get("--work-item") === undefined ? {} : { workItemId: parsed.options.get("--work-item") }),
             ...(parsed.options.get("--commit") === undefined ? {} : { commit: parsed.options.get("--commit") }),
@@ -3460,9 +3397,7 @@ function planReviewRepairWave(args, store, options) {
             if (currentTask.status !== "active") {
                 throw usageError(inactiveTaskMessage(currentTask, "creating a review repair wave"));
             }
-            if (taskActor(tx, options, currentTask.id) !== "leader") {
-                throw usageError("Only the Task Leader may create a review repair wave.");
-            }
+            taskActor(tx, options, currentTask.id);
             const openItems = tx.listWorkItems(currentTask.id)
                 .filter((item) => item.status === "pending" || item.status === "running");
             return groups.map((group) => {
@@ -3561,9 +3496,7 @@ function requestTaskReviewRound(args, store, options) {
         const task = requireTask(tx, parsed.positionals[0]);
         if (task.status !== "active")
             throw usageError(`Task is not active: ${task.id}.`);
-        if (taskActor(tx, options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may request a Task-final Review.");
-        }
+        const requestedBy = taskActor(tx, options, task.id);
         if (task.projectBindings.length === 0) {
             throw usageError(`Task ${task.id} has no bound Projects for a Task-final Review.`);
         }
@@ -3715,8 +3648,8 @@ function requestTaskReviewRound(args, store, options) {
             deltaRecord = validateDeltaRecheckRequest(tx, task.id, provenance.candidate, options.deltaRecheckPreflight);
         }
         let created = deltaRecord === undefined
-            ? createTaskReviewRound(tx.nextReviewRoundId(task.id), task.id, reviewerRoleName, "leader", provenance.candidate, now, taskFinalContract)
-            : createTaskDeltaReviewRound(tx.nextReviewRoundId(task.id), task.id, reviewerRoleName, "leader", provenance.candidate, deltaRecord, now, taskFinalContract);
+            ? createTaskReviewRound(tx.nextReviewRoundId(task.id), task.id, reviewerRoleName, requestedBy, provenance.candidate, now, taskFinalContract)
+            : createTaskDeltaReviewRound(tx.nextReviewRoundId(task.id), task.id, reviewerRoleName, requestedBy, provenance.candidate, deltaRecord, now, taskFinalContract);
         let group = createExecutionGroup(`execution-group-${created.id}`, task.id, {
             purpose: "review",
             target: executionTargetForReviewRound(task, created),
@@ -3792,9 +3725,7 @@ function forceFreshTaskReviewRound(args, store, options) {
         const task = requireTask(tx, reference.taskId);
         if (task.status !== "active")
             throw usageError(`Task is not active: ${task.id}.`);
-        if (taskActor(tx, options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may force a fresh Task-final ReviewRound.");
-        }
+        const requestedBy = taskActor(tx, options, task.id);
         if ((source.scope ?? "work-item") !== "task") {
             throw usageError(`ReviewRound ${source.id} is not a Task-final ReviewRound.`);
         }
@@ -3868,7 +3799,7 @@ function forceFreshTaskReviewRound(args, store, options) {
             reviewer = createTaskRole(tx, task, source.reviewerRoleName, undefined, now, source.reviewerRoleName);
             tx.saveRole(task.id, reviewer);
         }
-        let created = createTaskReviewRound(tx.nextReviewRoundId(task.id), task.id, source.reviewerRoleName, "leader", source.taskCandidate, now, taskFinalContract);
+        let created = createTaskReviewRound(tx.nextReviewRoundId(task.id), task.id, source.reviewerRoleName, requestedBy, source.taskCandidate, now, taskFinalContract);
         const group = createExecutionGroup(`execution-group-${created.id}`, task.id, {
             purpose: "review",
             target: executionTargetForReviewRound(task, created),
@@ -3884,7 +3815,8 @@ function forceFreshTaskReviewRound(args, store, options) {
             reviewerRoleName: created.reviewerRoleName,
             taskCandidate: JSON.stringify(created.taskCandidate),
             reason: "source-round-terminal-without-semantic-review",
-            leaderActionRunId: taskLeaderActionRunId(tx, task.id, options.environment, options.yuiHome) ?? "leader"
+            requestedBy,
+            ...(requestedBy === "leader" ? leaderActionEventPayload(tx, task.id, options) : {})
         }, now);
         return { round: created, source, created: true };
     });
@@ -4004,9 +3936,7 @@ function retryFailedTaskReviewRound(args, store, options) {
         const task = requireTask(tx, reference.taskId);
         if (task.status !== "active")
             throw usageError(`Task is not active: ${task.id}.`);
-        if (taskActor(tx, options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may retry a failed Task-final ReviewRound.");
-        }
+        const requestedBy = taskActor(tx, options, task.id);
         if ((round.scope ?? "work-item") !== "task") {
             throw usageError(`ReviewRound ${round.id} is not a failed Task-final ReviewRound.`);
         }
@@ -4088,7 +4018,7 @@ function retryFailedTaskReviewRound(args, store, options) {
         // Issue 06: infra retry resets the same semantic Round to pending instead
         // of manufacturing a new Round, so Round count and finding identity stay
         // stable across execution-attempt failures.
-        const resetRound = retryTaskReviewRound(round);
+        const resetRound = retryTaskReviewRound(round, requestedBy);
         tx.saveReviewRound(task.id, resetRound);
         recordTaskEvent(tx, task.id, "review.task-final-retried", {
             reviewRoundId: round.id
@@ -4350,9 +4280,7 @@ function settleStaleFinalReviewRun(args, store, options) {
         const task = requireTask(tx, run.taskId);
         if (task.status !== "active")
             throw usageError(`Task is not active: ${task.id}.`);
-        if (taskActor(tx, options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may settle a stale final review Run.");
-        }
+        const actor = taskActor(tx, options, task.id);
         const round = tx.getReviewRound(task.id, run.reviewRoundId);
         if (round === null) {
             throw dataError(`ReviewRound not found for run ${run.id}: ${run.reviewRoundId}.`);
@@ -4461,7 +4389,9 @@ function settleStaleFinalReviewRun(args, store, options) {
             runId: run.id,
             reviewRoundId: round.id,
             previousTaskCandidate: JSON.stringify(round.taskCandidate),
-            currentTaskCandidate: JSON.stringify(currentTaskCandidate)
+            currentTaskCandidate: JSON.stringify(currentTaskCandidate),
+            settledBy: actor,
+            ...(actor === "leader" ? leaderActionEventPayload(tx, task.id, options) : {})
         }, now);
         return { run, round: terminal, changed: true };
     });
@@ -5012,7 +4942,7 @@ function assertPendingFinalReviewWorkspaceEvidence(store, task, round) {
     }
 }
 /**
- * Leader-only retry of an exact failed Task-final review Run. The old failed
+ * Task-control retry of an exact failed Task-final review Run. The old failed
  * Run remains the attempt trail, while the semantic ReviewRound is reset to
  * pending under its existing identity. Every identity and frozen-head fence is
  * checked inside one transaction so a partial fail-old-without-reset state can
@@ -5039,9 +4969,7 @@ function retryFailedReviewRun(previous, store, options, now) {
             throw usageError(`Review Run ${run.id} still owns an unsettled Provider continuation; `
                 + "reconcile it before retrying the Lane.");
         }
-        if (taskActor(tx, options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may retry a failed final review Run.");
-        }
+        const requestedBy = taskActor(tx, options, task.id);
         const round = tx.getReviewRound(task.id, run.reviewRoundId);
         if (round === null) {
             throw dataError(`ReviewRound not found for run ${run.id}: ${run.reviewRoundId}.`);
@@ -5221,7 +5149,7 @@ function retryFailedReviewRun(previous, store, options, now) {
         // Issue 06: infra retry resets the same semantic Round to pending instead
         // of manufacturing a new Round, so Round count and finding identity stay
         // stable across execution-attempt failures.
-        const resetRound = retryTaskReviewRound(roundToReset, run.executionLaneId);
+        const resetRound = retryTaskReviewRound(roundToReset, requestedBy, run.executionLaneId);
         tx.saveReviewRound(task.id, resetRound);
         recordTaskEvent(tx, task.id, "run.review-retried", {
             runId: run.id,
@@ -5266,9 +5194,7 @@ function recoverRun(args, store, options) {
         const task = requireTask(tx, active.taskId);
         if (task.status !== "active")
             throw usageError(inactiveTaskMessage(task, "recovering a run"));
-        if (taskActor(tx, options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may control exact Agent Run recovery.");
-        }
+        taskActor(tx, options, task.id);
         const roleName = parsed.options.get("--role") ?? active.roleName;
         if (roleName !== active.roleName) {
             throw usageError(`Recovery Role does not match Run ${active.id}: ${roleName}.`);
@@ -6559,52 +6485,6 @@ function recordTaskEventRecord(store, taskId, type, payload, now) {
     store.saveEvent(taskId, event);
     return event;
 }
-function publishedTreeAuthorizationPayload(actor, proof) {
-    return {
-        by: actor,
-        projectId: proof.projectId,
-        publicationId: proof.publicationId,
-        ...(proof.reviewRoundId === undefined
-            ? { reviewAnchor: publishedTreeReviewAnchor(proof) }
-            : { reviewRoundId: proof.reviewRoundId }),
-        localCommit: proof.localCommit,
-        remoteCommit: proof.remoteCommit,
-        tree: proof.tree
-    };
-}
-function matchingPublishedTreeAuthorization(store, proof) {
-    const events = store.listEvents(proof.taskId);
-    for (let index = events.length - 1; index >= 0; index -= 1) {
-        const event = events[index];
-        if (event.type === "task.completed" || event.type === "task.reopened")
-            return undefined;
-        if (event.type === TASK_COMPLETION_PUBLISHED_TREE_AUTHORIZED_EVENT
-            && (event.payload.by === "user" || event.payload.by === "operator")
-            && event.payload.projectId === proof.projectId
-            && event.payload.publicationId === proof.publicationId
-            && (event.payload.reviewAnchor ?? event.payload.reviewRoundId)
-                === publishedTreeReviewAnchor(proof)
-            && event.payload.localCommit === proof.localCommit
-            && event.payload.remoteCommit === proof.remoteCommit
-            && event.payload.tree === proof.tree) {
-            return event;
-        }
-    }
-    return undefined;
-}
-function requirePublishedTreeAuthorization(store, proof) {
-    const authorization = matchingPublishedTreeAuthorization(store, proof);
-    if (authorization === undefined) {
-        throw usageError(`Published-tree completion requires explicit user or global Operator authorization for `
-            + `${proof.taskId}/${proof.publicationId} at ${proof.reviewRoundId === undefined
-                ? "the Leader-owned Task-main head"
-                : `Task-final Review ${proof.reviewRoundId}`}.`);
-    }
-    return authorization;
-}
-function publishedTreeReviewAnchor(proof) {
-    return proof.reviewRoundId ?? "direct";
-}
 /** Keeps a free-text run-fact note bounded so an event payload stays compact. */
 function truncateEventNote(note) {
     const normalized = note.trim();
@@ -7083,10 +6963,8 @@ function taskMilestoneCommand(args, store, options) {
         const result = store.transaction((tx) => {
             const task = requireTask(tx, parsed.positionals[0]);
             assertTaskOpen(task);
-            if (taskActor(tx, options, task.id) !== "leader") {
-                throw usageError("Only the Task Leader can add a Milestone.");
-            }
-            const milestone = createMilestone(tx.nextMilestoneId(task.id), task.id, title, summary, now);
+            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,

package/dist/commands/taskIntegrationCommands.js

@@ -183,7 +183,7 @@ async function runIntegration(store, home, integration, now, options) {
     const output = result.status === "committed"
         ? `Integrated ${result.attempt.changeSetIds.join(", ")} into ${result.attempt.targetRef} with CAS (${result.attempt.id})\n`
         : result.status === "blocked"
-            ? `Integration ${result.attempt.id} requires a Leader resolution decision in ${result.workspace.path}\n`
+            ? `Integration ${result.attempt.id} requires a Task Agent resolution decision in ${result.workspace.path}\n`
             : result.status === "checks-running"
                 ? `Integration ${result.attempt.id} checks are running as DurableJob ${result.job.id}; run 'yui task integration continue ${result.attempt.taskId}/${result.attempt.id}' when the job finishes\n`
                 : `Integration ${result.attempt.id} failed; target ref was not advanced\n`;
@@ -201,20 +201,18 @@ function resolveDecision(args, store, now, environment, home) {
     const resolved = store.transaction((tx) => {
         const integration = requireIntegration(tx, parsed.positionals[0], environment);
         const task = requireActiveIntegrationTask(tx, integration);
-        if (taskLocalActor(tx, environment, task.id, home) !== "leader") {
-            throw usageError("Only the Task Leader can resolve an Integration conflict.");
-        }
+        const actor = taskLocalActor(tx, environment, task.id, home);
         const updated = recordResolutionDecision(integration, {
             action: selectedOption,
             rationale
-        }, now());
+        }, actor, now());
         tx.saveIntegrationAttempt(updated.taskId, updated);
         return updated;
     });
     return {
         output: selectedOption === "manual-resolution"
-            ? `Leader selected manual resolution for ${resolved.id}; resolve its candidate worktree, then run integration continue\n`
-            : `Leader rejected Integration ${resolved.id}\n`,
+            ? `Selected manual resolution for ${resolved.id}; resolve its candidate worktree, then run integration continue\n`
+            : `Rejected Integration ${resolved.id}\n`,
         data: { integration: resolved }
     };
 }
@@ -275,8 +273,8 @@ function supersedeIntegrationCommand(args, store, now, environment, home) {
     const reason = parsed.one.get("--reason");
     if (reason === undefined)
         throw usageError(usage);
-    // Only the Task Leader (or Operator/user) may supersede a committed
-    // Integration: it rewrites delivery-baseline evidence and audit history.
+    // Superseding a committed Integration rewrites delivery-baseline evidence
+    // and audit history, so it remains an explicit Task-control decision.
     taskLocalActor(store, environment, integration.taskId, home);
     // A queue-backed committed Attempt cannot be superseded: the queue entry
     // would remain in its current status while its Attempt becomes "superseded",

package/dist/commands/taskIntegrationQueueCommands.js

@@ -37,7 +37,7 @@ async function enqueue(args, store, options, home) {
     if (parsed.positionals.length !== 1)
         throw usageError(usage);
     const task = requireActiveTask(store, parsed.positionals[0]);
-    requireLeader(store, options.environment, task.id, home);
+    requireTaskControlActor(store, options.environment, task.id, home);
     const projectRef = parsed.one.get("--project");
     const changeSetId = parsed.one.get("--change-set");
     if (projectRef === undefined || changeSetId === undefined)
@@ -120,7 +120,7 @@ async function process(args, store, home, options) {
     if (parsed.positionals.length !== 1)
         throw usageError(usage);
     const task = requireActiveTask(store, parsed.positionals[0]);
-    requireLeader(store, options.environment, task.id, home);
+    requireTaskControlActor(store, options.environment, task.id, home);
     const limitValue = parsed.one.get("--limit");
     const limit = limitValue === undefined ? undefined : Number.parseInt(limitValue, 10);
     if (limitValue !== undefined && (!Number.isSafeInteger(limit) || limit < 1)) {
@@ -154,11 +154,11 @@ function supersede(args, store, options, home) {
     if (parsed.positionals.length !== 1)
         throw usageError(usage);
     const entry = requireQueueEntry(store, parsed.positionals[0], options.environment);
-    requireLeader(store, options.environment, entry.taskId, home);
+    const actor = requireTaskControlActor(store, options.environment, entry.taskId, home);
     const reason = parsed.one.get("--reason");
     if (reason === undefined)
         throw usageError(usage);
-    const superseded = supersedeIntegrationQueueEntry(store, entry.taskId, entry.id, reason, options.now ?? (() => new Date()));
+    const superseded = supersedeIntegrationQueueEntry(store, entry.taskId, entry.id, reason, actor, options.now ?? (() => new Date()));
     return {
         output: `Superseded ${superseded.id}: ${reason}\n`,
         data: { entry: superseded }
@@ -169,8 +169,8 @@ function requeue(args, store, options, home) {
     if (args.length !== 1)
         throw usageError(usage);
     const entry = requireQueueEntry(store, args[0], options.environment);
-    requireLeader(store, options.environment, entry.taskId, home);
-    const waiting = requeueIntegrationQueueEntry(store, entry.taskId, entry.id, options.now ?? (() => new Date()));
+    const actor = requireTaskControlActor(store, options.environment, entry.taskId, home);
+    const waiting = requeueIntegrationQueueEntry(store, entry.taskId, entry.id, actor, options.now ?? (() => new Date()));
     return {
         output: `Requeued ${waiting.id}; it will be processed again on the next queue run\n`,
         data: { entry: waiting }
@@ -181,7 +181,7 @@ async function reconcile(args, store, options, home) {
     if (args.length !== 1)
         throw usageError(usage);
     const entry = requireQueueEntry(store, args[0], options.environment);
-    requireLeader(store, options.environment, entry.taskId, home);
+    requireTaskControlActor(store, options.environment, entry.taskId, home);
     const committed = await reconcileIntegrationQueueEntry(store, entry.taskId, entry.id, new NodeGitWorkspace(), options.now ?? (() => new Date()));
     return {
         output: `Reconciled ${committed.id} as committed -> ${committed.targetAfter ?? "-"}\n`,
@@ -221,8 +221,6 @@ function requireQueueEntry(store, value, environment) {
     }
     return entry;
 }
-function requireLeader(store, environment, taskId, home) {
-    if (taskLocalActor(store, environment, taskId, home) !== "leader") {
-        throw usageError("Only the Task Leader can change the integration queue.");
-    }
+function requireTaskControlActor(store, environment, taskId, home) {
+    return taskLocalActor(store, environment, taskId, home);
 }

package/dist/commands/taskPublicationCommands.js

@@ -34,10 +34,6 @@ function addPublication(args, store, options) {
         throw usageError(`Project is not bound to Task ${task.id}: ${projectReference}.`, usage);
     }
     const actor = taskActor(options.environment, task.id);
-    if (actor === "leader") {
-        throw usageError("A managed Task Leader cannot record external publication evidence; "
-            + "use a user or global Operator session.", usage);
-    }
     const state = enumOption(parsed.options, "--state", STATES, usage) ?? "open";
     const verification = parseVerification(parsed, usage);
     const input = {

package/dist/commands/taskWorkspaceCommands.js

@@ -135,7 +135,7 @@ function replaceTaskCommand(args, store, options) {
     }
     const now = options.now?.() ?? new Date();
     const milestone = createMilestone(store.nextMilestoneId(replacement.id), replacement.id, `Replaces ${old.id}`, `Replacement Task for ${old.id} (${old.status}); the original Task, its refs, `
-        + "and its evidence are preserved and were not rewritten.", now);
+        + "and its evidence are preserved and were not rewritten.", "user", now);
     store.saveMilestone(replacement.id, milestone);
     return {
         output: `${created.output}\nRecorded replacement of ${old.id} on ${replacement.id} `

package/dist/controller/jobClient.js

@@ -68,16 +68,13 @@ function parseJobResult(value) {
  * list/show paths do not use this port and stay lean.
  */
 export function createControllerIntegrationJobPort(home, clientOptions = {}) {
-    const { store, ...controllerOptions } = clientOptions;
     return {
         async startCheckJob(input) {
             const owner = {
                 kind: "integration-attempt",
                 integrationAttemptId: input.integrationId
             };
-            // rr8/rr12: Bind the Integration-issued job to the caller's managed
-            // identity. A user-scope caller carries a verified Leader assertion.
-            const caller = resolveJobCaller(controllerOptions.environment, input.taskId, store);
+            const caller = resolveJobCaller(clientOptions.environment, input.taskId);
             const { job } = await startDurableJob(home, {
                 taskId: input.taskId,
                 owner,
@@ -87,16 +84,16 @@ export function createControllerIntegrationJobPort(home, clientOptions = {}) {
                 env: input.env,
                 steps: input.steps,
                 caller
-            }, controllerOptions);
+            }, clientOptions);
             return job;
         },
         async getJob(taskId, jobId) {
-            return getDurableJob(home, taskId, jobId, controllerOptions);
+            return getDurableJob(home, taskId, jobId, clientOptions);
         },
         async cancelJob(taskId, jobId) {
             // rr8/rr12: Bind the cancel request to the caller's managed identity.
-            const caller = resolveJobCaller(controllerOptions.environment, taskId, store);
-            await cancelDurableJob(home, taskId, jobId, caller, controllerOptions);
+            const caller = resolveJobCaller(clientOptions.environment, taskId);
+            await cancelDurableJob(home, taskId, jobId, caller, clientOptions);
         }
     };
 }