@zq-silk/yui 0.12.3 → 0.13.0

package/dist/commands/taskIntegrationCommands.js

@@ -6,7 +6,7 @@ import { defaultTableWidth, renderTable } from "../output/table.js";
 import { createIntegrationAttempt, recordResolutionDecision, supersedeIntegration, updateIntegrationAttempt } from "../integration/integrationAttempt.js";
 import { GitIntegrationService } from "../integration/gitIntegrationService.js";
 import { runTaskIntegrationQueueCommand } from "./taskIntegrationQueueCommands.js";
-import { taskActor } from "./taskActor.js";
+import { taskLocalActor } from "./taskActor.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
 import { runDeliveryGuardPreflight, withGuardWarnings } from "./deliveryGuardPreflight.js";
 export async function runTaskIntegrationCommand(args, store, home, options = {}) {
@@ -18,12 +18,13 @@ export async function runTaskIntegrationCommand(args, store, home, options = {})
         return continueIntegration(rest, store, home, now, options);
     }
     if (command === "resolve") {
-        return resolveDecision(rest, store, now, options.environment);
+        return resolveDecision(rest, store, now, options.environment, home);
     }
     if (command === "abort")
-        return abortIntegration(rest, store, now(), options);
-    if (command === "supersede")
-        return supersedeIntegrationCommand(rest, store, now(), options.environment);
+        return abortIntegration(rest, store, now(), options, home);
+    if (command === "supersede") {
+        return supersedeIntegrationCommand(rest, store, now(), options.environment, home);
+    }
     if (command === "cleanup") {
         return cleanupIntegration(rest, store, home, options.environment);
     }
@@ -43,6 +44,7 @@ async function cleanupIntegration(args, store, home, environment) {
         throw usageError("Task Integration cleanup usage: yui task integration cleanup <task>/<integration>.");
     }
     const integration = requireIntegration(store, args[0], environment);
+    taskLocalActor(store, environment, integration.taskId, home);
     if (integration.status !== "committed"
         && integration.status !== "superseded"
         && integration.status !== "failed") {
@@ -83,6 +85,7 @@ async function start(args, store, home, now, options) {
     if (task.status !== "active") {
         throw usageError(`Task is not active: ${task.id}/${task.status}.`);
     }
+    taskLocalActor(store, options.environment, task.id, home);
     const changeSetIds = parsed.many.get("--change-set") ?? [];
     if (changeSetIds.length === 0)
         throw usageError("--change-set is required.", usage);
@@ -135,6 +138,7 @@ async function start(args, store, home, now, options) {
     // record creation are atomic, so a concurrent Leader cannot sneak a
     // duplicate Integration between the guard and the write.
     const integration = store.transaction((tx) => {
+        taskLocalActor(tx, options.environment, task.id, home);
         const guard = runDeliveryGuardPreflight(tx, task.id, {
             kind: "integration-start",
             projectId: project.id,
@@ -165,6 +169,7 @@ async function continueIntegration(args, store, home, now, options) {
         throw usageError(usage);
     const integration = requireIntegration(store, parsed.positionals[0], options.environment);
     requireActiveIntegrationTask(store, integration);
+    taskLocalActor(store, options.environment, integration.taskId, home);
     if (integration.status !== "validating"
         && integration.status !== "running"
         && (integration.status !== "blocked"
@@ -178,45 +183,47 @@ 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`;
     return { output, data: result };
 }
-function resolveDecision(args, store, now, environment) {
+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)
         throw usageError(usage);
-    const integration = requireIntegration(store, parsed.positionals[0], environment);
-    const task = requireActiveIntegrationTask(store, integration);
-    if (taskActor(environment, task.id) !== "leader") {
-        throw usageError("Only the Task Leader can resolve an Integration conflict.");
-    }
     const selectedOption = parsed.one.get("--option");
     const rationale = parsed.one.get("--rationale");
     if (selectedOption === undefined || rationale === undefined)
         throw usageError(usage);
-    const resolved = recordResolutionDecision(integration, {
-        action: selectedOption,
-        rationale
-    }, now());
-    store.saveIntegrationAttempt(resolved.taskId, resolved);
+    const resolved = store.transaction((tx) => {
+        const integration = requireIntegration(tx, parsed.positionals[0], environment);
+        const task = requireActiveIntegrationTask(tx, integration);
+        const actor = taskLocalActor(tx, environment, task.id, home);
+        const updated = recordResolutionDecision(integration, {
+            action: selectedOption,
+            rationale
+        }, 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 }
     };
 }
-async function abortIntegration(args, store, now, options) {
+async function abortIntegration(args, store, now, options, home) {
     const usage = "Task Integration abort usage: yui task integration abort <task>/<integration> --reason <text>.";
     const parsed = parseRepeatable(args, new Set(), new Set(["--reason"]), usage);
     if (parsed.positionals.length !== 1)
         throw usageError(usage);
     const integration = requireIntegration(store, parsed.positionals[0], options.environment);
     requireActiveIntegrationTask(store, integration);
+    taskLocalActor(store, options.environment, integration.taskId, home);
     if (integration.status !== "running" && integration.status !== "blocked") {
         throw usageError(`Integration cannot be aborted from ${integration.status}: ${integration.id}.`);
     }
@@ -238,6 +245,7 @@ async function abortIntegration(args, store, now, options) {
         if (current.status !== "running" && current.status !== "blocked") {
             throw usageError(`Integration cannot be aborted from ${current.status}: ${current.id}.`);
         }
+        taskLocalActor(tx, options.environment, current.taskId, home);
         const aborted = updateIntegrationAttempt(current, {
             status: "failed",
             checks: [
@@ -252,7 +260,7 @@ async function abortIntegration(args, store, now, options) {
         };
     });
 }
-function supersedeIntegrationCommand(args, store, now, environment) {
+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)
@@ -265,9 +273,9 @@ function supersedeIntegrationCommand(args, store, now, environment) {
     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.
-    taskActor(environment, integration.taskId);
+    // 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",
     // leaving contradictory terminal records that never converge. This covers
@@ -287,6 +295,7 @@ function supersedeIntegrationCommand(args, store, now, environment) {
         if (current.status !== "committed") {
             throw usageError(`Integration cannot be superseded from ${current.status}: ${current.id}.`);
         }
+        taskLocalActor(tx, environment, current.taskId, home);
         const superseded = supersedeIntegration(current, reason, now);
         tx.saveIntegrationAttempt(superseded.taskId, superseded);
         return {

package/dist/commands/taskIntegrationQueueCommands.js

@@ -3,7 +3,7 @@ import { defaultTableWidth, renderTable } from "../output/table.js";
 import { resolveProject } from "../repository/project.js";
 import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
 import { enqueueIntegrationQueueEntry, processIntegrationQueue, reconcileIntegrationQueueEntry, requeueIntegrationQueueEntry, supersedeIntegrationQueueEntry } from "../integration/integrationQueueService.js";
-import { taskActor } from "./taskActor.js";
+import { taskLocalActor } from "./taskActor.js";
 import { parseRepeatable } from "./taskIntegrationCommands.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
 /**
@@ -22,11 +22,11 @@ export async function runTaskIntegrationQueueCommand(args, store, home, options
     if (command === "process")
         return process(rest, store, home, options);
     if (command === "supersede")
-        return supersede(rest, store, options);
+        return supersede(rest, store, options, home);
     if (command === "requeue")
-        return requeue(rest, store, options);
+        return requeue(rest, store, options, home);
     if (command === "reconcile")
-        return reconcile(rest, store, options);
+        return reconcile(rest, store, options, home);
     throw usageError(command === undefined
         ? "Task Integration queue command is required."
         : `Unknown command: task integration queue ${command}`);
@@ -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(options.environment, task.id);
+    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(options.environment, task.id);
+    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)) {
@@ -148,40 +148,40 @@ async function process(args, store, home, options) {
         : `${lines.join("\n")}\n`;
     return { output, data: { processed } };
 }
-function supersede(args, store, options) {
+function supersede(args, store, options, home) {
     const usage = "Task Integration queue supersede usage: yui task integration queue supersede <task>/<entry> --reason <text>.";
     const parsed = parseRepeatable(args, new Set(), new Set(["--reason"]), usage);
     if (parsed.positionals.length !== 1)
         throw usageError(usage);
     const entry = requireQueueEntry(store, parsed.positionals[0], options.environment);
-    requireLeader(options.environment, entry.taskId);
+    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 }
     };
 }
-function requeue(args, store, options) {
+function requeue(args, store, options, home) {
     const usage = "Task Integration queue requeue usage: yui task integration queue requeue <task>/<entry>.";
     if (args.length !== 1)
         throw usageError(usage);
     const entry = requireQueueEntry(store, args[0], options.environment);
-    requireLeader(options.environment, entry.taskId);
-    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 }
     };
 }
-async function reconcile(args, store, options) {
+async function reconcile(args, store, options, home) {
     const usage = "Task Integration queue reconcile usage: yui task integration queue reconcile <task>/<entry>.";
     if (args.length !== 1)
         throw usageError(usage);
     const entry = requireQueueEntry(store, args[0], options.environment);
-    requireLeader(options.environment, entry.taskId);
+    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(environment, taskId) {
-    if (taskActor(environment, taskId) !== "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/context/runContextPack.js

@@ -1,3 +1,4 @@
+import { rejectedYieldAttemptFromTaskEvent, RUN_YIELD_REJECTED_EVENT } from "../run/rejectedYieldAttempt.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { TASK_COMPLETION_PUBLISHED_TREE_AUTHORIZED_EVENT } from "../task/publicationReference.js";
 import { RUN_BOOTSTRAP_MAX_DELTAS } from "./runContextContract.js";
@@ -426,6 +427,20 @@ function collectAuthorizedContext(store, run) {
         for (const event of publishedTreeAuthorizations.reverse().slice(-16)) {
             result.push(materialize("L4", "task-event", event.id, event));
         }
+        for (const event of events.filter(({ type }) => (type === RUN_YIELD_REJECTED_EVENT)).slice(-16)) {
+            result.push(materialize("L4", "task-event", event.id, event));
+            const attempt = rejectedYieldAttemptFromTaskEvent(event);
+            if (attempt === null)
+                continue;
+            const rejectedRun = store.getAgentRun(task.id, attempt.runId);
+            if (rejectedRun !== null) {
+                result.push(materialize("L4", "agent-run", rejectedRun.id, rejectedRun));
+            }
+            const rejectedRound = store.getReviewRound(task.id, attempt.reviewRoundId);
+            if (rejectedRound !== null) {
+                result.push(materialize("L3", "review-round", rejectedRound.id, rejectedRound));
+            }
+        }
         for (const request of store.listOpenInputRequests([task.id])) {
             result.push(materialize("L4", "input-request", request.id, request));
         }

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -1714,8 +1714,24 @@ export class FileSchedulerStoreAdapter {
                     }
                 }
             }
-            store.saveRole(task.id, updateRoleStatus(role, "exited", input.now));
+            const blocksAutomaticLeaderRecovery = role.name === "leader"
+                && input.leaderRecovery === "blocked";
+            store.saveRole(task.id, updateRoleStatus(role, blocksAutomaticLeaderRecovery ? "failed" : "exited", input.now));
             stopTaskSessionIfPresent(store, task.id, role.name, currentRun.effective.agentId, input.now);
+            if (blocksAutomaticLeaderRecovery) {
+                const failure = recordLeaderFailure(task.id, input.session?.nativeSessionId ?? "(unregistered)", input.summary, input.now, store.getLeaderFailure(task.id));
+                store.saveLeaderFailure(failure);
+                recordLeaderAttentionRequired(store, {
+                    taskId: task.id,
+                    reason: "leader-recovery-failed",
+                    payload: {
+                        message: failure.message,
+                        runId: currentRun.id
+                    },
+                    now: input.now
+                });
+                return "failed";
+            }
             queueLeaderWakeup(store, task.id, wakeReason(role.name === "leader" ? "leader-run-failed" : "role-run-failed"), input.now);
             return "failed";
         });

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);
         }
     };
 }