@astrosheep/keiyaku 2.9.9 → 2.9.10

package/build/cli/render/audit.js

@@ -1,114 +1,433 @@
 import { asMessage, FlowError } from "../../flow-error.js";
-function streamLines(name, result) {
+import { shortCommitHash } from "../../git/commits.js";
+function shortRef(ref) {
+    return ref.replace(/^refs\/heads\//, "");
+}
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const seconds = ms / 1000;
+    if (seconds < 60)
+        return `${seconds.toFixed(seconds < 10 ? 1 : 0)}s`;
+    const minutes = Math.floor(seconds / 60);
+    const rem = Math.round(seconds % 60);
+    return `${minutes}m${rem.toString().padStart(2, "0")}s`;
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} bytes`;
+    const kib = bytes / 1024;
+    if (kib < 1024)
+        return `${kib < 10 ? kib.toFixed(1) : Math.round(kib)} KiB`;
+    const mib = kib / 1024;
+    return `${mib < 10 ? mib.toFixed(1) : Math.round(mib)} MiB`;
+}
+function padLabel(label, width) {
+    return label.length >= width ? label : `${label}${" ".repeat(width - label.length)}`;
+}
+function scopeMatchLabel(file) {
+    if (file.matcher.decisivePattern) {
+        const effect = file.matcher.decisivePattern.effect === "exclude" ? "excluded by" : "matched";
+        return `${effect}: ${file.matcher.decisivePattern.pattern}`;
+    }
+    if (file.class === "downgraded")
+        return "no declared term · explained companions only";
+    return "no declared term";
+}
+function explanationLine(item) {
+    if (item.kind === "file-rename")
+        return `rename ${item.from} -> ${item.to} (${item.similarity}%)`;
+    if (item.kind === "symbol-rename") {
+        return `symbol rename ${item.from} -> ${item.to} · h${item.hunk} old:${item.oldLine ?? "-"} new:${item.newLine ?? "-"}`;
+    }
+    return `import · h${item.hunk} old:${item.oldLine ?? "-"} new:${item.newLine ?? "-"}`;
+}
+function residueSummary(file) {
+    if (file.class !== "violated" || file.residue.length === 0)
+        return null;
+    const hunks = [...new Set(file.residue.map((item) => item.hunk).filter((hunk) => hunk >= 0))].sort((a, b) => a - b);
+    if (file.residue.some((item) => item.kind === "binary")) {
+        return `unexplained: binary content changed`;
+    }
+    if (hunks.length === 0)
+        return `unexplained: ${file.residue.length} changes`;
+    return `unexplained: ${file.residue.length} lines across hunk ${hunks.join(", ")}`;
+}
+function indentBlock(text, prefix = "    ") {
+    return text.split("\n").map((line) => `${prefix}${line}`);
+}
+function selectedFor(file, report) {
+    return report.presentation?.selected.filter((item) => item.path === file.path) ?? [];
+}
+function omissionsFor(file, report) {
+    return report.presentation?.omissions.filter((item) => item.path === file.path) ?? [];
+}
+function renderFileBlock(file, report) {
+    const rename = file.oldPath ? `${file.oldPath} -> ` : "";
+    const header = `  ${file.status} ${rename}${file.path}`.padEnd(62) + `+${file.stats.insertions} -${file.stats.deletions}`;
+    const lines = [header, `    ${scopeMatchLabel(file)}`];
+    for (const explanation of file.explanations)
+        lines.push(`    ${explanationLine(explanation)}`);
+    const residue = residueSummary(file);
+    if (residue)
+        lines.push(`    ${residue}`);
+    const selected = selectedFor(file, report);
+    const omissions = omissionsFor(file, report);
+    for (const item of selected) {
+        if (item.hunk === null)
+            continue;
+        lines.push("");
+        lines.push(...indentBlock(item.content));
+    }
+    if (omissions.length > 0) {
+        const omittedHunks = omissions.filter((item) => item.hunk !== null).length;
+        const omittedBytes = omissions.reduce((sum, item) => sum + item.bytes, 0);
+        const subject = omissions.every((item) => item.hunk === null)
+            ? "file content omitted"
+            : `${omittedHunks} hunk${omittedHunks === 1 ? "" : "s"} omitted`;
+        lines.push("");
+        lines.push(`    [${subject} · ${formatBytes(omittedBytes)}]`);
+    }
+    return lines;
+}
+function classRank(value) {
+    if (value === "violated")
+        return 0;
+    if (value === "downgraded")
+        return 1;
+    return 2;
+}
+function orderedFiles(report) {
+    return [...(report.files ?? [])].sort((left, right) => {
+        const rank = classRank(left.class) - classRank(right.class);
+        return rank || left.path.localeCompare(right.path);
+    });
+}
+function hasCoordinateRace(report) {
+    return report.findings.some((finding) => finding.code === "COORDINATE_RACE");
+}
+function isMatchedScope(file) {
+    return file.class === "in-scope" || file.matcher.matched;
+}
+function renderChanges(report) {
+    if (!report.diff || !report.presentation || !report.files) {
+        return [hasCoordinateRace(report) || report.rehearsal.status === "conflict" || report.rehearsal.status === "unknown" ? "—" : "not evaluated"];
+    }
+    const files = orderedFiles(report);
+    const outside = files.filter((file) => !isMatchedScope(file));
+    const declared = files.filter((file) => isMatchedScope(file));
+    const lines = [
+        `${report.diff.stat.filesChanged} files · +${report.diff.stat.insertions} -${report.diff.stat.deletions}`,
+    ];
+    if (outside.length > 0) {
+        lines.push("", "Outside declared write set", "");
+        for (const file of outside) {
+            lines.push(...renderFileBlock(file, report), "");
+        }
+    }
+    if (declared.length > 0) {
+        lines.push("", "Declared changes", "");
+        for (const file of declared) {
+            lines.push(...renderFileBlock(file, report), "");
+        }
+    }
+    const selectedCount = report.presentation.selected.filter((item) => item.hunk !== null).length;
+    const omittedCount = report.presentation.omissions.filter((item) => item.hunk !== null).length;
+    const totalHunks = selectedCount + omittedCount;
+    if (totalHunks > 0 || report.presentation.budget.limit === 0) {
+        lines.push(`Shown ${selectedCount} of ${totalHunks || selectedCount} hunks · ${formatBytes(report.presentation.budget.limit)} presentation limit`);
+    }
+    while (lines.at(-1) === "")
+        lines.pop();
+    return lines;
+}
+function shouldExpandResult(result) {
+    if (result.status === "runner_failed")
+        return true;
+    if (result.status === "executed" && result.exitCode !== 0)
+        return true;
+    return [result.stdout, result.stderr].some((stream) => stream.truncated || stream.tail.length > 0);
+}
+function streamDetail(name, result, forceEmpty) {
     const stream = result[name];
-    return [
-        `${name} tail (${stream.truncated ? `truncated, ${stream.omittedBytes} bytes omitted` : "complete, 0 bytes omitted"}):`,
-        stream.tail || "(empty)",
+    if (!forceEmpty && !stream.truncated && stream.tail.length === 0)
+        return [];
+    const mark = stream.truncated ? `truncated · ${formatBytes(stream.omittedBytes)} omitted` : "complete";
+    return [`  ${name} (${mark})`, ...indentBlock(stream.tail || "(empty)", "    ")];
+}
+function verificationStatus(result) {
+    if (result.status === "runner_failed")
+        return "unknown";
+    return result.exitCode === 0 ? "passed" : "failed";
+}
+function sourceHeading(source) {
+    return source === "contract" ? "contract" : "repository gate";
+}
+function preparationReason(reason) {
+    if (reason === "verification_not_configured")
+        return "no verification plan";
+    if (reason === "verification_plan_unavailable")
+        return "verification plan unavailable";
+    if (reason === "coordinate_race")
+        return "coordinate change";
+    return "candidate unavailable";
+}
+function preparationResult(result) {
+    if (result.kind === "exit")
+        return `exit ${result.code}`;
+    if (result.kind === "signal")
+        return `signal ${result.signal}`;
+    if (result.kind === "timeout")
+        return "timeout";
+    return `spawn · ${result.message}`;
+}
+function preparationStreams(preparation) {
+    const lines = [];
+    for (const stream of ["stdout", "stderr"]) {
+        const tail = preparation[`${stream}Tail`];
+        const truncated = preparation[`${stream}Truncated`];
+        if (tail === undefined && !truncated)
+            continue;
+        lines.push(`  ${stream} (${truncated ? "truncated" : "complete"})`);
+        lines.push(...indentBlock(tail || "(empty)", "    "));
+    }
+    return lines;
+}
+function renderCandidatePreparation(report) {
+    const preparation = report.candidatePreparation;
+    if (preparation.status === "not-required")
+        return [`  preparation  not required · ${preparationReason(preparation.reason)}`];
+    if (preparation.status === "not-configured")
+        return ["  preparation  not configured · no bind bootstrap plan"];
+    const command = JSON.stringify(preparation.plan.command);
+    if (preparation.status === "succeeded") {
+        return [
+            `  preparation  passed   ${padLabel(formatDuration(preparation.durationMs), 6)}  ${command}`,
+            ...preparationStreams(preparation),
+        ];
+    }
+    const lines = [
+        `  preparation  failed   ${padLabel(formatDuration(preparation.durationMs), 6)}  ${preparationResult(preparation.result)}`,
+        `    ${preparation.cause.code}: ${preparation.cause.message}`,
+        `    argv ${command} · timeout ${preparation.plan.timeoutMs}ms`,
     ];
+    if (preparation.integrity) {
+        lines.push(`    integrity head=${preparation.integrity.head ?? "unknown"} · tree=${preparation.integrity.tree ?? "unknown"} · tracked=${preparation.integrity.trackedChanges.length}`);
+    }
+    lines.push(...preparationStreams(preparation));
+    return lines;
 }
-function renderVerification(report) {
+function renderVerificationResults(report) {
     if (report.verification.status === "not_configured")
         return ["not configured"];
-    if (report.verification.status === "not_evaluated")
-        return [`not evaluated: ${report.verification.reason}`];
-    if (report.verification.status === "unknown")
-        return [`unknown: ${report.verification.cause.code}: ${report.verification.cause.message}`];
+    if (report.verification.status === "not_evaluated") {
+        if (hasCoordinateRace(report) || report.verification.reason === "renew_conflict" || report.verification.reason === "renew_unknown") {
+            return ["—"];
+        }
+        return [`not evaluated · ${report.verification.reason.replaceAll("_", " ")}`];
+    }
+    if (report.verification.status === "unknown") {
+        return [`unknown · ${report.verification.cause.code}: ${report.verification.cause.message}`];
+    }
+    const labels = report.verification.results.map((result) => result.label);
+    const width = Math.max(8, ...labels.map((label) => label.length));
     const lines = [];
-    for (const result of report.verification.results) {
-        lines.push(`command ${result.label}`, `exec ${result.command}`, `argv ${JSON.stringify(result.argv)}`, `head ${result.head}`);
-        if (result.status === "unverifiable") {
-            lines.push(`not executable: ${result.cause}`, "");
+    const groups = ["contract", "repository-gate"];
+    for (const source of groups) {
+        const results = report.verification.results.filter((result) => result.source === source);
+        if (results.length === 0)
             continue;
+        lines.push(`  ${sourceHeading(source)}`);
+        for (const result of results) {
+            const status = padLabel(verificationStatus(result), 7);
+            const duration = formatDuration(result.durationMs);
+            lines.push(`  ${padLabel(result.label, width)}  ${status}  ${padLabel(duration, 6)}  ${result.declaration}`);
+            if (result.status === "runner_failed") {
+                lines.push(`    ${result.cause.code}: ${result.cause.message}`);
+            }
+            if (shouldExpandResult(result)) {
+                const forceEmpty = result.status === "runner_failed" || (result.status === "executed" && result.exitCode !== 0);
+                lines.push(...streamDetail("stdout", result, forceEmpty), ...streamDetail("stderr", result, forceEmpty));
+            }
         }
-        lines.push(`\`\`\`${result.executor}`, result.body, "\`\`\`", `exit ${result.exitCode} · duration ${result.durationMs}ms`, ...streamLines("stdout", result), ...streamLines("stderr", result), "");
     }
     return lines;
 }
-function renderScope(report) {
-    if (!report.scope)
-        return ["not evaluated"];
-    return report.scope.flatMap((row) => {
-        const decisive = row.matcher.decisivePattern
-            ? `rule ${row.matcher.decisivePattern.index}:${row.matcher.decisivePattern.pattern} (${row.matcher.decisivePattern.effect})`
-            : `rule none (${row.matcher.outcome})`;
-        const explanations = row.explanations.map((item) => {
-            if (item.kind === "file-rename")
-                return `  explain file rename ${item.from} -> ${item.to} (${item.similarity}%)`;
-            if (item.kind === "symbol-rename")
-                return `  explain symbol rename ${item.from} -> ${item.to} at h${item.hunk} old:${item.oldLine ?? "-"} new:${item.newLine ?? "-"}`;
-            return `  explain import at h${item.hunk} old:${item.oldLine ?? "-"} new:${item.newLine ?? "-"}`;
-        });
-        const residue = row.residue.map((item) => `  residue h${item.hunk} old:${item.oldLine ?? "-"} new:${item.newLine ?? "-"} ${item.kind} ${item.content}`);
-        return [`${row.class} ${row.path} · ${decisive}`, ...explanations, ...residue];
-    });
+function renderVerification(report) {
+    const preparation = renderCandidatePreparation(report);
+    const results = renderVerificationResults(report);
+    return [...preparation, "", ...results];
+}
+function residueParts(readiness) {
+    const residue = readiness.deliveryResidue;
+    const parts = [];
+    if (residue.staged.length > 0)
+        parts.push(`${residue.staged.length} staged`);
+    if (residue.unstaged.length > 0)
+        parts.push(`${residue.unstaged.length} unstaged`);
+    if (residue.untracked.length > 0)
+        parts.push(`${residue.untracked.length} untracked`);
+    if (parts.length === 0 && residue.tracked.length > 0)
+        parts.push(`${residue.tracked.length} tracked dirty`);
+    return parts.join(" · ");
 }
-function renderReadiness(report) {
+function renderDeliveryContext(report) {
+    const race = report.findings.find((finding) => finding.code === "COORDINATE_RACE");
+    if (race)
+        return renderCoordinateRace(race);
     const readiness = report.readiness;
     if (!readiness)
-        return ["not evaluated: coordinate race"];
-    return [
-        `delivery residue tracked=${readiness.deliveryResidue.tracked.length} staged=${readiness.deliveryResidue.staged.length} unstaged=${readiness.deliveryResidue.unstaged.length} untracked=${readiness.deliveryResidue.untracked.length}`,
-        `arc open=${readiness.arc.open ?? "none"} max=${readiness.arc.max} fence=${readiness.arc.fence} loose=${readiness.arc.looseCommits.length}`,
-        `renew session=${readiness.renewSession.open ? "open" : "none"}`,
-        `rewrite guard=${readiness.rewriteGuard.liveProjection ? "live projection" : "clear"}`,
-        ...readiness.dependencies.map((item) => `dependency ${item.id} ${item.satisfied ? "satisfied" : `open (${item.state})`}`),
-        `petition state=${readiness.petition.state}${readiness.petition.queue ? ` queue=${readiness.petition.queue.position ?? "?"}/${readiness.petition.queue.length}` : " queue=none"}`,
-    ];
+        return ["not evaluated"];
+    const lines = [];
+    const residue = residueParts(readiness);
+    lines.push(`  worktree       ${residue || "clean"}`);
+    const arcBits = [`max ${readiness.arc.max}`];
+    if (readiness.arc.open !== null)
+        arcBits.unshift(`open ${readiness.arc.open}`);
+    if (readiness.arc.fence)
+        arcBits.push(`fence ${shortCommitHash(readiness.arc.fence)}`);
+    if (readiness.arc.looseCommits.length > 0)
+        arcBits.push(`${readiness.arc.looseCommits.length} loose`);
+    lines.push(`  arc            ${arcBits.join(" · ")}`);
+    lines.push(`  projection     ${readiness.rewriteGuard.liveProjection ? "active" : "none"}`);
+    if (readiness.dependencies.length === 0) {
+        lines.push("  dependencies   none");
+    }
+    else {
+        const deps = readiness.dependencies
+            .map((item) => `${item.id} ${item.satisfied ? "settled" : item.state}`)
+            .join(" · ");
+        lines.push(`  dependencies   ${deps}`);
+    }
+    if (readiness.petition.queue) {
+        const position = readiness.petition.queue.position ?? "?";
+        lines.push(`  petition       ${readiness.petition.state} · queue ${position}/${readiness.petition.queue.length}`);
+    }
+    else {
+        lines.push(`  petition       ${readiness.petition.state}`);
+    }
+    return lines;
+}
+function formatRaceValue(value) {
+    if (typeof value === "string") {
+        return /^[0-9a-f]{40}$/i.test(value) ? shortCommitHash(value) : value;
+    }
+    if (value === null || value === undefined)
+        return String(value);
+    if (typeof value !== "object" || Array.isArray(value))
+        return JSON.stringify(value);
+    const record = value;
+    const preferred = ["cwd", "ref", "head", "tree", "residueFingerprint"];
+    const parts = [];
+    for (const key of preferred) {
+        if (!(key in record))
+            continue;
+        const raw = record[key];
+        if (raw === undefined)
+            continue;
+        if (key === "head" || key === "tree" || key === "residueFingerprint") {
+            parts.push(`${key}=${typeof raw === "string" ? (key === "residueFingerprint" ? raw.slice(0, 12) : formatRaceValue(raw)) : JSON.stringify(raw)}`);
+            continue;
+        }
+        if (key === "ref" && typeof raw === "string") {
+            parts.push(`${key}=${shortRef(raw)}`);
+            continue;
+        }
+        parts.push(`${key}=${typeof raw === "string" ? raw : JSON.stringify(raw)}`);
+    }
+    if (parts.length === 0)
+        return JSON.stringify(value);
+    return parts.join(" · ");
 }
-function omissionLine(omission) {
-    const subject = omission.hunk === null ? "file" : `hunk ${omission.hunk}`;
-    return `omit ${subject} ${omission.path} · ${omission.bytes} bytes · ${omission.reason} · retrieve ${omission.retrieval.argv.map((part) => JSON.stringify(part)).join(" ")}`;
+function renderCoordinateRace(finding) {
+    const lines = [`  coordinate change observed`, `  ${finding.detail}`];
+    const race = finding.race;
+    if (!race)
+        return lines;
+    lines.push(`  which ${race.which}`);
+    lines.push(`  pinned    ${formatRaceValue(race.pinned)}`);
+    lines.push(`  observed  ${formatRaceValue(race.observed)}`);
+    return lines;
 }
-function renderDiff(report) {
-    if (!report.diff || !report.presentation)
-        return ["not evaluated"];
-    const selected = report.presentation.selected.map((item) => item.content);
-    const omissions = report.presentation.omissions.map(omissionLine);
-    const rows = report.files?.map((file) => `${file.status} ${file.oldPath ? `${file.oldPath} -> ` : ""}${file.path} · +${file.stats.insertions} -${file.stats.deletions} · ${file.class}`) ?? [];
-    return [
-        `${report.diff.stat.filesChanged} files · +${report.diff.stat.insertions} -${report.diff.stat.deletions}`,
-        `budget ${report.presentation.budget.limit} bytes · used ${report.presentation.budget.used} bytes · omissions ${report.presentation.omissions.length}`,
-        ...rows,
-        ...selected,
-        ...omissions,
-    ];
+function renderRehearsal(report) {
+    const rehearsal = report.rehearsal;
+    if (rehearsal.status === "fresh")
+        return "fresh";
+    if (rehearsal.status === "clean") {
+        return `clean onto ${shortRef(report.coordinates.target.ref)}@${shortCommitHash(rehearsal.newBase)}`;
+    }
+    if (rehearsal.status === "conflict") {
+        const paths = rehearsal.paths.length > 0 ? rehearsal.paths.join(", ") : "paths unavailable";
+        return `conflict · ${paths}`;
+    }
+    return `unknown · ${rehearsal.cause.code}: ${rehearsal.cause.message}`;
+}
+function renderCandidate(report) {
+    const target = `${shortRef(report.coordinates.target.ref)}@${shortCommitHash(report.coordinates.target.head)}`;
+    const delivery = `${shortRef(report.coordinates.delivery.ref)}@${shortCommitHash(report.coordinates.delivery.head)}`;
+    const lines = [];
+    if (report.candidate) {
+        const candidateHead = shortCommitHash(report.candidate.head);
+        const candidateBase = shortCommitHash(report.candidate.base);
+        if (report.candidate.kind === "renew-rehearsal") {
+            lines.push(`  ${candidateBase}..${candidateHead} · renew rehearsal`);
+            lines.push(`  delivery ${delivery}`);
+            lines.push(`  target ${target}`);
+        }
+        else {
+            lines.push(`  ${target}..${candidateHead}`);
+            if (report.candidate.head !== report.coordinates.delivery.head) {
+                lines.push(`  delivery ${delivery}`);
+            }
+        }
+    }
+    else {
+        lines.push(`  ${target}..${delivery}`);
+    }
+    if (report.diff) {
+        lines.push(`  ${report.diff.stat.filesChanged} files · +${report.diff.stat.insertions} -${report.diff.stat.deletions}`);
+    }
+    else if (report.findings.some((finding) => finding.code === "COORDINATE_RACE")) {
+        lines.push("  evidence not evaluated · coordinate change");
+    }
+    else if (report.rehearsal.status === "conflict") {
+        lines.push("  evidence not evaluated · renew conflict");
+    }
+    else if (report.rehearsal.status === "unknown") {
+        lines.push("  evidence not evaluated · renew unknown");
+    }
+    lines.push(`  rehearsal: ${renderRehearsal(report)}`);
+    lines.push(`  ledger ${shortCommitHash(report.coordinates.ledger.head)}`);
+    return lines;
+}
+function renderAcceptance(report) {
+    if (report.terms.criteria.length === 0)
+        return ["  (none)"];
+    return report.terms.criteria.map((term, index) => `  ${index + 1}. ${term}`);
 }
 export function buildAuditResponse(report, json) {
     const payload = report;
     if (json)
         return { text: JSON.stringify(report), payload };
-    const text = [
+    const sections = [
         `Audit ${report.contract}`,
         "",
-        "Coordinates",
-        `ledger ${report.coordinates.ledger.head}`,
-        `delivery ${report.coordinates.delivery.ref} ${report.coordinates.delivery.head} tree ${report.coordinates.delivery.tree}`,
-        `target ${report.coordinates.target.ref} ${report.coordinates.target.head} tree ${report.coordinates.target.tree}`,
-        "",
-        "Criteria",
-        ...report.terms.criteria.map((term) => `criterion ${term}`),
-        ...report.terms.scope.map((term) => `scope ${term}`),
-        ...report.terms.appendScope.map((term) => `append-scope ${term}`),
+        "Candidate",
+        ...renderCandidate(report),
         "",
-        "Renew Rehearsal",
-        JSON.stringify(report.rehearsal),
+        "Acceptance",
+        ...renderAcceptance(report),
         "",
-        "Diff",
-        ...renderDiff(report),
-        `counts files=${report.counts.files} selected=${report.counts.selected} omitted=${report.counts.omitted} in-scope=${report.counts.inScope} downgraded=${report.counts.downgraded} violated=${report.counts.violated} findings=${report.counts.findings}`,
-        "",
-        "Scope",
-        ...renderScope(report),
+        "Changes",
+        ...renderChanges(report),
         "",
         "Verification",
         ...renderVerification(report),
-        "Readiness",
-        ...renderReadiness(report),
         "",
-        "Findings",
-        ...(report.findings.length === 0 ? ["none"] : report.findings.flatMap((finding) => [`${finding.code}: ${finding.detail}`, `Next: ${finding.nextCommand}`])),
-    ].join("\n");
-    return { text, payload };
+        "Delivery Context",
+        ...renderDeliveryContext(report),
+    ];
+    return { text: sections.join("\n"), payload };
 }
 export function buildAuditConstructionFailure(error, json) {
     const cause = { code: error instanceof FlowError ? error.code : "INTERNAL_STATE", message: asMessage(error) };

package/build/cli/render/kanshi.js

@@ -117,6 +117,10 @@ function renderKeiyakuSection(board, width) {
             facts: contractFacts(contract),
             width,
         }));
+        if (contract.replayBlockers.length > 0) {
+            lines.push(`  ! incomplete replay · ${contract.replayBlockers.map((blocker) => blocker.surface).join(", ")}`);
+            lines.push(`  • ${contract.replayBlockers[0].recoveryCommand}`);
+        }
     }
     return lines.join("\n");
 }
@@ -231,13 +235,14 @@ function renderTaskSection(tasks, width) {
         lines.push(alignedBoardRow({
             prefix: "▶",
             title: taskLabel(task),
-            facts: [{ text: `in_progress · active ${formatAgeMs(task.activityAgeMs) ?? "0s"}` }],
+            facts: [{ text: `${task.state === "on_hold" ? "on hold · updated" : "in_progress · active"} ${formatAgeMs(task.activityAgeMs) ?? "0s"}` }],
             width,
         }));
     }
     const folded = [
         tasks.ready > 0 ? `${tasks.ready} ready` : undefined,
         tasks.blocked > 0 ? `${tasks.blocked} blocked` : undefined,
+        tasks.onHold > 0 ? `${tasks.onHold} on hold` : undefined,
     ].filter((fact) => fact !== undefined);
     if (folded.length > 0)
         lines.push(tone(`+ ${folded.join(" · ")}`, "description"));

package/build/cli/render/lifecycle.js

@@ -0,0 +1,56 @@
+import { attachAddressCarrier } from "../../core/addressing.js";
+import { isCompleteLifecycleOutcome } from "../../core/outcome-base.js";
+import { FlowError } from "../../flow-error.js";
+import { handleCliError } from "./errors.js";
+import { coreTextResponse } from "./shared.js";
+function isSuccessfulDerivedCleanup(result) {
+    return result.family === "precommit-effects-only"
+        && "status" in result
+        && result.status === "success"
+        && "cleanup" in result
+        && typeof result.cleanup === "object"
+        && result.cleanup !== null
+        && "status" in result.cleanup
+        && result.cleanup.status === "succeeded"
+        && [...result.prerequisites, ...result.downstream].every((row) => row.status !== "failed");
+}
+export async function buildLifecycleOutcomeResponse(result, context) {
+    if (result.family === "committed") {
+        return coreTextResponse(`lifecycle committed at ${result.committed.head}${result.replay.action === "reconcile" ? "; downstream reconciliation required" : ""}`, result);
+    }
+    const cause = result.family === "cancelled-before-effects"
+        ? result.cancellation
+        : result.family === "refused-before-effects"
+            ? result.failedInvariant
+            : [...result.prerequisites, ...result.downstream].find((row) => row.status === "failed")?.cause
+                ?? { code: "INTERNAL_STATE", message: "durable prerequisite effects require lifecycle reconciliation" };
+    if (!context) {
+        return { ...coreTextResponse(cause.message, result), exitCode: result.family === "cancelled-before-effects" ? 130 : 1 };
+    }
+    const facts = "facts" in cause ? cause.facts : undefined;
+    const error = new FlowError(cause.code, cause.message, {
+        ...(facts ? { facts: facts } : {}),
+    });
+    const rendered = await handleCliError({
+        error: context.address ? attachAddressCarrier(error, context.address) : error,
+        cwd: context.cwd,
+        logLabel: "lifecycle",
+    });
+    return {
+        ...rendered,
+        payload: result,
+        isDomainFailure: true,
+        exitCode: result.family === "cancelled-before-effects" ? 130 : 1,
+    };
+}
+export async function renderLifecycleResult(work, render, context) {
+    const value = await work;
+    if (isCompleteLifecycleOutcome(value))
+        return render(value);
+    if (isSuccessfulDerivedCleanup(value)) {
+        // Derived cleanup is a successful verb result, but deliberately is not a
+        // committed lifecycle result. The verb renderer owns that exact payload.
+        return render(value);
+    }
+    return buildLifecycleOutcomeResponse(value, context);
+}