@zq-silk/yui 0.13.4 → 0.13.5

package/dist/commands/taskExecutionCommands.js

@@ -0,0 +1,254 @@
+import { createTaskEvent } from "../event/taskEvent.js";
+import { terminalizeTaskRoleRunSession } from "../executor/agentExecutor.js";
+import { recordExecutionLaneResult } from "../execution/executionGroup.js";
+import { usageError } from "../errors/cliError.js";
+import { requestDurableJobCancel } from "../job/durableJob.js";
+import { finishReviewRound, updateReviewExecutionGroup } from "../review/reviewRound.js";
+import { updateRoleStatus } from "../role/role.js";
+import { failAgentRun } from "../run/agentRun.js";
+import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
+import { startTaskExecution, stopTaskExecution } from "../task/task.js";
+import { updateWorkItemExecutionGroup, workItemExecutionGroupById } from "../workItem/workItem.js";
+import { taskActor } from "./taskActor.js";
+export function parseTaskExecutionStopRequest(args) {
+    const taskId = args[0];
+    if (taskId === undefined || taskId.startsWith("--")) {
+        throw usageError("Task execution stop usage: yui task execution stop <task> --force --reason <text>.");
+    }
+    let force = false;
+    let reason;
+    for (let index = 1; index < args.length; index += 1) {
+        const argument = args[index];
+        if (argument === "--force" && !force) {
+            force = true;
+            continue;
+        }
+        if (argument === "--reason" && reason === undefined) {
+            reason = args[index + 1];
+            index += 1;
+            continue;
+        }
+        throw usageError(`Unknown or duplicated Task execution stop option: ${String(argument)}.`);
+    }
+    if (!force)
+        throw usageError("Task execution stop requires --force.");
+    const normalizedReason = reason?.trim();
+    if (normalizedReason === undefined
+        || normalizedReason.length === 0
+        || normalizedReason.startsWith("--")) {
+        throw usageError("Task execution stop requires --reason <text>.");
+    }
+    return { taskId, reason: normalizedReason };
+}
+export function parseTaskExecutionStartRequest(args) {
+    if (args.length !== 1 || args[0].startsWith("--")) {
+        throw usageError("Task execution start usage: yui task execution start <task>.");
+    }
+    return args[0];
+}
+/**
+ * Fence execution before touching the physical runtime. Progress records and
+ * workspaces remain intact; only current attempts and delivery claims end.
+ */
+export function stopTaskExecutionCommand(request, store, options = {}) {
+    const now = options.now?.() ?? new Date();
+    const actor = requireOperatorOrUser(options.environment, request.taskId);
+    return store.transaction((tx) => {
+        const task = tx.getTask(request.taskId);
+        if (task === null)
+            throw usageError(`Task not found: ${request.taskId}.`);
+        if (task.status !== "active") {
+            throw usageError(`Only an active Task can be stopped: ${task.id}.`);
+        }
+        const changed = task.executionGate.state !== "stopped";
+        tx.saveTask(stopTaskExecution(task, now));
+        const activeRuns = tx.listAgentRuns(task.id).filter((run) => run.status === "active");
+        const activeJobs = tx.listDurableJobs(task.id)
+            .filter((job) => job.status === "queued" || job.status === "running");
+        for (const job of activeJobs) {
+            tx.saveDurableJob(task.id, requestDurableJobCancel(job, now));
+        }
+        failExecutionAttempts(tx, task.id, activeRuns, request.reason, now);
+        for (const run of activeRuns) {
+            tx.saveAgentRun(failAgentRun(run, `Task execution stopped: ${request.reason}`, now));
+            if (run.executionGroupId !== undefined && run.executionLaneId !== undefined) {
+                tx.clearActiveExecutionLaneRun(task.id, run.executionGroupId, run.executionLaneId);
+            }
+            tx.clearActiveAgentRun(task.id, run.roleName);
+        }
+        const roleNames = taskRuntimeRoleNames(tx, task.id, activeRuns);
+        for (const roleName of roleNames) {
+            tx.clearActiveAgentRun(task.id, roleName);
+            const sessions = tx.getTaskRoleSessionSet(task.id, roleName);
+            if (sessions !== null && sessions.inFlight !== null) {
+                tx.saveTaskRoleSessionSet(terminalizeCurrentRun(sessions, now));
+            }
+            const role = tx.getRole(task.id, roleName);
+            if (role !== null && role.status !== "idle") {
+                tx.saveRole(task.id, updateRoleStatus(role, "idle", now));
+            }
+        }
+        // A stop is allowed to discard stale pointer projections even when their
+        // historical Runs are already terminal.
+        for (const run of tx.listAgentRuns(task.id)) {
+            if (run.executionGroupId !== undefined && run.executionLaneId !== undefined) {
+                tx.clearActiveExecutionLaneRun(task.id, run.executionGroupId, run.executionLaneId);
+            }
+        }
+        for (const mailbox of tx.listWorkMailboxes()) {
+            if ("taskId" in mailbox.target && mailbox.target.taskId === task.id) {
+                tx.removeWorkMailbox(mailbox.target);
+            }
+        }
+        tx.clearLeaderFailure(task.id);
+        tx.saveEvent(task.id, createTaskEvent(tx.nextEventId(task.id), task.id, "task.execution-stopped", {
+            by: actor,
+            reason: request.reason,
+            terminatedRuns: String(activeRuns.length)
+        }, now));
+        return {
+            taskId: task.id,
+            changed,
+            roleNames,
+            terminatedRunIds: activeRuns.map(({ id }) => id),
+            cancelledJobIds: activeJobs.map(({ id }) => id),
+            output: changed
+                ? `Stopped Task execution: ${task.id}. Progress was preserved; `
+                    + `${activeRuns.length} active attempt(s) were terminated and `
+                    + `${activeJobs.length} DurableJob(s) were cancelled.`
+                : `Task execution is already stopped: ${task.id}. Runtime cleanup will be verified.`
+        };
+    });
+}
+/** Enable execution only after the caller has proven all old physical writers absent. */
+export function startTaskExecutionCommand(taskId, store, options = {}) {
+    const now = options.now?.() ?? new Date();
+    const actor = requireOperatorOrUser(options.environment, taskId);
+    return store.transaction((tx) => {
+        const task = tx.getTask(taskId);
+        if (task === null)
+            throw usageError(`Task not found: ${taskId}.`);
+        if (task.status !== "active") {
+            throw usageError(`Only an active Task can be started: ${task.id}.`);
+        }
+        if (task.executionGate.state === "enabled") {
+            return { taskId: task.id, changed: false, output: `Task execution is already enabled: ${task.id}.` };
+        }
+        if (tx.listAgentRuns(task.id).some((run) => run.status === "active")
+            || tx.listDurableJobs(task.id).some((job) => job.status === "queued" || job.status === "running")) {
+            throw usageError(`Task still has an active execution attempt: ${task.id}.`);
+        }
+        for (const mailbox of tx.listWorkMailboxes()) {
+            if ("taskId" in mailbox.target && mailbox.target.taskId === task.id) {
+                tx.removeWorkMailbox(mailbox.target);
+            }
+        }
+        tx.clearLeaderFailure(task.id);
+        tx.saveTask(startTaskExecution(task, now));
+        queueLeaderWakeup(tx, task.id, "execution-started", now);
+        tx.saveEvent(task.id, createTaskEvent(tx.nextEventId(task.id), task.id, "task.execution-started", { by: actor }, now));
+        return {
+            taskId: task.id,
+            changed: true,
+            output: `Started Task execution: ${task.id}. The Leader will continue from durable progress.`
+        };
+    });
+}
+/** Remove cleanup-generated delivery records after physical release is proven. */
+export function finalizeStoppedTaskExecution(taskId, store) {
+    store.transaction((tx) => {
+        const task = tx.getTask(taskId);
+        if (task === null)
+            throw usageError(`Task not found: ${taskId}.`);
+        if (task.executionGate.state !== "stopped") {
+            throw usageError(`Task execution is not stopped: ${taskId}.`);
+        }
+        for (const mailbox of tx.listWorkMailboxes()) {
+            if ("taskId" in mailbox.target && mailbox.target.taskId === taskId) {
+                tx.removeWorkMailbox(mailbox.target);
+            }
+        }
+        tx.clearLeaderFailure(taskId);
+    });
+}
+function requireOperatorOrUser(environment, taskId) {
+    const actor = taskActor(environment, taskId);
+    if (actor === "leader") {
+        throw usageError("Task execution stop/start requires the global Operator or a human user.");
+    }
+    return actor;
+}
+function terminalizeCurrentRun(sessions, now) {
+    const inFlight = sessions.inFlight;
+    return terminalizeTaskRoleRunSession(sessions, {
+        agentId: inFlight.agentId,
+        runId: inFlight.runId,
+        receiptId: inFlight.receiptId
+    }, now);
+}
+function taskRuntimeRoleNames(store, taskId, runs) {
+    const names = new Set(store.listRoles(taskId).map(({ name }) => name));
+    for (const sessions of store.listRoleSessionSets(taskId))
+        names.add(sessions.owner.roleName);
+    for (const run of runs)
+        names.add(run.roleName);
+    for (const owner of store.listSessionOwners()) {
+        if (owner.owner.scope === "task" && owner.owner.taskId === taskId) {
+            names.add(owner.owner.roleName);
+        }
+    }
+    return [...names].sort();
+}
+function failExecutionAttempts(store, taskId, runs, reason, now) {
+    const summary = `Task execution stopped: ${reason}`;
+    const workItems = new Map(store.listWorkItems(taskId).map((item) => [item.id, item]));
+    const reviewRounds = new Map(store.listReviewRounds(taskId).map((round) => [round.id, round]));
+    const affectedReviewRoundIds = new Set();
+    for (const run of runs) {
+        if (run.executionGroupId === undefined || run.executionLaneId === undefined)
+            continue;
+        if (run.workItemId !== undefined) {
+            const item = workItems.get(run.workItemId);
+            const group = item === undefined
+                ? undefined
+                : workItemExecutionGroupById(item, run.executionGroupId);
+            const lane = group?.lanes.find(({ id }) => id === run.executionLaneId);
+            if (item !== undefined && group !== undefined && lane !== undefined
+                && item.currentExecutionGroupId === group.id
+                && !["yielded", "completed", "failed", "skipped"].includes(lane.status)) {
+                const updated = updateWorkItemExecutionGroup(item, recordExecutionLaneResult(group, lane.id, { summary }, "failed", now), now);
+                workItems.set(item.id, updated);
+            }
+        }
+        if (run.reviewRoundId !== undefined) {
+            affectedReviewRoundIds.add(run.reviewRoundId);
+            const round = reviewRounds.get(run.reviewRoundId);
+            const group = round?.executionGroup?.id === run.executionGroupId
+                ? round.executionGroup
+                : undefined;
+            const lane = group?.lanes.find(({ id }) => id === run.executionLaneId);
+            if (round !== undefined && group !== undefined && lane !== undefined
+                && !["yielded", "completed", "failed", "skipped"].includes(lane.status)) {
+                reviewRounds.set(round.id, updateReviewExecutionGroup(round, recordExecutionLaneResult(group, lane.id, { summary }, "failed", now)));
+            }
+        }
+    }
+    for (const item of workItems.values()) {
+        const original = store.getWorkItem(item.taskId, item.id);
+        if (original !== null && original.revision !== item.revision) {
+            store.saveWorkItem(item.taskId, item);
+        }
+    }
+    for (const reviewRoundId of affectedReviewRoundIds) {
+        const round = reviewRounds.get(reviewRoundId);
+        const original = store.getReviewRound(round.taskId, round.id);
+        if (original === null)
+            continue;
+        const changed = JSON.stringify(original.executionGroup) !== JSON.stringify(round.executionGroup);
+        const terminal = round.status === "pending" || round.status === "running"
+            ? finishReviewRound(round, "failed", summary, now)
+            : round;
+        if (changed || terminal !== round)
+            store.saveReviewRound(round.taskId, terminal);
+    }
+}

package/dist/commands/taskNextActionCommand.js

@@ -5,7 +5,6 @@ import { extractReviewFindings, planRepairWave } from "../task/repairWave.js";
 import { projectTaskOrchestration } from "../observability/orchestrationMetrics.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
-import { projectExecutionLaneRunRecoveries } from "../run/recoveryProjection.js";
 import { projectReviewDecision } from "../review/reviewDecision.js";
 /**
  * Issue 07 (Leader convergence): read-only `yui task next-action <task>`.
@@ -42,8 +41,7 @@ export function runTaskNextActionCommand(args, store, currentTaskReviewCandidate
         const actionFacts = {
             ...facts,
             currentTaskReviewCandidate,
-            executionGroups: execution.executionGroups,
-            runRecoveries: projectExecutionLaneRunRecoveries(reader, taskId, execution.executionGroups)
+            executionGroups: execution.executionGroups
         };
         const action = projectNextAction(actionFacts);
         const repairWave = repairWaveFor(action, actionFacts);

package/dist/commands/taskOverviewCommand.js

@@ -123,14 +123,21 @@ function buildTaskOverviewEntry(task, store, now, runtimeHealthPolicy) {
         now,
         runtimeHealthPolicy
     });
-    const next = execution.action === "recover-execution"
+    const next = execution.status === "stopped"
         ? {
             action: execution.action,
             owner: execution.owner,
             kind: "execution",
             summary: execution.summary
         }
-        : legacyNext;
+        : execution.action === "recover-execution"
+            ? {
+                action: execution.action,
+                owner: execution.owner,
+                kind: "execution",
+                summary: execution.summary
+            }
+            : legacyNext;
     return {
         ...task,
         brief,

package/dist/commands/taskRoleRuntimeStatus.js

@@ -1,6 +1,6 @@
 import { isDeepStrictEqual } from "node:util";
 import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
-import { hasRuntimeCleanupObligation, hasRuntimeLifecycleWork, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
 import { createRuntimeObservation, runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { classifyRuntimeHealth, projectRuntimeMailbox, projectRuntimeObservation, projectRuntimeTaskEvents, runtimeDisplayStatus } from "../runtime/runtimeProjection.js";
@@ -9,7 +9,6 @@ import { resolveRuntimeHealth } from "../config/yuiConfig.js";
 import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { projectSessionTokenMetrics, resolveSessionTokenIdentity } from "../runtime/sessionTokenMetrics.js";
-import { freshConversationLaunchBlockers, projectConversationSwitch } from "../runtime/conversationSwitch.js";
 export function inspectTaskRoleRuntimeStatuses(taskId, roles, store, panes, now = new Date()) {
     const taskOpenInputRequestCount = store.listInputRequests(taskId)
         .filter((request) => request.status === "open").length;
@@ -94,15 +93,9 @@ export function renderTaskRoleRuntimeStatus(status) {
             ? `needs-attention (${status.stall.kind ?? "workflow-not-progressing"}; no workflow progress since ${status.stall.progressAt ?? "unknown"})`
             : "none"}`,
         `  Native session   ${nativeSession}`,
-        `  Session switch   ${status.conversationSwitch === null
-            ? "none"
-            : `${status.conversationSwitch.status} (${status.conversationSwitch.requestId}; ${status.conversationSwitch.reason})`}`,
         `  Agent runtime    ${runtime}`,
         `  Session tokens   ${sessionTokens}`,
         `  Runtime cleanup  ${status.runtimeCleanupPending ? "pending" : "none"}`,
-        `  Fresh launch     ${status.freshLaunchAllowed
-            ? "allowed"
-            : `blocked (${status.freshLaunchBlockers.join(", ")})`}`,
         `  tmux pane        ${tmux}`,
         `  Workspace        ${status.workspace.managed ? status.workspace.root : status.workspace.path}`,
         ...workspaceDetails
@@ -127,26 +120,12 @@ export function taskRoleNativeSessionLabel(status) {
     return status.nativeSession?.status ?? "unbound";
 }
 export function inspectTaskRoleSessionRecovery(taskId, roleName, store) {
-    const sessions = store.getTaskRoleSessionSet(taskId, roleName);
     const target = runtimeLifecycleTarget({ scope: "task", taskId, roleName });
     const runtimeMailbox = store.getWorkMailbox(target);
-    const roleMailbox = store.getWorkMailbox({ kind: "role", taskId, roleName });
-    const switchBlockers = freshConversationLaunchBlockers({
-        sessions,
-        events: store.listEvents(taskId),
-        mailbox: roleMailbox,
-        roleName
-    });
-    const freshLaunchBlockers = [
-        ...switchBlockers,
-        ...(hasRuntimeLifecycleWork(runtimeMailbox) ? ["runtime-lifecycle-busy"] : [])
-    ];
     return {
         taskId,
         roleName,
-        runtimeCleanupPending: hasRuntimeCleanupObligation(runtimeMailbox),
-        freshLaunchAllowed: freshLaunchBlockers.length === 0,
-        freshLaunchBlockers
+        runtimeCleanupPending: hasRuntimeCleanupObligation(runtimeMailbox)
     };
 }
 export function taskRoleOpenInputLabel(status) {
@@ -203,7 +182,6 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
         ? { managed: false, path: role.workspace }
         : { ...managedWorkspace, managed: true };
     const events = store.listEvents(taskId);
-    const conversationSwitch = projectConversationSwitch(events, role.name, sessions);
     const sessionTokens = projectSessionTokenMetrics(events, resolveSessionTokenIdentity(nativeSession === null
         ? null
         : { taskId, roleName: role.name, ...nativeSession }));
@@ -243,7 +221,6 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
         tmux,
         workspace,
         sessionTokens,
-        conversationSwitch,
         runtime,
         stall
     };

package/dist/controller/agentRuntimeObserver.js

@@ -242,11 +242,13 @@ export class AgentRuntimeObserver {
         // FileTaskStore remains a development/compatibility fallback. The normal
         // Controller store is SQLite and must discover only its indexed hot set.
         const activeTasks = indexedTaskIds === undefined
-            ? this.store.listTasks().filter((task) => task.status === "active")
+            ? this.store.listTasks().filter((task) => (task.status === "active" && task.executionGate.state === "enabled"))
             : [...new Set(indexedTaskIds)]
                 .sort(numericCompare)
                 .map((taskId) => this.store.getTask(taskId))
-                .filter((task) => (task !== null && task.status === "active"));
+                .filter((task) => (task !== null
+                && task.status === "active"
+                && task.executionGate.state === "enabled"));
         for (const task of activeTasks) {
             // A Task still incurs one O(E) event projection. Group those observations
             // by Run and sort each group once so every active Run can reuse the same

package/dist/controller/clientRuntime.js

@@ -427,10 +427,12 @@ export class FileTaskWorkflowRuntime {
         this.clientOptions = clientOptions;
     }
     notifyStateChanged(taskId) {
-        this.notifyMailboxChanged({ kind: "task", taskId });
+        void this.notifyMailboxChanged({ kind: "task", taskId });
     }
     notifyMailboxChanged(target) {
-        void callFileTaskController(this.home, "scheduler.signal", { key: controllerMailboxKey(target) }, this.clientOptions).catch(this.clientOptions.onError ?? (() => { }));
+        const pending = callFileTaskController(this.home, "scheduler.signal", { key: controllerMailboxKey(target) }, this.clientOptions).then(() => { });
+        void pending.catch(this.clientOptions.onError ?? (() => { }));
+        return pending;
     }
     reconcileTask(taskId) {
         void this.#prepareAndScan(taskId).catch(this.clientOptions.onError ?? (() => { }));
@@ -469,12 +471,52 @@ export class FileTaskWorkflowRuntime {
             }
         }
     }
+    /** Wait until every cancellation requested by Task execution stop is physically settled. */
+    async stopTaskDurableJobs(taskId) {
+        const deadline = Date.now() + LIFECYCLE_REQUEST_TIMEOUT_MS;
+        for (;;) {
+            const active = this.store.listActiveDurableJobs()
+                .filter((job) => job.taskId === taskId);
+            if (active.length === 0)
+                return;
+            await callFileTaskController(this.home, "scheduler.scan", {}, {
+                ...this.clientOptions,
+                requestTimeoutMs: LIFECYCLE_REQUEST_TIMEOUT_MS
+            });
+            const remaining = this.store.listActiveDurableJobs()
+                .filter((job) => job.taskId === taskId);
+            if (remaining.length === 0)
+                return;
+            if (Date.now() >= deadline) {
+                throw new Error(`DurableJobs did not stop: ${remaining.map(({ id }) => `${taskId}/${id}`).join(", ")}.`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    }
     /**
      * Issue 03 archive postcondition. Re-verifies physical absence after the
      * runtime stop and blocks archive while any owned Provider root is still
      * live, preserving the owner records for Operator recovery.
      */
     async assertTaskPhysicalResourcesReleased(taskId) {
+        const activeJobs = this.store.listActiveDurableJobs()
+            .filter((job) => job.taskId === taskId);
+        if (activeJobs.length > 0) {
+            throw new WorkspaceCleanupBlockedError("physical-resource-live", `task:${taskId}`, true, `Task physical resources are not released: ${activeJobs.length} DurableJob(s) are still active: `
+                + activeJobs.map(({ id }) => id).join(", "));
+        }
+        const liveSessions = this.store.listRoleSessionSets(taskId).flatMap((sessions) => (Object.values(sessions.sessions)
+            .filter((session) => session.status !== "stopped" && session.status !== "broken")
+            .map((session) => `${sessions.owner.roleName}/${session.agentId}/${session.status}`)));
+        if (liveSessions.length > 0) {
+            throw new WorkspaceCleanupBlockedError("physical-resource-live", `task:${taskId}`, true, `Task physical resources are not released: current Role Session state is still live: `
+                + liveSessions.join(", "));
+        }
+        const livePanes = this.tmux.inspectTaskRolePanes(taskId).filter((pane) => !pane.dead);
+        if (livePanes.length > 0) {
+            throw new WorkspaceCleanupBlockedError("physical-resource-live", `task:${taskId}`, true, `Task physical resources are not released: ${livePanes.length} tmux Role pane(s) are still live: `
+                + livePanes.map(({ roleName, pid }) => `${roleName} (pid ${pid ?? "?"})`).join(", "));
+        }
         const reconciliation = new SessionOwnerReconciliation({
             home: this.home,
             store: this.store,
@@ -596,6 +638,7 @@ export class FileTaskWorkflowRuntime {
         const task = this.store.getTask(taskId);
         if (task !== null
             && task.status === "active"
+            && task.executionGate.state === "enabled"
             && this.workspacePreparer !== undefined) {
             await this.workspacePreparer.prepareTaskWorkspace(taskId);
         }

package/dist/controller/controller.js

@@ -658,7 +658,7 @@ async function prepareActiveWorkspaces(store, workspace, selection, maintenanceF
             if (selection.blockedTaskIds?.has(taskId))
                 return [];
             const task = store.getTask(taskId);
-            return task?.status === "active" ? [task] : [];
+            return task?.status === "active" && task.executionGate.state === "enabled" ? [task] : [];
         });
     const failed = new Set();
     const ready = new Set();
@@ -1383,7 +1383,8 @@ export class FileTaskController {
     #scheduleTaskPassRetry(scope) {
         if (this.#stopped || this.#pendingFull)
             return;
-        if (this.store.getTask(scope.taskId)?.status !== "active") {
+        const task = this.store.getTask(scope.taskId);
+        if (task?.status !== "active" || task.executionGate.state !== "enabled") {
             this.#clearTaskPassRetry(scope.taskId);
             return;
         }
@@ -1410,7 +1411,9 @@ export class FileTaskController {
             if (this.#stopped || this.#pendingFull)
                 return;
             try {
-                if (this.store.getTask(scope.taskId)?.status !== "active") {
+                const currentTask = this.store.getTask(scope.taskId);
+                if (currentTask?.status !== "active"
+                    || currentTask.executionGate.state !== "enabled") {
                     this.#clearTaskPassRetry(scope.taskId);
                     return;
                 }