@zq-silk/yui 0.6.0 → 0.6.2

package/dist/commands/controllerCommands.js

@@ -1,6 +1,7 @@
 import { usageError } from "../errors/cliError.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
 import { DEFAULT_RECONCILIATION_INTERVAL_SECONDS } from "../config/yuiConfig.js";
+import { evaluateStorageHealth, UNSUPPORTED } from "../observability/runtimeIdentity.js";
 export function parseControllerStatusOptions(args) {
     const allowed = new Set(["--all", "--verbose"]);
     if (args.some((argument) => !allowed.has(argument))
@@ -122,6 +123,108 @@ export function renderControllerResourceStatus(snapshot, verbose, width = defaul
     }
     return lines.join("\n");
 }
+export function summarizeDurablePhysicalMismatch(snapshot) {
+    let durableActiveSessions = 0;
+    let residualProcesses = 0;
+    let liveResidualResources = 0;
+    let protectedWithoutProcess = 0;
+    for (const resource of snapshot.resources) {
+        if (resource.kind === "agent-session") {
+            if (resource.disposition === "protected") {
+                durableActiveSessions += 1;
+                if (resource.processes.length === 0)
+                    protectedWithoutProcess += 1;
+            }
+            else if (resource.processes.length > 0) {
+                liveResidualResources += 1;
+            }
+        }
+        if (resource.disposition !== "protected") {
+            residualProcesses += resource.processes.length;
+        }
+    }
+    return {
+        durableActiveSessions,
+        residualProcesses,
+        liveResidualResources,
+        protectedWithoutProcess
+    };
+}
+export function parseControllerRuntimeSnapshot(result, droppedEvents) {
+    if (result === null || typeof result !== "object" || Array.isArray(result)) {
+        return { source: "unsupported", droppedEvents };
+    }
+    const record = result;
+    const runtime = (record.runtime ?? {});
+    const inbox = runtime.inbox;
+    const drain = runtime.drain;
+    const commands = runtime.commands;
+    const routes = commands?.routes;
+    const dispatcher = commands?.dispatcher;
+    const eventLoopDelay = commands?.eventLoopDelay;
+    const queueDepth = (typeof routes?.inFlight === "number" ? routes.inFlight : 0)
+        + (typeof dispatcher?.inFlight === "number" ? dispatcher.inFlight : 0);
+    return {
+        source: "controller.status",
+        pid: typeof record.pid === "number" ? record.pid : undefined,
+        uptimeMs: typeof record.uptimeMs === "number" ? record.uptimeMs : undefined,
+        rssBytes: typeof record.rssBytes === "number" ? record.rssBytes : undefined,
+        protocolVersion: typeof record.protocolVersion === "number"
+            ? record.protocolVersion
+            : undefined,
+        inbox: inbox === undefined ? undefined : {
+            depth: typeof inbox.depth === "number" ? inbox.depth : 0,
+            semanticDepth: typeof inbox.semanticDepth === "number" ? inbox.semanticDepth : 0,
+            progressDepth: typeof inbox.progressDepth === "number" ? inbox.progressDepth : 0
+        },
+        coalescedEvents: typeof drain?.progressEventsCoalesced === "number"
+            ? drain.progressEventsCoalesced
+            : undefined,
+        droppedEvents,
+        queueDepth,
+        oldestInFlightAgeMs: typeof routes?.oldestInFlightAgeMs === "number"
+            ? routes.oldestInFlightAgeMs
+            : null,
+        eventLoopMaxLagMs: typeof eventLoopDelay?.maximumLagMs === "number"
+            ? eventLoopDelay.maximumLagMs
+            : undefined
+    };
+}
+export function renderRuntimeIdentitySection(input) {
+    const { build, storage, runtime, mismatch, inventoryRssBytes } = input;
+    const health = evaluateStorageHealth(storage);
+    const lines = [
+        "Runtime identity",
+        `  Package         ${build.packageName} ${build.packageVersion}`,
+        `  Package digest  ${build.packageDigest}`,
+        `  Entry           ${build.entryPath}`,
+        `  Entry digest    ${build.entryDigest}`,
+        `  Source commit   ${build.sourceCommit}`,
+        `  Node            ${build.nodeVersion} (${build.platform})`,
+        `  Storage         layout ${storage.logicalLayout} (manifest ${storage.manifestStatus}) · backend ${storage.configuredBackend} · worker ${storage.workerEnabled ? "on" : "off"}`,
+        `  Store files     state.json ${storage.physicalStateJson.present ? "present" : "absent"} · yui.db ${storage.physicalDatabase.present ? "present" : "absent"}${storage.physicalDatabase.wal ? " +WAL" : ""}${storage.physicalDatabase.present && storage.physicalDatabase.health !== UNSUPPORTED ? ` (${storage.physicalDatabase.health})` : ""}`
+    ];
+    for (const finding of storage.findings) {
+        lines.push(`  ! ${finding.severity === "contradiction" ? "CONTRADICTION" : finding.severity === "needs-repair" ? "NEEDS-REPAIR" : "warning"} ${finding.code}: ${finding.message}`, `    remediation: ${finding.remediation}`);
+    }
+    lines.push(`  Health          ${health.status === "ok" ? "ok" : health.status === "degraded" ? "DEGRADED (needs-repair above)" : "FAIL (contradictions above)"}`, `  Controller      ${runtime.source === "controller.status" && runtime.pid !== undefined
+        ? `PID ${runtime.pid}${runtime.uptimeMs === undefined ? "" : `, up ${formatDuration(runtime.uptimeMs)}`}${runtime.protocolVersion === undefined ? "" : `, protocol ${runtime.protocolVersion}`}`
+        : "not running (unsupported)"}`, `  Controller RSS  ${runtime.rssBytes !== undefined ? formatBytes(runtime.rssBytes) : UNSUPPORTED} (inventory ${formatBytes(inventoryRssBytes)})`, `  Command queue   depth ${runtime.queueDepth ?? UNSUPPORTED} · oldest ${runtime.oldestInFlightAgeMs === undefined
+        ? UNSUPPORTED
+        : runtime.oldestInFlightAgeMs === null
+            ? "—"
+            : formatDuration(runtime.oldestInFlightAgeMs)}`, `  Runtime inbox   ${runtime.inbox === undefined
+        ? UNSUPPORTED
+        : `depth ${runtime.inbox.depth} (semantic ${runtime.inbox.semanticDepth}, progress ${runtime.inbox.progressDepth})`} · coalesced ${runtime.coalescedEvents ?? UNSUPPORTED} · dropped ${runtime.droppedEvents ?? UNSUPPORTED}`, `  Event loop      ${runtime.eventLoopMaxLagMs === undefined
+        ? UNSUPPORTED
+        : `max lag ${runtime.eventLoopMaxLagMs.toFixed(0)}ms`}`, 
+    // Persistence latency/lock-wait have no producer in the current
+    // controller.status RPC; render the documented `unsupported` fallback
+    // rather than silently dropping the field. A future capability provider
+    // can register a persistence observer without changing this schema.
+    `  Persistence     latency ${UNSUPPORTED} · lock/busy wait ${UNSUPPORTED}`, `  Durable/physical ${mismatch.durableActiveSessions} active sessions · ${mismatch.residualProcesses} residual processes · ${mismatch.liveResidualResources} live residual · ${mismatch.protectedWithoutProcess} protected without process`);
+    return lines.join("\n");
+}
 export async function runInteractiveControllerCleanup(input) {
     if (!input.io.interactive) {
         throw usageError("Controller cleanup requires an interactive terminal.");

package/dist/commands/deliveryGuardPreflight.js

@@ -0,0 +1,30 @@
+import { leaderNextActionMode } 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 = leaderNextActionMode(store.getConfig().leaderNextActionMode, options.environment);
+    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);
+        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/durableJobCommands.js

@@ -0,0 +1,231 @@
+import { usageError } from "../errors/cliError.js";
+import { ensureFileTaskController } from "../controller/clientRuntime.js";
+import { acknowledgeDurableJob, cancelDurableJob, getDurableJob, startDurableJob } from "../controller/jobClient.js";
+import { resolveJobCaller, taskActor } from "./taskActor.js";
+/**
+ * The textual `--owner` forms accepted by `job start`. The public help text in
+ * the command catalog must document exactly these forms.
+ */
+export const JOB_OWNER_USAGE = "task|work-item:<id>|integration-attempt:<id>";
+/**
+ * `yui job start|get|cancel` — the operational surface for Controller-owned
+ * DurableJobs. Every request goes through the Controller socket; this command
+ * never spawns a runner itself.
+ */
+export async function runDurableJobCommand(args, options) {
+    const [command, ...rest] = args;
+    if (command === "start")
+        return startJob(rest, options);
+    if (command === "get")
+        return getJob(rest, options);
+    if (command === "cancel")
+        return cancelJob(rest, options);
+    if (command === "acknowledge")
+        return acknowledgeJob(rest, options);
+    throw usageError(command === undefined
+        ? "Job command is required: start, get, cancel, or acknowledge."
+        : `Unknown command: job ${command}`, "yui job start --task <id> --project <project> --head <sha> --workspace <dir> "
+        + "--step <name>=<command> [--step ...] [--env K=V ...] "
+        + `[--owner ${JOB_OWNER_USAGE}] [--retry-of <job-id>]\n`
+        + "yui job get --task <id> --job <job-id>\n"
+        + "yui job cancel --task <id> --job <job-id>\n"
+        + "yui job acknowledge --task <id> --job <job-id>");
+}
+async function startJob(args, options) {
+    const parsed = parseStartArgs(args);
+    await ensureFileTaskController(options.home, { environment: options.environment });
+    // rr8/rr12: Bind the declared owner to the caller's managed identity. The
+    // Controller rejects a Reviewer, constrains a Worker to its own Work Item,
+    // and requires a verified Leader assertion for user scope.
+    const caller = resolveJobCaller(options.environment, parsed.taskId, options.store);
+    const params = {
+        taskId: parsed.taskId,
+        owner: parsed.owner,
+        projectId: parsed.projectId,
+        head: parsed.head,
+        workspace: parsed.workspace,
+        env: parsed.env,
+        steps: parsed.steps,
+        caller,
+        ...(parsed.retryOf === undefined ? {} : { retryOf: parsed.retryOf })
+    };
+    const result = await startDurableJob(options.home, params);
+    if (options.json === true)
+        return `${JSON.stringify(result, null, 2)}\n`;
+    const verb = result.created ? "queued" : "already exists";
+    return `Job ${result.job.id} ${verb} (status: ${result.job.status})\n`;
+}
+async function getJob(args, options) {
+    const ref = parseRefArgs(args, "get");
+    await ensureFileTaskController(options.home, { environment: options.environment });
+    const job = await getDurableJob(options.home, ref.taskId, ref.jobId);
+    if (options.json === true)
+        return `${JSON.stringify(job, null, 2)}\n`;
+    const lines = [
+        `Job ${job.id} (task ${job.taskId})`,
+        `  status: ${job.status}`,
+        `  owner: ${formatOwner(job.owner)}`,
+        `  head: ${job.head}`,
+        `  workspace: ${job.workspace}`,
+        `  created: ${job.createdAt}`
+    ];
+    if (job.startedAt !== undefined)
+        lines.push(`  started: ${job.startedAt}`);
+    if (job.terminalAt !== undefined)
+        lines.push(`  terminal: ${job.terminalAt}`);
+    if (job.result !== undefined) {
+        lines.push(`  outcome: ${job.result.outcome}`);
+        if (job.result.failedStep !== undefined)
+            lines.push(`  failed step: ${job.result.failedStep}`);
+        if (job.result.unknownReason !== undefined)
+            lines.push(`  reason: ${job.result.unknownReason}`);
+    }
+    for (const step of job.steps) {
+        lines.push(`  step ${step.name}: ${step.command}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+async function cancelJob(args, options) {
+    const ref = parseRefArgs(args, "cancel");
+    await ensureFileTaskController(options.home, { environment: options.environment });
+    // rr8/rr12: Bind the cancel request to the caller's managed identity.
+    const caller = resolveJobCaller(options.environment, ref.taskId, options.store);
+    const result = await cancelDurableJob(options.home, ref.taskId, ref.jobId, caller);
+    if (options.json === true)
+        return `${JSON.stringify(result, null, 2)}\n`;
+    return result.cancelRequested
+        ? `Cancel requested for job ${result.job.id}\n`
+        : `Job ${result.job.id} is already terminal (${result.job.status})\n`;
+}
+async function acknowledgeJob(args, options) {
+    const ref = parseRefArgs(args, "acknowledge");
+    // rr5/f5(a): only the Task Leader may acknowledge an
+    // unknown-needs-attention job. A non-Leader (Worker, Operator, or plain
+    // user) is rejected at the CLI boundary.
+    const actor = taskActor(options.environment, ref.taskId);
+    if (actor !== "leader") {
+        throw usageError("Only the Task Leader may acknowledge a DurableJob: "
+            + `${ref.taskId}.`);
+    }
+    if (options.store === undefined) {
+        throw usageError("job acknowledge requires a Task store to resolve the Leader assertion.");
+    }
+    // Carry the full managed task caller, including its ephemeral launch key.
+    // A durable leaderAssertion by itself is intentionally not sufficient.
+    const caller = resolveJobCaller(options.environment, ref.taskId, options.store);
+    await ensureFileTaskController(options.home, { environment: options.environment });
+    const result = await acknowledgeDurableJob(options.home, ref.taskId, ref.jobId, caller);
+    if (options.json === true)
+        return `${JSON.stringify(result, null, 2)}\n`;
+    return result.acknowledged
+        ? `Job ${result.job.id} acknowledged (status: ${result.job.status})\n`
+        : `Job ${result.job.id} is not in unknown-needs-attention state (${result.job.status})\n`;
+}
+function parseStartArgs(args) {
+    let taskId;
+    let projectId;
+    let head;
+    let workspace;
+    let owner = { kind: "task" };
+    let retryOf;
+    const env = {};
+    const steps = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const flag = args[index];
+        const value = args[index + 1];
+        if (value === undefined || value.startsWith("--")) {
+            throw usageError(`Missing value for ${flag}.`, "yui job start ...");
+        }
+        index += 1;
+        switch (flag) {
+            case "--task":
+                taskId = value;
+                break;
+            case "--project":
+                projectId = value;
+                break;
+            case "--head":
+                head = value;
+                break;
+            case "--workspace":
+                workspace = value;
+                break;
+            case "--owner":
+                owner = parseJobOwner(value);
+                break;
+            case "--retry-of":
+                retryOf = value;
+                break;
+            case "--env": {
+                const separator = value.indexOf("=");
+                if (separator <= 0) {
+                    throw usageError(`Invalid --env value: ${value}.`, "yui job start ...");
+                }
+                env[value.slice(0, separator)] = value.slice(separator + 1);
+                break;
+            }
+            case "--step": {
+                const separator = value.indexOf("=");
+                if (separator <= 0) {
+                    throw usageError(`Invalid --step value: ${value}.`, "yui job start ...");
+                }
+                steps.push({ name: value.slice(0, separator), command: value.slice(separator + 1) });
+                break;
+            }
+            default:
+                throw usageError(`Unknown flag: ${flag}.`, "yui job start ...");
+        }
+    }
+    if (taskId === undefined || projectId === undefined || head === undefined
+        || workspace === undefined || steps.length === 0) {
+        throw usageError("job start requires --task, --project, --head, --workspace, and at least one --step.", "yui job start ...");
+    }
+    return { taskId, owner, projectId, head, workspace, env, steps, retryOf };
+}
+export function parseJobOwner(value) {
+    if (value === "task")
+        return { kind: "task" };
+    if (value.startsWith("work-item:")) {
+        const id = value.slice("work-item:".length);
+        if (id.length === 0)
+            throw usageError("Invalid --owner work-item id.", "yui job start ...");
+        return { kind: "work-item", workItemId: id };
+    }
+    if (value.startsWith("integration-attempt:")) {
+        const id = value.slice("integration-attempt:".length);
+        if (id.length === 0) {
+            throw usageError("Invalid --owner integration-attempt id.", "yui job start ...");
+        }
+        return { kind: "integration-attempt", integrationAttemptId: id };
+    }
+    throw usageError(`Invalid --owner: ${value}. Use ${JOB_OWNER_USAGE}.`, "yui job start ...");
+}
+function parseRefArgs(args, command) {
+    let taskId;
+    let jobId;
+    for (let index = 0; index < args.length; index += 1) {
+        const flag = args[index];
+        const value = args[index + 1];
+        if (value === undefined || value.startsWith("--")) {
+            throw usageError(`Missing value for ${flag}.`, `yui job ${command} ...`);
+        }
+        index += 1;
+        if (flag === "--task")
+            taskId = value;
+        else if (flag === "--job")
+            jobId = value;
+        else
+            throw usageError(`Unknown flag: ${flag}.`, `yui job ${command} ...`);
+    }
+    if (taskId === undefined || jobId === undefined) {
+        throw usageError(`job ${command} requires --task and --job.`, `yui job ${command} ...`);
+    }
+    return { taskId, jobId };
+}
+function formatOwner(owner) {
+    if (owner.kind === "task")
+        return "task";
+    if (owner.kind === "work-item")
+        return `work-item:${owner.workItemId}`;
+    return `integration-attempt:${owner.integrationAttemptId}`;
+}

package/dist/commands/executionAuditCommands.js

@@ -0,0 +1,193 @@
+/**
+ * `yui execution audit` — read-only execution history report (Issue 11 §3).
+ *
+ * The command opens the Home read-only, aggregates durable records, and never
+ * writes state or wakes a Leader. Filtering is by Task and optional ISO time
+ * window. Output is a compact text report; `--json` emits the full report.
+ */
+import { usageError } from "../errors/cliError.js";
+import { defaultTableWidth, renderTable } from "../output/table.js";
+import { runExecutionAudit } from "../observability/executionAudit.js";
+export function parseExecutionAuditOptions(args) {
+    const options = {};
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index];
+        if (argument === "--task") {
+            const value = args[++index];
+            if (value === undefined || value.startsWith("--")) {
+                throw usageError("execution audit --task requires a Task id.");
+            }
+            options.taskId = value;
+            continue;
+        }
+        if (argument === "--since" || argument === "--until") {
+            const value = args[++index];
+            if (value === undefined || value.startsWith("--")) {
+                throw usageError(`execution audit ${argument} requires an ISO timestamp.`);
+            }
+            const parsed = new Date(value);
+            if (Number.isNaN(parsed.getTime())) {
+                throw usageError(`execution audit ${argument} timestamp is invalid: ${value}.`);
+            }
+            if (argument === "--since")
+                options.since = parsed;
+            else
+                options.until = parsed;
+            continue;
+        }
+        throw usageError("execution audit usage: yui execution audit [--task <id>] [--since <iso>] [--until <iso>].");
+    }
+    if (options.since !== undefined
+        && options.until !== undefined
+        && options.since.getTime() > options.until.getTime()) {
+        throw usageError("execution audit --since must not be after --until.");
+    }
+    return options;
+}
+export function runExecutionAuditCommand(home, options) {
+    const report = runExecutionAudit(home, options);
+    return { output: renderExecutionAudit(report), report };
+}
+function formatDuration(milliseconds) {
+    if (!Number.isFinite(milliseconds) || milliseconds <= 0)
+        return "—";
+    const hours = milliseconds / 3_600_000;
+    if (hours >= 1)
+        return `${hours.toFixed(1)}h`;
+    const minutes = milliseconds / 60_000;
+    if (minutes >= 1)
+        return `${minutes.toFixed(1)}m`;
+    return `${(milliseconds / 1_000).toFixed(1)}s`;
+}
+function formatBytes(bytes) {
+    if (typeof bytes === "string")
+        return bytes;
+    if (!Number.isFinite(bytes) || bytes <= 0)
+        return "—";
+    const units = ["B", "KiB", "MiB", "GiB", "TiB"];
+    let value = bytes;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit += 1;
+    }
+    return `${value.toFixed(value >= 10 || unit === 0 ? 0 : 1)} ${units[unit]}`;
+}
+function sectionError(name, report) {
+    const section = report[name];
+    if (section?.status === "error") {
+        return [`${name}: read error — ${section.error ?? "unknown error"}`];
+    }
+    return [];
+}
+export function renderExecutionAudit(report, width = defaultTableWidth()) {
+    const lines = [
+        `Execution audit for ${report.home}`,
+        `Generated ${report.generatedAt} · Home identity ${report.homeIdentity}`,
+        `Scope: ${report.scope.taskId ?? "all Tasks"}${report.scope.since === undefined ? "" : ` since ${report.scope.since}`}${report.scope.until === undefined ? "" : ` until ${report.scope.until}`}`
+    ];
+    if (report.tasks.status === "ok" && report.tasks.data !== undefined) {
+        lines.push("", `Tasks: ${report.tasks.data.total} total · ${report.tasks.data.archived} archived · ${report.tasks.data.active} active`);
+    }
+    else {
+        lines.push("", ...sectionError("tasks", report));
+    }
+    if (report.runs.status === "ok" && report.runs.data !== undefined) {
+        const runs = report.runs.data;
+        lines.push("", `Agent runs: ${runs.total} total · ${runs.failed} failed (${(runs.failureRate * 100).toFixed(1)}%) · ${runs.yielded} yielded · ${runs.active} active`, `Duration: ${formatDuration(runs.cumulativeDurationMs)} total · ${formatDuration(runs.failedDurationMs)} in failed runs`, `By role: ${runs.byRole.leader} leader · ${runs.byRole.reviewer} reviewer · ${runs.byRole.implementer} implementer/worker · ${runs.byRole.other} other`, `By purpose: ${runs.byPurpose.execution} execution · ${runs.byPurpose.review} review`);
+        const faultRows = Object.entries(runs.faultClasses)
+            .filter(([, count]) => count > 0)
+            .sort((left, right) => right[1] - left[1]);
+        if (faultRows.length > 0) {
+            lines.push(renderTable("Run failure classes", [
+                { header: "Class", minWidth: 24, maxWidth: 40 },
+                { header: "Count", minWidth: 5, maxWidth: 8 }
+            ], faultRows.map(([name, count]) => [name, String(count)]), width));
+        }
+    }
+    else {
+        lines.push("", ...sectionError("runs", report));
+    }
+    if (report.wakes.status === "ok" && report.wakes.data !== undefined) {
+        const wakes = report.wakes.data;
+        lines.push("", `Leader wakes: ${wakes.leaderRuns} runs · ${wakes.withWakeReasons} with reasons · ${wakes.orphanWakes} orphan wakes (${wakes.orphanYieldOnly} yield-only)`);
+        if (wakes.suppressedWakes.status === "unsupported") {
+            lines.push("Suppressed wakes: unsupported (no quiescence producer in this build)");
+        }
+        const reasonRows = Object.entries(wakes.byReason).slice(0, 8);
+        if (reasonRows.length > 0) {
+            lines.push(renderTable("Wake reasons", [
+                { header: "Reason", minWidth: 20, maxWidth: 40 },
+                { header: "Count", minWidth: 5, maxWidth: 8 }
+            ], reasonRows.map(([name, count]) => [name, String(count)]), width));
+        }
+    }
+    else {
+        lines.push("", ...sectionError("wakes", report));
+    }
+    if (report.sessions.status === "ok" && report.sessions.data !== undefined) {
+        const sessions = report.sessions.data;
+        lines.push("", `Sessions: ${sessions.generations} generations · ${sessions.broken} broken · ${sessions.stopped} stopped · ${sessions.other} other`, `Resets: ${sessions.resets} · lifecycle events ${sessions.lifecycleEvents} · stop failures ${sessions.stopFailures}`);
+    }
+    else {
+        lines.push("", ...sectionError("sessions", report));
+    }
+    if (report.reviews.status === "ok" && report.reviews.data !== undefined) {
+        const reviews = report.reviews.data;
+        lines.push("", `Review rounds: ${reviews.total} total · ${reviews.completed} completed · ${reviews.failed} failed`, `Execution failures: ${reviews.infraFailed} · semantic negatives: ${reviews.semanticNegative}`);
+    }
+    else {
+        lines.push("", ...sectionError("reviews", report));
+    }
+    if (report.integrations.status === "ok" && report.integrations.data !== undefined) {
+        const integrations = report.integrations.data;
+        lines.push("", `Integration attempts: ${integrations.total} total · ${integrations.committed} committed · ${integrations.failed} failed · ${integrations.superseded} superseded`, `Failure classes: ${integrations.environmentFailures} environment · ${integrations.staleCasFailures} stale-base/CAS · ${integrations.candidateFailures} candidate`, `Gate reuse: ${integrations.gateReuse} attempt(s) reused an exact (commit, checks) signature`);
+    }
+    else {
+        lines.push("", ...sectionError("integrations", report));
+    }
+    if (report.events.status === "ok" && report.events.data !== undefined) {
+        const events = report.events.data;
+        lines.push("", `Events: ${events.total} total · ${events.progressEvents} provider-progress (${(events.progressShare * 100).toFixed(1)}%) · ${events.semanticEvents} semantic · ${events.obsoleteEvents} obsolete`, `Messages: ${events.messages}`);
+    }
+    else {
+        lines.push("", ...sectionError("events", report));
+    }
+    if (report.workItems.status === "ok" && report.workItems.data !== undefined) {
+        const items = report.workItems.data;
+        lines.push("", `Work items: ${items.total} total · ${items.completed} completed · ${items.retired} retired`);
+    }
+    else {
+        lines.push("", ...sectionError("workItems", report));
+    }
+    if (report.storage.status === "ok" && report.storage.data !== undefined) {
+        const storage = report.storage.data;
+        lines.push("", `Storage: backend ${storage.backend} · state.json ${formatBytes(storage.stateJsonBytes)} · yui.db ${formatBytes(storage.databaseBytes)}`
+            + ` · runtime/ ${formatBytes(storage.runtimeDirBytes)} · deployments ${formatBytes(storage.deploymentsBytes)}`);
+    }
+    else {
+        lines.push("", ...sectionError("storage", report));
+    }
+    if (report.topLongRunning.status === "ok" && report.topLongRunning.data !== undefined) {
+        const entries = report.topLongRunning.data;
+        if (entries.length > 0) {
+            lines.push("", renderTable("Top long-running runs", [
+                { header: "Task", minWidth: 8, maxWidth: 14 },
+                { header: "Run", minWidth: 14, maxWidth: 24 },
+                { header: "Role", minWidth: 10, maxWidth: 20 },
+                { header: "Status", minWidth: 8, maxWidth: 10 },
+                { header: "Duration", minWidth: 8, maxWidth: 10 }
+            ], entries.map((entry) => [
+                entry.taskId,
+                entry.runId,
+                entry.roleName,
+                entry.status,
+                formatDuration(entry.durationMs)
+            ]), width));
+        }
+    }
+    else {
+        lines.push("", ...sectionError("topLongRunning", report));
+    }
+    return lines.join("\n");
+}