@zq-silk/yui 0.15.12 → 0.16.0

package/dist/commands/deliveryGuardPreflight.js

@@ -1,30 +0,0 @@
-import { resolveLeaderNextActionMode, resolveLeaderSemanticBudgetRuns } from "../config/yuiConfig.js";
-import { usageError } from "../errors/cliError.js";
-import { detectDeliveryDuplicates, evaluateDeliveryGuard, evaluateSemanticBudget, formatDeliveryDuplicate } from "../task/deliveryGuard.js";
-export function runDeliveryGuardPreflight(store, taskId, intent, options = {}) {
-    const mode = resolveLeaderNextActionMode(store.getConfig().leaderNextActionMode);
-    if (mode === "display")
-        return { warnings: [] };
-    const facts = store.readNextActionFacts(taskId);
-    if (facts === null)
-        return { warnings: [] };
-    const outcome = evaluateDeliveryGuard(detectDeliveryDuplicates(facts, intent), mode);
-    const warnings = outcome.warnings.map(formatDeliveryDuplicate);
-    if (outcome.blocked !== null) {
-        throw usageError(`${formatDeliveryDuplicate(outcome.blocked)} `
-            + "Reuse the existing proof, or set leader.nextActionMode=warn to proceed with a warning.");
-    }
-    if (options.budget === true) {
-        const budget = evaluateSemanticBudget(facts, resolveLeaderSemanticBudgetRuns(store.getConfig().leaderSemanticBudgetRuns));
-        if (budget.exhausted) {
-            warnings.push(`Semantic progress budget: ${budget.reason}`);
-        }
-    }
-    return { warnings };
-}
-/** Prepend guard warnings to a command's normal output. */
-export function withGuardWarnings(preflight, output) {
-    if (preflight.warnings.length === 0)
-        return output;
-    return `${preflight.warnings.map((warning) => `Warning: ${warning}\n`).join("")}${output}`;
-}

package/dist/commands/taskIntegrationQueueCommands.js

@@ -1,226 +0,0 @@
-import { usageError } from "../errors/cliError.js";
-import { defaultTableWidth, renderTable } from "../output/table.js";
-import { resolveProject } from "../repository/project.js";
-import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
-import { enqueueIntegrationQueueEntry, processIntegrationQueue, reconcileIntegrationQueueEntry, requeueIntegrationQueueEntry, supersedeIntegrationQueueEntry } from "../integration/integrationQueueService.js";
-import { assertTaskDeliveryAuthority as taskLocalActor } from "./taskActor.js";
-import { parseRepeatable } from "./taskIntegrationCommands.js";
-import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
-/**
- * `yui task integration queue` — the serialized merge queue.  Only terminal
- * Candidates explicitly enqueued enter the queue; the queue never blocks
- * parallel development, it orders exact-commit integration.
- */
-export async function runTaskIntegrationQueueCommand(args, store, home, options = {}) {
-    const [command, ...rest] = args;
-    if (command === "enqueue")
-        return enqueue(rest, store, options, home);
-    if (command === "list")
-        return list(rest, store);
-    if (command === "show")
-        return show(rest, store, options.environment);
-    if (command === "process")
-        return process(rest, store, home, options);
-    if (command === "supersede")
-        return supersede(rest, store, options, home);
-    if (command === "requeue")
-        return requeue(rest, store, options, home);
-    if (command === "reconcile")
-        return reconcile(rest, store, options, home);
-    throw usageError(command === undefined
-        ? "Task Integration queue command is required."
-        : `Unknown command: task integration queue ${command}`);
-}
-async function enqueue(args, store, options, home) {
-    const usage = "Task Integration queue enqueue usage: yui task integration queue enqueue <task> --project <project> --change-set <id> [--target <ref>] [--check <command> ...].";
-    const parsed = parseRepeatable(args, new Set(["--check"]), new Set(["--project", "--change-set", "--target"]), usage);
-    if (parsed.positionals.length !== 1)
-        throw usageError(usage);
-    const task = requireActiveTask(store, parsed.positionals[0]);
-    requireTaskControlActor(store, options.environment, task.id, home);
-    const projectRef = parsed.one.get("--project");
-    const changeSetId = parsed.one.get("--change-set");
-    if (projectRef === undefined || changeSetId === undefined)
-        throw usageError(usage);
-    const projectId = resolveProjectId(store, projectRef);
-    const result = await enqueueIntegrationQueueEntry({
-        store,
-        taskId: task.id,
-        projectId,
-        changeSetId,
-        targetRef: parsed.one.get("--target"),
-        checkCommands: parsed.many.get("--check") ?? [],
-        now: options.now
-    });
-    const label = {
-        queued: "Enqueued",
-        "already-queued": "Already queued",
-        "already-committed": "Already committed",
-        converged: "Converged"
-    }[result.outcome];
-    return {
-        output: `${label} ${result.entry.changeSetId} as ${result.entry.id} (${result.entry.status})\n`,
-        data: result
-    };
-}
-function list(args, store) {
-    const usage = "Task Integration queue list usage: yui task integration queue list <task> [--project <project>].";
-    const parsed = parseRepeatable(args, new Set(), new Set(["--project"]), usage);
-    if (parsed.positionals.length !== 1)
-        throw usageError(usage);
-    const task = requireActiveTask(store, parsed.positionals[0]);
-    const projectRef = parsed.one.get("--project");
-    const projectId = projectRef === undefined ? undefined : resolveProjectId(store, projectRef);
-    // The store already returns entries in numeric id order; trust it instead of
-    // re-sorting with a lexicographic compare (which yields 1, 10, 2, ...).
-    const entries = store.listIntegrationQueueEntries(task.id)
-        .filter((entry) => projectId === undefined || entry.projectId === projectId);
-    const output = entries.length === 0
-        ? "Integration queue is empty.\n"
-        : `${renderTable(`Integration queue: ${task.id}`, [
-            { header: "Entry", minWidth: 12, maxWidth: 24 },
-            { header: "Project", minWidth: 8, maxWidth: 20 },
-            { header: "ChangeSet", minWidth: 10, maxWidth: 20 },
-            { header: "Target", minWidth: 8, maxWidth: 30 },
-            { header: "Status", minWidth: 8, maxWidth: 16 }
-        ], entries.map((entry) => [
-            entry.id,
-            entry.projectId,
-            entry.changeSetId,
-            entry.targetRef,
-            entry.status
-        ]), defaultTableWidth())}\n`;
-    return { output, data: { entries } };
-}
-function show(args, store, environment) {
-    const usage = "Task Integration queue show usage: yui task integration queue show <task>/<entry>.";
-    if (args.length !== 1)
-        throw usageError(usage);
-    const entry = requireQueueEntry(store, args[0], environment);
-    const lines = [
-        `Integration queue entry: ${entry.id}`,
-        `Task: ${entry.taskId}`,
-        `Project: ${entry.projectId}`,
-        `ChangeSet: ${entry.changeSetId}`,
-        `Target: ${entry.targetRef}`,
-        `Status: ${entry.status}`,
-        `Target before: ${entry.targetBefore ?? "-"}`,
-        `Target after: ${entry.targetAfter ?? "-"}`,
-        `Integration: ${entry.integrationAttemptId ?? "-"}`,
-        `Affected paths: ${entry.affectedPaths === undefined ? "-" : entry.affectedPaths.join(", ")}`,
-        `Evidence: ${entry.evidenceRefs.length === 0 ? "-" : entry.evidenceRefs.join(", ")}`,
-        `Conflict: ${entry.conflictSummary ?? "-"}`,
-        `Superseded: ${entry.supersedeReason ?? "-"}`
-    ];
-    return { output: `${lines.join("\n")}\n`, data: { entry } };
-}
-async function process(args, store, home, options) {
-    const usage = "Task Integration queue process usage: yui task integration queue process <task> [--project <project>] [--limit <n>].";
-    const parsed = parseRepeatable(args, new Set(), new Set(["--project", "--limit"]), usage);
-    if (parsed.positionals.length !== 1)
-        throw usageError(usage);
-    const task = requireActiveTask(store, parsed.positionals[0]);
-    requireTaskControlActor(store, options.environment, task.id, home);
-    const limitValue = parsed.one.get("--limit");
-    const limit = limitValue === undefined ? undefined : Number.parseInt(limitValue, 10);
-    if (limitValue !== undefined && (!Number.isSafeInteger(limit) || limit < 1)) {
-        throw usageError(`--limit must be a positive integer: ${limitValue}.`);
-    }
-    const projectRef = parsed.one.get("--project");
-    const projectId = projectRef === undefined ? undefined : resolveProjectId(store, projectRef);
-    const processed = await processIntegrationQueue(store, home, task.id, {
-        projectId,
-        limit,
-        now: options.now,
-        environment: options.environment
-    });
-    const lines = processed.map(({ entry, result }) => {
-        if (result.status === "committed") {
-            return `${entry.id} committed ${entry.changeSetId} -> ${entry.targetAfter ?? "-"}`;
-        }
-        if (result.status === "blocked" || result.status === "conflicted") {
-            return `${entry.id} conflicted ${entry.changeSetId}: ${entry.conflictSummary ?? "blocked"}`;
-        }
-        return `${entry.id} conflicted ${entry.changeSetId}: ${entry.conflictSummary ?? "gate failure"}`;
-    });
-    const output = processed.length === 0
-        ? "Integration queue: nothing to process.\n"
-        : `${lines.join("\n")}\n`;
-    return { output, data: { processed } };
-}
-function supersede(args, store, options, home) {
-    const usage = "Task Integration queue supersede usage: yui task integration queue supersede <task>/<entry> --reason <text>.";
-    const parsed = parseRepeatable(args, new Set(), new Set(["--reason"]), usage);
-    if (parsed.positionals.length !== 1)
-        throw usageError(usage);
-    const entry = requireQueueEntry(store, parsed.positionals[0], options.environment);
-    const actor = requireTaskControlActor(store, options.environment, entry.taskId, home);
-    const reason = parsed.one.get("--reason");
-    if (reason === undefined)
-        throw usageError(usage);
-    const superseded = supersedeIntegrationQueueEntry(store, entry.taskId, entry.id, reason, actor, options.now ?? (() => new Date()));
-    return {
-        output: `Superseded ${superseded.id}: ${reason}\n`,
-        data: { entry: superseded }
-    };
-}
-function requeue(args, store, options, home) {
-    const usage = "Task Integration queue requeue usage: yui task integration queue requeue <task>/<entry>.";
-    if (args.length !== 1)
-        throw usageError(usage);
-    const entry = requireQueueEntry(store, args[0], options.environment);
-    const actor = requireTaskControlActor(store, options.environment, entry.taskId, home);
-    const waiting = requeueIntegrationQueueEntry(store, entry.taskId, entry.id, actor, options.now ?? (() => new Date()));
-    return {
-        output: `Requeued ${waiting.id}; it will be processed again on the next queue run\n`,
-        data: { entry: waiting }
-    };
-}
-async function reconcile(args, store, options, home) {
-    const usage = "Task Integration queue reconcile usage: yui task integration queue reconcile <task>/<entry>.";
-    if (args.length !== 1)
-        throw usageError(usage);
-    const entry = requireQueueEntry(store, args[0], options.environment);
-    requireTaskControlActor(store, options.environment, entry.taskId, home);
-    const committed = await reconcileIntegrationQueueEntry(store, entry.taskId, entry.id, new NodeGitWorkspace(), options.now ?? (() => new Date()));
-    return {
-        output: `Reconciled ${committed.id} as committed -> ${committed.targetAfter ?? "-"}\n`,
-        data: { entry: committed }
-    };
-}
-function requireActiveTask(store, taskId) {
-    const task = store.getTask(taskId);
-    if (task === null)
-        throw usageError(`Task not found: ${taskId}.`);
-    if (task.status !== "active") {
-        throw usageError(`Task is not active: ${task.id}/${task.status}.`);
-    }
-    return task;
-}
-function resolveProjectId(store, reference) {
-    const project = resolveProject(store.listProjects(), reference);
-    if (project === null)
-        throw usageError(`Project not found: ${reference}.`);
-    return project.id;
-}
-function requireQueueEntry(store, value, environment) {
-    let reference;
-    try {
-        reference = resolveTaskRecordReference(value, {
-            kind: "integrationQueue",
-            contextTaskId: environment?.YUI_TASK_ID,
-            label: "Integration queue entry"
-        });
-    }
-    catch (error) {
-        throw usageError(error instanceof Error ? error.message : String(error));
-    }
-    const entry = store.getIntegrationQueueEntry(reference.taskId, reference.localId);
-    if (entry === null) {
-        throw usageError(`Integration queue entry not found: ${reference.taskId}/${reference.localId}.`);
-    }
-    return entry;
-}
-function requireTaskControlActor(store, environment, taskId, home) {
-    return taskLocalActor(store, environment, taskId);
-}

package/dist/commands/taskOverviewCommand.js

@@ -1,377 +0,0 @@
-import { usageError } from "../errors/cliError.js";
-import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
-import { formatTimestamp } from "../output/timePresentation.js";
-import { pendingWakeupProjection } from "../storage/taskStore.js";
-import { defaultTableWidth, renderTable } from "../output/table.js";
-import { projectTaskExecutionFromFacts } from "../scheduler/taskExecutionProjection.js";
-import { resolveRuntimeHealth } from "../config/yuiConfig.js";
-import { projectNextAction } from "../task/nextAction.js";
-import { projectTaskRemoteDeliveryFromStore } from "./taskRemoteDeliveryCommand.js";
-import { formatUsageMetric } from "../runtime/taskUsageMetrics.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, now = new Date(), taskId) {
-    const runtimeHealthPolicy = resolveRuntimeHealth(store.getConfig().runtimeHealth);
-    const tasks = (taskId === undefined ? store.listTasks() : [store.getTask(taskId)].filter((task) => task !== null))
-        .filter((task) => options.all || task.status !== "archived")
-        .map((task) => buildTaskOverviewEntry(task, store, now, runtimeHealthPolicy));
-    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: "Delivery", minWidth: 12, maxWidth: 28 },
-        { 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}`,
-        deliveryCell(task.remoteDelivery),
-        nextCell(task.next)
-    ]), width);
-    if (!options.verbose)
-        return `${output}\n`;
-    return `${output}\n\n${renderVerboseDetails(result.tasks, timeZone)}\n`;
-}
-function buildTaskOverviewEntry(task, store, now, runtimeHealthPolicy) {
-    const brief = store.getTaskBrief(task.id);
-    const roles = store.listRoles(task.id);
-    const leaderRole = roles.find((role) => role.name === "leader") ?? null;
-    const workItems = store.listWorkItems(task.id);
-    const inputRequests = store.listInputRequests(task.id);
-    const openInputRequests = inputRequests.filter((request) => request.status === "open");
-    const runs = store.listRuns(task.id);
-    const events = store.listEvents(task.id);
-    const leaderFailure = store.getLeaderFailure(task.id);
-    const leaderMailbox = store.getWorkMailbox({ kind: "role", taskId: task.id, roleName: "leader" });
-    const pendingWakeup = pendingWakeupProjection(leaderMailbox);
-    const reviewRounds = store.listReviewRounds(task.id);
-    const changeSets = store.listChangeSets(task.id);
-    const integrations = store.listIntegrationAttempts(task.id);
-    const roleSessions = roles.flatMap((role) => {
-        const session = store.getRoleSession(task.id, role.name);
-        return session === null ? [] : [{ roleName: role.name, ...session }];
-    });
-    const providerRuns = new Map(roles.map((role) => [role.name, store.getTaskRoleSessionSet(task.id, role.name)?.providerBinding?.run]));
-    const runDelivery = Object.fromEntries(runs.map((run) => {
-        const native = providerRuns.get(run.roleName);
-        return [run.id, native?.runId === run.id ? native.status : "unobserved"];
-    }));
-    const attention = collectAttention(task, runs, events, leaderFailure);
-    const blockers = collectBlockers(workItems, openInputRequests, attention);
-    const leader = {
-        role: "leader",
-        roleStatus: leaderRole === null
-            ? "missing"
-            : providerRuns.get("leader")?.status === "accepted" ? "running"
-                : roleSessions.some((session) => session.roleName === "leader") ? "unknown" : "idle",
-        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 = runs
-        .filter((run) => run.status === "active")
-        .map((run) => ({
-        id: run.id,
-        roleName: run.roleName,
-        status: run.status,
-        runtime: runDelivery[run.id],
-        createdAt: run.createdAt,
-        updatedAt: run.updatedAt
-    }));
-    const runtime = {
-        activeRuns: runtimeRuns,
-        activeRunCount: runtimeRuns.length,
-        pendingDeliveryCount: runtimeRuns.filter((run) => run.runtime !== "accepted").length
-    };
-    // Fold the execution projection from the facts already read above instead of
-    // reading the store a second time for the same unchanged revision.
-    const execution = projectTaskExecutionFromFacts({
-        task,
-        roles,
-        runs,
-        runDelivery,
-        workItems,
-        inputRequests,
-        reviewRounds,
-        changeSets,
-        integrations,
-        events,
-        brief,
-        pendingWakeup,
-        leaderMailbox,
-        leaderFailure,
-        roleSessions,
-        contextSnapshots: store.listContextSnapshots(task.id),
-        now,
-        runtimeHealthPolicy
-    });
-    const nextActionFacts = store.readNextActionFacts(task.id);
-    if (nextActionFacts === null) {
-        throw new Error(`Task disappeared while building its overview: ${task.id}.`);
-    }
-    const next = overviewNextAction(task, workItems, execution, projectNextAction({
-        ...nextActionFacts,
-        currentTaskReviewCandidate: null,
-        executionGroups: execution.executionGroups
-    }));
-    const persistedCandidate = task.status === "active" || task.status === "cancelled"
-        ? taskRemoteDeliveryCandidate(task)
-        : null;
-    const remoteDelivery = projectTaskRemoteDeliveryFromStore(store, task, persistedCandidate);
-    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,
-        remoteDelivery
-    };
-}
-function collectAttention(task, runs, events, failure) {
-    const items = [];
-    if (failure !== null) {
-        items.push({
-            kind: "leader-recovery",
-            id: `leader-recovery:${task.id}`,
-            status: "failed",
-            owner: "operator",
-            summary: failure.message,
-            updatedAt: failure.lastFailedAt
-        });
-    }
-    for (const run of runs) {
-        if (run.roleName !== "leader"
-            || run.status !== "active"
-            || !isRoleRunStalled(events, 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: `AgentRun ${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 === "open" && item.currentCandidateId !== undefined)) {
-            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 !== "open")
-            continue;
-        const dependencies = item.dependsOn.filter((dependency) => (workById.get(dependency)?.status !== "accepted"));
-        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 overviewNextAction(task, workItems, execution, action) {
-    if (task.status !== "active" && task.status !== "draft")
-        return null;
-    const primary = action.refs[0];
-    const workItem = action.refs
-        .filter(({ kind }) => kind === "work-item")
-        .map(({ id }) => workItems.find((item) => item.id === id))
-        .find((item) => item !== undefined);
-    const kind = primary?.kind === "input-request"
-        ? "input"
-        : primary?.kind === "work-item"
-            ? "work"
-            : action.kind.includes("attention") || action.kind.includes("inconsistency")
-                ? "attention"
-                : "execution";
-    return {
-        action: action.kind,
-        owner: action.kind === "resolve-input"
-            ? "user"
-            : workItem?.assignee ?? execution.owner,
-        kind,
-        ...(primary === undefined ? {} : { id: primary.id }),
-        summary: action.reason
-    };
-}
-function countWorkItems(items) {
-    const counts = {
-        total: items.length,
-        open: 0,
-        accepted: 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 deliveryCell(delivery) {
-    if (delivery.status === "none")
-        return "none";
-    return `${delivery.status} · ${delivery.mergedProjectCount}/${delivery.codeProjectCount} merged`
-        + (delivery.allMerged
-            ? ` · ${delivery.verifiedProjectCount}/${delivery.codeProjectCount} verified`
-            : "");
-}
-function taskRemoteDeliveryCandidate(task) {
-    const projects = task.projectBindings.flatMap(({ projectId, currentCommit }) => (currentCommit === undefined ? [] : [{ projectId, commit: currentCommit }]));
-    return projects.length === task.projectBindings.length
-        ? { projects }
-        : null;
-}
-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}`,
-            `  Remote delivery: ${deliveryCell(task.remoteDelivery)}; source=${task.remoteDelivery.source}${task.remoteDelivery.provisional ? " (provisional)" : ""}`,
-            `  Monitoring: ${task.execution.monitoring}; attention: ${task.execution.attention.length}`,
-            `  DAG: ${task.execution.observability.dag.nodes.length} nodes, ${task.execution.observability.dag.edges.length} edges; ready=${task.execution.observability.dag.readyIds.join(", ") || "none"}; blocked=${task.execution.observability.dag.blockedIds.join(", ") || "none"}`,
-            `  Observed usage (Task lifetime, observed sources only): tokens=${formatUsageMetric(task.execution.observability.cost.tokens)}; tools=${formatUsageMetric(task.execution.observability.cost.toolCalls)}; elapsed=${formatUsageMetric(task.execution.observability.cost.elapsedSeconds, "s")}; native execution sum=${formatUsageMetric(task.execution.observability.cost.executionSeconds, "s")}; retries=${task.execution.observability.cost.retryCount}`,
-            `  Context: snapshots=${task.execution.observability.context.snapshotCount}; bytes=${task.execution.observability.context.totalBytes ?? "partial"}; compression=unavailable`,
-            `  Session tokens: ${task.execution.observability.sessionTokens.length === 0
-                ? "unobserved"
-                : task.execution.observability.sessionTokens.map(({ roleName, metrics }) => {
-                    const total = metrics.cumulativeTotal.status === "observed"
-                        ? metrics.cumulativeTotal.totalTokens
-                        : "unobserved";
-                    const maximum = metrics.maximumRequestInput.status === "observed"
-                        ? metrics.maximumRequestInput.inputTokens
-                        : "unobserved";
-                    return `${roleName}: total=${total}, max-request-input=${maximum}`;
-                }).join("; ")}`,
-            `  Projects: ${task.projectBindings.length === 0
-                ? "none"
-                : task.projectBindings.map(({ directory, projectId, baseRef }) => (`${directory} (${projectId} @ ${baseRef})`)).join(", ")}`
-        ])
-    ].join("\n");
-}