@zq-silk/yui 0.2.0 → 0.4.2

package/dist/commands/taskIntegrationCommands.js

@@ -0,0 +1,303 @@
+import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
+import { resolveProject } from "../repository/project.js";
+import { workspaceProjectEntry } from "../worktree/managedWorkspace.js";
+import { usageError } from "../errors/cliError.js";
+import { defaultTableWidth, renderTable } from "../output/table.js";
+import { createIntegrationAttempt, recordResolutionDecision, updateIntegrationAttempt } from "../integration/integrationAttempt.js";
+import { GitIntegrationService } from "../integration/gitIntegrationService.js";
+import { taskActor } from "./taskActor.js";
+import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
+export async function runTaskIntegrationCommand(args, store, home, options = {}) {
+    const now = options.now ?? (() => new Date());
+    const [command, ...rest] = args;
+    if (command === "start")
+        return start(rest, store, home, now, options.environment);
+    if (command === "continue") {
+        return continueIntegration(rest, store, home, now, options.environment);
+    }
+    if (command === "resolve") {
+        return resolveDecision(rest, store, now, options.environment);
+    }
+    if (command === "abort")
+        return abortIntegration(rest, store, now(), options.environment);
+    if (command === "cleanup") {
+        return cleanupIntegration(rest, store, home, options.environment);
+    }
+    if (command === "list")
+        return list(rest, store);
+    if (command === "show")
+        return show(rest, store, options.environment);
+    throw usageError(command === undefined
+        ? "Task Integration command is required."
+        : `Unknown command: task integration ${command}`);
+}
+async function cleanupIntegration(args, store, home, environment) {
+    if (args.length !== 1) {
+        throw usageError("Task Integration cleanup usage: yui task integration cleanup <task>/<integration>.");
+    }
+    const integration = requireIntegration(store, args[0], environment);
+    if (integration.status !== "committed" && integration.status !== "failed") {
+        throw usageError(`Integration is not terminal: ${integration.id}/${integration.status}.`);
+    }
+    const result = await new GitIntegrationService(home, store).cleanup(integration);
+    if (result === "dirty") {
+        throw usageError(`Integration worktree contains unresolved or uncommitted changes: ${integration.id}. Inspect it before cleanup.`);
+    }
+    return {
+        output: result === "removed"
+            ? `Cleaned Integration worktree and check logs ${integration.id}\n`
+            : `Integration worktree and check logs already clean: ${integration.id}\n`,
+        data: { integrationId: integration.id, cleanup: result }
+    };
+}
+async function start(args, store, home, now, environment) {
+    const usage = "Task Integration start usage: yui task integration start <task> [--project <project>] --change-set <id> [--change-set <id> ...] [--target <ref>] [--check <command> ...].";
+    const parsed = parseRepeatable(args, new Set(["--change-set", "--check"]), new Set(["--project", "--target"]), usage);
+    if (parsed.positionals.length !== 1)
+        throw usageError(usage);
+    const task = store.getTask(parsed.positionals[0]);
+    if (task === null)
+        throw usageError(`Task not found: ${parsed.positionals[0]}.`);
+    if (task.status !== "active") {
+        throw usageError(`Task is not active: ${task.id}/${task.status}.`);
+    }
+    const changeSetIds = parsed.many.get("--change-set") ?? [];
+    if (changeSetIds.length === 0)
+        throw usageError("--change-set is required.", usage);
+    const changeSets = changeSetIds.map((id) => {
+        const changeSet = store.getChangeSet(task.id, id);
+        if (changeSet === null)
+            throw usageError(`ChangeSet not found: ${id}.`);
+        return changeSet;
+    });
+    const reviewEvidence = new Set(store.listReviewRounds(task.id)
+        .flatMap(({ evidenceCommit }) => evidenceCommit === undefined ? [] : [evidenceCommit]));
+    const reviewSource = changeSets.find(({ headCommit }) => reviewEvidence.has(headCommit));
+    if (reviewSource !== undefined) {
+        throw usageError(`ReviewRound evidence commit cannot become an Integration source: ${reviewSource.id}.`);
+    }
+    const projectIds = [...new Set(changeSets.map(({ projectId }) => projectId))];
+    if (projectIds.length !== 1) {
+        throw usageError("An Integration may only contain ChangeSets from one Project.");
+    }
+    const requestedProject = parsed.one.get("--project");
+    const project = requestedProject === undefined
+        ? store.getProject(projectIds[0])
+        : resolveProject(store.listProjects(), requestedProject);
+    if (project === null)
+        throw usageError(`Project not found: ${requestedProject ?? projectIds[0]}.`);
+    if (project.id !== projectIds[0]) {
+        throw usageError(`ChangeSets belong to another Project: ${projectIds[0]}.`);
+    }
+    if (!task.projectBindings.some(({ projectId }) => projectId === project.id)) {
+        throw usageError(`Project does not belong to Task: ${project.id}.`);
+    }
+    const mainWorkspace = store.getTaskWorkspace(task.id);
+    const mainEntry = mainWorkspace === null
+        ? undefined
+        : workspaceProjectEntry(mainWorkspace, project.id);
+    const targetRef = parsed.one.get("--target") ?? mainEntry?.branch;
+    if (targetRef === undefined) {
+        throw usageError(`Task main worktree is not ready; reconcile the Task first: ${task.id}.`);
+    }
+    const expectedHead = (await new NodeGitWorkspace().inspect(project.path, targetRef)).baseCommit;
+    const integration = store.transaction((tx) => {
+        const created = createIntegrationAttempt({
+            id: tx.nextIntegrationAttemptId(task.id),
+            taskId: task.id,
+            projectId: project.id,
+            targetRef,
+            expectedHead,
+            changeSetIds,
+            checkCommands: parsed.many.get("--check") ?? []
+        }, now());
+        tx.saveIntegrationAttempt(task.id, created);
+        return created;
+    });
+    return runIntegration(store, home, integration, now, environment);
+}
+async function continueIntegration(args, store, home, now, environment) {
+    const usage = "Task Integration continue usage: yui task integration continue <task>/<integration>.";
+    const parsed = parseRepeatable(args, new Set(), new Set(), usage);
+    if (parsed.positionals.length !== 1)
+        throw usageError(usage);
+    const integration = requireIntegration(store, parsed.positionals[0], environment);
+    requireActiveIntegrationTask(store, integration);
+    if (integration.status !== "validating"
+        && (integration.status !== "blocked"
+            || integration.resolution?.action !== "manual-resolution")) {
+        throw usageError(`Integration is not ready to continue: ${integration.id}/${integration.status}.`);
+    }
+    return runIntegration(store, home, integration, now, environment);
+}
+async function runIntegration(store, home, integration, now, environment) {
+    const result = await new GitIntegrationService(home, store, undefined, now, environment)
+        .integrate(integration.taskId, integration.id);
+    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} failed; target ref was not advanced\n`;
+    return { output, data: result };
+}
+function resolveDecision(args, store, now, environment) {
+    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);
+    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`,
+        data: { integration: resolved }
+    };
+}
+function abortIntegration(args, store, now, environment) {
+    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], environment);
+    requireActiveIntegrationTask(store, integration);
+    if (integration.status !== "running" && integration.status !== "blocked") {
+        throw usageError(`Integration cannot be aborted from ${integration.status}: ${integration.id}.`);
+    }
+    const reason = parsed.one.get("--reason");
+    if (reason === undefined)
+        throw usageError(usage);
+    const aborted = updateIntegrationAttempt(integration, {
+        status: "failed",
+        checks: [
+            ...(integration.checks ?? []),
+            { name: "aborted", outcome: "failed", details: reason }
+        ]
+    }, now);
+    store.saveIntegrationAttempt(aborted.taskId, aborted);
+    return {
+        output: `Aborted Integration ${aborted.id}; start a new Integration Attempt to retry\n`,
+        data: { integration: aborted }
+    };
+}
+function requireActiveIntegrationTask(store, integration) {
+    const task = store.getTask(integration.taskId);
+    if (task === null)
+        throw usageError(`Task not found: ${integration.taskId}.`);
+    if (task.status !== "active") {
+        throw usageError(`Task is not active: ${task.id}/${task.status}.`);
+    }
+    return task;
+}
+function list(args, store) {
+    if (args.length !== 1)
+        throw usageError("Task Integration list usage: yui task integration list <task>.");
+    const task = store.getTask(args[0]);
+    if (task === null)
+        throw usageError(`Task not found: ${args[0]}.`);
+    const integrations = store.listIntegrationAttempts(task.id);
+    const output = integrations.length === 0
+        ? "No Integration Attempts found.\n"
+        : `${renderTable(`Integration Attempts: ${task.id}`, [
+            { header: "Integration", minWidth: 11, maxWidth: 24 },
+            { header: "Project", minWidth: 8, maxWidth: 20 },
+            { header: "Target", minWidth: 8, maxWidth: 30 },
+            { header: "Changes", minWidth: 7, maxWidth: 10 },
+            { header: "Status", minWidth: 7, maxWidth: 20 }
+        ], integrations.map((entry) => [
+            entry.id,
+            entry.projectId,
+            entry.targetRef,
+            String(entry.changeSetIds.length),
+            entry.status
+        ]), defaultTableWidth())}\n`;
+    return { output, data: { integrations } };
+}
+function show(args, store, environment) {
+    if (args.length !== 1)
+        throw usageError("Task Integration show usage: yui task integration show <task>/<integration>.");
+    const integration = requireIntegration(store, args[0], environment);
+    return {
+        output: `${[
+            `Integration Attempt: ${integration.id}`,
+            `Task: ${integration.taskId}`,
+            `Project: ${integration.projectId}`,
+            `Target: ${integration.targetRef}`,
+            `Expected head: ${integration.expectedHead}`,
+            `Candidate: ${integration.candidateCommit ?? "-"}`,
+            `ChangeSets: ${integration.changeSetIds.join(", ")}`,
+            `Status: ${integration.status}`,
+            `Conflict: ${integration.conflict?.summary ?? "-"}`,
+            `Resolution: ${integration.resolution?.action ?? "-"}`,
+            ...(integration.checks === undefined
+                ? ["Checks: -"]
+                : [
+                    "Checks:",
+                    ...integration.checks.flatMap((check) => [
+                        `- ${check.outcome}: ${check.name}`,
+                        ...(check.details === undefined ? [] : [`  ${check.details}`]),
+                        ...(check.logPath === undefined ? [] : [`  Log: ${check.logPath}`])
+                    ])
+                ])
+        ].join("\n")}\n`,
+        data: { integration }
+    };
+}
+function requireIntegration(store, value, environment) {
+    let reference;
+    try {
+        reference = resolveTaskRecordReference(value, {
+            kind: "integrationAttempt",
+            contextTaskId: environment?.YUI_TASK_ID,
+            label: "Integration Attempt"
+        });
+    }
+    catch (error) {
+        throw usageError(error instanceof Error ? error.message : String(error));
+    }
+    const attempt = store.getIntegrationAttempt(reference.taskId, reference.localId);
+    if (attempt === null) {
+        throw usageError(`Integration Attempt not found: ${reference.taskId}/${reference.localId}.`);
+    }
+    return attempt;
+}
+function parseRepeatable(args, repeatable, singular, usage) {
+    const positionals = [];
+    const many = new Map();
+    const one = new Map();
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (!value.startsWith("--")) {
+            positionals.push(value);
+            continue;
+        }
+        if (!repeatable.has(value) && !singular.has(value)) {
+            throw usageError(`Unsupported option: ${value}.`, usage);
+        }
+        if (singular.has(value) && one.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);
+        }
+        if (repeatable.has(value))
+            many.set(value, [...(many.get(value) ?? []), optionValue]);
+        else
+            one.set(value, optionValue);
+        index += 1;
+    }
+    return { positionals, many, one };
+}

package/dist/commands/taskOverviewCommand.js

@@ -0,0 +1,363 @@
+import { usageError } from "../errors/cliError.js";
+import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
+import { formatTimestamp } from "../output/timePresentation.js";
+import { defaultTableWidth, renderTable } from "../output/table.js";
+import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
+export function parseTaskListOptions(args) {
+    const allowed = new Set(["--all", "--verbose"]);
+    if (args.some((argument) => !allowed.has(argument))
+        || new Set(args).size !== args.length) {
+        throw usageError("Task list usage: yui task list [--all] [--verbose].");
+    }
+    return {
+        all: args.includes("--all"),
+        verbose: args.includes("--verbose")
+    };
+}
+export function buildTaskOverview(store, options) {
+    const tasks = store.listTasks()
+        .filter((task) => options.all || task.status !== "archived")
+        .map((task) => buildTaskOverviewEntry(task, store));
+    return { tasks };
+}
+export function renderTaskOverview(result, options, timeZone, width = defaultTableWidth()) {
+    if (result.tasks.length === 0)
+        return "No tasks found.\n";
+    const title = options.all ? "Tasks (all)" : "Tasks (unarchived)";
+    const output = renderTable(title, [
+        { header: "Task", minWidth: 8, maxWidth: 20 },
+        { header: "Title", minWidth: 10, maxWidth: 46 },
+        { header: "Lifecycle", minWidth: 9, maxWidth: 14 },
+        { header: "Leader", minWidth: 12, maxWidth: 48 },
+        { header: "Summary updated", minWidth: 16, maxWidth: 28 },
+        { header: "Work", minWidth: 8, maxWidth: 38 },
+        { header: "Blockers", minWidth: 9, maxWidth: 42 },
+        { header: "Execution", minWidth: 14, maxWidth: 34 },
+        { header: "Next action / owner", minWidth: 16, maxWidth: 42 }
+    ], result.tasks.map((task) => [
+        task.id,
+        task.title,
+        task.status,
+        leaderCell(task),
+        task.summaryUpdatedAt === null
+            ? "missing"
+            : formatTimestamp(task.summaryUpdatedAt, timeZone),
+        workCell(task.work.counts),
+        blockersCell(task.blockers),
+        `${task.execution.status} / ${task.execution.owner}`,
+        nextCell(task.next)
+    ]), width);
+    if (!options.verbose)
+        return `${output}\n`;
+    return `${output}\n\n${renderVerboseDetails(result.tasks, timeZone)}\n`;
+}
+function buildTaskOverviewEntry(task, store) {
+    const brief = store.getTaskBrief(task.id);
+    const leaderRole = store.getRole(task.id, "leader");
+    const workItems = store.listWorkItems(task.id);
+    const inputRequests = store.listInputRequests(task.id);
+    const openInputRequests = inputRequests.filter((request) => request.status === "open");
+    const agentRuns = store.listAgentRuns(task.id);
+    const events = store.listEvents(task.id);
+    const attention = collectAttention(task, agentRuns, events, store.getLeaderFailure(task.id), store.getOperatorNotification(task.id));
+    const blockers = collectBlockers(workItems, openInputRequests, attention);
+    const next = deriveNextAction(task, brief, workItems, openInputRequests, blockers, store.getPendingWakeup(task.id));
+    const leader = {
+        role: "leader",
+        roleStatus: leaderRole?.status ?? "missing",
+        summary: brief?.leaderSummary ?? null,
+        currentFocus: brief?.currentFocus ?? null,
+        updatedAt: brief?.updatedAt ?? null,
+        updatedBy: brief?.updatedBy ?? null,
+        summaryStatus: brief === null ? "missing" : "available"
+    };
+    const counts = countWorkItems(workItems);
+    const runtimeRuns = agentRuns
+        .filter((run) => run.status === "active")
+        .map((run) => ({
+        id: run.id,
+        roleName: run.roleName,
+        status: run.status,
+        delivery: run.deliveredAt === undefined ? "pending" : "delivered",
+        deliveredAt: run.deliveredAt ?? null,
+        createdAt: run.createdAt,
+        updatedAt: run.updatedAt
+    }));
+    const runtime = {
+        activeRuns: runtimeRuns,
+        activeRunCount: runtimeRuns.length,
+        pendingDeliveryCount: runtimeRuns.filter((run) => run.delivery === "pending").length
+    };
+    const execution = buildTaskExecutionProjection(store, task.id, task);
+    if (execution === null) {
+        throw new Error(`Task execution projection disappeared: ${task.id}.`);
+    }
+    return {
+        ...task,
+        brief,
+        leader,
+        leaderSummary: leader.summary,
+        currentFocus: leader.currentFocus,
+        summaryUpdatedAt: leader.updatedAt,
+        summaryUpdatedBy: leader.updatedBy,
+        summaryStatus: leader.summaryStatus,
+        work: { counts, items: workItems },
+        input: { open: openInputRequests, openCount: openInputRequests.length },
+        attention,
+        attentionCount: attention.length,
+        blockers,
+        next,
+        nextAction: next?.action ?? null,
+        nextOwner: next?.owner ?? null,
+        runtime,
+        execution
+    };
+}
+function collectAttention(task, runs, events, failure, notification) {
+    const items = [];
+    if (failure !== null || notification?.type === "leader-recovery-failed") {
+        items.push({
+            kind: "leader-recovery",
+            id: `leader-recovery:${task.id}`,
+            status: "failed",
+            owner: "operator",
+            summary: failure?.message
+                ?? (notification?.type === "leader-recovery-failed"
+                    ? notification.message
+                    : "Leader recovery failed."),
+            updatedAt: failure?.lastFailedAt
+                ?? (notification?.type === "leader-recovery-failed"
+                    ? notification.updatedAt
+                    : task.updatedAt)
+        });
+    }
+    const notificationStall = notification?.type === "leader-stalled"
+        ? notification
+        : null;
+    if (notificationStall !== null) {
+        items.push({
+            kind: "leader-stalled",
+            id: `leader-stall:${notificationStall.runId}:${notificationStall.progressAt}`,
+            status: "needs-attention",
+            owner: "operator",
+            summary: notificationStall.message,
+            updatedAt: notificationStall.updatedAt,
+            runId: notificationStall.runId,
+            roleName: "leader"
+        });
+    }
+    for (const run of runs) {
+        if (run.roleName !== "leader"
+            || run.status !== "active"
+            || !isRoleRunStalled(events, run.id))
+            continue;
+        if (notificationStall?.runId === run.id)
+            continue;
+        const progressAt = latestStallProgressAt(events, run.id) ?? run.updatedAt;
+        items.push({
+            kind: "leader-stalled",
+            id: `leader-stall:${run.id}:${progressAt}`,
+            status: "needs-attention",
+            owner: "operator",
+            summary: `Run ${run.id} for ${run.roleName} has no durable progress after ${progressAt}.`,
+            updatedAt: progressAt,
+            runId: run.id,
+            roleName: run.roleName
+        });
+    }
+    return items.sort((left, right) => (Date.parse(left.updatedAt) - Date.parse(right.updatedAt)
+        || left.id.localeCompare(right.id)));
+}
+function collectBlockers(workItems, openInputRequests, attention) {
+    const blockers = [];
+    const workById = new Map(workItems.map((item) => [item.id, item]));
+    for (const item of workItems) {
+        if (item.status === "failed") {
+            blockers.push({
+                kind: "work",
+                type: "work",
+                id: item.id,
+                status: item.status,
+                owner: item.assignee ?? "leader",
+                action: "review-failed-work",
+                summary: item.outcome ?? `Work Item ${item.id} failed.`
+            });
+            continue;
+        }
+        if (item.status === "awaiting_acceptance") {
+            blockers.push({
+                kind: "work",
+                type: "work",
+                id: item.id,
+                status: item.status,
+                owner: "leader",
+                action: "accept-work-item",
+                summary: `Work Item ${item.id} is awaiting Leader acceptance.`
+            });
+            continue;
+        }
+        if (item.status !== "pending")
+            continue;
+        const dependencies = item.dependsOn.filter((dependency) => (workById.get(dependency)?.status !== "completed"));
+        if (dependencies.length === 0)
+            continue;
+        blockers.push({
+            kind: "work",
+            type: "work",
+            id: item.id,
+            status: item.status,
+            owner: item.assignee ?? "leader",
+            action: "unblock-work-item",
+            summary: `Work Item ${item.id} is waiting on ${dependencies.join(", ")}.`
+        });
+    }
+    for (const request of openInputRequests) {
+        blockers.push({
+            kind: "input",
+            type: "input",
+            id: request.id,
+            status: request.status,
+            owner: "user",
+            action: "answer-input",
+            summary: request.question,
+            blockedRefs: request.blockedRefs
+        });
+    }
+    for (const item of attention) {
+        blockers.push({
+            kind: "attention",
+            type: "attention",
+            id: item.id,
+            status: item.status,
+            owner: item.owner,
+            action: item.kind === "leader-recovery"
+                ? "inspect-leader-recovery"
+                : "inspect-leader-stall",
+            summary: item.summary
+        });
+    }
+    return blockers;
+}
+function deriveNextAction(task, brief, workItems, openInputRequests, blockers, pendingWakeup) {
+    const input = openInputRequests[0];
+    if (input !== undefined) {
+        return {
+            action: "answer-input",
+            owner: "user",
+            kind: "input",
+            id: input.id,
+            summary: input.question
+        };
+    }
+    const attention = blockers.find((blocker) => blocker.kind === "attention");
+    if (attention !== undefined) {
+        return {
+            action: attention.action,
+            owner: attention.owner,
+            kind: "attention",
+            id: attention.id,
+            summary: attention.summary
+        };
+    }
+    const workBlocker = blockers.find((blocker) => blocker.kind === "work");
+    if (workBlocker !== undefined) {
+        return {
+            action: workBlocker.action,
+            owner: workBlocker.owner,
+            kind: "work",
+            id: workBlocker.id,
+            summary: workBlocker.summary
+        };
+    }
+    if (pendingWakeup !== null) {
+        return {
+            action: "process-leader-wakeup",
+            owner: "leader",
+            kind: "wakeup",
+            summary: pendingWakeup.reasons.join(", ")
+        };
+    }
+    const pending = workItems.find((item) => item.status === "pending");
+    if (pending !== undefined) {
+        return {
+            action: "start-work-item",
+            owner: pending.assignee ?? "leader",
+            kind: "work",
+            id: pending.id,
+            summary: pending.title
+        };
+    }
+    if (task.status === "active" && brief === null) {
+        return {
+            action: "update-leader-summary",
+            owner: "leader",
+            kind: "summary",
+            summary: "No persisted Task Brief is available."
+        };
+    }
+    return null;
+}
+function countWorkItems(items) {
+    const counts = {
+        total: items.length,
+        pending: 0,
+        running: 0,
+        awaiting_acceptance: 0,
+        completed: 0,
+        failed: 0,
+        retired: 0
+    };
+    for (const item of items)
+        counts[item.status] += 1;
+    return counts;
+}
+function leaderCell(task) {
+    const status = task.leader.roleStatus;
+    if (task.leader.summaryStatus === "missing")
+        return `${status} · missing summary`;
+    const values = [task.leader.summary, task.leader.currentFocus]
+        .filter((value) => value !== null && value.length > 0);
+    return values.length === 0
+        ? `${status} · summary unavailable`
+        : compactText(`${status} · ${values.join(" · ")}`);
+}
+function workCell(counts) {
+    if (counts.total === 0)
+        return "none";
+    const details = Object.keys(counts)
+        .filter((status) => status !== "total" && counts[status] > 0)
+        .map((status) => `${status}:${counts[status]}`);
+    return `${counts.total} total${details.length === 0 ? "" : ` (${details.join(", ")})`}`;
+}
+function blockersCell(blockers) {
+    if (blockers.length === 0)
+        return "none";
+    return blockers.map((blocker) => `${blocker.kind}:${blocker.id}`).join(", ");
+}
+function nextCell(next) {
+    return next === null ? "—" : `${next.action} / ${next.owner}`;
+}
+function compactText(value) {
+    const oneLine = value.replace(/\s+/g, " ").trim();
+    return oneLine.length <= 240 ? oneLine : `${oneLine.slice(0, 237)}...`;
+}
+function renderVerboseDetails(tasks, timeZone) {
+    return [
+        "Task details",
+        ...tasks.flatMap((task) => [
+            `${task.id}: ${task.title}`,
+            `  Description: ${task.description ?? "—"}`,
+            `  Current focus: ${task.currentFocus ?? "missing"}`,
+            `  Leader summary: ${task.leaderSummary ?? "missing"}`,
+            `  Summary updated by: ${task.summaryUpdatedBy ?? "unknown"}`,
+            `  Summary updated at: ${task.summaryUpdatedAt === null
+                ? "missing"
+                : formatTimestamp(task.summaryUpdatedAt, timeZone)}`,
+            `  Execution: ${task.execution.status} (${task.execution.owner}); ${task.execution.summary}`,
+            `  Monitoring: ${task.execution.monitoring}; attention: ${task.execution.attention.length}`,
+            `  Projects: ${task.projectBindings.length === 0
+                ? "none"
+                : task.projectBindings.map(({ directory, projectId, baseRef }) => (`${directory} (${projectId} @ ${baseRef})`)).join(", ")}`
+        ])
+    ].join("\n");
+}