@martinloop/mcp 0.5.3 → 0.5.6

package/dist/vendor/core/verified-handoff.js

@@ -33,6 +33,9 @@ export function verifierActuallyPassed(evidence, expected) {
     if (!evidence?.passed || !evidence.binding || !evidence.steps) {
         return false;
     }
+    if (expected.commands.length === 0) {
+        return false;
+    }
     if (evidence.binding.runId !== expected.runId ||
         evidence.binding.workspaceId !== expected.workspaceId ||
         evidence.binding.cwd !== expected.cwd ||
@@ -93,7 +96,6 @@ export function deriveVerifiedHandoffExecutionBoundary(loop) {
     const persistedMode = isExecutionMode(loop.metadata["executionMode"])
         ? loop.metadata["executionMode"]
         : undefined;
-    const groundingEvidenceAvailable = loop.metadata["groundingEvidenceStatus"] !== "unavailable";
     const executionMode = hasSimulatedAdapter
         ? "simulated"
         : hasVerifierOnlyAdapter
@@ -101,7 +103,7 @@ export function deriveVerifiedHandoffExecutionBoundary(loop) {
             : persistedMode ?? (adapterIds.length > 0 ? "governed" : "simulated");
     return {
         executionMode,
-        governanceClaimEligible: executionMode === "governed" && adapterIds.length > 0 && groundingEvidenceAvailable,
+        governanceClaimEligible: executionMode === "governed" && adapterIds.length > 0,
     };
 }
 function toEvidenceStatus(status) {
@@ -157,17 +159,34 @@ export function buildVerifiedHandoff(input) {
             "Test integrity was not evaluated for this run.",
     };
     const executionBoundary = deriveVerifiedHandoffExecutionBoundary(input.loop);
+    const verifierStepsActuallyPassed = input.verification.steps.length > 0 &&
+        input.verification.steps.every((step) => step.launched === true &&
+            step.completed === true &&
+            step.crashed === false &&
+            step.timedOut !== true &&
+            step.exitCode === 0);
+    const effectiveVerificationStatus = input.verification.status === "passed" && !verifierStepsActuallyPassed
+        ? input.verification.steps.length === 0
+            ? "not_run"
+            : "contradicted"
+        : input.verification.status;
+    const verificationWarnings = [
+        ...input.verification.warnings,
+        ...(effectiveVerificationStatus !== input.verification.status
+            ? ["A VERIFIED claim requires at least one launched, completed, exit-zero verifier step."]
+            : []),
+    ];
     const outcome = resolveVerifiedHandoffOutcome({
         lifecycleState: input.loop.lifecycleState,
         executionStatus: input.executionStatus,
-        verificationStatus: input.verification.status,
+        verificationStatus: effectiveVerificationStatus,
         receiptIntegrity: input.receiptIntegrity.state,
         scopeStatus: scope.status,
         testIntegrityStatus: testIntegrity.status,
         mutationRequired: input.mutationRequired ?? input.loop.task.mutationMode === "edit",
         changedFileCount: scope.changedFiles.length,
         definitionOfDonePreSatisfied: input.definitionOfDonePreSatisfied,
-        evidenceContradicted: input.evidenceContradicted ?? input.verification.status === "contradicted",
+        evidenceContradicted: input.evidenceContradicted ?? effectiveVerificationStatus === "contradicted",
         governanceClaimEligible: executionBoundary.governanceClaimEligible,
         unresolvedWorkCount: unresolvedWork.length,
     });
@@ -196,10 +215,10 @@ export function buildVerifiedHandoff(input) {
             lifecycleState: input.loop.lifecycleState,
         },
         verification: {
-            status: toEvidenceStatus(input.verification.status),
+            status: toEvidenceStatus(effectiveVerificationStatus),
             summary: input.verification.summary,
             checks: input.verification.steps.map(toCheck),
-            warnings: input.verification.warnings,
+            warnings: verificationWarnings,
         },
         requirements: input.requirements ?? [],
         scope,

package/dist/vendor/presentation/governed-plan.d.ts

@@ -0,0 +1,33 @@
+import type { LoopBudget, ReceiptScope } from "../contracts/index.js";
+import { type RenderEnvironment } from "./theme.js";
+export type PlanStageState = "READY" | "BLOCKED" | "NEXT" | "CONDITIONAL";
+export interface GovernedPlanStage {
+    label: string;
+    state: PlanStageState;
+    gate: string;
+    purpose: string;
+}
+export interface GovernedRunPlanView {
+    ready: boolean;
+    task: string;
+    engine: string;
+    mode: "live" | "proof";
+    budget: LoopBudget;
+    verifier: string[];
+    receiptScope: ReceiptScope;
+    policyProfile: string;
+    blockingIssues: string[];
+    warnings: string[];
+    stages: GovernedPlanStage[];
+}
+export declare function buildGovernedPlanStages(input: Pick<GovernedRunPlanView, "ready" | "engine" | "verifier" | "blockingIssues">): GovernedPlanStage[];
+export declare function renderGovernedRunPlan(input: GovernedRunPlanView, options?: {
+    width?: number;
+    environment?: RenderEnvironment;
+}): string;
+/**
+ * Renders a GovernedRunPlanView as plain Markdown (no ANSI).
+ */
+export declare function renderGovernedRunPlanMarkdown(input: GovernedRunPlanView, options?: {
+    includeStatus?: boolean;
+}): string;

package/dist/vendor/presentation/governed-plan.js

@@ -0,0 +1,146 @@
+import { renderTable } from "./table.js";
+import { horizontalRule, terminalWidth, truncateVisible } from "./text.js";
+import { bold, paint, } from "./theme.js";
+function stageTone(state) {
+    switch (state) {
+        case "READY":
+            return "success";
+        case "BLOCKED":
+            return "danger";
+        case "NEXT":
+            return "info";
+        case "CONDITIONAL":
+            return "warning";
+    }
+}
+export function buildGovernedPlanStages(input) {
+    const blocked = !input.ready || input.blockingIssues.length > 0;
+    return [
+        {
+            label: "Contract & scope",
+            state: blocked ? "BLOCKED" : "READY",
+            gate: "request + paths",
+            purpose: "Bind the task to its governed workspace",
+        },
+        {
+            label: "Budget & policy",
+            state: blocked ? "BLOCKED" : "READY",
+            gate: "hard cap + policy",
+            purpose: "Arm execution limits before work starts",
+        },
+        {
+            label: "Agent execution",
+            state: blocked ? "BLOCKED" : "NEXT",
+            gate: input.engine,
+            purpose: "Run the selected coding agent",
+        },
+        {
+            label: "Verification",
+            state: input.verifier.length > 0 && !blocked ? "NEXT" : "BLOCKED",
+            gate: input.verifier.length > 0 ? input.verifier.join(", ") : "no verifier",
+            purpose: "Run configured completion checks",
+        },
+        {
+            label: "Recovery",
+            state: "CONDITIONAL",
+            gate: "stop / fail",
+            purpose: "Preserve rollback and recovery evidence",
+        },
+        {
+            label: "Proof",
+            state: blocked ? "BLOCKED" : "NEXT",
+            gate: "receipt",
+            purpose: "Produce the final governed record",
+        },
+    ];
+}
+function bounded(line, width) {
+    return truncateVisible(line, width);
+}
+export function renderGovernedRunPlan(input, options = {}) {
+    const environment = options.environment ?? {};
+    const width = terminalWidth(options.width);
+    const rows = input.stages.map((stage) => ({
+        ...stage,
+        renderedState: paint(stage.state, stageTone(stage.state), environment),
+    }));
+    const lines = [
+        horizontalRule(width, "━"),
+        bounded(bold("MARTINLOOP", environment) +
+            " ▸ " +
+            paint("GOVERNED RUN PLAN", input.ready ? "success" : "danger", environment), width),
+        horizontalRule(width, "━"),
+        "",
+        bounded(paint("Task".padEnd(18), "info", environment) + input.task, width),
+        bounded(paint("Engine".padEnd(18), "info", environment) + input.engine, width),
+        bounded(paint("Mode".padEnd(18), "info", environment) + input.mode, width),
+        "",
+        renderTable(rows, [
+            { header: "STAGE", value: (row) => row.label, minWidth: 18, maxWidth: 24 },
+            {
+                header: "STATUS",
+                value: (row) => row.renderedState,
+                minWidth: 12,
+                maxWidth: 14,
+            },
+            { header: "GATE", value: (row) => row.gate, minWidth: 18, maxWidth: 36 },
+            { header: "PURPOSE", value: (row) => row.purpose, minWidth: 24 },
+        ], width),
+        "",
+        bounded(bold("Budget cap", environment) +
+            "  " +
+            paint("$" + input.budget.maxUsd.toFixed(2), "success", environment), width),
+        bounded(bold("Soft limit", environment) +
+            "  $" +
+            input.budget.softLimitUsd.toFixed(2), width),
+        bounded(bold("Attempts", environment) + "    " + input.budget.maxIterations, width),
+        bounded(bold("Verifier", environment) +
+            "    " +
+            (input.verifier.join(", ") || "NOT CONFIGURED"), width),
+        bounded(bold("Policy", environment) + "      " + input.policyProfile, width),
+    ];
+    if (input.blockingIssues.length > 0) {
+        lines.push("", bold("BLOCKING", environment), ...input.blockingIssues.map((issue) => bounded("  " + paint("✗", "danger", environment) + " " + issue, width)));
+    }
+    if (input.warnings.length > 0) {
+        lines.push("", bold("WARNINGS", environment), ...input.warnings.map((warning) => bounded("  " + paint("!", "warning", environment) + " " + warning, width)));
+    }
+    lines.push("", input.ready
+        ? paint("✓ READY TO EXECUTE", "success", environment)
+        : paint("✗ PREFLIGHT BLOCKED", "danger", environment), horizontalRule(width, "━"));
+    return lines.map((line) => bounded(line, width)).join("\n");
+}
+/**
+ * Renders a GovernedRunPlanView as plain Markdown (no ANSI).
+ */
+export function renderGovernedRunPlanMarkdown(input, options = {}) {
+    void options;
+    const lines = [
+        `## MartinLoop Governed Run Plan — ${input.ready ? "READY" : "BLOCKED"}`,
+        "",
+        "| Field | Value |",
+        "|-------|-------|",
+        `| Task | ${input.task} |`,
+        `| Engine | ${input.engine} |`,
+        `| Mode | ${input.mode} |`,
+        `| Budget cap | $${input.budget.maxUsd.toFixed(2)} |`,
+        `| Soft limit | $${input.budget.softLimitUsd.toFixed(2)} |`,
+        `| Max attempts | ${input.budget.maxIterations} |`,
+        `| Verifier | ${input.verifier.join(", ") || "NOT CONFIGURED"} |`,
+        `| Policy | ${input.policyProfile} |`,
+        "",
+        "### Stages",
+        "",
+        "| Stage | Status | Gate | Purpose |",
+        "|-------|--------|------|---------|",
+        ...input.stages.map((s) => `| ${s.label} | ${s.state} | ${s.gate} | ${s.purpose} |`),
+    ];
+    if (input.blockingIssues.length > 0) {
+        lines.push("", "### Blocking Issues", "", ...input.blockingIssues.map((issue) => `- ✗ ${issue}`));
+    }
+    if (input.warnings.length > 0) {
+        lines.push("", "### Warnings", "", ...input.warnings.map((w) => `- ${w}`));
+    }
+    lines.push("", input.ready ? "**✓ READY TO EXECUTE**" : "**✗ PREFLIGHT BLOCKED**");
+    return lines.join("\n");
+}

package/dist/vendor/presentation/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./governed-plan.js";
+export * from "./motion.js";
+export * from "./status.js";
+export * from "./table.js";
+export * from "./text.js";
+export * from "./theme.js";
+export * from "./verified-handoff.js";

package/dist/vendor/presentation/index.js

@@ -0,0 +1,7 @@
+export * from "./governed-plan.js";
+export * from "./motion.js";
+export * from "./status.js";
+export * from "./table.js";
+export * from "./text.js";
+export * from "./theme.js";
+export * from "./verified-handoff.js";

package/dist/vendor/presentation/motion.d.ts

@@ -0,0 +1,12 @@
+import { type RenderEnvironment } from "./theme.js";
+export interface MotionEnvironment extends RenderEnvironment {
+    readonly outputMode?: "human" | "json" | "quiet";
+    readonly stdinIsTty?: boolean;
+    readonly stdoutIsTty?: boolean;
+    readonly ci?: boolean;
+    readonly noMotion?: boolean;
+}
+export declare function canAnimate(env?: MotionEnvironment): boolean;
+export declare function animateBannerShine(input: string, env?: MotionEnvironment): Promise<void>;
+export declare function withSpinner<T>(label: string, task: () => Promise<T>, env?: MotionEnvironment): Promise<T>;
+export declare function writeHumanOutputWithShine(text: string, env?: MotionEnvironment): Promise<void>;

package/dist/vendor/presentation/motion.js

@@ -0,0 +1,123 @@
+import { setTimeout as sleep } from "node:timers/promises";
+import { paint, terminalAnsi } from "./theme.js";
+import { stripAnsi } from "./text.js";
+function envFlag(name) {
+    const value = process.env[name];
+    return value === "1" || value === "true" || value === "yes";
+}
+export function canAnimate(env = {}) {
+    const mode = env.outputMode ?? "human";
+    if (mode !== "human") {
+        return false;
+    }
+    const noColor = env.noColor ?? Object.prototype.hasOwnProperty.call(process.env, "NO_COLOR");
+    if (noColor) {
+        return false;
+    }
+    const stdoutTty = env.stdoutIsTty ?? process.stdout.isTTY === true;
+    if (!stdoutTty) {
+        return false;
+    }
+    const ci = env.ci ?? Boolean(process.env.CI);
+    if (ci) {
+        return false;
+    }
+    const noMotion = env.noMotion ??
+        (envFlag("MARTIN_NO_MOTION") || envFlag("MARTIN_REDUCED_MOTION"));
+    if (noMotion) {
+        return false;
+    }
+    const term = env.term ?? process.env.TERM;
+    return term !== "dumb";
+}
+function shineCharacter(character, distance, env) {
+    if (character === " ") {
+        return character;
+    }
+    if (distance === 0) {
+        return paint(character, "plain", { ...env, color: "always" });
+    }
+    if (distance === 1) {
+        return paint(character, "info", { ...env, color: "always" });
+    }
+    return paint(character, "brand", { ...env, color: "always" });
+}
+export async function animateBannerShine(input, env = {}) {
+    if (!canAnimate(env)) {
+        return;
+    }
+    const target = [...stripAnsi(input)].slice(0, 100);
+    if (target.length === 0) {
+        return;
+    }
+    try {
+        process.stdout.write(terminalAnsi.hideCursor);
+        for (let center = -2; center < target.length + 4; center += 1) {
+            const frame = target
+                .map((character, index) => shineCharacter(character, Math.abs(index - center), env))
+                .join("");
+            process.stdout.write(terminalAnsi.cursorHome +
+                terminalAnsi.eraseLine +
+                frame +
+                terminalAnsi.reset);
+            await sleep(18);
+        }
+    }
+    finally {
+        process.stdout.write(terminalAnsi.cursorHome +
+            terminalAnsi.eraseLine +
+            terminalAnsi.reset +
+            terminalAnsi.showCursor);
+    }
+}
+const spinnerFrames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export async function withSpinner(label, task, env = {}) {
+    if (!canAnimate(env)) {
+        return task();
+    }
+    let frame = 0;
+    process.stdout.write(terminalAnsi.hideCursor);
+    const timer = setInterval(() => {
+        const glyph = spinnerFrames[frame % spinnerFrames.length] ?? "•";
+        frame += 1;
+        process.stdout.write(terminalAnsi.cursorHome +
+            terminalAnsi.eraseLine +
+            paint(glyph, "brand", { ...env, color: "always" }) +
+            " " +
+            label);
+    }, 70);
+    try {
+        return await task();
+    }
+    finally {
+        clearInterval(timer);
+        process.stdout.write(terminalAnsi.cursorHome +
+            terminalAnsi.eraseLine +
+            terminalAnsi.reset +
+            terminalAnsi.showCursor);
+    }
+}
+export async function writeHumanOutputWithShine(text, env = {}) {
+    if (!text) {
+        return;
+    }
+    if (!canAnimate(env)) {
+        process.stdout.write(text + "\n");
+        return;
+    }
+    const lines = text.split("\n");
+    const headingIndex = lines.findIndex((line) => stripAnsi(line).toUpperCase().includes("MARTINLOOP"));
+    if (headingIndex < 0) {
+        process.stdout.write(text + "\n");
+        return;
+    }
+    if (headingIndex > 0) {
+        process.stdout.write(lines.slice(0, headingIndex).join("\n") + "\n");
+    }
+    const heading = lines[headingIndex] ?? "";
+    await animateBannerShine(heading, env);
+    process.stdout.write(heading + "\n");
+    if (headingIndex < lines.length - 1) {
+        process.stdout.write(lines.slice(headingIndex + 1).join("\n") + "\n");
+    }
+}

package/dist/vendor/presentation/status.d.ts

@@ -0,0 +1,8 @@
+import type { MartinTone } from "./theme.js";
+export type ProofStatus = "VERIFIED" | "NEEDS_REVIEW" | "STOPPED" | "FAILED" | "RUNNING" | "PENDING";
+export interface StatusPresentation {
+    readonly glyph: string;
+    readonly label: string;
+    readonly tone: MartinTone;
+}
+export declare function statusPresentation(status: ProofStatus): StatusPresentation;

package/dist/vendor/presentation/status.js

@@ -0,0 +1,11 @@
+const presentations = {
+    VERIFIED: { glyph: "✓", label: "VERIFIED", tone: "success" },
+    NEEDS_REVIEW: { glyph: "!", label: "NEEDS REVIEW", tone: "warning" },
+    STOPPED: { glyph: "■", label: "STOPPED", tone: "danger" },
+    FAILED: { glyph: "×", label: "FAILED", tone: "danger" },
+    RUNNING: { glyph: "◆", label: "RUNNING", tone: "info" },
+    PENDING: { glyph: "○", label: "PENDING", tone: "muted" },
+};
+export function statusPresentation(status) {
+    return presentations[status];
+}

package/dist/vendor/presentation/table.d.ts

@@ -0,0 +1,11 @@
+export interface TableColumn<Row> {
+    readonly header: string;
+    readonly value: (row: Row) => string;
+    readonly minWidth?: number;
+    readonly maxWidth?: number;
+}
+export interface RenderTableOptions {
+    readonly separator?: string;
+    readonly width?: number;
+}
+export declare function renderTable<Row>(rows: readonly Row[], columns: readonly TableColumn<Row>[], options?: RenderTableOptions | number): string;

package/dist/vendor/presentation/table.js

@@ -0,0 +1,47 @@
+import { padRightVisible, truncateVisible, visibleWidth } from "./text.js";
+function columnWidth(rows, column) {
+    const contentWidth = Math.max(visibleWidth(column.header), ...rows.map((row) => visibleWidth(column.value(row))), column.minWidth ?? 0);
+    return Math.min(contentWidth, column.maxWidth ?? Number.POSITIVE_INFINITY);
+}
+function fitWidths(naturalWidths, columns, availableWidth) {
+    const widths = [...naturalWidths];
+    const floors = columns.map((column, index) => Math.min(widths[index] ?? 0, Math.max(4, visibleWidth(column.header))));
+    while (widths.reduce((sum, width) => sum + width, 0) > availableWidth) {
+        let candidate = -1;
+        let largestSlack = 0;
+        for (let index = 0; index < widths.length; index += 1) {
+            const slack = (widths[index] ?? 0) - (floors[index] ?? 0);
+            if (slack > largestSlack) {
+                candidate = index;
+                largestSlack = slack;
+            }
+        }
+        if (candidate < 0) {
+            break;
+        }
+        widths[candidate] = (widths[candidate] ?? 0) - 1;
+    }
+    return widths;
+}
+export function renderTable(rows, columns, options = {}) {
+    if (columns.length === 0) {
+        return "";
+    }
+    const normalizedOptions = typeof options === "number" ? { width: options } : options;
+    const separator = normalizedOptions.separator ?? " │ ";
+    const naturalWidths = columns.map((column) => columnWidth(rows, column));
+    const separatorWidth = visibleWidth(separator) * (columns.length - 1);
+    const availableWidth = normalizedOptions.width === undefined
+        ? Number.POSITIVE_INFINITY
+        : Math.max(columns.length * 4, normalizedOptions.width - separatorWidth);
+    const widths = Number.isFinite(availableWidth)
+        ? fitWidths(naturalWidths, columns, availableWidth)
+        : naturalWidths;
+    const renderCells = (cells) => cells
+        .map((cell, index) => padRightVisible(truncateVisible(cell, widths[index] ?? 0), widths[index] ?? 0))
+        .join(separator);
+    const header = renderCells(columns.map((column) => column.header));
+    const divider = widths.map((width) => "─".repeat(width)).join("─┼─");
+    const body = rows.map((row) => renderCells(columns.map((column) => column.value(row))));
+    return [header, divider, ...body].join("\n");
+}

package/dist/vendor/presentation/text.d.ts

@@ -0,0 +1,6 @@
+export declare function stripAnsi(value: string): string;
+export declare function visibleWidth(value: string): number;
+export declare function padRightVisible(value: string, width: number): string;
+export declare function truncateVisible(value: string, width: number): string;
+export declare function terminalWidth(width?: number): number;
+export declare function horizontalRule(width: number, character?: string): string;

package/dist/vendor/presentation/text.js

@@ -0,0 +1,30 @@
+const csiPattern = /\u001B\[[0-?]*[ -/]*[@-~]/g;
+const oscPattern = /\u001B\][^\u0007]*(?:\u0007|\u001B\\)/g;
+export function stripAnsi(value) {
+    return value.replace(oscPattern, "").replace(csiPattern, "");
+}
+export function visibleWidth(value) {
+    return Array.from(stripAnsi(value)).length;
+}
+export function padRightVisible(value, width) {
+    return value + " ".repeat(Math.max(0, width - visibleWidth(value)));
+}
+export function truncateVisible(value, width) {
+    if (width <= 0) {
+        return "";
+    }
+    if (visibleWidth(value) <= width) {
+        return value;
+    }
+    if (width === 1) {
+        return "…";
+    }
+    return Array.from(stripAnsi(value)).slice(0, width - 1).join("") + "…";
+}
+export function terminalWidth(width) {
+    const resolved = width ?? process.stdout.columns ?? 80;
+    return Math.max(40, Math.min(160, Math.floor(resolved)));
+}
+export function horizontalRule(width, character = "─") {
+    return character.repeat(Math.max(0, width));
+}

package/dist/vendor/presentation/theme.d.ts

@@ -0,0 +1,31 @@
+export type MartinTone = "brand" | "success" | "danger" | "warning" | "info" | "muted" | "plain";
+export interface RenderEnvironment {
+    readonly color?: "auto" | "always" | "never";
+    readonly isTty?: boolean;
+    readonly noColor?: boolean;
+    readonly term?: string;
+    readonly colorDepth?: number;
+}
+export declare const palette: {
+    readonly brand: readonly [107, 85, 198];
+    readonly success: readonly [94, 225, 115];
+    readonly danger: readonly [255, 93, 93];
+    readonly warning: readonly [244, 200, 74];
+    readonly info: readonly [85, 199, 243];
+    readonly muted: readonly [148, 163, 184];
+    readonly plain: readonly [248, 250, 252];
+};
+declare function rgb(red: number, green: number, blue: number): string;
+export declare function resolveColorEnabled(env?: RenderEnvironment): boolean;
+export declare function paint(value: string, tone: MartinTone, env?: RenderEnvironment): string;
+export declare function bold(value: string, env?: RenderEnvironment): string;
+export declare function dim(value: string, env?: RenderEnvironment): string;
+export declare const terminalAnsi: {
+    readonly reset: string;
+    readonly hideCursor: string;
+    readonly showCursor: string;
+    readonly eraseLine: string;
+    readonly cursorHome: "\r";
+    readonly rgb: typeof rgb;
+};
+export {};

package/dist/vendor/presentation/theme.js

@@ -0,0 +1,82 @@
+const escape = "\u001B[";
+const basic = {
+    reset: escape + "0m",
+    bold: escape + "1m",
+    dim: escape + "2m",
+    brand: escape + "35m",
+    success: escape + "32m",
+    danger: escape + "31m",
+    warning: escape + "33m",
+    info: escape + "36m",
+    muted: escape + "90m",
+    plain: "",
+};
+export const palette = {
+    brand: [107, 85, 198],
+    success: [94, 225, 115],
+    danger: [255, 93, 93],
+    warning: [244, 200, 74],
+    info: [85, 199, 243],
+    muted: [148, 163, 184],
+    plain: [248, 250, 252],
+};
+function rgb(red, green, blue) {
+    return escape + "38;2;" + red + ";" + green + ";" + blue + "m";
+}
+function resolveColorDepth() {
+    const stream = process.stdout;
+    try {
+        return stream.getColorDepth?.() ?? 1;
+    }
+    catch {
+        return 1;
+    }
+}
+export function resolveColorEnabled(env = {}) {
+    if (env.color === "always") {
+        return true;
+    }
+    if (env.color === "never") {
+        return false;
+    }
+    const noColor = env.noColor ?? Object.prototype.hasOwnProperty.call(process.env, "NO_COLOR");
+    if (noColor) {
+        return false;
+    }
+    const term = env.term ?? process.env.TERM;
+    if (term === "dumb") {
+        return false;
+    }
+    return env.isTty ?? process.stdout.isTTY === true;
+}
+function toneCode(tone, env) {
+    if (tone === "plain") {
+        return "";
+    }
+    const depth = env.colorDepth ?? resolveColorDepth();
+    if (depth >= 24) {
+        const [red, green, blue] = palette[tone];
+        return rgb(red, green, blue);
+    }
+    return basic[tone];
+}
+export function paint(value, tone, env = {}) {
+    if (!resolveColorEnabled(env) || tone === "plain") {
+        return value;
+    }
+    return toneCode(tone, env) + value + basic.reset;
+}
+export function bold(value, env = {}) {
+    return resolveColorEnabled(env) ? basic.bold + value + basic.reset : value;
+}
+export function dim(value, env = {}) {
+    return resolveColorEnabled(env) ? basic.dim + value + basic.reset : value;
+}
+export const terminalAnsi = {
+    reset: basic.reset,
+    hideCursor: escape + "?25l",
+    showCursor: escape + "?25h",
+    eraseLine: escape + "2K",
+    cursorHome: "\r",
+    rgb,
+};

package/dist/vendor/presentation/verified-handoff.d.ts

@@ -0,0 +1,15 @@
+import type { VerifiedHandoffV1 } from "../contracts/index.js";
+import { type RenderEnvironment } from "./theme.js";
+export interface VerifiedHandoffRenderOptions {
+    readonly width?: number;
+    readonly environment?: RenderEnvironment;
+}
+export declare function renderVerifiedHandoff(handoff: VerifiedHandoffV1, options?: VerifiedHandoffRenderOptions): string;
+/**
+ * Renders a VerifiedHandoffV1 as plain Markdown (no ANSI).
+ *
+ * CRITICAL: replicates the exact effectiveOutcome trust-authority check from
+ * renderVerifiedHandoff so that CLI and MCP surfaces always agree on
+ * VERIFIED / NEEDS REVIEW / STOPPED for the same input.
+ */
+export declare function renderVerifiedHandoffMarkdown(handoff: VerifiedHandoffV1, options?: VerifiedHandoffRenderOptions): string;