@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/cli/render/projection-activity.js

@@ -1,332 +0,0 @@
-import { compactText } from "./compact-text.js";
-import { displayColumns, fitVariableLine, resolveLineColumns, truncateMiddleColumns, truncateColumns } from "./line-width.js";
-import { presentFoldedToolActivity, } from "./tool-presentation.js";
-import { presentLedgerPath, summarizeToolLedger } from "./tool-ledger-rollup.js";
-const TIME_GUTTER_WIDTH = 5;
-const VERB_WIDTH = 7;
-const SILENCE_THRESHOLD_MS = 60_000;
-const TIMELINE_GAP_MARKER = "⋮";
-/** Keep the renderer and its gap grammar while giving Kanshi its smaller live window. */
-export function selectProjectionActivityWindow(activity, ordinaryRows) {
-    // A Kanshi flow narrows only the settled history window. Unfinished activity
-    // remains pinned in its timeline position; it is not another history row.
-    const selected = activity.window.slice(-ordinaryRows);
-    const selectedOrders = new Set([
-        ...selected.map((row) => row.order),
-        ...activity.pinned.map((row) => row.order),
-    ]);
-    return {
-        activity: {
-            ...activity,
-            window: selected,
-            // Turn seals are a wait concern. Kanshi's narrow operational flow contains
-            // only ordinary activity plus durable tells.
-            timeline: activity.timeline.filter((row) => selectedOrders.has(row.order)),
-        },
-        leadingOmittedCount: activity.omittedSettledCount + activity.window.length - selected.length,
-    };
-}
-export function formatTimelineDuration(ms) {
-    const totalSeconds = Math.max(0, Math.floor(ms / 1_000));
-    if (totalSeconds < 60)
-        return `${totalSeconds}s`;
-    const totalMinutes = Math.floor(totalSeconds / 60);
-    const seconds = totalSeconds % 60;
-    if (totalMinutes < 60)
-        return `${totalMinutes}m${String(seconds).padStart(2, "0")}s`;
-    const hours = Math.floor(totalMinutes / 60);
-    const minutes = totalMinutes % 60;
-    if (hours < 24)
-        return `${hours}h${String(minutes).padStart(2, "0")}m`;
-    const days = Math.floor(hours / 24);
-    return `${days}d${String(hours % 24).padStart(2, "0")}h`;
-}
-function formatActionDuration(ms) {
-    if (ms === undefined)
-        return undefined;
-    if (ms < 10_000 && ms % 1_000 !== 0)
-        return `${(ms / 1_000).toFixed(1)}s`;
-    return formatTimelineDuration(ms);
-}
-function elapsedLabel(anchorMs, at) {
-    const eventMs = Date.parse(at);
-    if (!Number.isFinite(eventMs))
-        return "now";
-    return formatTimelineDuration(Math.max(0, anchorMs - eventMs));
-}
-export function formatWallClock(at) {
-    const value = new Date(at);
-    if (!Number.isFinite(value.getTime()))
-        return "  :  │";
-    return `${String(value.getHours()).padStart(2, "0")}:${String(value.getMinutes()).padStart(2, "0")}│`;
-}
-/** One durable-tell line dialect shared by wait and the embedded Kanshi flow. */
-export function renderPendingProjectionTell(tell, input) {
-    const createdAtMs = Date.parse(tell.createdAt);
-    const age = Math.max(0, input.anchorMs - (Number.isFinite(createdAtMs) ? createdAtMs : input.anchorMs));
-    const fixed = `${formatWallClock(tell.createdAt)} ${"told".padEnd(VERB_WIDTH)} `;
-    const tail = ` — ${formatTimelineDuration(age)}…`;
-    return `${fixed}${truncateColumns(`“${tell.text}”`, Math.max(0, input.maxColumns - displayColumns(fixed) - displayColumns(tail)))}${input.renderUnconsumedTail?.(tail) ?? tail}`;
-}
-function commonPrefix(left, right) {
-    const a = [...left];
-    const b = [...right];
-    let index = 0;
-    while (index < a.length && index < b.length && a[index] === b[index])
-        index += 1;
-    return a.slice(0, index).join("");
-}
-function compressedPrefix(prefix) {
-    const points = [...prefix];
-    if (points.length < 24)
-        return undefined;
-    let cut = -1;
-    for (let index = points.length - 1; index >= 0; index -= 1) {
-        if (points[index] === " ") {
-            cut = index;
-            break;
-        }
-    }
-    if (cut < 0)
-        return undefined;
-    const stable = points.slice(0, cut).join("");
-    const stablePoints = [...stable];
-    if (stablePoints.length < 24)
-        return undefined;
-    return {
-        text: `${stablePoints.slice(0, 10).join("")}…${stablePoints.slice(-14).join("")}`,
-        resumeAt: cut + 1,
-    };
-}
-function timelineGutter(label, spine) {
-    return label || `${"".padStart(TIME_GUTTER_WIDTH)}${spine}`;
-}
-function renderTimelineGap(omittedRowCount, maxColumns) {
-    return fitVariableLine(`${timelineGutter("", TIMELINE_GAP_MARKER)} `, `${omittedRowCount} more`, maxColumns);
-}
-function compactTokens(value) {
-    if (value < 1_000)
-        return String(value);
-    const compact = (value / 1_000).toFixed(value < 10_000 ? 1 : 0).replace(/\.0$/, "");
-    return `${compact}k`;
-}
-function warningText(row) {
-    const warning = row.warning;
-    if (warning.reason === "rate-limit") {
-        return `provider rate limit exhausted${row.count > 1 ? ` (${row.count})` : ""}`;
-    }
-    if (warning.reason === "retry") {
-        const status = warning.errorStatus === null ? "no response" : String(warning.errorStatus);
-        return `provider retrying ${warning.attempt}/${warning.maxRetries} · retry in ${formatTimelineDuration(warning.retryDelayMs)} · status ${status}${row.count > 1 ? ` (${row.count})` : ""}`;
-    }
-    const modelRoute = warning.originalModel && warning.fallbackModel
-        ? ` ${warning.originalModel}→${warning.fallbackModel}`
-        : warning.direction
-            ? ` ${warning.direction}`
-            : "";
-    return `provider ${warning.reason}${modelRoute}${row.count > 1 ? ` (${row.count})` : ""}`;
-}
-function renderPlan(plan, maxColumns) {
-    const width = 5;
-    const filled = plan.total === 0 ? 0 : Math.min(width, Math.round((plan.done / plan.total) * width));
-    const bar = `${"▰".repeat(filled)}${"▱".repeat(width - filled)}`;
-    const fixed = `${"now".padStart(TIME_GUTTER_WIDTH)}│ ${"plan".padEnd(VERB_WIDTH)} ${bar} ${plan.done}/${plan.total}`;
-    return fitVariableLine(fixed, plan.activeItem ? ` → ${compactText(plan.activeItem)}` : "", maxColumns);
-}
-function rollupCountLabel(semanticClass) {
-    return semanticClass === "run" ? "ran" : semanticClass;
-}
-function summarizeProjectionToolLedger(activity, workspaceRoot) {
-    return summarizeToolLedger(activity.ledgerActivities, activity.ledgerTurns, (value) => presentLedgerPath(value, workspaceRoot));
-}
-function toolCountSegments(summary) {
-    return summary.counts.map(({ semanticClass, count }) => `${count} ${rollupCountLabel(semanticClass)}`);
-}
-function projectionSummarySegments(summary) {
-    const segments = toolCountSegments(summary);
-    if (summary.tokens !== undefined) {
-        segments.push(`${compactTokens(summary.tokens)} tok`);
-    }
-    if (summary.costUsd !== undefined) {
-        segments.push(`$${summary.costUsd.toFixed(2)}`);
-    }
-    return segments;
-}
-export function renderProjectionActivitySummary(activity, input) {
-    const summary = summarizeProjectionToolLedger(activity, input.workspaceRoot);
-    const segments = projectionSummarySegments(summary);
-    if (segments.length === 0)
-        return undefined;
-    const spine = input.state === "dead" || input.state === "lost" ? "┆" : "│";
-    return fitVariableLine(`${"".padStart(TIME_GUTTER_WIDTH)}${spine} `, segments.join(" · "), input.maxColumns ?? resolveLineColumns());
-}
-function renderTerminalRollup(activity, input) {
-    const summary = summarizeProjectionToolLedger(activity, input.workspaceRoot);
-    const segments = projectionSummarySegments(summary);
-    const rows = input.diagnostic
-        ? [{
-                kind: "diagnostic",
-                line: fitVariableLine(`${elapsedLabel(input.anchorMs, input.diagnostic.at).padStart(TIME_GUTTER_WIDTH)}┆ ${"warning".padEnd(VERB_WIDTH)} `, compactText(input.diagnostic.text), input.maxColumns),
-            }]
-        : [];
-    const endPrefix = `${"end".padStart(TIME_GUTTER_WIDTH)}└`;
-    rows.push({
-        kind: "end-anchor",
-        line: segments.length > 0
-            ? fitVariableLine(`${endPrefix} `, segments.join(" · "), input.maxColumns)
-            : endPrefix,
-    });
-    if (input.includeFiles !== false) {
-        for (const file of summary.files) {
-            const repeat = file.count > 1 ? ` ×${file.count}` : "";
-            const diffstat = file.diffstat ? ` +${file.diffstat.additions} −${file.diffstat.deletions}` : "";
-            rows.push({ kind: "file", line: fitVariableLine("", `${file.path}${repeat}${diffstat}`, input.maxColumns) });
-        }
-        if (summary.hiddenFileCount > 0) {
-            rows.push({ kind: "file", line: fitVariableLine("", `… ${summary.hiddenFileCount} more files`, input.maxColumns) });
-        }
-    }
-    return { rows, hasMutationFiles: summary.files.length > 0 };
-}
-function timelineEntries(activity) {
-    const entries = [];
-    for (const row of activity.timeline) {
-        if (row.kind === "ran") {
-            for (const observation of row.observations) {
-                if (observation.order !== row.order)
-                    entries.push({ kind: "clock", order: observation.order, at: observation.at });
-            }
-        }
-        entries.push({ kind: "row", order: row.order, at: row.at, row });
-    }
-    return entries.sort((left, right) => left.order - right.order);
-}
-export function renderProjectionActivity(activity, input) {
-    const lines = [];
-    const rowKinds = [];
-    const rowAts = [];
-    let priorAtMs;
-    let priorMinute;
-    let priorCompletedRan;
-    let hasEndAnchor = false;
-    let lastRunningTool;
-    const interrupted = input.state === "dead" || input.state === "lost" || input.state === "dismissed";
-    const maxColumns = input.maxColumns ?? resolveLineColumns();
-    const entries = timelineEntries(activity);
-    const gapBeforeOrder = input.leadingOmittedCount ? activity.window[0]?.order : undefined;
-    let gapEmitted = false;
-    const pushRow = (line, kind, at) => {
-        lines.push(line);
-        rowKinds.push(kind);
-        rowAts.push(at);
-        return true;
-    };
-    for (let index = 0; index < entries.length; index += 1) {
-        const entry = entries[index];
-        const atMs = Date.parse(entry.at);
-        if (entry.kind === "clock") {
-            if (Number.isFinite(atMs))
-                priorAtMs = atMs;
-            continue;
-        }
-        if (!gapEmitted && input.leadingOmittedCount && gapBeforeOrder !== undefined && entry.row.order >= gapBeforeOrder) {
-            pushRow(renderTimelineGap(input.leadingOmittedCount, maxColumns), "activity", entry.at);
-            gapEmitted = true;
-        }
-        if (input.showSilence !== false && priorAtMs !== undefined && Number.isFinite(atMs) && atMs - priorAtMs >= SILENCE_THRESHOLD_MS) {
-            pushRow(fitVariableLine(`${"".padStart(TIME_GUTTER_WIDTH)}┆ `, `${formatTimelineDuration(atMs - priorAtMs)} pass in silence`, maxColumns), "silence", entry.at);
-        }
-        if (Number.isFinite(atMs))
-            priorAtMs = atMs;
-        const row = entry.row;
-        const minute = row.kind === "turn" ? "" : formatWallClock(row.at);
-        const label = row.kind === "turn" || minute === priorMinute ? "" : minute;
-        if (minute)
-            priorMinute = minute;
-        const spine = row.kind === "turn"
-            ? "├"
-            : interrupted
-                ? "┆"
-                : "│";
-        if (row.kind === "ran") {
-            const duration = formatActionDuration(row.durationMs);
-            const activityState = row.state === "completed"
-                ? "completed"
-                : interrupted
-                    ? "interrupted"
-                    : input.state === "stalled" || input.state === "unknown"
-                        ? "unresolved"
-                        : "running";
-            const presentation = presentFoldedToolActivity(row, { state: activityState, ...(duration ? { duration } : {}) }, (value) => presentLedgerPath(value, input.workspaceRoot) ?? value);
-            const fixed = `${timelineGutter(label, spine)} ${(presentation.semanticClass === "run" ? "ran" : presentation.semanticClass).padEnd(VERB_WIDTH)} `;
-            let variable = presentation.variableText;
-            if (row.state === "completed" && priorCompletedRan !== undefined) {
-                const common = commonPrefix(priorCompletedRan, variable);
-                const prefix = compressedPrefix(common);
-                if (prefix) {
-                    variable = `${prefix.text} ${[...variable].slice(prefix.resumeAt).join("")}`;
-                }
-            }
-            priorCompletedRan = row.state === "completed" ? presentation.variableText : undefined;
-            const budget = Math.max(0, maxColumns - displayColumns(fixed) - displayColumns(presentation.fixedSuffix));
-            pushRow(`${fixed}${truncateMiddleColumns(variable, budget)}${presentation.fixedSuffix}`, "activity", entry.at);
-            continue;
-        }
-        if (row.kind === "said") {
-            priorCompletedRan = undefined;
-            pushRow(fitVariableLine(`${timelineGutter(label, spine)} ${"said".padEnd(VERB_WIDTH)} `, `“${compactText(row.text)}”`, maxColumns), "activity", entry.at);
-        }
-        else if (row.kind === "thought") {
-            priorCompletedRan = undefined;
-            const text = `${compactText(row.text)}${row.truncated && !row.text.endsWith("…") ? "…" : ""}`;
-            const duration = formatActionDuration(row.durationMs);
-            pushRow(fitVariableLine(`${timelineGutter(label, spine)} ${"thought".padEnd(VERB_WIDTH)} `, `${duration ? `${duration} — ` : ""}“${text}”`, maxColumns), "activity", entry.at);
-        }
-        else if (row.kind === "warning") {
-            priorCompletedRan = undefined;
-            pushRow(fitVariableLine(`${timelineGutter(label, spine)} ${"warning".padEnd(VERB_WIDTH)} `, warningText(row), maxColumns), "activity", entry.at);
-        }
-        else {
-            priorCompletedRan = undefined;
-            const usage = row.inputTokens !== undefined && row.outputTokens !== undefined
-                ? ` · ${compactTokens(row.inputTokens)}▸${compactTokens(row.outputTokens)} tok`
-                : "";
-            const cost = row.costUsd !== undefined ? ` · $${row.costUsd.toFixed(2)}` : "";
-            pushRow(fitVariableLine(`${"".padStart(TIME_GUTTER_WIDTH)}├ `, `turn ${row.turn}${usage}${cost}`, maxColumns), "activity", entry.at);
-        }
-    }
-    for (const row of activity.pinned) {
-        if (row.kind === "ran" && row.state === "running")
-            lastRunningTool = compactText(row.tool);
-    }
-    if (input.showPlan && activity.plan) {
-        const planAtMs = Date.parse(activity.plan.at);
-        if (input.showSilence !== false && priorAtMs !== undefined && Number.isFinite(planAtMs) && planAtMs - priorAtMs >= SILENCE_THRESHOLD_MS) {
-            pushRow(fitVariableLine(`${"".padStart(TIME_GUTTER_WIDTH)}┆ `, `${formatTimelineDuration(planAtMs - priorAtMs)} pass in silence`, maxColumns), "silence", activity.plan.at);
-        }
-        pushRow(renderPlan(activity.plan, maxColumns), "plan", activity.plan.at);
-    }
-    let hasMutationFiles = false;
-    if (["returned", "dead", "lost", "dismissed"].includes(input.state)) {
-        const rollup = renderTerminalRollup(activity, {
-            anchorMs: input.anchorMs,
-            ...(input.workspaceRoot ? { workspaceRoot: input.workspaceRoot } : {}),
-            ...(input.terminalDiagnostic ? { diagnostic: input.terminalDiagnostic } : {}),
-            includeFiles: input.showTerminalFiles !== false,
-            maxColumns,
-        });
-        for (const row of rollup.rows) {
-            pushRow(row.line, row.kind, new Date(input.anchorMs).toISOString());
-        }
-        hasEndAnchor = true;
-        hasMutationFiles = rollup.hasMutationFiles;
-    }
-    return {
-        lines,
-        rowKinds,
-        rowAts,
-        ...(lastRunningTool ? { lastRunningTool } : {}),
-        hasEndAnchor,
-        hasMutationFiles,
-    };
-}

package/build/cli/render/projection-history.js

@@ -1,77 +0,0 @@
-import { renderProjectionActivity } from "./projection-activity.js";
-function fact(value) {
-    return value ?? "unavailable";
-}
-function consequenceLines(run) {
-    const consequences = run.consequences;
-    if (consequences === null)
-        return [];
-    if (consequences.retention === "unavailable") {
-        return [`consequences: unavailable · ${consequences.reason}`];
-    }
-    const retained = (name, value, detail) => value.retention === "retained" ? `${name}: retained · ${detail}` : `${name}: unavailable · ${value.reason}`;
-    return [
-        `review: unavailable · ${consequences.review.reason}`,
-        retained("petition", consequences.petition, consequences.petition.retention === "retained" ? `${consequences.petition.intent} · ${consequences.petition.objectId}` : ""),
-        retained("verdict", consequences.verdict, consequences.verdict.retention === "retained" ? `${consequences.verdict.result} · ${consequences.verdict.objectId}` : ""),
-        retained("claim", consequences.claim, consequences.claim.retention === "retained" ? `${consequences.claim.objectId} · ${consequences.claim.mergeCommit}` : ""),
-        retained("landed commit", consequences.landedCommit, consequences.landedCommit.retention === "retained" ? consequences.landedCommit.commit : ""),
-    ];
-}
-function runLines(run) {
-    return [
-        `${run.id}${run.alias ? ` (${run.alias})` : ""} · ${run.outcome}`,
-        `akuma: ${fact(run.akuma)} · provider: ${fact(run.provider)}${run.pid === null ? "" : ` · pid: ${run.pid}`} · role: ${run.role}`,
-        `contract: ${fact(run.contractId)}`,
-        `created: ${fact(run.mintedAt)}${run.terminalAt ? ` · terminal: ${run.terminalAt}` : ""}`,
-        ...(run.generation ? [`generation: ${run.generation.executionId} · created: ${run.generation.createdAt}${run.generation.adoptedAt ? ` · adopted: ${run.generation.adoptedAt}` : ""}`] : []),
-        `activity: ${run.activityRetention} · ${run.activityCount} retained${run.activityRange ? ` · ${run.activityRange.first}-${run.activityRange.last}` : ""}`,
-        ...(run.telemetry ? [`telemetry: ${run.telemetry.inputTokens} in · ${run.telemetry.outputTokens} out${run.telemetry.cachedInputTokens !== undefined ? ` · ${run.telemetry.cachedInputTokens} cached` : ""}${run.telemetry.costUsd !== undefined ? ` · $${run.telemetry.costUsd.toFixed(2)}` : ""}`] : []),
-        ...(run.artifact ? [`artifact: ${fact(run.artifact.id)} · ${run.artifact.retention}${run.artifact.path ? ` · path: ${run.artifact.path}` : ""}`] : []),
-        ...(run.terminalAnswer ? [`answer: ${run.terminalAnswer.text}`] : []),
-        ...consequenceLines(run),
-        ...run.diagnostics.map((diagnostic) => `diagnostic: ${diagnostic}`),
-    ];
-}
-export function renderProjectionHistoryList(runs, pagination) {
-    const lines = runs.flatMap((run, index) => index === 0 ? runLines(run) : ["", ...runLines(run)]);
-    if (!pagination)
-        return lines.join("\n");
-    const range = runs.length === 0
-        ? "none"
-        : `${pagination.offset}-${pagination.offset + runs.length - 1}`;
-    return [...lines, ...(lines.length > 0 ? [""] : []), `entries: ${range} of ${pagination.total}${pagination.nextOffset === null ? "" : ` · next offset: ${pagination.nextOffset}`}`].join("\n");
-}
-export function renderProjectionHistoryDetail(detail, entry) {
-    const lines = runLines(detail);
-    if (entry) {
-        return [...lines, "", `entry: ${entry.index}`, `event: ${JSON.stringify(entry.event)}`,
-            ...(entry.raw ? [`raw: ${entry.raw.retention} · ${entry.raw.reason}`] : []),
-        ].join("\n");
-    }
-    if (!detail.activity || detail.activity.retainedTimeline.length === 0) {
-        return lines.join("\n");
-    }
-    const state = detail.outcome === "done" ? "returned"
-        : detail.outcome === "out" ? "running"
-            : detail.outcome === "failed" || detail.outcome === "dead" ? "dead"
-                : detail.outcome === "lost" ? "lost"
-                    : detail.outcome === "killed" || detail.outcome === "dismissed" ? "dismissed"
-                        : detail.outcome === "startup-timeout" ? "stalled"
-                            : "unknown";
-    const activity = renderProjectionActivity({
-        ...detail.activity,
-        timeline: detail.activity.retainedTimeline,
-        omittedSettledCount: 0,
-    }, {
-        anchorMs: Date.now(),
-        state,
-        showPlan: false,
-        showSilence: false,
-        showTerminalFiles: false,
-    });
-    return [...lines, "", ...activity.lines].join("\n");
-}
-export function projectionHistoryJson(value) {
-    return `${JSON.stringify(value)}\n`;
-}

package/build/cli/render/response-style.js

@@ -1,27 +0,0 @@
-export const RESPONSE_MARKERS = {
-    arc: "◆",
-    claim: "✓",
-    forfeit: "✗",
-    // Top-level outcome marker for failed calls.
-    failure: "✕",
-};
-export const DIFF_OVERVIEW_SECTION_TITLE = "Diff Overview";
-export const BIND_RULES_SECTION_TITLE = "Rules (Project Level)";
-export const WARNING_SECTION_TITLE = "Warning";
-export const SECTION_ICONS = {
-    keiyaku: "·",
-    contract: "·",
-    goal: "▸",
-    rules: "!",
-    [BIND_RULES_SECTION_TITLE.toLowerCase()]: "!",
-    criteria: "✓",
-    context: "·",
-    summary: "·",
-    "diff overview": "±",
-    info: "i",
-    [WARNING_SECTION_TITLE.toLowerCase()]: "!",
-    blocked: "⊘",
-    // Detail-section marker for the ERROR block.
-    error: "‼",
-    hints: "…",
-};

package/build/cli/render/shared.js

@@ -1,232 +0,0 @@
-import { KEIYAKU_FILE } from "../../keiyaku.js";
-import { isCompleteLifecycleOutcome } from "../../core/outcome-base.js";
-import { commissionSlug, formatCommissionCoordinate } from "../../core/ids.js";
-import { assembleResponse, buildSection, DISPLAY_TEXT_MAX_CHARS, FORMAT_LIST_MAX_ITEM_CHARS, FORMAT_LIST_MAX_ITEMS, formatMaybe, formatWarnings, shellQuote, truncateForDisplay, } from "./format.js";
-import { WARNING_SECTION_TITLE } from "./response-style.js";
-import { prependAddressReceipt } from "./address.js";
-import { renderPathPreview, renderPatternPair } from "./path-prefix-compaction.js";
-export function textResponse(text) {
-    const payload = {};
-    return {
-        text,
-        payload,
-    };
-}
-/** Carrier boundary: data must already be a named command payload assignable to JsonObject. */
-export function coreTextResponse(text, data) {
-    return {
-        text,
-        payload: data,
-    };
-}
-export async function renderCoreResult(work, render) {
-    return render(await work);
-}
-export function buildBindDraftResponse(draftPath) {
-    const payload = { draftPath };
-    return coreTextResponse(`Draft saved to ${draftPath}.`, payload);
-}
-export function buildBindPreviewResponse(result) {
-    const overlapWarnings = renderScopeOverlapWarnings(result.scopeOverlaps);
-    const payload = {
-        id: result.id,
-        canonicalDraft: result.canonicalDraft,
-        target: result.target,
-        place: result.place,
-        workspace: result.workspace,
-        after: result.after,
-        warnings: overlapWarnings,
-        scopeOverlaps: result.scopeOverlaps,
-    };
-    return {
-        ...coreTextResponse(result.canonicalDraft, payload),
-        ...(overlapWarnings.length > 0 ? { stderr: ["Warnings:", ...overlapWarnings].join("\n") } : {}),
-    };
-}
-export function buildBindResponse(result, cwd) {
-    void cwd;
-    const overlapWarnings = renderScopeOverlapWarnings(result.scopeOverlaps);
-    const place = result.place;
-    const payload = {
-        id: result.id,
-        ref: result.ref,
-        worktreePath: result.worktreePath,
-        workspace: result.workspace,
-        place: result.place,
-        target: result.target,
-        ledgerHead: result.ledgerHead,
-        warnings: overlapWarnings,
-        scopeOverlaps: result.scopeOverlaps,
-        ...(result.branch ? { branch: result.branch } : {}),
-    };
-    return coreTextResponse([
-        `Bound${place ? ` @${place}` : ""} · commission ${result.id} · target ${result.target}`,
-        ...(overlapWarnings.length > 0 ? ["Warnings:", ...overlapWarnings] : []),
-    ].join("\n"), payload);
-}
-export function buildContainedBindResponse(result) {
-    const payload = {
-        family: result.family,
-        completion: result.completion,
-        committed: result.committed,
-        heads: result.heads,
-        reconciliationKey: result.reconciliationKey,
-        prerequisites: result.prerequisites,
-        downstream: result.downstream,
-        replay: result.replay,
-        carrier: result.carrier,
-        cancellationObserved: result.cancellationObserved,
-    };
-    return coreTextResponse(`Bind committed with incomplete replay · head ${result.committed.head} · reconcile ${result.reconciliationKey}`, payload);
-}
-export function buildBindOutcomeResponse(result, cwd) {
-    return isCompleteLifecycleOutcome(result)
-        ? buildBindResponse(result, cwd)
-        : buildContainedBindResponse(result);
-}
-function renderScopeOverlapWarnings(overlaps) {
-    const overlapsByCounterparty = new Map();
-    for (const overlap of overlaps) {
-        const counterparty = overlap.contracts[1];
-        const group = overlapsByCounterparty.get(counterparty);
-        if (group)
-            group.push(overlap);
-        else
-            overlapsByCounterparty.set(counterparty, [overlap]);
-    }
-    return [...overlapsByCounterparty.entries()].map(([contractId, overlaps]) => renderScopeOverlapGroup(commissionSlug(contractId), overlaps));
-}
-function renderScopeOverlapGroup(contractAddr, overlaps) {
-    const nextAddr = commissionSlug(overlaps[0].contracts[0]);
-    const pairs = overlaps.flatMap((overlap) => {
-        const [nextPattern, existingPattern] = overlap.patterns;
-        const patternPair = renderPatternPair(nextAddr, nextPattern, contractAddr, existingPattern);
-        const evidence = overlap.kind === "potential"
-            ? ["potential · no current tracked path proves it"]
-            : renderPathPreview(overlap.paths);
-        return [...patternPair, ...evidence].map((line) => `  ${line}`);
-    });
-    return [
-        `▲ overlap ${nextAddr} ↔ ${contractAddr}`,
-        ...pairs,
-        `  consider --after ${contractAddr}`,
-    ].join("\n");
-}
-export function buildForfeitResponse(result) {
-    const { address: _address, ...resultData } = result;
-    const payload = resultData;
-    const place = result.address.binding.kind === "commission"
-        ? (result.address.place?.display ?? null)
-        : null;
-    const coordinate = formatCommissionCoordinate({ commissionId: result.contractId, place });
-    const base = `Forfeited ${coordinate}.`;
-    const warnings = [
-        ...(result.cleanup.worktreeRemoveFailure
-            ? [
-                `Could not remove contract worktree ${result.cleanup.worktreeRemoveFailure.path}: ${result.cleanup.worktreeRemoveFailure.reason}`,
-            ]
-            : []),
-        ...(result.cleanup.deliveryRef.status === "mismatch"
-            ? [`Delivery ref ${result.cleanup.deliveryRef.mismatch.ref} remains present at ${result.cleanup.deliveryRef.mismatch.observed.head}; terminal replay preserved it as a projected-surface mismatch.`]
-            : []),
-    ];
-    if (warnings.length === 0) {
-        return prependAddressReceipt(coreTextResponse(base, payload), result.address);
-    }
-    const warningSection = buildSection(WARNING_SECTION_TITLE, formatWarnings(warnings));
-    return prependAddressReceipt(coreTextResponse(assembleResponse(base, "", [warningSection].filter((section) => section !== null)), payload), result.address);
-}
-export const RULES_SECTION_MAX_CHARS = 5000;
-export const INFO_SECTION_TITLE = "Info";
-export const HINTS_SECTION_TITLE = "Hints";
-export const REVIEW_SECTION_TITLE = "Review";
-export const STATUS_KEIYAKU_SECTION_TITLE = "Keiyaku";
-export const STATUS_WORKTREE_SECTION_TITLE = "Worktree";
-export const STATUS_COMMANDS_SECTION_TITLE = "Commands";
-export const CONTENT_SECTION_TITLE = "Content";
-export const STATUS_ACTIVE_SUMMARY_PREFIX = "● Active";
-export const STATUS_INACTIVE_SUMMARY = "○ Inactive";
-export const SAVED_TO_PREFIX = "Saved to";
-export const INFO_AKUMA_MAX_CHARS = 120;
-export const INFO_FROM_DRAFT_MAX_CHARS = 300;
-export const EXISTING_BRANCHES_MAX_ITEMS = FORMAT_LIST_MAX_ITEMS;
-export const INFO_BRANCH_MAX_CHARS = 200;
-export const INFO_COMMIT_MAX_CHARS = 100;
-export const INFO_PLEA_MAX_CHARS = 220;
-export const DROPPED_CHANGES_MAX_ITEMS = FORMAT_LIST_MAX_ITEMS;
-export const HINTS_LIST_MAX_ITEMS = 12;
-export const STATUS_PREVIEW_MAX_CHARS = 400;
-export const BIND_PROTOCOL_FILES_CREATED = [KEIYAKU_FILE];
-export const BIND_PROTOCOL_FILES_LABEL = "Protocol Files";
-export function formatReview(review) {
-    const lines = [
-        `Review ${review.review}: ${review.result}`,
-        ...formatMaybe("See", review.historyPath, FORMAT_LIST_MAX_ITEM_CHARS),
-    ];
-    if (review.findings?.trim()) {
-        lines.push("", truncateForDisplay(review.findings, DISPLAY_TEXT_MAX_CHARS));
-    }
-    return lines;
-}
-export function toReviewPayload(review) {
-    return {
-        review: review.review,
-        result: review.result,
-        ...(review.historyPath ? { historyPath: review.historyPath } : {}),
-        ...(review.findings ? { findings: review.findings } : {}),
-    };
-}
-export function formatPersistenceSummary(responsePath) {
-    if (!responsePath)
-        return "";
-    return `${SAVED_TO_PREFIX} ${responsePath}.`;
-}
-export function formatCallCompletionHeading(projection) {
-    switch (projection?.phase) {
-        case "active":
-        case "quiescent": return "still out there";
-        case "done": return "returned";
-        case "failed": return "dead";
-        case "dismissed": return "dismissed";
-        case "lost": return undefined;
-        default: return "no record of this akuma";
-    }
-}
-/** Machine-generated durable fork command: artifactId + explicit repository coordinate. */
-export function formatDurableReviveCommand(input) {
-    return input.repositoryCoordinate
-        ? `keiyaku fork ${input.artifactId} --repo ${shellQuote(input.repositoryCoordinate)}`
-        : `keiyaku fork ${input.artifactId}`;
-}
-export function formatTellCommand(projectionId, body) {
-    return `keiyaku tell ${projectionId} [--wait DURATION] ${body}`;
-}
-export function projectionRejoinHintLines(projectionId) {
-    return [
-        "Come back for the result:",
-        `  » keiyaku wait ${projectionId} [--timeout DURATION]`,
-        "Steer it while it works:",
-        `  » ${formatTellCommand(projectionId, '"your words"')}`,
-    ];
-}
-export function formatCallNextAction(input) {
-    if (input.projection?.phase === "active") {
-        return projectionRejoinHintLines(input.projection.id).join("\n");
-    }
-    if (input.projection?.phase === "done") {
-        return [
-            "The akuma is back.",
-            ...(input.artifactId ? [`record: ${input.artifactId}`] : []),
-            "talk to it:",
-            `  » ${formatTellCommand(input.projection.id, '"your words"')}`,
-        ].join("\n");
-    }
-    return "» keiyaku status";
-}
-export function appendPersistenceSummary(base, responsePath) {
-    const persistence = formatPersistenceSummary(responsePath);
-    return persistence ? `${base} ${persistence}` : base;
-}
-export function formatUnavailableReasons(reasons) {
-    return reasons.map((reason) => reason.trim().replace(/[.。]+$/, "")).join("; ");
-}

package/build/cli/render/skills.js

@@ -1,10 +0,0 @@
-/** Skills install success receipt: target rows plus optional warning block. */
-export function renderSkillsInstallReceipt(result) {
-    return [
-        "Installed official Keiyaku skills:",
-        ...result.targets.map((target) => `- ${target.path} -> ${target.source} (${target.status})`),
-        ...(result.warnings.length > 0
-            ? ["", "## Warning", ...result.warnings.map((warning) => `- ${warning}`)]
-            : []),
-    ].join("\n");
-}