@iowarp/clio-coder 0.4.2 → 0.4.4

package/dist/{chunk-CRFOIAX3.js → chunk-7UGL4MB5.js}

@@ -1,13 +1,13 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  loadSkills
-} from "./chunk-O3YUNJZ2.js";
 import {
   parseFrontmatter
 } from "./chunk-RKKLTLYB.js";
+import {
+  loadSkills
+} from "./chunk-2ZSONWVL.js";
 import {
   enabledExtensionResourceRoots
-} from "./chunk-HLAFFSEK.js";
+} from "./chunk-TQAHXW6Y.js";
 import {
   assertAgentSpecPolicy,
   isAgentAudience,
@@ -19,7 +19,7 @@ import {
   isShadowAgent,
   normalizeAgentSpec,
   parseResultContract
-} from "./chunk-PGF63K6I.js";
+} from "./chunk-KFV5L5SK.js";
 import {
   resolvePackageRoot
 } from "./chunk-IWHMRKLL.js";
@@ -396,4 +396,4 @@ export {
   parseAgentRecipeSchema,
   discoverAgentRecipes
 };
-//# sourceMappingURL=chunk-CRFOIAX3.js.map
+//# sourceMappingURL=chunk-7UGL4MB5.js.map

package/dist/{chunk-HIICAHCJ.js → chunk-AUPNRN7C.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-H7IXIC72.js";
 import {
   isAgentCapabilityClass
-} from "./chunk-PGF63K6I.js";
+} from "./chunk-KFV5L5SK.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -995,4 +995,4 @@ export {
   routingIntentRejection,
   explainRouteDecision
 };
-//# sourceMappingURL=chunk-HIICAHCJ.js.map
+//# sourceMappingURL=chunk-AUPNRN7C.js.map

package/dist/{chunk-7BHIY2MW.js → chunk-BJVFZO5U.js}

@@ -1,65 +1,26 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  truncateUtf8
-} from "./chunk-6XLNIQDB.js";
-import {
-  VERIFICATION_SCRIPT_FAMILY_HINT
-} from "./chunk-UL3WSD3F.js";
 import {
   typebox_exports
 } from "./chunk-5B2AEOW5.js";
+import {
+  truncateUtf8
+} from "./chunk-6XLNIQDB.js";
 import {
   ToolNames
-} from "./chunk-K6BSR66V.js";
+} from "./chunk-4NSRCOYP.js";
 import {
   SAFE_EXEC_DEFAULT_MAX_OUTPUT_BYTES,
   SAFE_EXEC_DEFAULT_TIMEOUT_MS,
   combineSafeOutput,
   runCommandVector
-} from "./chunk-HJWWJ6IL.js";
+} from "./chunk-TOIVGRUX.js";
 import {
   StringEnum
-} from "./chunk-VXMFAE2W.js";
+} from "./chunk-YPC6ZR5L.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
 
-// src/tools/verify/surface.ts
-init_esm_shims();
-var BROWSER_MODES = ["auto", "required", "off"];
-function prepareVerifyArguments(args) {
-  if (!args || typeof args !== "object" || Array.isArray(args)) return args;
-  const next = { ...args };
-  if (typeof next.args === "string") {
-    try {
-      const parsed = JSON.parse(next.args);
-      if (Array.isArray(parsed)) next.args = parsed;
-    } catch {
-    }
-  }
-  return next;
-}
-var verifyToolSurface = {
-  name: ToolNames.Verify,
-  description: 'Run a declared verification check: no arguments lists package scripts and .clio-coder/verifiers.yaml entries, check=<id> runs one, and check="frontend" with path validates an HTML/CSS/JS artifact.',
-  parameters: typebox_exports.Object({
-    check: typebox_exports.Optional(
-      typebox_exports.String({
-        description: `Check id, package script (${VERIFICATION_SCRIPT_FAMILY_HINT}), or "frontend"; omit to list.`
-      })
-    ),
-    path: typebox_exports.Optional(typebox_exports.String({ description: "frontend: artifact file under the workspace root." })),
-    args: typebox_exports.Optional(typebox_exports.Array(typebox_exports.String(), { description: "Package scripts only: arguments after --." })),
-    browser: typebox_exports.Optional(StringEnum(BROWSER_MODES, { description: "frontend: headless browser mode (default auto)." })),
-    cwd: typebox_exports.Optional(typebox_exports.String({ description: "Package scripts only: working directory." })),
-    timeout_ms: typebox_exports.Optional(typebox_exports.Number({ description: "Package and frontend checks only: timeout in ms." })),
-    max_output_bytes: typebox_exports.Optional(typebox_exports.Number({ description: "Output cap in bytes (default 600000)." }))
-  }),
-  baseActionClass: "execute",
-  executionMode: "sequential",
-  prepareArguments: prepareVerifyArguments
-};
-
 // src/tools/safe-exec.ts
 init_esm_shims();
 var TRUNCATION_MARKER = "\n[output truncated]\n";
@@ -166,9 +127,6 @@ export {
   timeoutArg,
   maxOutputArg,
   runVectorTool,
-  gitTool,
-  BROWSER_MODES,
-  prepareVerifyArguments,
-  verifyToolSurface
+  gitTool
 };
-//# sourceMappingURL=chunk-7BHIY2MW.js.map
+//# sourceMappingURL=chunk-BJVFZO5U.js.map

package/dist/{chunk-B74PXLU7.js → chunk-CUSRQKPU.js}

@@ -3,13 +3,13 @@ import {
   ROUTE_POLICY_VERSION,
   isRouteDecisionAgentSelection,
   isRoutingIntent
-} from "./chunk-HIICAHCJ.js";
+} from "./chunk-AUPNRN7C.js";
 import {
   isExecutionRole
 } from "./chunk-H7IXIC72.js";
 import {
   readSettings
-} from "./chunk-34BHNEE3.js";
+} from "./chunk-GHS5EBTQ.js";
 import {
   readClioVersion,
   resolvePackageRoot
@@ -101,6 +101,9 @@ var RECEIPT_INTEGRITY_FIELD_COVERAGE = {
   plan: true,
   fleetGate: true,
   personaOverride: true,
+  // Absent unless the parent board held decisions, so older receipts and
+  // decision-free runs digest exactly as before.
+  decisionRefs: true,
   projectContext: true,
   // Always set on receipts written after #104 landed; absent only on older
   // receipts, which omit these fields from canonical serialization.
@@ -188,6 +191,7 @@ function ledgerDigestFields(envelope) {
     executionRole: envelope.executionRole,
     task: envelope.task,
     ...envelope.budget !== void 0 ? { budget: envelope.budget } : {},
+    ...envelope.decisionRefs !== void 0 ? { decisionRefs: envelope.decisionRefs } : {},
     targetId: envelope.targetId,
     wireModelId: envelope.wireModelId,
     runtimeId: envelope.runtimeId,
@@ -536,6 +540,13 @@ function normalizeTrustStatus(value) {
     completionEvidence: normalizeAxis("completionEvidence", value.completionEvidence)
   };
 }
+function validateTrustStatus(value) {
+  try {
+    return { ok: true, status: normalizeTrustStatus(value) };
+  } catch (error) {
+    return { ok: false, reason: error instanceof Error ? error.message : String(error) };
+  }
+}
 function absentTrustStatus(reason) {
   return { state: "absent", reason };
 }
@@ -558,6 +569,18 @@ function composeTrustStatus(...projections) {
   }
   return normalizeTrustStatus({ version: TRUST_STATUS_VERSION, ...axes });
 }
+function projectTrustStatus(status, axes) {
+  const normalized = normalizeTrustStatus(status);
+  const projection = {};
+  const requested = new Set(axes);
+  if (requested.has("artifactIntegrity")) projection.artifactIntegrity = normalized.artifactIntegrity;
+  if (requested.has("validationGrounding")) projection.validationGrounding = normalized.validationGrounding;
+  if (requested.has("independentReview")) projection.independentReview = normalized.independentReview;
+  if (requested.has("contextProvenance")) projection.contextProvenance = normalized.contextProvenance;
+  if (requested.has("autonomyEnforcement")) projection.autonomyEnforcement = normalized.autonomyEnforcement;
+  if (requested.has("completionEvidence")) projection.completionEvidence = normalized.completionEvidence;
+  return projection;
+}
 function sha256Reference(kind, id, digest) {
   const reference = { kind, id };
   if (digest !== void 0 && /^[a-f0-9]{64}$/u.test(digest)) {
@@ -892,6 +915,20 @@ function adaptGroundedEvidenceValidationStatus(input) {
     uniqueBoundedReferences([{ kind: "evidence_bundle", id: input.evidenceId }, ...observed])
   );
 }
+function adaptFinishContractCompletionStatus(assessment, options = {}) {
+  const artifacts = uniqueBoundedReferences(
+    options.artifacts ?? assessment.evidence.map((evidence, index) => ({
+      kind: evidence.turnId === void 0 ? "finish_contract_evidence" : "session_entry",
+      id: evidence.turnId ?? `${evidence.kind}:${index + 1}`
+    }))
+  );
+  const source = { kind: "finish_contract", id: options.sourceId ?? assessment.reason };
+  const authority = { kind: "clio", id: "finish-contract" };
+  if (assessment.reason === "no_mutation") return attributed("not_applicable", source, authority, artifacts);
+  if (assessment.reason === "validation_evidence") return attributed("evidenced", source, authority, artifacts);
+  if (assessment.reason === "explicit_limitation") return attributed("limited", source, authority, artifacts);
+  return attributed("incomplete", source, authority, artifacts);
+}
 function uniqueBoundedReferences(references) {
   const sorted = [...references].sort(compareArtifactReferences);
   const unique = sorted.filter(
@@ -904,6 +941,13 @@ function uniqueBoundedReferences(references) {
 init_esm_shims();
 var TRUST_SUMMARY_VERSION = 1;
 var TRUST_SUMMARY_MAX_REFS = 8;
+var TRUST_VERDICTS = [
+  "reviewed",
+  "grounded",
+  "unverified",
+  "compromised",
+  "unknown"
+];
 var TRUST_STATE_WORDS = {
   artifactIntegrity: {
     verified: "sealed",
@@ -1387,22 +1431,40 @@ export {
   withReceiptIntegrity,
   isReceiptIntegrity,
   verifyReceiptIntegrity,
+  TRUST_STATUS_VERSION,
+  TRUST_STATUS_MAX_ARTIFACT_REFERENCES,
+  TRUST_STATUS_MAX_IDENTIFIER_LENGTH,
   TRUST_STATUS_AXES,
+  TRUST_STATUS_STATES,
   isTrustStatusIdentifier,
   normalizeTrustStatus,
+  validateTrustStatus,
+  absentTrustStatus,
   composeTrustStatus,
+  projectTrustStatus,
   retiredReceiptIntegrity,
   retiredReceiptIntegrityReason,
+  verifyReceiptIntegrityOutcome,
   retiredIntegrityVersionOf,
+  adaptReceiptIntegrityStatus,
+  adaptRunReceiptValidationStatus,
+  adaptRunReceiptContextStatus,
+  adaptRunReceiptAutonomyStatus,
   adaptRunReceiptTrustStatus,
   inspectRunReceiptTrustStatus,
   adaptGateDecisionReviewStatus,
   adaptGroundedEvidenceValidationStatus,
+  adaptFinishContractCompletionStatus,
+  TRUST_SUMMARY_VERSION,
+  TRUST_SUMMARY_MAX_REFS,
+  TRUST_VERDICTS,
+  TRUST_STATE_WORDS,
   trustStateWord,
   formatTrustSummary,
   formatTrustSummaryLine,
   formatTrustAxes,
   trustVerdict,
+  trustSummaryReferences,
   summarizeTrustStatus,
   evalClioProvenance,
   evalEnvironmentProvenance,
@@ -1412,4 +1474,4 @@ export {
   loadEvalTaskFile,
   EvalTaskFileError
 };
-//# sourceMappingURL=chunk-B74PXLU7.js.map
+//# sourceMappingURL=chunk-CUSRQKPU.js.map

package/dist/chunk-DQOVN6KV.js

@@ -0,0 +1,386 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  terminalColumns,
+  wrapPlain
+} from "./chunk-2IR2NMPA.js";
+import {
+  source_default
+} from "./chunk-JCI2ROMZ.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/cli/lifecycle-presenter.ts
+init_esm_shims();
+import { lstatSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { stdin as defaultInput, stdout as defaultOutput } from "node:process";
+import { createInterface } from "node:readline/promises";
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let value = bytes / 1024;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex += 1;
+  }
+  return `${value.toFixed(1)} ${units[unitIndex]}`;
+}
+function measurePath(targetPath) {
+  let stats;
+  try {
+    stats = lstatSync(targetPath);
+  } catch {
+    return { bytes: 0, exists: false, isDirectory: false, isSymbolicLink: false };
+  }
+  if (stats.isSymbolicLink()) {
+    return { bytes: stats.size, exists: true, isDirectory: false, isSymbolicLink: true };
+  }
+  if (!stats.isDirectory()) {
+    return { bytes: stats.size, exists: true, isDirectory: false, isSymbolicLink: false };
+  }
+  let total = 0;
+  function walk(dir) {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = join(dir, entry.name);
+      try {
+        if (entry.isDirectory()) walk(full);
+        else total += lstatSync(full).size;
+      } catch {
+      }
+    }
+  }
+  walk(targetPath);
+  return { bytes: total, exists: true, isDirectory: true, isSymbolicLink: false };
+}
+function shortenPath(targetPath, home = homedir()) {
+  if (!targetPath) return targetPath;
+  if (targetPath === home) return "~";
+  if (targetPath.startsWith(`${home}/`) || targetPath.startsWith(`${home}\\`)) {
+    return `~/${targetPath.slice(home.length + 1)}`;
+  }
+  return targetPath;
+}
+var LifecyclePresenter = class {
+  json;
+  plain;
+  out;
+  in;
+  columns;
+  report;
+  lastBlock = null;
+  emitted = false;
+  constructor(options = {}) {
+    this.json = Boolean(options.json);
+    const stream = options.stream ?? defaultOutput;
+    const isTty = Boolean(stream.isTTY);
+    this.plain = options.plain ?? (!isTty || Boolean(process.env.NO_COLOR));
+    this.out = stream;
+    this.in = options.inputStream ?? defaultInput;
+    this.columns = options.columns ?? terminalColumns(stream);
+    this.report = {
+      command: "",
+      title: "",
+      status: "success",
+      items: [],
+      steps: [],
+      warnings: [],
+      errors: [],
+      advice: []
+    };
+  }
+  isJson() {
+    return this.json;
+  }
+  isPlain() {
+    return this.plain;
+  }
+  getReport() {
+    return this.report;
+  }
+  setMethod(method) {
+    this.report.method = method;
+  }
+  /** Open a block, writing the one separator that belongs before it. */
+  open(block) {
+    if (this.lastBlock !== null && this.lastBlock !== block) this.separator();
+    this.lastBlock = block;
+  }
+  separator() {
+    this.out.write(this.plain ? "\n" : `${source_default.cyan("\u2502")}
+`);
+  }
+  /**
+   * Close the current block, for a caller that is about to draw its own lines
+   * on the rail. `configure` hands the rail to the arrow-key selector after
+   * rendering a screen's values, and the selector cannot know what came before
+   * it.
+   */
+  blank() {
+    if (this.json) return;
+    this.separator();
+    this.lastBlock = null;
+  }
+  /** Rail-level prose, wrapped to the terminal so the rail survives a narrow window. */
+  prose(text) {
+    const prefix = this.plain ? "  " : `${source_default.cyan("\u2502")}  `;
+    for (const line of wrapPlain(text, this.columns - 3)) this.out.write(`${prefix}${line}
+`);
+  }
+  header(title, command = "") {
+    this.report.title = title;
+    this.report.command = command;
+    if (this.json) return;
+    if (this.plain) {
+      this.out.write(`
+${title}
+`);
+    } else {
+      this.out.write(`
+${source_default.cyan("\u250C")}  ${source_default.bold(title)}
+`);
+    }
+    this.lastBlock = "header";
+  }
+  /** One detected fact. Consecutive facts group into a single block. */
+  step(text) {
+    this.report.steps.push({ type: "step", message: text });
+    if (this.json) return;
+    this.open("step");
+    if (this.plain) this.out.write(`  ${text}
+`);
+    else this.out.write(`${source_default.blue("\u25CF")}  ${text}
+`);
+  }
+  /** A line of prose on the rail, not a detected fact. */
+  note(text) {
+    this.report.steps.push({ type: "note", message: text });
+    if (this.json) return;
+    this.open("note");
+    this.prose(text);
+  }
+  /**
+   * Aligned label/value rows for a settings screen. Not `note()`, because
+   * these must not reflow: the column is what makes eight values scannable,
+   * and a wrap would put the value under the wrong label.
+   */
+  fields(rows) {
+    for (const [label, value] of rows) this.report.steps.push({ type: "field", message: `${label}: ${value}` });
+    if (this.json || rows.length === 0) return;
+    this.open("step");
+    const width = Math.max(...rows.map(([label]) => label.length));
+    for (const [label, value] of rows) {
+      const padded = `${label}${" ".repeat(width - label.length)}`;
+      if (this.plain) this.out.write(`  ${padded}  ${value}
+`);
+      else this.out.write(`${source_default.blue("\u25CF")}  ${source_default.dim(padded)}  ${value}
+`);
+    }
+  }
+  substep(text, glyph = "\u2713") {
+    this.report.steps.push({ type: "substep", message: text });
+    if (this.json) return;
+    this.open("list");
+    if (this.plain) {
+      this.out.write(`    ${glyph} ${text}
+`);
+      return;
+    }
+    const coloredGlyph = glyph === "\u2713" ? source_default.green(glyph) : source_default.dim(glyph);
+    this.out.write(`${source_default.blue("\u25CF")}    ${coloredGlyph} ${text}
+`);
+  }
+  listItems(header, items) {
+    for (const item of items) {
+      this.report.items.push(item);
+    }
+    if (this.json) return;
+    this.open("note");
+    this.prose(`${header}:`);
+    this.open("list");
+    for (const item of items) {
+      const sizeStr = item.status !== "absent" && item.bytes !== void 0 && item.bytes !== null ? ` (${formatBytes(item.bytes)})` : "";
+      const removes = item.status === void 0 || item.status === "remove";
+      let suffix = "";
+      if (item.status === "keep") suffix = item.detail ? ` (${item.detail})` : " (kept)";
+      else if (item.status === "absent") suffix = item.detail ? ` (${item.detail})` : " (absent)";
+      else if (item.status === "skip") suffix = item.detail ? ` (${item.detail})` : " (skipped)";
+      else if (item.status === "clean") suffix = item.detail ? ` (${item.detail})` : " (nothing to remove)";
+      else if (item.detail) suffix = ` (${item.detail})`;
+      const body = `${item.label}: ${shortenPath(item.path)}${sizeStr}`;
+      if (this.plain) {
+        this.out.write(`    ${removes ? "\u2713" : "\u2013"} ${body}${suffix}
+`);
+        continue;
+      }
+      const glyph = removes ? source_default.green("\u2713") : item.status === "skip" ? source_default.yellow("\u2013") : source_default.dim("\u2013");
+      const tail = suffix.length === 0 ? "" : item.status === "skip" ? source_default.yellow(suffix) : source_default.dim(suffix);
+      this.out.write(
+        `${source_default.blue("\u25CF")}    ${glyph} ${source_default.bold(item.label)}: ${shortenPath(item.path)}${sizeStr}${tail}
+`
+      );
+    }
+  }
+  /** One action that has already happened. Consecutive results group together. */
+  completedStep(text) {
+    this.report.steps.push({ type: "completed", message: text });
+    if (this.json) return;
+    this.open("completed");
+    if (this.plain) this.out.write(`  \u2713 ${text}
+`);
+    else this.out.write(`${source_default.green("\u25C7")}  ${text}
+`);
+  }
+  warn(text) {
+    this.report.warnings.push(text);
+    if (this.json) return;
+    this.open("warn");
+    if (this.plain) {
+      for (const line of wrapPlain(text, this.columns - 3)) this.out.write(`  ${line}
+`);
+      return;
+    }
+    const prefix = `${source_default.yellow("\u25B2")}  `;
+    const continuation = `${source_default.cyan("\u2502")}  `;
+    wrapPlain(text, this.columns - 3).forEach((line, index) => {
+      this.out.write(`${index === 0 ? prefix : continuation}${source_default.yellow(line)}
+`);
+    });
+  }
+  /**
+   * Record a failure and say it once on stderr. The JSON report is not written
+   * here: a command that fails still has advice to add, and emitting mid-flight
+   * either dropped it or put a second document on stdout. Callers end on
+   * `finish()`.
+   */
+  fail(message, detail) {
+    this.report.status = "error";
+    this.report.errors.push(detail ? `${message}: ${detail}` : message);
+    if (this.json) return;
+    if (this.plain) {
+      process.stderr.write(`error: ${message}
+`);
+      if (detail) process.stderr.write(`  ${detail}
+`);
+      return;
+    }
+    process.stderr.write(`${source_default.red("\u2716")}  ${source_default.red(message)}
+`);
+    if (detail) process.stderr.write(`${source_default.cyan("\u2502")}  ${source_default.dim(detail)}
+`);
+  }
+  commandAdvice(lead, command) {
+    this.report.advice.push({ lead, command });
+    if (this.json) return;
+    this.open("advice");
+    this.prose(lead);
+    for (const line of command.split("\n")) {
+      if (this.plain) this.out.write(`    ${line}
+`);
+      else this.out.write(`${source_default.blue("\u25CF")}    ${source_default.cyan(line)}
+`);
+    }
+  }
+  message(text) {
+    this.report.steps.push({ type: "message", message: text });
+    if (this.json) return;
+    this.open("message");
+    if (this.plain) this.out.write(`  ${text}
+`);
+    else this.out.write(`${source_default.cyan("\u25C6")}  ${source_default.bold(text)}
+`);
+  }
+  /**
+   * Ask once, and treat a closed input as a refusal.
+   *
+   * `rl.question()` from readline/promises settles on an answer and on an abort
+   * signal, but not on the input ending: at EOF the interface emits `close` and
+   * the promise is simply never resolved. Every caller here guards a delete, so
+   * the failure mode was a `clio-coder uninstall` that printed its prompt and
+   * then hung forever on Ctrl-D. Racing the `close` event settles that case as
+   * "no", which is the only safe reading of an input that stopped talking.
+   */
+  async confirm(question, defaultYes = false) {
+    if (this.json) return false;
+    const hint = defaultYes ? "Y/n" : "y/N";
+    this.open("confirm");
+    const rl = createInterface({ input: this.in, output: this.out });
+    try {
+      const promptStr = this.plain ? `  ${question} [${hint}]: ` : `${source_default.cyan("\u25C7")}  ${source_default.bold(question)} [${hint}]
+${source_default.cyan("\u2502")}  `;
+      const answer = await new Promise((resolve) => {
+        let settled = false;
+        const settle = (value) => {
+          if (settled) return;
+          settled = true;
+          resolve(value);
+        };
+        rl.once("close", () => settle(null));
+        rl.question(promptStr).then(
+          (value) => settle(value),
+          () => settle(null)
+        );
+      });
+      if (answer === null) return false;
+      const normalized = answer.trim().toLowerCase();
+      const confirmed = normalized.length === 0 ? defaultYes : normalized === "y" || normalized === "yes";
+      this.out.write(this.plain ? `  ${confirmed ? "Yes" : "No"}
+` : `${source_default.cyan("\u2502")}  ${confirmed ? "Yes" : "No"}
+`);
+      return confirmed;
+    } finally {
+      rl.close();
+    }
+  }
+  /**
+   * Close the transcript. Every command ends here, on success and on failure,
+   * so `--json` emits exactly one document containing everything that was
+   * recorded, including advice added after a failure.
+   */
+  done(summary = "Done") {
+    this.report.summary = summary;
+    if (this.json) {
+      this.emit();
+      return;
+    }
+    if (this.plain) {
+      this.out.write(`
+${summary}
+`);
+      return;
+    }
+    this.separator();
+    this.out.write(`${source_default.cyan("\u2514")}  ${source_default.bold(summary)}
+
+`);
+  }
+  /** Emit the JSON report without a closing line, for paths that ended in an error. */
+  finish() {
+    if (this.json) this.emit();
+  }
+  emit() {
+    if (this.emitted) return;
+    this.emitted = true;
+    this.out.write(`${JSON.stringify(this.report, null, 2)}
+`);
+  }
+};
+function createLifecyclePresenter(options = {}) {
+  return new LifecyclePresenter(options);
+}
+
+export {
+  formatBytes,
+  measurePath,
+  shortenPath,
+  createLifecyclePresenter
+};
+//# sourceMappingURL=chunk-DQOVN6KV.js.map