@zq-silk/yui 0.2.0 → 0.4.2

package/dist/commands/taskInputCommands.js

@@ -1,18 +1,20 @@
 import { dataError, roleNotFound, taskNotFound, usageError } from "../errors/cliError.js";
 import { createTaskEvent } from "../event/taskEvent.js";
-import { updateRoleAgentSessionStatus } from "../executor/agentExecutor.js";
+import { activeLiveRoleAgentSession } from "../executor/agentExecutor.js";
 import { answerInputRequest, cancelInputRequest, createInputRequest } from "../input/inputRequest.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
-import { updateRoleStatus } from "../role/role.js";
-import { yieldAgentRun } from "../run/agentRun.js";
-import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
+import { formatTimestamp } from "../output/timePresentation.js";
+import { enqueueWork } from "../coordination/workMailboxQueue.js";
+import { clearMatchingLeaderStallAttention, isRoleRunStalled, RUN_RECOVERED_EVENT } from "../scheduler/roleRunStall.js";
+import { terminalizeExactTaskRun } from "../lifecycle/exactRunTerminalization.js";
+import { formatAgentRunReceiptId, resolveTaskRecordReference } from "../task/taskRecordReference.js";
 const LEADER_ROLE = "leader";
 export function runTaskInputCommand(args, store, options) {
     const [command, ...rest] = args;
     switch (command) {
         case "request": return createRequest(rest, store, options);
         case "list": return listRequests(rest, store);
-        case "show": return showRequest(rest, store);
+        case "show": return showRequest(rest, store, options);
         case "answer": return answerRequest(rest, store, options);
         case "cancel": return cancelRequest(rest, store, options);
         default:
@@ -36,7 +38,7 @@ function createRequest(args, store, options) {
     exactPositionals(parsed.positionals, 1, usage);
     const question = requiredOption(parsed.options, "--question");
     const choices = (parsed.multiOptions.get("--choice") ?? []).map(parseInputChoice);
-    const blockedRefs = (parsed.multiOptions.get("--blocks") ?? []).map(parseInputBlockedRef);
+    const blockedValues = parsed.multiOptions.get("--blocks") ?? [];
     const recommendedChoiceKey = optionalNonEmptyOption(parsed.options, "--recommend");
     const timeoutSeconds = optionalNonEmptyOption(parsed.options, "--timeout-seconds");
     if ((recommendedChoiceKey === undefined) !== (timeoutSeconds === undefined)) {
@@ -54,16 +56,42 @@ function createRequest(args, store, options) {
         const task = requireTask(tx, parsed.positionals[0]);
         if (task.status !== "active")
             throw usageError(inactiveTaskMessage(task, "requesting input"));
+        const blockedRefs = blockedValues.map((value) => parseInputBlockedRef(value, task.id));
         validateBlockedInputOwnership(tx, task.id, blockedRefs);
         const origin = requireLeaderInputOrigin(tx, task.id, options.environment);
         const created = createInputRequest(tx.nextInputRequestId(task.id), task.id, origin.requester, { question, choices, blockedRefs, policy }, now);
+        const wasStalled = isRoleRunStalled(tx.listEvents(task.id), origin.run.id);
         tx.saveInputRequest(task.id, created);
-        tx.saveAgentRun(yieldAgentRun(origin.run, `Waiting for input ${created.id}: ${created.question}`, now));
-        tx.clearActiveAgentRun(task.id, LEADER_ROLE);
-        tx.saveRole(task.id, updateRoleStatus(origin.role, "idle", now));
-        if (origin.sessions?.sessions[origin.role.activeAgentId]?.status === "running") {
-            tx.saveTaskRoleSessionSet(updateRoleAgentSessionStatus(origin.sessions, origin.role.activeAgentId, "ready", now));
+        enqueueWork(tx, { kind: "operator" }, "input-requested", now, [
+            { type: "input", taskId: task.id, id: created.id },
+            { type: "run", taskId: task.id, id: origin.run.id }
+        ]);
+        const terminal = terminalizeExactTaskRun(tx, {
+            taskId: task.id,
+            roleName: LEADER_ROLE,
+            agentId: origin.run.effective.agentId,
+            runId: origin.run.id,
+            receiptId: formatAgentRunReceiptId(task.id, origin.run.id),
+            ...(origin.requester.nativeSessionId === undefined
+                ? {}
+                : { nativeSessionId: origin.requester.nativeSessionId }),
+            outcome: {
+                status: "yielded",
+                summary: `Waiting for input ${created.id}: ${created.question}`
+            }
+        }, now);
+        if (terminal.disposition !== "applied") {
+            throw usageError(`Task Leader Run changed while requesting input: ${origin.run.id}/${terminal.reason}.`);
+        }
+        if (wasStalled) {
+            recordTaskEvent(tx, task.id, RUN_RECOVERED_EVENT, {
+                runId: origin.run.id,
+                roleName: LEADER_ROLE,
+                progressAt: now.toISOString(),
+                kind: "input-request"
+            }, now);
         }
+        clearMatchingLeaderStallAttention(tx, task.id, origin.run.id);
         recordTaskEvent(tx, task.id, "input.requested", {
             requestId: created.id,
             requesterRunId: created.requester.runId,
@@ -71,7 +99,7 @@ function createRequest(args, store, options) {
         }, now);
         return created;
     });
-    options.runtime?.notifyStateChanged(request.taskId);
+    notifyMailbox(options, { kind: "operator" }, request.taskId);
     return output(`Created input request ${request.id} for ${request.taskId}\n`, { request });
 }
 function listRequests(args, store) {
@@ -88,9 +116,10 @@ function listRequests(args, store) {
     const requests = parsed.options.has("--all")
         ? all
         : all.filter((request) => request.status === "open");
-    const rendered = requests.length === 0
-        ? "No input requests found.\n"
-        : `${renderTable(taskId === undefined ? "Input inbox" : `Input requests: ${taskId}`, [
+    let rendered = "No input requests found.\n";
+    if (requests.length > 0) {
+        const timeZone = store.getConfig().timeZone;
+        rendered = `${renderTable(taskId === undefined ? "Input inbox" : `Input requests: ${taskId}`, [
             { header: "Input", minWidth: 6, maxWidth: 18 },
             { header: "Task", minWidth: 6, maxWidth: 18 },
             { header: "Status", minWidth: 6, maxWidth: 10 },
@@ -98,29 +127,29 @@ function listRequests(args, store) {
             { header: "Question", minWidth: 8, maxWidth: 72 },
             { header: "Created", minWidth: 10, maxWidth: 28 }
         ], requests.map((request) => [
-            request.id,
+            taskId === undefined ? `${request.taskId}/${request.id}` : request.id,
             request.taskId,
             request.status,
             request.policy.kind,
             request.question,
-            request.createdAt
+            formatTimestamp(request.createdAt, timeZone)
         ]), defaultTableWidth())}\n`;
+    }
     return output(rendered, { requests });
 }
-function showRequest(args, store) {
-    const usage = "Task input show usage: yui task input show <input> [--task <task>].";
+function showRequest(args, store, options) {
+    const usage = "Task input show usage: yui task input show (<task>/<input> | <input> --task <task>).";
     const parsed = parseTail(args, new Set(["--task"]), usage);
     exactPositionals(parsed.positionals, 1, usage);
-    const taskId = optionalNonEmptyOption(parsed.options, "--task");
-    const request = taskId === undefined
-        ? store.findInputRequest(parsed.positionals[0])
-        : store.getInputRequest(requireTask(store, taskId).id, parsed.positionals[0]);
-    if (request === null)
-        throw dataError(`Input request not found: ${parsed.positionals[0]}.`);
-    return output(renderInputRequest(request), { request });
+    const reference = inputRequestReference(store, parsed.positionals[0], optionalNonEmptyOption(parsed.options, "--task"), options.environment);
+    const request = store.getInputRequest(reference.taskId, reference.localId);
+    if (request === null) {
+        throw dataError(`Input request not found: ${reference.taskId}/${reference.localId}.`);
+    }
+    return output(renderInputRequest(request, store.getConfig().timeZone), { request });
 }
 function answerRequest(args, store, options) {
-    const usage = "Task input answer usage: yui task input answer <input> [--task <task>] (--choice <key> | --text <text>).";
+    const usage = "Task input answer usage: yui task input answer (<task>/<input> | <input> --task <task>) (--choice <key> | --text <text>).";
     const parsed = parseTail(args, new Set(["--task", "--choice", "--text"]), usage);
     exactPositionals(parsed.positionals, 1, usage);
     const choice = optionalNonEmptyOption(parsed.options, "--choice");
@@ -128,12 +157,11 @@ function answerRequest(args, store, options) {
     if ((choice === undefined) === (text === undefined)) {
         throw usageError("Exactly one of --choice or --text is required.", usage);
     }
-    const taskHint = optionalNonEmptyOption(parsed.options, "--task");
-    const located = taskHint === undefined
-        ? store.findInputRequest(parsed.positionals[0])
-        : store.getInputRequest(requireTask(store, taskHint).id, parsed.positionals[0]);
-    if (located === null)
-        throw dataError(`Input request not found: ${parsed.positionals[0]}.`);
+    const reference = inputRequestReference(store, parsed.positionals[0], optionalNonEmptyOption(parsed.options, "--task"), options.environment);
+    const located = store.getInputRequest(reference.taskId, reference.localId);
+    if (located === null) {
+        throw dataError(`Input request not found: ${reference.taskId}/${reference.localId}.`);
+    }
     const answer = choice === undefined ? { text: text } : { choiceKey: choice };
     const now = clock(options);
     const request = store.transaction((tx) => {
@@ -149,10 +177,10 @@ function answerRequest(args, store, options) {
             requestId: answered.id,
             answeredBy: answered.resolution.answeredBy
         }, now);
-        queueLeaderWakeup(tx, task.id, `input-answered:${answered.id}`, now);
+        enqueueWork(tx, { kind: "role", taskId: task.id, roleName: LEADER_ROLE }, `input-answered:${answered.id}`, now, [{ type: "input", taskId: task.id, id: answered.id }]);
         return answered;
     });
-    options.runtime?.notifyStateChanged(request.taskId);
+    notifyMailbox(options, { kind: "role", taskId: request.taskId, roleName: LEADER_ROLE }, request.taskId);
     return output(`Answered input request ${request.id} for ${request.taskId}\n`, { request });
 }
 function cancelRequest(args, store, options) {
@@ -168,13 +196,21 @@ function cancelRequest(args, store, options) {
         const current = tx.getInputRequest(task.id, parsed.positionals[1]);
         if (current === null)
             throw dataError(`Input request not found: ${parsed.positionals[1]}.`);
-        assertInputCancelOrigin(current, options.environment);
+        const cancelledBy = assertInputCancelOrigin(tx, current, options.environment);
         const cancelled = cancelInputRequest(current, reason, now);
+        if (cancelled.status !== "cancelled") {
+            throw new Error(`Input request ${cancelled.id} did not enter the cancelled state.`);
+        }
         tx.saveInputRequest(task.id, cancelled);
-        recordTaskEvent(tx, task.id, "input.cancelled", { requestId: cancelled.id }, now);
+        recordTaskEvent(tx, task.id, "input.cancelled", {
+            requestId: cancelled.id,
+            cancelledBy,
+            reason: cancelled.cancellation.reason
+        }, now);
+        enqueueWork(tx, { kind: "role", taskId: task.id, roleName: LEADER_ROLE }, `input-cancelled:${cancelled.id}`, now, [{ type: "input", taskId: task.id, id: cancelled.id }]);
         return cancelled;
     });
-    options.runtime?.notifyStateChanged(request.taskId);
+    notifyMailbox(options, { kind: "role", taskId: request.taskId, roleName: LEADER_ROLE }, request.taskId);
     return output(`Cancelled input request ${request.id} for ${request.taskId}\n`, { request });
 }
 function requireLeaderInputOrigin(store, taskId, environment) {
@@ -184,24 +220,24 @@ function requireLeaderInputOrigin(store, taskId, environment) {
     if (env.YUI_SESSION_SCOPE !== "task"
         || env.YUI_TASK_ID !== taskId
         || env.YUI_ROLE !== LEADER_ROLE
-        || env.YUI_AGENT_ID !== role.activeAgentId
         || run === null
-        || env.YUI_RUN_ID !== run.id
+        || env.YUI_AGENT_ID !== run.effective.agentId
         || run.status !== "active"
-        || run.deliveredAt === undefined
+        || run.pushedAt === undefined
         || run.workItemId !== undefined) {
         throw usageError("Task input request requires the active Leader Run environment.");
     }
     const sessions = store.getTaskRoleSessionSet(taskId, LEADER_ROLE);
     const nativeSessionId = trimmed(env.YUI_NATIVE_SESSION_ID);
     if (nativeSessionId !== undefined
-        && sessions?.sessions[role.activeAgentId]?.nativeSessionId !== nativeSessionId) {
+        && sessions?.sessions[run.effective.agentId]?.nativeSessionId !== nativeSessionId) {
         throw usageError("Task input request native session does not match the active Leader session.");
     }
     return {
         requester: {
+            taskId,
             roleName: "leader",
-            agentId: role.activeAgentId,
+            agentId: run.effective.agentId,
             runId: run.id,
             ...(nativeSessionId === undefined ? {} : { nativeSessionId })
         },
@@ -210,17 +246,62 @@ function requireLeaderInputOrigin(store, taskId, environment) {
         sessions
     };
 }
-function assertInputCancelOrigin(request, environment) {
+function assertInputCancelOrigin(store, request, environment) {
     const env = environment ?? {};
+    if (isCurrentGlobalOperator(store, env)) {
+        return "operator";
+    }
     if (env.YUI_SESSION_SCOPE !== "task"
         || env.YUI_TASK_ID !== request.taskId
         || env.YUI_ROLE !== request.requester.roleName
         || env.YUI_AGENT_ID !== request.requester.agentId
-        || env.YUI_RUN_ID !== request.requester.runId
         || (request.requester.nativeSessionId !== undefined
             && env.YUI_NATIVE_SESSION_ID !== request.requester.nativeSessionId)) {
         throw usageError("Only the originating Leader may cancel this input request.");
     }
+    return "leader";
+}
+function isCurrentGlobalOperator(store, environment) {
+    if (environment.YUI_SESSION_SCOPE !== "global"
+        || environment.YUI_ROLE !== "operator"
+        || environment.YUI_TASK_ID !== undefined)
+        return false;
+    const role = store.getGlobalRole("operator");
+    if (role === null)
+        return false;
+    const sessions = store.getGlobalRoleSessionSet(role.name);
+    const session = activeLiveRoleAgentSession(sessions);
+    if (sessions === null || session === null || sessions.activeAgentId !== role.activeAgentId) {
+        return false;
+    }
+    const agentId = exactIdentity(environment.YUI_AGENT_ID);
+    const adapterId = exactIdentity(environment.YUI_ADAPTER_ID);
+    const launchId = exactIdentity(environment.YUI_LAUNCH_ID);
+    const nativeSessionId = exactIdentity(environment.YUI_NATIVE_SESSION_ID);
+    const binding = role.agentBindings[role.activeAgentId];
+    // A fresh Codex launch discovers its native Session asynchronously. Its
+    // launch envelope therefore cannot carry YUI_NATIVE_SESSION_ID, but the
+    // durable Session still binds that provider identity to the exact launch
+    // generation. Accept that one transport shape only when the current
+    // launch, Agent, and adapter all match; Claude and stale/unknown launches
+    // remain fail-closed on the native identity fence.
+    const nativeSessionMatches = binding !== undefined && (nativeSessionId === session.nativeSessionId
+        || (nativeSessionId === undefined
+            && binding.adapterId === "codex"
+            && session.adapterId === "codex"
+            && session.launchId !== undefined
+            && session.launchId === launchId));
+    return agentId !== undefined
+        && adapterId !== undefined
+        && launchId !== undefined
+        && binding !== undefined
+        && binding.agentId === session.agentId
+        && binding.adapterId === session.adapterId
+        && session.agentId === agentId
+        && session.adapterId === adapterId
+        && session.launchId !== undefined
+        && session.launchId === launchId
+        && nativeSessionMatches;
 }
 function inputAnswerer(environment) {
     const env = environment ?? {};
@@ -237,28 +318,49 @@ function parseInputChoice(value) {
     }
     return { key: value.slice(0, separator).trim(), label: value.slice(separator + 1).trim() };
 }
-function parseInputBlockedRef(value) {
+function parseInputBlockedRef(value, taskId) {
     const separator = value.indexOf(":");
     const type = value.slice(0, separator);
     const id = value.slice(separator + 1).trim();
     if ((type !== "work-item" && type !== "run") || separator <= 0 || id.length === 0) {
         throw usageError("--blocks must use work-item:<id> or run:<id>.");
     }
-    return { type, id };
+    return { type, taskId, id };
 }
 function validateBlockedInputOwnership(store, taskId, references) {
     for (const reference of references) {
         const record = reference.type === "work-item"
-            ? store.findWorkItem(reference.id)
-            : store.findAgentRun(reference.id);
+            ? store.getWorkItem(taskId, reference.id)
+            : store.getAgentRun(taskId, reference.id);
         if (record === null)
             throw dataError(`Blocked ${reference.type} not found: ${reference.id}.`);
-        if (record.taskId !== taskId) {
-            throw usageError(`Blocked ${reference.type} belongs to another Task: ${reference.id}.`);
-        }
     }
 }
-function renderInputRequest(request) {
+function inputRequestReference(store, value, taskHint, environment) {
+    const explicitTaskId = taskHint === undefined
+        ? undefined
+        : requireTask(store, taskHint).id;
+    let reference;
+    try {
+        reference = resolveTaskRecordReference(value, {
+            kind: "inputRequest",
+            label: "Input request reference",
+            ...(explicitTaskId !== undefined
+                ? { contextTaskId: explicitTaskId }
+                : environment?.YUI_TASK_ID === undefined
+                    ? {}
+                    : { contextTaskId: environment.YUI_TASK_ID })
+        });
+    }
+    catch (error) {
+        throw usageError(error instanceof Error ? error.message : String(error));
+    }
+    if (explicitTaskId !== undefined && reference.taskId !== explicitTaskId) {
+        throw usageError(`Input request belongs to another Task: ${reference.taskId}/${reference.localId}.`);
+    }
+    return reference;
+}
+function renderInputRequest(request, timeZone) {
     return [
         `Input: ${request.id}`,
         `Task: ${request.taskId}`,
@@ -275,22 +377,22 @@ function renderInputRequest(request) {
             ? ["Policy: user response required"]
             : [
                 `Policy: use recommended choice ${request.policy.recommendedChoiceKey} after timeout`,
-                `Timeout: ${request.policy.timeoutAt}`
+                `Timeout: ${formatTimestamp(request.policy.timeoutAt, timeZone)}`
             ]),
         ...(request.status === "answered"
             ? [
                 `Answered by: ${request.resolution.answeredBy}`,
                 `Answer: ${request.resolution.answer.text}`,
-                `Answered: ${request.resolution.answeredAt}`
+                `Answered: ${formatTimestamp(request.resolution.answeredAt, timeZone)}`
             ]
             : request.status === "cancelled"
                 ? [
                     `Cancellation: ${request.cancellation.reason}`,
-                    `Cancelled: ${request.cancellation.cancelledAt}`
+                    `Cancelled: ${formatTimestamp(request.cancellation.cancelledAt, timeZone)}`
                 ]
                 : []),
-        `Created: ${request.createdAt}`,
-        `Updated: ${request.updatedAt}`
+        `Created: ${formatTimestamp(request.createdAt, timeZone)}`,
+        `Updated: ${formatTimestamp(request.updatedAt, timeZone)}`
     ].join("\n").concat("\n");
 }
 function requireTask(store, taskId) {
@@ -313,6 +415,8 @@ function inactiveTaskMessage(task, action) {
     if (task.status === "completed") {
         return `Task ${task.id} is completed; reopen it before ${action}.`;
     }
+    if (task.status === "retired")
+        return `Task ${task.id} is retired; it cannot resume ${action}.`;
     return `Task is archived: ${task.id}.`;
 }
 function requiredOption(options, name) {
@@ -332,7 +436,7 @@ function clock(options) {
     return options.now?.() ?? new Date();
 }
 function recordTaskEvent(store, taskId, type, payload, now) {
-    store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), type, payload, now));
+    store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, type, payload, now));
 }
 function requiredText(value, label) {
     const normalized = value?.trim();
@@ -344,6 +448,12 @@ function trimmed(value) {
     const normalized = value?.trim();
     return normalized === undefined || normalized.length === 0 ? undefined : normalized;
 }
+function exactIdentity(value) {
+    if (value === undefined || value.includes("\0"))
+        return undefined;
+    const normalized = value.trim();
+    return normalized.length === 0 || normalized !== value ? undefined : normalized;
+}
 function timeoutAfter(now, value) {
     if (!/^[1-9][0-9]*$/.test(value)) {
         throw usageError("--timeout-seconds must be a positive integer.");
@@ -421,3 +531,11 @@ function parseMultiValueTail(args, valueOptions, repeatOptions, usage) {
     }
     return { positionals, options, multiOptions };
 }
+function notifyMailbox(options, target, compatibilityTaskId) {
+    if (options.runtime?.notifyMailboxChanged !== undefined) {
+        options.runtime.notifyMailboxChanged(target);
+    }
+    else {
+        options.runtime?.notifyStateChanged(compatibilityTaskId);
+    }
+}