@zq-silk/yui 0.0.0

package/dist/commands/taskContextCommand.js

@@ -0,0 +1,215 @@
+import { taskNotFound, usageError } from "../errors/cliError.js";
+import { taskMessageAuthorLabel } from "../message/message.js";
+const RECENT_RECORD_LIMIT = 5;
+const RELATED_RECORD_LIMIT = 5;
+const SUMMARY_TEXT_LIMIT = 400;
+const TERMINAL_WORK_ITEM_STATUSES = new Set([
+    "completed",
+    "failed",
+    "cancelled",
+    "superseded"
+]);
+export function runTaskContextCommand(args, store) {
+    if (args.length !== 1 || args[0]?.trim().length === 0) {
+        throw usageError("Task context usage: yui task context <task>.");
+    }
+    const taskId = args[0].trim();
+    const data = store.transaction((reader) => {
+        const task = reader.getTask(taskId);
+        if (task === null)
+            throw taskNotFound(taskId);
+        const workItems = reader.listWorkItems(task.id);
+        const workItemIds = new Set(workItems.map((item) => item.id));
+        const inputRequests = reader.listInputRequests(task.id);
+        return {
+            task,
+            brief: reader.getTaskBrief(task.id),
+            activeDecisions: reader.listDecisions(task.id)
+                .filter((decision) => decision.status === "active"),
+            milestones: reader.listMilestones(task.id),
+            roles: reader.listRoles(task.id),
+            workItems,
+            runs: reader.listAgentRuns(task.id)
+                .filter((run) => run.workItemId !== undefined && workItemIds.has(run.workItemId)),
+            messages: reader.listMessages(task.id),
+            openInputRequests: inputRequests.filter((request) => request.status === "open"),
+            resolvedInputRequests: inputRequests.filter((request) => request.status !== "open"),
+            events: reader.listEvents(task.id)
+        };
+    });
+    const { task, brief, activeDecisions, milestones, roles, workItems, runs, messages, openInputRequests, resolvedInputRequests, events } = data;
+    const displayedActiveDecisions = activeDecisions.slice(-RECENT_RECORD_LIMIT);
+    const displayedWorkItems = currentAndRecentWorkItems(workItems);
+    const displayedOpenInputRequests = openInputRequests.slice(-RECENT_RECORD_LIMIT);
+    const displayedResolvedInputRequests = resolvedInputRequests.slice(-RECENT_RECORD_LIMIT);
+    const lines = [
+        `Task context: ${task.id}`,
+        `Title: ${compactText(task.title)}`,
+        `Status: ${task.status}`,
+        ...(task.description === undefined ? [] : [`Description: ${compactText(task.description)}`]),
+        ...(task.priority === undefined ? [] : [`Priority: ${task.priority}`]),
+        ...(task.tags === undefined ? [] : [`Tags: ${task.tags.join(", ")}`]),
+        ...(task.dueAt === undefined ? [] : [`Due: ${task.dueAt}`]),
+        ...(task.completionSummary === undefined ? [] : [`Completion summary: ${task.completionSummary}`]),
+        ...(task.archiveSummary === undefined ? [] : [`Archive summary: ${task.archiveSummary}`]),
+        ...(task.repositoryId === undefined ? [] : [`Repository: ${task.repositoryId}`]),
+        ...(task.baseRef === undefined ? [] : [`Base: ${task.baseRef}`]),
+        ...(task.cwd === undefined ? [] : [`Workspace: ${task.cwd}`]),
+        "",
+        "Brief:",
+        ...(brief === null
+            ? ["  No brief."]
+            : [
+                `  Objective: ${compactText(brief.objective)}`,
+                "  Boundaries:",
+                ...(brief.boundaries.length === 0
+                    ? ["    None."]
+                    : brief.boundaries.map((boundary) => `    - ${compactText(boundary)}`)),
+                `  Current focus: ${compactText(brief.currentFocus)}`,
+                `  Leader summary: ${compactText(brief.leaderSummary)}`,
+                `  Updated by ${brief.updatedBy} at ${brief.updatedAt}`
+            ]),
+        "",
+        `Active decisions (${displayedActiveDecisions.length}${activeDecisions.length > displayedActiveDecisions.length ? ` of ${activeDecisions.length}` : ""}):`,
+        ...(displayedActiveDecisions.length === 0
+            ? ["  None."]
+            : displayedActiveDecisions.flatMap((decision) => [
+                `  ${decision.id}: ${compactText(decision.title)}`,
+                `    Rationale: ${compactText(decision.rationale)}`
+            ])),
+        "",
+        ...recentSection("milestones", milestones, (milestone) => [
+            `  ${milestone.id}: ${compactText(milestone.title)} (${milestone.createdAt})`,
+            `    ${compactText(milestone.summary)}`
+        ]),
+        "",
+        `Roles (${roles.length}):`,
+        ...(roles.length === 0
+            ? ["  None."]
+            : roles.map((role) => (`  ${role.name} [${role.status}] — Agent: ${role.activeAgentId}`))),
+        "",
+        `Current and recent work items (${displayedWorkItems.length}${workItems.length > displayedWorkItems.length ? ` of ${workItems.length}` : ""}):`,
+        ...(displayedWorkItems.length === 0
+            ? ["  None."]
+            : displayedWorkItems.flatMap((item) => {
+                const itemRuns = runs.filter((run) => run.workItemId === item.id);
+                const latestRun = itemRuns.at(-1);
+                return [
+                    `  ${item.id} [${item.status}] ${item.assignee}: ${compactText(item.title)}`,
+                    ...(item.outcome === undefined
+                        ? []
+                        : [`    Outcome: ${compactText(item.outcome)}`]),
+                    ...(latestRun === undefined
+                        ? ["    Runs: none."]
+                        : [
+                            `    Runs: ${itemRuns.length}; latest ${latestRun.id} [${latestRun.status}] ${latestRun.roleName}`,
+                            `      Input: ${compactText(latestRun.input)}`,
+                            ...(latestRun.summary === undefined
+                                ? []
+                                : [`      Summary: ${compactText(latestRun.summary)}`])
+                        ])
+                ];
+            })),
+        "",
+        ...recentSection("messages", messages, (message) => [
+            `  ${message.id} [${taskMessageAuthorLabel(message.author)}] ${message.createdAt}`,
+            `    ${compactText(message.body)}`
+        ]),
+        "",
+        `Open input requests (${displayedOpenInputRequests.length}${openInputRequests.length > displayedOpenInputRequests.length ? ` of ${openInputRequests.length}` : ""}):`,
+        ...(displayedOpenInputRequests.length === 0
+            ? ["  None."]
+            : displayedOpenInputRequests.flatMap(renderOpenInputRequest)),
+        "",
+        `Recent resolved input requests (${displayedResolvedInputRequests.length}${resolvedInputRequests.length > displayedResolvedInputRequests.length ? ` of ${resolvedInputRequests.length}` : ""}):`,
+        ...(displayedResolvedInputRequests.length === 0
+            ? ["  None."]
+            : displayedResolvedInputRequests.flatMap(renderResolvedInputRequest)),
+        "",
+        ...recentSection("events", events, (event) => [
+            `  ${event.id} ${event.type} (${event.createdAt})`,
+            ...(Object.keys(event.payload).length === 0
+                ? []
+                : [`    ${Object.entries(event.payload)
+                        .map(([key, value]) => `${key}=${compactText(value)}`)
+                        .join(", ")}`])
+        ])
+    ];
+    return {
+        kind: "output",
+        output: `${lines.join("\n")}\n`,
+        data
+    };
+}
+function renderResolvedInputRequest(request) {
+    if (request.status === "open")
+        return [];
+    return [
+        `  ${request.id} [${request.status}]`,
+        `    Question: ${compactText(request.question)}`,
+        ...(request.status === "answered"
+            ? [
+                `    Answer: ${compactText(request.resolution.answer.text)}`,
+                `    Answered by ${request.resolution.answeredBy} at ${request.resolution.answeredAt}`
+            ]
+            : [
+                `    Cancelled: ${compactText(request.cancellation.reason)}`,
+                `    Cancelled at: ${request.cancellation.cancelledAt}`
+            ])
+    ];
+}
+function renderOpenInputRequest(request) {
+    const choices = request.choices.slice(0, RELATED_RECORD_LIMIT);
+    const blockedRefs = request.blockedRefs.slice(0, RELATED_RECORD_LIMIT);
+    const recommendedChoiceKey = request.policy.kind === "recommended"
+        ? request.policy.recommendedChoiceKey
+        : undefined;
+    const recommendedChoice = recommendedChoiceKey === undefined
+        ? undefined
+        : request.choices.find((choice) => choice.key === recommendedChoiceKey);
+    return [
+        `  ${request.id} [${request.policy.kind}]`,
+        `    Question: ${compactText(request.question)}`,
+        ...(request.choices.length === 0
+            ? ["    Choices: none (free-text answer)."]
+            : [
+                `    Choices (${choices.length}${request.choices.length > choices.length ? ` of ${request.choices.length}` : ""}):`,
+                ...choices.map((choice) => `      ${choice.key}: ${compactText(choice.label)}`)
+            ]),
+        ...(request.policy.kind === "recommended"
+            ? [
+                `    Recommended choice: ${request.policy.recommendedChoiceKey}: ${compactText(recommendedChoice?.label ?? request.policy.recommendedChoiceKey)}`,
+                `    Timeout at: ${request.policy.timeoutAt}`
+            ]
+            : []),
+        ...(request.blockedRefs.length === 0
+            ? ["    Blocks: none."]
+            : [
+                `    Blocks (${blockedRefs.length}${request.blockedRefs.length > blockedRefs.length ? ` of ${request.blockedRefs.length}` : ""}):`,
+                ...blockedRefs.map((reference) => `      ${reference.type}:${reference.id}`)
+            ])
+    ];
+}
+function recentSection(label, records, render) {
+    const recent = records.slice(-RECENT_RECORD_LIMIT);
+    const title = `Recent ${label} (${recent.length}${records.length > recent.length ? ` of ${records.length}` : ""}):`;
+    return recent.length === 0
+        ? [title, "  None."]
+        : [title, ...recent.flatMap(render)];
+}
+function currentAndRecentWorkItems(records) {
+    const current = records.filter((record) => !TERMINAL_WORK_ITEM_STATUSES.has(record.status));
+    if (current.length >= RECENT_RECORD_LIMIT)
+        return current;
+    const recentTerminal = records
+        .filter((record) => TERMINAL_WORK_ITEM_STATUSES.has(record.status))
+        .slice(-(RECENT_RECORD_LIMIT - current.length));
+    const selected = new Set([...current, ...recentTerminal]);
+    return records.filter((record) => selected.has(record));
+}
+function compactText(value) {
+    const oneLine = value.replace(/\s+/g, " ").trim();
+    return oneLine.length <= SUMMARY_TEXT_LIMIT
+        ? oneLine
+        : `${oneLine.slice(0, SUMMARY_TEXT_LIMIT - 3)}...`;
+}

package/dist/commands/taskInputCommands.js

@@ -0,0 +1,423 @@
+import { dataError, roleNotFound, taskNotFound, usageError } from "../errors/cliError.js";
+import { createTaskEvent } from "../event/taskEvent.js";
+import { updateRoleAgentSessionStatus } 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";
+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 "answer": return answerRequest(rest, store, options);
+        case "cancel": return cancelRequest(rest, store, options);
+        default:
+            throw usageError(command === undefined
+                ? "Task input command is required."
+                : `Unknown command: task input ${command}`);
+    }
+}
+export function openInputRequestCount(store, taskId) {
+    return store.listInputRequests(taskId).filter((request) => request.status === "open").length;
+}
+export function assertNoOpenInputRequests(store, taskId, action) {
+    const open = store.listInputRequests(taskId).find((request) => request.status === "open");
+    if (open !== undefined) {
+        throw usageError(`Task ${taskId} has open input ${open.id}; resolve it before ${action}.`);
+    }
+}
+function createRequest(args, store, options) {
+    const usage = "Task input request usage: yui task input request <task> --question <text> [--choice <key=label> ...] [--blocks <work-item:id|run:id> ...] [--recommend <key> --timeout-seconds <seconds>].";
+    const parsed = parseMultiValueTail(args, new Set(["--question", "--recommend", "--timeout-seconds"]), new Set(["--choice", "--blocks"]), usage);
+    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 recommendedChoiceKey = optionalNonEmptyOption(parsed.options, "--recommend");
+    const timeoutSeconds = optionalNonEmptyOption(parsed.options, "--timeout-seconds");
+    if ((recommendedChoiceKey === undefined) !== (timeoutSeconds === undefined)) {
+        throw usageError("--recommend and --timeout-seconds must be used together.", usage);
+    }
+    const now = clock(options);
+    const policy = recommendedChoiceKey === undefined
+        ? { kind: "required" }
+        : {
+            kind: "recommended",
+            recommendedChoiceKey,
+            timeoutAt: timeoutAfter(now, timeoutSeconds)
+        };
+    const request = store.transaction((tx) => {
+        const task = requireTask(tx, parsed.positionals[0]);
+        if (task.status !== "active")
+            throw usageError(inactiveTaskMessage(task, "requesting input"));
+        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);
+        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));
+        }
+        recordTaskEvent(tx, task.id, "input.requested", {
+            requestId: created.id,
+            requesterRunId: created.requester.runId,
+            policy: created.policy.kind
+        }, now);
+        return created;
+    });
+    options.runtime?.notifyStateChanged(request.taskId);
+    return output(`Created input request ${request.id} for ${request.taskId}\n`, { request });
+}
+function listRequests(args, store) {
+    const usage = "Task input list usage: yui task input list [task] [--all].";
+    const parsed = parseTail(args, new Set(), usage, new Set(["--all"]));
+    if (parsed.positionals.length > 1)
+        throw usageError(usage);
+    const taskId = parsed.positionals[0];
+    if (taskId !== undefined)
+        requireTask(store, taskId);
+    const all = taskId === undefined
+        ? store.listAllInputRequests()
+        : store.listInputRequests(taskId);
+    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}`, [
+            { header: "Input", minWidth: 6, maxWidth: 18 },
+            { header: "Task", minWidth: 6, maxWidth: 18 },
+            { header: "Status", minWidth: 6, maxWidth: 10 },
+            { header: "Policy", minWidth: 8, maxWidth: 12 },
+            { header: "Question", minWidth: 8, maxWidth: 72 },
+            { header: "Created", minWidth: 10, maxWidth: 28 }
+        ], requests.map((request) => [
+            request.id,
+            request.taskId,
+            request.status,
+            request.policy.kind,
+            request.question,
+            request.createdAt
+        ]), defaultTableWidth())}\n`;
+    return output(rendered, { requests });
+}
+function showRequest(args, store) {
+    const usage = "Task input show usage: yui task input show <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 });
+}
+function answerRequest(args, store, options) {
+    const usage = "Task input answer usage: yui task input answer <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");
+    const text = optionalNonEmptyOption(parsed.options, "--text");
+    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 answer = choice === undefined ? { text: text } : { choiceKey: choice };
+    const now = clock(options);
+    const request = store.transaction((tx) => {
+        const current = tx.getInputRequest(located.taskId, located.id);
+        if (current === null)
+            throw dataError(`Input request not found: ${located.id}.`);
+        const task = requireTask(tx, current.taskId);
+        if (task.status !== "active")
+            throw usageError(inactiveTaskMessage(task, "answering input"));
+        const answered = answerInputRequest(current, answer, inputAnswerer(options.environment), now);
+        tx.saveInputRequest(task.id, answered);
+        recordTaskEvent(tx, task.id, "input.answered", {
+            requestId: answered.id,
+            answeredBy: answered.resolution.answeredBy
+        }, now);
+        queueLeaderWakeup(tx, task.id, `input-answered:${answered.id}`, now);
+        return answered;
+    });
+    options.runtime?.notifyStateChanged(request.taskId);
+    return output(`Answered input request ${request.id} for ${request.taskId}\n`, { request });
+}
+function cancelRequest(args, store, options) {
+    const usage = "Task input cancel usage: yui task input cancel <task> <input> --reason <text>.";
+    const parsed = parseTail(args, new Set(["--reason"]), usage);
+    exactPositionals(parsed.positionals, 2, usage);
+    const reason = requiredOption(parsed.options, "--reason");
+    const now = clock(options);
+    const request = store.transaction((tx) => {
+        const task = requireTask(tx, parsed.positionals[0]);
+        if (task.status !== "active")
+            throw usageError(inactiveTaskMessage(task, "cancelling input"));
+        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 cancelled = cancelInputRequest(current, reason, now);
+        tx.saveInputRequest(task.id, cancelled);
+        recordTaskEvent(tx, task.id, "input.cancelled", { requestId: cancelled.id }, now);
+        return cancelled;
+    });
+    options.runtime?.notifyStateChanged(request.taskId);
+    return output(`Cancelled input request ${request.id} for ${request.taskId}\n`, { request });
+}
+function requireLeaderInputOrigin(store, taskId, environment) {
+    const env = environment ?? {};
+    const role = requireRole(store, taskId, LEADER_ROLE);
+    const run = store.getActiveAgentRun(taskId, LEADER_ROLE);
+    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
+        || run.status !== "active"
+        || run.deliveredAt === 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) {
+        throw usageError("Task input request native session does not match the active Leader session.");
+    }
+    return {
+        requester: {
+            roleName: "leader",
+            agentId: role.activeAgentId,
+            runId: run.id,
+            ...(nativeSessionId === undefined ? {} : { nativeSessionId })
+        },
+        role,
+        run,
+        sessions
+    };
+}
+function assertInputCancelOrigin(request, environment) {
+    const env = environment ?? {};
+    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.");
+    }
+}
+function inputAnswerer(environment) {
+    const env = environment ?? {};
+    if (env.YUI_SESSION_SCOPE === undefined && env.YUI_ROLE === undefined)
+        return "user";
+    if (env.YUI_SESSION_SCOPE === "global" && env.YUI_ROLE === "operator")
+        return "operator";
+    throw usageError("Task input answers may be submitted only by the user or Operator.");
+}
+function parseInputChoice(value) {
+    const separator = value.indexOf("=");
+    if (separator <= 0 || separator === value.length - 1) {
+        throw usageError("--choice must use key=label.");
+    }
+    return { key: value.slice(0, separator).trim(), label: value.slice(separator + 1).trim() };
+}
+function parseInputBlockedRef(value) {
+    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 };
+}
+function validateBlockedInputOwnership(store, taskId, references) {
+    for (const reference of references) {
+        const record = reference.type === "work-item"
+            ? store.findWorkItem(reference.id)
+            : store.findAgentRun(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) {
+    return [
+        `Input: ${request.id}`,
+        `Task: ${request.taskId}`,
+        `Status: ${request.status}`,
+        `Question: ${request.question}`,
+        `Requested by: ${request.requester.agentId}/${request.requester.runId}`,
+        ...(request.choices.length === 0
+            ? ["Answer type: text"]
+            : ["Choices:", ...request.choices.map((choice) => `  ${choice.key}: ${choice.label}`)]),
+        ...(request.blockedRefs.length === 0
+            ? []
+            : ["Blocks:", ...request.blockedRefs.map((reference) => `  ${reference.type}:${reference.id}`)]),
+        ...(request.policy.kind === "required"
+            ? ["Policy: user response required"]
+            : [
+                `Policy: use recommended choice ${request.policy.recommendedChoiceKey} after timeout`,
+                `Timeout: ${request.policy.timeoutAt}`
+            ]),
+        ...(request.status === "answered"
+            ? [
+                `Answered by: ${request.resolution.answeredBy}`,
+                `Answer: ${request.resolution.answer.text}`,
+                `Answered: ${request.resolution.answeredAt}`
+            ]
+            : request.status === "cancelled"
+                ? [
+                    `Cancellation: ${request.cancellation.reason}`,
+                    `Cancelled: ${request.cancellation.cancelledAt}`
+                ]
+                : []),
+        `Created: ${request.createdAt}`,
+        `Updated: ${request.updatedAt}`
+    ].join("\n").concat("\n");
+}
+function requireTask(store, taskId) {
+    const id = requiredText(taskId, "Task id");
+    const task = store.getTask(id);
+    if (task === null)
+        throw taskNotFound(id);
+    return task;
+}
+function requireRole(store, taskId, roleName) {
+    const role = store.getRole(taskId, roleName);
+    if (role === null)
+        throw roleNotFound(roleName);
+    return role;
+}
+function inactiveTaskMessage(task, action) {
+    if (task.status === "draft") {
+        return `Task ${task.id} is a Draft; activate it before ${action}.`;
+    }
+    if (task.status === "completed") {
+        return `Task ${task.id} is completed; reopen it before ${action}.`;
+    }
+    return `Task is archived: ${task.id}.`;
+}
+function requiredOption(options, name) {
+    return requiredText(options.get(name), name);
+}
+function optionalNonEmptyOption(options, name) {
+    if (!options.has(name))
+        return undefined;
+    return requiredText(options.get(name), name);
+}
+function output(value, data) {
+    return data === undefined
+        ? { kind: "output", output: value }
+        : { kind: "output", output: value, data };
+}
+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));
+}
+function requiredText(value, label) {
+    const normalized = value?.trim();
+    if (normalized === undefined || normalized.length === 0)
+        throw usageError(`${label} is required.`);
+    return normalized;
+}
+function trimmed(value) {
+    const normalized = value?.trim();
+    return normalized === undefined || normalized.length === 0 ? undefined : normalized;
+}
+function timeoutAfter(now, value) {
+    if (!/^[1-9][0-9]*$/.test(value)) {
+        throw usageError("--timeout-seconds must be a positive integer.");
+    }
+    const seconds = Number(value);
+    const timestamp = now.getTime() + seconds * 1_000;
+    const timeout = new Date(timestamp);
+    if (!Number.isSafeInteger(seconds) || !Number.isFinite(timeout.getTime())) {
+        throw usageError("--timeout-seconds is too large.");
+    }
+    return timeout.toISOString();
+}
+function exactPositionals(values, count, usage) {
+    if (values.length !== count || values.some((value) => value.trim().length === 0)) {
+        throw usageError(usage);
+    }
+}
+function parseTail(args, valueOptions, usage, flagOptions = new Set()) {
+    const positionals = [];
+    const options = new Map();
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (!value.startsWith("--")) {
+            positionals.push(value);
+            continue;
+        }
+        if (!valueOptions.has(value) && !flagOptions.has(value)) {
+            throw usageError(`Unsupported option: ${value}.`, usage);
+        }
+        if (options.has(value))
+            throw usageError(`Option may only be specified once: ${value}.`, usage);
+        if (flagOptions.has(value)) {
+            options.set(value, "");
+            continue;
+        }
+        const optionValue = args[index + 1];
+        if (optionValue === undefined || optionValue.startsWith("--")) {
+            throw usageError(`${value} is required.`, usage);
+        }
+        options.set(value, optionValue);
+        index += 1;
+    }
+    return { positionals, options };
+}
+function parseMultiValueTail(args, valueOptions, repeatOptions, usage) {
+    const positionals = [];
+    const options = new Map();
+    const multiOptions = new Map();
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (!value.startsWith("--")) {
+            positionals.push(value);
+            continue;
+        }
+        if (!valueOptions.has(value) && !repeatOptions.has(value)) {
+            throw usageError(`Unsupported option: ${value}.`, usage);
+        }
+        if (repeatOptions.has(value)) {
+            const optionValue = args[index + 1];
+            if (optionValue === undefined || optionValue.startsWith("--")) {
+                throw usageError(`${value} is required.`, usage);
+            }
+            multiOptions.set(value, [...(multiOptions.get(value) ?? []), optionValue]);
+            index += 1;
+            continue;
+        }
+        if (options.has(value))
+            throw usageError(`Option may only be specified once: ${value}.`, usage);
+        const optionValue = args[index + 1];
+        if (optionValue === undefined || optionValue.startsWith("--")) {
+            throw usageError(`${value} is required.`, usage);
+        }
+        options.set(value, optionValue);
+        index += 1;
+    }
+    return { positionals, options, multiOptions };
+}