@astrosheep/keiyaku 2.9.13 → 4.0.0

package/build/src/cli/render/akuma.js

@@ -0,0 +1,254 @@
+import { toolRepr } from "./akuma-tool.js";
+import { safeText } from "./terminal.js";
+const GUTTER_MS = 60_000;
+const LABEL_WIDTH = 8;
+function mark(life) {
+    switch (life) {
+        case "running": return "●";
+        case "dead": return "×";
+        case "asleep": return "○";
+        case "stranded":
+        case "headless": return "!";
+    }
+}
+function ruler(parts) {
+    const prefix = `── ${parts.join(" ── ")} `;
+    return `${prefix}${"─".repeat(Math.max(1, 64 - prefix.length))}`;
+}
+function clock(at) {
+    if (at === undefined)
+        return "";
+    const date = new Date(at);
+    if (!Number.isFinite(date.getTime()))
+        return "";
+    return `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
+}
+function renderSpine(items) {
+    let lastPrintedAt;
+    return items.map((item) => {
+        const timestamp = item.at === undefined ? undefined : Date.parse(item.at);
+        const printable = timestamp !== undefined && Number.isFinite(timestamp)
+            && (lastPrintedAt === undefined || timestamp - lastPrintedAt >= GUTTER_MS);
+        if (printable)
+            lastPrintedAt = timestamp;
+        const time = printable ? clock(item.at) : "";
+        const index = item.index === undefined ? "" : String(item.index).padStart(4, " ");
+        const gutter = `${index}${index.length === 0 ? "" : " "}${time.padStart(5, " ")}`;
+        return `${gutter} │ ${item.label.padEnd(LABEL_WIDTH, " ")} ${item.text}`.trimEnd();
+    });
+}
+function activityItem(row) {
+    if (row.kind === "said")
+        return { at: row.at, label: "say", text: row.text };
+    if (row.kind === "thought")
+        return { at: row.at, label: "thought", text: row.text };
+    if (row.kind === "note")
+        return { at: row.at, label: "note", text: row.text };
+    const repr = toolRepr(row);
+    return {
+        at: row.at,
+        label: repr.label,
+        text: repr.text,
+    };
+}
+function pendingItems(status) {
+    return status.activity.pendingTells.map((tell) => ({ label: "⧗ tell", text: JSON.stringify(tell.body) }));
+}
+function outcomeItems(status) {
+    if (status.answer !== undefined) {
+        return [{
+                ...(status.outcomeAt === undefined ? {} : { at: status.outcomeAt }),
+                label: "✓",
+                text: `answered · keiyaku history ${status.answerHistoryId ?? ""} --last`.trim(),
+            }];
+    }
+    if (status.failure !== undefined) {
+        return [{
+                ...(status.outcomeAt === undefined ? {} : { at: status.outcomeAt }),
+                label: "!",
+                text: `failed · ${status.failure}`,
+            }];
+    }
+    return [];
+}
+function statusItems(status) {
+    return [
+        ...status.activity.rows.map(activityItem),
+        ...pendingItems(status),
+        ...outcomeItems(status),
+    ];
+}
+function omission(status) {
+    return status.activity.omitted === 0
+        ? []
+        : [`      ⋮ +${status.activity.omitted}`];
+}
+function statusText(status, facts = []) {
+    return [
+        ruler([`${mark(status.life)} ${status.id}`]),
+        ...facts,
+        ...omission(status),
+        ...renderSpine(statusItems(status)),
+    ].join("\n");
+}
+function historyItems(history) {
+    const activity = history.rows.map((row) => ({ ...activityItem(row), index: row.sequence }));
+    const boundaries = history.turns.map((turn) => turn.outcome.kind === "answered"
+        ? { at: turn.completedAt, label: "✓", text: `answered · keiyaku history ${turn.outcome.historyId} --last` }
+        : { at: turn.completedAt, label: "!", text: `failed · ${turn.outcome.diagnostic}` });
+    return [...activity, ...boundaries].sort((left, right) => {
+        const leftAt = left.at === undefined ? Number.POSITIVE_INFINITY : Date.parse(left.at);
+        const rightAt = right.at === undefined ? Number.POSITIVE_INFINITY : Date.parse(right.at);
+        return (Number.isFinite(leftAt) ? leftAt : Number.POSITIVE_INFINITY)
+            - (Number.isFinite(rightAt) ? rightAt : Number.POSITIVE_INFINITY);
+    });
+}
+function historyText(command, result) {
+    if (command.last)
+        return result.answer ?? "";
+    const history = result.history;
+    const scope = command.before === undefined && command.since === undefined
+        ? "history"
+        : `history ── ${command.before === undefined ? `since ${command.since}` : `before ${command.before}`}`;
+    const lines = [ruler([result.akuma, scope])];
+    const first = history.rows[0]?.sequence;
+    const last = history.rows.at(-1)?.sequence;
+    if (history.hasEarlier && first !== undefined) {
+        lines.push(`   ⋮ ${history.omitted} earlier · keiyaku history ${result.akuma} --before ${first}`);
+    }
+    else if (history.historyLost) {
+        lines.push("   ⋮ earlier history no longer kept");
+    }
+    if (history.hasLater && last !== undefined) {
+        lines.push(`   ⋮ more · keiyaku history ${result.akuma} --since ${last}`);
+    }
+    if (command.since !== undefined && history.rows.length === 0) {
+        lines.push(`   ⋮ no activity since ${command.since}`);
+    }
+    lines.push(...renderSpine(historyItems(history)));
+    return lines.join("\n");
+}
+function waitText(status) {
+    if (status.life === "running")
+        return statusText(status);
+    if (status.answer !== undefined)
+        return status.answer;
+    if (status.failure !== undefined)
+        return `failure ${status.failure}`;
+    return statusText(status);
+}
+function wakeFailure(receipt) {
+    return typeof receipt.wake === "string" ? null : `wake failed: ${safeText(receipt.wake.diagnostic)}`;
+}
+function tellText(status, receipt) {
+    const failure = wakeFailure(receipt);
+    return failure === null ? statusText(status) : `${statusText(status)}\n${failure}`;
+}
+function dispatchLines(stage) {
+    if (stage.kind === "none")
+        return [];
+    if (stage.kind === "dispatched")
+        return [`dispatch ${stage.dispatch.contractId}`];
+    const failure = stage.failure;
+    if (failure.kind === "conflict") {
+        return [`dispatch failed conflict ${failure.current.contractId}`];
+    }
+    if (failure.kind === "contention")
+        return ["dispatch failed contention"];
+    return [`dispatch failed ${failure.kind} ${safeText(failure.diagnostic)}`];
+}
+function callText(result) {
+    const called = result.result;
+    const stages = [...dispatchLines(called.dispatch)];
+    if (called.alias.kind === "aliased")
+        stages.push(`alias ${called.alias.alias.alias}`);
+    else if (called.alias.kind === "failed") {
+        stages.push(`alias failed ${called.alias.failure.kind} ${safeText(called.alias.failure.diagnostic)}`);
+    }
+    if (called.observation.kind === "detached")
+        return [called.akuma, ...stages].join("\n");
+    if (called.observation.kind === "failed") {
+        return [
+            called.akuma,
+            ...stages,
+            `wait failed ${called.observation.failure.kind} ${safeText(called.observation.failure.diagnostic)}`,
+        ].join("\n");
+    }
+    const status = called.observation.status;
+    if (status.answer !== undefined || status.failure !== undefined) {
+        return [called.akuma, ...stages, waitText(status)].join("\n");
+    }
+    return statusText(status, stages);
+}
+export function renderAkumaText(command, result) {
+    switch (result.action) {
+        case "call": return callText(result);
+        case "status": return statusText(result.status);
+        case "wait": return waitText(result.status);
+        case "tell": return tellText(result.status, result.receipt);
+        case "interrupt": {
+            const receipt = result.receipt;
+            if (receipt.kind === "dead")
+                return `${result.akuma} interrupt dead`;
+            if (receipt.kind === "unstoppable")
+                return `${result.akuma} interrupt unstoppable ${receipt.evidence}`;
+            if ("kind" in receipt.tell)
+                return `${result.akuma} interrupted ${receipt.putDown} · tell refused: dead`;
+            const failure = wakeFailure(receipt.tell);
+            return `${result.akuma} interrupted ${receipt.putDown}${failure === null ? "" : ` · ${failure}`}`;
+        }
+        case "history": return historyText(command, result);
+        case "fork": {
+            const receipt = result.receipt;
+            if (receipt.kind === "forked")
+                return [receipt.child, ...dispatchLines(receipt.dispatch)].join("\n");
+            if (receipt.kind === "provider-cannot-fork")
+                return `${receipt.provider} cannot fork`;
+            if (receipt.kind === "unknown-history")
+                return `${receipt.at} has no matching retained answered turn`;
+            if (receipt.kind === "fork-failed")
+                return receipt.diagnostic;
+            return `session ${receipt.childSession.sessionId}\n${receipt.diagnostic}`;
+        }
+        case "kill": return `${result.id} ${result.evidence}`;
+    }
+}
+export function akumaExitCode(result) {
+    if (result.action === "call"
+        && (result.result.dispatch.kind === "failed"
+            || result.result.alias.kind === "failed"
+            || result.result.observation.kind === "failed"))
+        return 2;
+    if (result.action === "kill" && (result.evidence === "unavailable" || result.evidence === "alive-after-sigkill"))
+        return 1;
+    if (result.action === "tell" && typeof result.receipt.wake !== "string")
+        return 2;
+    if (result.action === "interrupt") {
+        if (result.receipt.kind !== "interrupted" || "kind" in result.receipt.tell)
+            return 1;
+        if (typeof result.receipt.tell.wake !== "string")
+            return 2;
+    }
+    if (result.action === "fork") {
+        if (result.receipt.kind === "forked")
+            return result.receipt.dispatch.kind === "failed" ? 2 : 0;
+        return result.receipt.kind === "upstream-forked" ? 2 : 1;
+    }
+    return 0;
+}
+export function akumaJsonValue(command, result) {
+    if (result.action === "call")
+        return result.result;
+    if (result.action === "fork")
+        return result.receipt;
+    if (result.action === "status" || result.action === "wait")
+        return result.status;
+    if (result.action === "tell")
+        return { receipt: result.receipt, status: result.status };
+    if (result.action === "history")
+        return command.command === "history" && command.last ? result.answer ?? "" : result.history;
+    return result;
+}
+export function renderAkumaJson(command, result) {
+    return JSON.stringify(akumaJsonValue(command, result));
+}

package/build/src/cli/render/board.d.ts

@@ -0,0 +1,2 @@
+import type { ObservationResult } from "../result.js";
+export declare function renderObservation(result: ObservationResult): string;

package/build/src/cli/render/board.js

@@ -0,0 +1,4 @@
+export function renderObservation(result) {
+    const { kind: _kind, command, ...observation } = result;
+    return [`observation ${command}`, JSON.stringify(observation, null, 2)].join("\n");
+}

package/build/src/cli/render/contract.d.ts

@@ -0,0 +1,4 @@
+import type { AcceptedResult, RetryResult } from "../result.js";
+export declare function obligationLines(value: Pick<AcceptedResult, "verification" | "placement" | "leak">): readonly string[];
+export declare function renderAccepted(result: AcceptedResult): string;
+export declare function renderRetry(result: RetryResult): string;

package/build/src/cli/render/contract.js

@@ -0,0 +1,69 @@
+function effectLine(effect) {
+    if (effect.kind === "worktree")
+        return `effect worktree ${effect.action} ${effect.path}`.trimEnd();
+    return `effect ref ${effect.action} ${effect.name} ${effect.before ?? "null"} -> ${effect.after ?? "null"}`;
+}
+function lagLine(lag) {
+    if (lag.kind === "worktree-retained")
+        return `lag worktree-retained ${lag.path}`;
+    if (lag.kind === "worktree-hook-failed") {
+        return `lag worktree-hook-failed ${lag.phase} ${lag.path} command=${lag.command} ${JSON.stringify(lag.failure)}`;
+    }
+    return `lag reconcile-failed ${lag.stage} ${lag.diagnostic}`;
+}
+function leakLine(leak) {
+    if (leak === undefined)
+        return undefined;
+    return `leak worktree ${leak.path} ${leak.diagnostic}`;
+}
+export function obligationLines(value) {
+    const lines = [];
+    for (const name of ["verification", "placement"]) {
+        const stop = value[name];
+        if (stop === undefined)
+            continue;
+        lines.push(`stop ${name} ${JSON.stringify(stop)}`);
+    }
+    const leak = leakLine(value.leak);
+    if (leak !== undefined)
+        lines.push(leak);
+    return lines;
+}
+export function renderAccepted(result) {
+    const lines = [`accepted ${result.verb} ${result.contract} head=${result.head ?? "null"}`];
+    if (result.target !== undefined)
+        lines.push(`target ${result.target ?? "null"}`);
+    for (const fact of result.facts)
+        lines.push(`fact ${fact.contract} ${fact.entry} ${fact.kind}`);
+    lines.push(...obligationLines(result));
+    const reportLeak = leakLine(result.report?.leak);
+    if (reportLeak !== undefined)
+        lines.push(reportLeak);
+    for (const overlap of result.overlaps ?? []) {
+        for (const pattern of overlap.patterns) {
+            lines.push(`overlap ${overlap.contract} ${pattern.mine} ~ ${pattern.theirs}`);
+        }
+    }
+    if (result.overlapFailure !== undefined)
+        lines.push(`overlap unavailable ${result.overlapFailure}`);
+    if (result.report !== undefined)
+        lines.push(`report ${JSON.stringify(result.report)}`);
+    if (result.diff !== undefined)
+        lines.push(typeof result.diff === "string" ? result.diff : JSON.stringify(result.diff));
+    for (const effect of result.effects)
+        lines.push(effectLine(effect));
+    for (const lag of result.lag ?? [])
+        lines.push(lagLine(lag));
+    for (const action of result.settlement.actions) {
+        lines.push(action.kind === "task"
+            ? `settlement task ${action.action} ${action.taskId}`
+            : `settlement namespace-context ${action.action} ${action.path}`);
+    }
+    for (const lag of result.settlement.lags)
+        lines.push(`settlement lag ${JSON.stringify(lag)}`);
+    return lines.join("\n");
+}
+export function renderRetry(result) {
+    const contract = result.contract === undefined ? "" : ` ${result.contract}`;
+    return `retry ${result.verb}${contract} ${JSON.stringify(result.detail)}`;
+}

package/build/src/cli/render/kanshi.d.ts

@@ -0,0 +1,3 @@
+import type { KanshiReport } from "../../kanshi/index.js";
+import { type TextRenderContext } from "./terminal.js";
+export declare function renderKanshiText(report: KanshiReport, context?: TextRenderContext, selection?: "world" | "contract"): string;

package/build/src/cli/render/kanshi.js

@@ -0,0 +1,204 @@
+import { displayColumns, renderTextBlock, safeText, tone } from "./terminal.js";
+function contractMark(phase) {
+    if (phase === "claimed")
+        return "✓";
+    if (phase === "abandoned")
+        return "×";
+    if (phase === "waiting" || phase === "pending-delivery")
+        return "⧗";
+    return "●";
+}
+function taskMark(row) {
+    if (row.disposition === "done")
+        return "✓";
+    if (row.disposition === "drop")
+        return "×";
+    if (row.disposition === "on_hold")
+        return "‖";
+    if (row.disposition === "in_progress")
+        return "●";
+    return row.disposition === "blocked" ? "⧗" : "○";
+}
+function akumaMark(life) {
+    if (life === "running")
+        return "●";
+    if (life === "stillborn")
+        return "!";
+    if (life === "asleep" || life === "dead")
+        return "○";
+    return "?";
+}
+function gateMark(report) {
+    if (report.current.kind !== "attested")
+        return "?";
+    return report.current.verdict === "satisfied" ? "✓" : "!";
+}
+function hotFirst(rows, hot) {
+    return [...rows.filter(hot), ...rows.filter((row) => !hot(row))];
+}
+function wrapChain(parts, columns) {
+    if (parts.length === 0)
+        return [];
+    const lines = [];
+    let current = "  ";
+    for (const part of parts.map(safeText)) {
+        const candidate = current === "  " ? `${current}${part}` : `${current} · ${part}`;
+        if (current !== "  " && displayColumns(candidate) > columns) {
+            lines.push(current);
+            current = `  ${part}`;
+        }
+        else
+            current = candidate;
+    }
+    lines.push(current);
+    return lines;
+}
+function wrapHeading(primary, facts, columns) {
+    const head = safeText(primary);
+    const lines = [];
+    let current = head;
+    for (const fact of facts.map(safeText)) {
+        const candidate = `${current} · ${fact}`;
+        if (displayColumns(candidate) > columns) {
+            lines.push(current);
+            current = `  ${fact}`;
+        }
+        else
+            current = candidate;
+    }
+    lines.push(current);
+    return lines;
+}
+function renderGates(reports, context, includeSummaries) {
+    const lines = [...wrapChain(reports.map((report) => `${gateMark(report)} ${safeText(report.gate)}`), context.columns)];
+    if (!includeSummaries)
+        return lines;
+    for (const report of reports) {
+        if (report.current.kind !== "attested" || report.current.summary === undefined)
+            continue;
+        lines.push(...renderTextBlock(`${safeText(report.gate)}: ${report.current.summary}`, "  ", context.columns)
+            .map((line) => tone(line, "dim", context.color)));
+    }
+    return lines;
+}
+function failure(name, section, context) {
+    return `${name} failed\n${tone(`! ${safeText(section.failure.message)}`, "alert", context.color)}`;
+}
+function renderContracts(report, context, selection) {
+    const section = report.contracts;
+    if (section.kind === "absent")
+        return "keiyaku absent";
+    if (section.kind === "failed")
+        return failure("keiyaku", section, context);
+    const rows = hotFirst(section.value.rows, (row) => row.phase === "waiting" || row.phase === "pending-delivery");
+    const lines = [`keiyaku ${rows.length}`];
+    for (const row of rows) {
+        const facts = [
+            row.workspace,
+            ...(row.candidate === null ? [] : [`candidate ${safeText(row.candidate).slice(0, 8)}`]),
+            ...(row.target === null ? [] : [`-> ${row.target}`]),
+        ];
+        lines.push(`${contractMark(row.phase)} ${safeText(row.id)} ${row.phase}`);
+        lines.push(...wrapChain(facts, context.columns));
+        lines.push(...renderGates(row.gates.reports, context, selection === "contract"));
+    }
+    return lines.join("\n");
+}
+function renderTasks(report, context) {
+    const section = report.tasks;
+    if (section.kind === "absent")
+        return "task absent";
+    if (section.kind === "failed")
+        return failure("task", section, context);
+    const active = section.value.rows.filter((row) => row.disposition !== "done" && row.disposition !== "drop");
+    const ready = active.filter((row) => row.disposition === "ready").length;
+    const onHold = active.filter((row) => row.disposition === "on_hold").length;
+    const visible = hotFirst(active.filter((row) => row.disposition === "in_progress" || row.disposition === "blocked"), (row) => row.disposition === "blocked");
+    const lines = [...wrapHeading(`task ${active.length}`, [`${ready} ready`, `${onHold} held`], context.columns)];
+    for (const row of visible) {
+        const contract = row.contract === undefined ? [] : [`keiyaku ${row.contract.id} (${row.contract.observed})`];
+        lines.push(`${taskMark(row)} ${safeText(row.id)} ${row.disposition}`);
+        lines.push(...renderTextBlock(row.title, "  ", context.columns));
+        lines.push(...wrapChain([`P${row.priority}`, ...contract], context.columns));
+    }
+    return lines.join("\n");
+}
+function isLost(life) {
+    return life === "stranded" || life === "headless";
+}
+function akumaPriority(row) {
+    if (isLost(row.life) || row.life === "stillborn")
+        return 0;
+    return row.life === "running" ? 1 : 2;
+}
+function firstLine(value) {
+    return value.split(/[\r\n\u2028\u2029]/u, 1)[0] ?? "";
+}
+function truncateDisplay(value, columns) {
+    if (displayColumns(value) <= columns)
+        return value;
+    if (columns <= 0)
+        return "";
+    const ellipsis = "…";
+    if (columns <= displayColumns(ellipsis))
+        return ellipsis;
+    let result = "";
+    let used = 0;
+    for (const character of value) {
+        const width = displayColumns(character);
+        if (used + width + displayColumns(ellipsis) > columns)
+            break;
+        result += character;
+        used += width;
+    }
+    return `${result}${ellipsis}`;
+}
+function bornFacts(row) {
+    if (!("pending" in row) || (row.life !== "running" && !isLost(row.life)))
+        return [];
+    const confinement = row.confinement.kind === "unconfined"
+        ? ["unconfined"]
+        : row.confinement.writableRoots.map((root, index) => index === 0 ? `writes ${root}` : root);
+    return [
+        ...(row.pending.length === 0 ? [] : [`pending ${row.pending.length}`]),
+        ...confinement,
+    ];
+}
+function stillbornEvidence(row, columns) {
+    if (row.life !== "stillborn" || !("seal" in row) || row.seal === undefined)
+        return null;
+    const prefix = "  seal ";
+    const evidence = safeText(firstLine(row.seal.evidence)).trim();
+    if (evidence.length === 0)
+        return null;
+    return `${prefix}${truncateDisplay(evidence, Math.max(0, columns - displayColumns(prefix)))}`;
+}
+function renderAkuma(report, context) {
+    const section = report.akuma;
+    if (section.kind === "absent")
+        return "akuma absent";
+    if (section.kind === "failed")
+        return failure("akuma", section, context);
+    const rows = [
+        ...section.value.rows.filter((row) => akumaPriority(row) === 0),
+        ...section.value.rows.filter((row) => akumaPriority(row) === 1),
+        ...section.value.rows.filter((row) => akumaPriority(row) === 2),
+    ];
+    const lines = [`akuma ${rows.length}`];
+    for (const row of rows) {
+        lines.push(`${akumaMark(row.life)} ${safeText(row.id)} ${row.life}`);
+        lines.push(...wrapChain(bornFacts(row), context.columns));
+        const evidence = stillbornEvidence(row, context.columns);
+        if (evidence !== null)
+            lines.push(evidence);
+    }
+    return lines.join("\n");
+}
+export function renderKanshiText(report, context = { columns: 80, color: false }, selection = "world") {
+    return [
+        `kanshi ${safeText(report.root)}`,
+        renderContracts(report, context, selection),
+        renderTasks(report, context),
+        renderAkuma(report, context),
+    ].join("\n\n");
+}

package/build/src/cli/render/refusal.d.ts

@@ -0,0 +1,2 @@
+import type { RefusedResult } from "../result.js";
+export declare function renderRefusal(result: RefusedResult): string;

package/build/src/cli/render/refusal.js

@@ -0,0 +1,4 @@
+export function renderRefusal(result) {
+    const contract = result.contract === undefined ? "" : ` ${result.contract}`;
+    return `refused ${result.verb}${contract} ${JSON.stringify(result.refusal)}`;
+}

package/build/src/cli/render/settings.d.ts

@@ -0,0 +1,3 @@
+import type { Settings } from "../../settings.js";
+export declare function settingsJsonValue(value: Settings): unknown;
+export declare function renderSettingsText(value: Settings): string;

package/build/src/cli/render/settings.js

@@ -0,0 +1,30 @@
+function namespaceNames(value) {
+    return [...new Set([value.scopes.user, value.scopes.project].flatMap((scope) => scope.kind === "read" ? scope.namespaces : []))].sort();
+}
+function scope(name, value) {
+    const path = value.path === undefined ? "" : ` ${value.path}`;
+    return value.kind === "failed"
+        ? `${name} failed${path} ${value.diagnostic}`
+        : `${name} ${value.kind}${path}`;
+}
+export function settingsJsonValue(value) {
+    return {
+        scopes: value.scopes,
+        namespaces: namespaceNames(value).map((name) => value.namespace(name)),
+    };
+}
+export function renderSettingsText(value) {
+    const lines = [scope("user", value.scopes.user), scope("project", value.scopes.project)];
+    for (const name of namespaceNames(value)) {
+        const view = value.namespace(name);
+        lines.push(`namespace ${name} ${view.kind}`);
+        if (view.kind === "failed") {
+            for (const failure of view.failures)
+                lines.push(`failure ${failure.scope} ${failure.diagnostic}`);
+        }
+        for (const entry of view.entries) {
+            lines.push(`entry ${entry.name} ${entry.source}${entry.shadows ? " shadows user" : ""} ${JSON.stringify(entry.value)}`);
+        }
+    }
+    return lines.join("\n");
+}

package/build/src/cli/render/task.d.ts

@@ -0,0 +1,6 @@
+import type { TaskCompositionResult } from "../../task/index.js";
+import type { TaskInvocationResult } from "../commands/task-invoke.js";
+import type { ParsedTaskCommand } from "../commands/task.js";
+export declare function renderTaskText(command: ParsedTaskCommand, result: TaskInvocationResult): string;
+export declare function renderTaskIncompleteDiagnostic(result: TaskCompositionResult): string;
+export declare function taskExitCode(result: TaskInvocationResult): number;