@zq-silk/yui 0.8.1 → 0.8.2

package/dist/commands/taskCommands.js

@@ -1,4 +1,4 @@
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { createRunAssignment } from "../context/runContextContract.js";
 import { buildRunContextPack, buildRunContextDelta, contextSnapshotDeltaRefIds, expandRunContextRef, freezeRunContextSnapshot } from "../context/runContextPack.js";
@@ -7,7 +7,8 @@ import { CliError, dataError, roleNotFound, runtimeError, taskNotFound, usageErr
 import { createTaskEvent } from "../event/taskEvent.js";
 import { clearMatchingLeaderStallAttention, isRoleRunStalled, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT } from "../scheduler/roleRunStall.js";
 import { readCommandText } from "./textInput.js";
-import { createRoleSessionSet, roleAgentSessionResumeMode } from "../executor/agentExecutor.js";
+import { createRoleSessionSet, roleAgentSessionResumeMode, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
+import { currentProviderActivation, transferProviderAuthority } from "../runtime/providerRuntimeIdentity.js";
 import { resolveEffectiveLaunch } from "../executor/effectiveLaunch.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
 import { formatTimestamp } from "../output/timePresentation.js";
@@ -16,7 +17,7 @@ import { createTaskMessage, taskMessageAuthorLabel } from "../message/message.js
 import { cancelInputRequest } from "../input/inputRequest.js";
 import { recoverExactAgentRun, terminalizeExactTaskRun, validateExactRunReviewRound } from "../lifecycle/exactRunTerminalization.js";
 import { resetTaskRoleSessionGeneration } from "../lifecycle/taskRoleSessionReset.js";
-import { activeRoleAgentBinding, copyGlobalRoleToTaskRole, createRole, createRoleAgentBinding, switchActiveRoleAgent, unbindRoleAgent, updateRole, updateRoleStatus } from "../role/role.js";
+import { copyGlobalRoleToTaskRole, createRole, createRoleAgentBinding, switchActiveRoleAgent, unbindRoleAgent, updateRole, updateRoleStatus } from "../role/role.js";
 import { agentRunDeliveryReceiptId, createAgentRun, withAgentRunContextSnapshot } from "../run/agentRun.js";
 import { projectRunRecovery, readRunRecoveryFacts } from "../run/recoveryProjection.js";
 import { matchYieldReceipt } from "../run/yieldReceipt.js";
@@ -240,7 +241,6 @@ export function runTaskCommand(args, store, options = {}) {
         case "milestone": return taskMilestoneCommand(rest, store, options);
         case "event": return taskEventCommand(rest, store);
         case "continuation": return taskContinuationCommand(rest, store);
-        case "enter": return enterTaskRoleAlias(rest, store, options);
         default:
             throw usageError(command === undefined
                 ? "Task command is required."
@@ -429,8 +429,8 @@ function updateTaskCommand(args, store, options) {
 /** Compatibility helper for call sites that cannot yet handle foreground enter. */
 export function runTaskOutputCommand(args, store, options = {}) {
     const execution = runTaskCommand(args, store, options);
-    if (execution.kind === "enter") {
-        throw runtimeError("Task role enter requires foreground tmux handoff by the CLI.");
+    if (execution.kind !== "output") {
+        throw runtimeError("Task Role foreground runtime control requires the CLI.");
     }
     return execution.output;
 }
@@ -1192,8 +1192,12 @@ function taskRoleCommand(args, store, options) {
         return output(unbindTaskRole(rest, store, options));
     if (command === "reset")
         return resetTaskRole(rest, store, options);
-    if (command === "enter")
-        return enterTaskRole(rest, store, options);
+    if (command === "view")
+        return viewTaskRole(rest, store);
+    if (command === "takeover")
+        return transferTaskRoleAuthority(rest, store, options, "takeover");
+    if (command === "release")
+        return transferTaskRoleAuthority(rest, store, options, "release");
     throw usageError(command === undefined
         ? "Task role command is required."
         : `Unknown command: task role ${command}`);
@@ -1506,60 +1510,111 @@ function unbindTaskRole(args, store, options) {
     });
     return `Unbound Agent ${args[2]} from ${result.taskId}/${result.name}\n`;
 }
-function enterTaskRole(args, store, _options) {
-    const usage = "Task role enter usage: yui task role enter <task> <role> "
-        + "[--read-only | --read-write].";
-    const parsed = parseTail(args, new Set(), usage, new Set(["--read-only", "--read-write"]));
-    exactPositionals(parsed.positionals, 2, usage);
-    if (parsed.options.has("--read-only") && parsed.options.has("--read-write")) {
-        throw usageError("--read-only and --read-write are mutually exclusive.", usage);
-    }
-    const task = requireTask(store, parsed.positionals[0]);
+function viewTaskRole(args, store) {
+    const usage = "Task role view usage: yui task role view <task> <role>.";
+    exactPositionals(args, 2, usage);
+    const task = requireTask(store, args[0]);
     if (task.status !== "active") {
-        throw usageError(inactiveTaskMessage(task, "entering a role session"));
+        throw usageError(inactiveTaskMessage(task, "viewing a role session"));
     }
-    const role = requireRole(store, task.id, parsed.positionals[1]);
-    const access = parsed.options.has("--read-write") ? "read-write" : "read-only";
-    if (access === "read-write") {
-        assertTaskRoleWritableAttachAvailable(store, task.id, role.name);
+    const role = requireRole(store, task.id, args[1]);
+    const session = store.getRoleSession(task.id, role.name);
+    if (session === null || session.status === "stopped" || session.status === "broken") {
+        throw usageError(`Task Role has no live Provider view: ${task.id}/${role.name}.`);
     }
     return {
-        kind: "enter",
+        kind: "view",
         taskId: task.id,
         roleName: role.name,
-        access,
-        output: `Attaching to ${role.name} for ${task.id} (${access})\n`
+        access: "read-only",
+        output: `Viewing ${role.name} for ${task.id} (read-only)\n`
     };
 }
-/** Re-run after the tmux writer lease exists to close attach/launch races. */
-export function assertTaskRoleWritableAttachAvailable(store, taskId, roleName, options = {}) {
-    const role = requireRole(store, taskId, roleName);
-    if (store.getActiveAgentRun(taskId, roleName) !== null) {
-        throw usageError(`Role has an active managed Run; writable attach is unavailable: ${taskId}/${roleName}.`);
-    }
-    const session = store.getRoleSession(taskId, roleName);
-    if (activeRoleAgentBinding(role).adapterId === "claude"
-        && ((session !== null
-            && session.status !== "stopped"
-            && session.status !== "broken")
-            || options.isManagedProcessRunning?.() === true)) {
-        throw usageError(`A managed Claude process is still running; writable attach is unavailable: ${taskId}/${roleName}.`);
-    }
-}
-function enterTaskRoleAlias(args, store, options) {
-    const usage = "Task enter usage: yui task enter <task> [role] "
-        + "[--read-only | --read-write].";
-    const parsed = parseTail(args, new Set(), usage, new Set(["--read-only", "--read-write"]));
-    if (parsed.positionals.length < 1 || parsed.positionals.length > 2
-        || parsed.positionals.some((value) => value.trim().length === 0)) {
-        throw usageError(usage);
+function transferTaskRoleAuthority(args, store, options, action) {
+    const usage = `Task role ${action} usage: yui task role ${action} <task> <role>.`;
+    exactPositionals(args, 2, usage);
+    const now = clock(options);
+    try {
+        return store.transaction((tx) => {
+            const task = requireTask(tx, args[0]);
+            if (task.status !== "active") {
+                throw usageError(inactiveTaskMessage(task, `${action} Provider authority`));
+            }
+            const role = requireRole(tx, task.id, args[1]);
+            const sessions = tx.getTaskRoleSessionSet(task.id, role.name);
+            const session = sessions?.sessions[role.activeAgentId];
+            const binding = sessions?.providerBinding;
+            if (sessions === null || sessions === undefined || session === undefined
+                || binding === null || binding === undefined
+                || session.launchId === undefined
+                || session.status === "stopped" || session.status === "broken") {
+                throw new Error(`Task Role has no live managed Provider: ${task.id}/${role.name}.`);
+            }
+            const activation = currentProviderActivation(binding);
+            if (activation === null) {
+                throw new Error(`Provider Activation is not live: ${task.id}/${role.name}.`);
+            }
+            if (action === "takeover") {
+                const activeRun = tx.getActiveAgentRun(task.id, role.name);
+                if (sessions.inFlight === null || activeRun?.id !== sessions.inFlight.runId) {
+                    throw new Error(`Task Role has no active managed Run for takeover: ${task.id}/${role.name}.`);
+                }
+            }
+            if (action === "takeover"
+                && binding.authority.owner !== "controller"
+                && binding.authority.owner !== "human") {
+                throw new Error(`Provider authority is not Controller-owned: ${task.id}/${role.name}.`);
+            }
+            if (action === "release"
+                && binding.authority.owner !== "human"
+                && binding.authority.owner !== "controller") {
+                throw new Error(`Provider authority is not human-owned: ${task.id}/${role.name}.`);
+            }
+            const desiredOwner = action === "takeover" ? "human" : "controller";
+            const unchanged = binding.authority.owner === desiredOwner;
+            const updatedBinding = unchanged
+                ? binding
+                : transferProviderAuthority(binding, {
+                    expectedEpoch: binding.authority.epoch,
+                    expectedOwner: binding.authority.owner,
+                    owner: desiredOwner,
+                    holderId: action === "takeover" ? `human:${randomUUID()}` : activation.activationId,
+                    changedAt: now.toISOString()
+                });
+            const authority = updatedBinding.authority;
+            if (authority.owner !== "controller" && authority.owner !== "human") {
+                throw new Error("Provider authority transfer did not produce a writer.");
+            }
+            if (!unchanged) {
+                tx.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(sessions, updatedBinding, now));
+                recordTaskEvent(tx, task.id, "runtime.provider-authority-transferred", {
+                    role: role.name,
+                    owner: authority.owner,
+                    holderId: authority.holderId,
+                    epoch: String(authority.epoch)
+                }, now);
+            }
+            return {
+                kind: "authority",
+                action,
+                taskId: task.id,
+                roleName: role.name,
+                launchId: session.launchId,
+                nativeSessionId: session.nativeSessionId,
+                authority: {
+                    epoch: authority.epoch,
+                    owner: authority.owner,
+                    holderId: authority.holderId
+                },
+                output: action === "takeover"
+                    ? `Human authority ${unchanged ? "replayed" : "acquired"} for ${task.id}/${role.name} at epoch ${authority.epoch}.\n`
+                    : `Controller authority ${unchanged ? "replayed" : "restored"} for ${task.id}/${role.name} at epoch ${authority.epoch}.\n`
+            };
+        });
+    }
+    catch (error) {
+        throw usageError(messageOf(error), usage);
     }
-    return enterTaskRole([
-        parsed.positionals[0],
-        parsed.positionals[1] ?? LEADER_ROLE,
-        ...(parsed.options.has("--read-only") ? ["--read-only"] : []),
-        ...(parsed.options.has("--read-write") ? ["--read-write"] : [])
-    ], store, options);
 }
 function taskWorkCommand(args, store, options) {
     const [command, ...rest] = args;