@cleocode/cleo 2026.10.3 → 2026.10.4

package/dist/cli/chunk-3ZO3M37V.js

@@ -0,0 +1,1002 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  getFieldContext,
+  getFormatContext,
+  getOutputMode,
+  getSummaryMode
+} from "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/renderers/index.ts
+import { randomUUID } from "node:crypto";
+import { getOutputContract } from "@cleocode/core/dispatch/contracts/output-contracts";
+import {
+  extractByJsonPointer,
+  isJsonPointer,
+  serializePointerValue
+} from "@cleocode/core/dispatch/projection";
+import { drainWarnings, formatSuccess } from "@cleocode/core/output";
+import {
+  metaFooter,
+  pagerFooter,
+  renderAuditReconstruct,
+  renderBlockers,
+  renderBrainBackfill,
+  renderBrainExport,
+  renderBrainMaintenance,
+  renderBrainPlasticityStats,
+  renderBrainPurge,
+  renderBrainQuality,
+  renderBriefing,
+  renderCurrent,
+  renderDecideAsk,
+  renderDecideConfig,
+  renderDecideProfiles,
+  renderDecideStatus,
+  renderDoctor,
+  renderGeneric,
+  renderNext,
+  renderNexusAnalyze,
+  renderNexusBrainAnchors,
+  renderNexusClusters,
+  renderNexusColdSymbols,
+  renderNexusConduitScan,
+  renderNexusContext as renderNexusContextResult,
+  renderNexusContractsLinkTasks,
+  renderNexusContractsShow,
+  renderNexusContractsSync,
+  renderNexusDiff,
+  renderNexusExport,
+  renderNexusFlows,
+  renderNexusFullContext,
+  renderNexusHotNodes,
+  renderNexusHotPaths,
+  renderNexusImpact,
+  renderNexusImpactFull,
+  renderNexusProjectsClean,
+  renderNexusProjectsCleanPreview,
+  renderNexusProjectsFleet,
+  renderNexusProjectsList,
+  renderNexusProjectsRegister,
+  renderNexusProjectsRemove,
+  renderNexusProjectsScan,
+  renderNexusProjectsStatus,
+  renderNexusQuery,
+  renderNexusRefreshBridge,
+  renderNexusRouteMap,
+  renderNexusSearchCode,
+  renderNexusSetup,
+  renderNexusShapeCheck,
+  renderNexusStatus,
+  renderNexusTaskFootprint,
+  renderNexusTaskSymbols,
+  renderNexusWhy,
+  renderNexusWiki,
+  renderPlan,
+  renderSchemaCommand,
+  renderSession,
+  renderStart,
+  renderStats,
+  renderStop,
+  renderTree,
+  renderVersion,
+  renderWaves
+} from "@cleocode/core/render/index";
+import { applyFieldFilter, extractFieldFromResult } from "@cleocode/lafs";
+
+// packages/cleo/src/cli/renderers/lafs-validator.ts
+import { ExitCode } from "@cleocode/contracts/exit-codes.js";
+var ENVELOPE_SUCCESS_KEY = "success";
+var ENVELOPE_DATA_KEY = "data";
+var ENVELOPE_META_KEY = "meta";
+function validateLafsShape(envelope) {
+  const report = {
+    isObject: false,
+    hasSuccessField: false,
+    successIsBoolean: false,
+    hasMeta: false,
+    resultOrErrorValid: false,
+    reasons: []
+  };
+  let parsed = envelope;
+  if (typeof envelope === "string") {
+    try {
+      parsed = JSON.parse(envelope);
+    } catch {
+      report.reasons.push("Envelope is not valid JSON");
+      return report;
+    }
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    report.reasons.push("Envelope is not a JSON object");
+    return report;
+  }
+  report.isObject = true;
+  const obj = parsed;
+  if (!(ENVELOPE_SUCCESS_KEY in obj)) {
+    report.reasons.push(`Envelope missing success indicator \u2014 expected: "${ENVELOPE_SUCCESS_KEY}"`);
+    return report;
+  }
+  report.hasSuccessField = true;
+  const successValue = obj[ENVELOPE_SUCCESS_KEY];
+  if (typeof successValue !== "boolean") {
+    report.reasons.push(
+      `Envelope "${ENVELOPE_SUCCESS_KEY}" field must be boolean, got ${typeof successValue}`
+    );
+    return report;
+  }
+  report.successIsBoolean = true;
+  report.hasMeta = ENVELOPE_META_KEY in obj && typeof obj[ENVELOPE_META_KEY] === "object";
+  if (!report.hasMeta) {
+    report.reasons.push(
+      `Envelope missing required "${ENVELOPE_META_KEY}" object (ADR-039 \u2014 every envelope must carry meta)`
+    );
+  }
+  if (successValue === true) {
+    const hasData = ENVELOPE_DATA_KEY in obj;
+    if (!hasData) {
+      report.reasons.push(
+        `Successful envelope missing "${ENVELOPE_DATA_KEY}" field (legacy "result" / "r" are no longer valid \u2014 ADR-039)`
+      );
+    } else {
+      report.resultOrErrorValid = true;
+    }
+  } else {
+    const errorField = obj["error"];
+    if (typeof errorField !== "object" || errorField === null) {
+      report.reasons.push('Failed envelope missing "error" object');
+    } else {
+      const err = errorField;
+      const hasCode = "code" in err;
+      const hasMessage = "message" in err && typeof err["message"] === "string";
+      if (!hasCode || !hasMessage) {
+        report.reasons.push(
+          'Failed envelope "error" object must contain "code" and "message" (string)'
+        );
+      } else {
+        report.resultOrErrorValid = true;
+      }
+    }
+  }
+  return report;
+}
+var LafsViolationError = class extends Error {
+  code = ExitCode.LAFS_VIOLATION;
+  report;
+  constructor(message, report) {
+    super(message);
+    this.name = "LafsViolationError";
+    this.report = report;
+  }
+};
+function emitLafsViolation(err) {
+  const envelope = {
+    success: false,
+    error: {
+      code: ExitCode.LAFS_VIOLATION,
+      codeName: "E_LAFS_VIOLATION",
+      message: err.message,
+      details: {
+        report: err.report
+      }
+    },
+    meta: {
+      operation: "cli.lafs-validator",
+      requestId: "lafs-validator-emit",
+      duration_ms: 0,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+  if (process.env["CLEO_DEBUG"]) {
+    process.stderr.write(`${JSON.stringify(envelope)}
+`);
+  }
+  process.exitCode = ExitCode.LAFS_VIOLATION;
+}
+
+// packages/cleo/src/cli/renderers/normalizer.ts
+function normalizeForHuman(command, data) {
+  switch (command) {
+    case "show":
+      return normalizeTaskWrapper(data);
+    case "list":
+    case "ls":
+      return normalizeTaskList(data);
+    case "find":
+    case "search":
+      return normalizeFindResults(data);
+    case "add":
+      return normalizeTaskWrapper(data);
+    case "update":
+      return normalizeTaskWrapper(data);
+    case "complete":
+    case "done":
+      return normalizeTaskWrapper(data);
+    case "delete":
+    case "rm":
+      return normalizeDeleteResult(data);
+    case "archive":
+      return normalizeArchiveResult(data);
+    default:
+      return data;
+  }
+}
+function normalizeTaskWrapper(data) {
+  if (data["task"]) return data;
+  if (data["id"] && typeof data["id"] === "string") {
+    return { task: data };
+  }
+  return data;
+}
+function normalizeTaskList(data) {
+  if (data["tasks"]) return data;
+  if (Array.isArray(data)) {
+    return { tasks: data, total: data.length };
+  }
+  return data;
+}
+function normalizeFindResults(data) {
+  if (data["results"]) return data;
+  if (Array.isArray(data)) {
+    return { results: data, total: data.length };
+  }
+  return data;
+}
+function normalizeDeleteResult(data) {
+  if (data["deletedTask"]) return data;
+  if (data["taskId"]) {
+    return { ...data, deletedTask: { id: data["taskId"] } };
+  }
+  return data;
+}
+function normalizeArchiveResult(data) {
+  if (data["archivedCount"] !== void 0) return data;
+  if (data["archived"] !== void 0 && typeof data["archived"] === "number") {
+    return {
+      ...data,
+      archivedCount: data["archived"],
+      archivedTasks: data["taskIds"]?.map((id) => ({ id }))
+    };
+  }
+  return data;
+}
+
+// packages/cleo/src/cli/renderers/output-mode.ts
+import {
+  COLLECTION_IDENTITY_FIELDS,
+  COLLECTION_KEYS as CONTRACT_COLLECTION_KEYS,
+  DEFAULT_IDENTITY_FIELD
+} from "@cleocode/contracts/collection-keys.js";
+import { truncateString } from "@cleocode/core/render/helpers";
+var COLLECTION_KEYS = CONTRACT_COLLECTION_KEYS;
+function pickCollectionEntry(rec) {
+  for (const key of COLLECTION_KEYS) {
+    const value = rec[key];
+    if (Array.isArray(value)) return { key, rows: value };
+  }
+  const candidates = Object.entries(rec).filter(
+    ([, value]) => Array.isArray(value) && value.length > 0 && value.every((row) => row !== null && typeof row === "object" && !Array.isArray(row))
+  );
+  if (candidates.length === 1) {
+    const [key, value] = candidates[0];
+    return { key, rows: value };
+  }
+  return void 0;
+}
+function pickCollection(rec) {
+  return pickCollectionEntry(rec)?.rows;
+}
+function identityFieldFor(key) {
+  return COLLECTION_IDENTITY_FIELDS[key] ?? DEFAULT_IDENTITY_FIELD;
+}
+function identityOf(row, key) {
+  if (row === null || typeof row !== "object") return void 0;
+  const value = row[identityFieldFor(key)];
+  return typeof value === "string" ? value : void 0;
+}
+function extractIds(data) {
+  if (data === null || typeof data !== "object") return [];
+  const rec = data;
+  const task = rec["task"];
+  if (task && typeof task === "object") {
+    const id2 = task["id"];
+    if (typeof id2 === "string") return [id2];
+  }
+  const entry = pickCollectionEntry(rec);
+  if (entry) {
+    return entry.rows.map((row) => identityOf(row, entry.key)).filter((id2) => id2 !== void 0);
+  }
+  const created = rec["created"];
+  const updated = rec["updated"];
+  const deleted = rec["deleted"];
+  if (typeof rec["count"] === "number" && Array.isArray(created) && Array.isArray(updated) && Array.isArray(deleted)) {
+    const affected = [...created, ...updated, ...deleted];
+    if (affected.every((id2) => typeof id2 === "string")) {
+      return [...new Set(affected)];
+    }
+  }
+  const id = rec["id"];
+  if (typeof id === "string") return [id];
+  return [];
+}
+function extractCount(data) {
+  if (data === null || typeof data !== "object") return 0;
+  const rec = data;
+  const population = taskPopulationFacts(data);
+  if (population) return population.returned;
+  const filtered = rec["filtered"];
+  if (typeof filtered === "number" && Number.isFinite(filtered)) return filtered;
+  const total = rec["total"];
+  if (typeof total === "number" && Number.isFinite(total)) return total;
+  const count = rec["count"];
+  if (typeof count === "number" && Number.isFinite(count)) return count;
+  const collection = pickCollection(rec);
+  if (collection) return collection.length;
+  if (rec["task"] && typeof rec["task"] === "object") return 1;
+  if (typeof rec["id"] === "string") return 1;
+  return 0;
+}
+function taskPopulationFacts(data) {
+  if (!data || typeof data !== "object" || !("population" in data)) return void 0;
+  const facts = data.population;
+  if (!facts || typeof facts !== "object" || !("matched" in facts) || !("returned" in facts) || !("truncated" in facts) || !("archive" in facts) || !("limit" in facts) || !("offset" in facts))
+    return void 0;
+  if (typeof facts.matched !== "number" || typeof facts.returned !== "number" || typeof facts.truncated !== "boolean" || typeof facts.offset !== "number" || facts.limit !== null && typeof facts.limit !== "number" || !["included", "excluded", "only"].includes(String(facts.archive)))
+    return void 0;
+  return {
+    matched: facts.matched,
+    returned: facts.returned,
+    truncated: facts.truncated,
+    archive: facts.archive,
+    limit: facts.limit,
+    offset: facts.offset
+  };
+}
+function formatTaskMatching(data) {
+  if (!data || typeof data !== "object" || !("searchType" in data)) return void 0;
+  if (typeof data.searchType !== "string") return void 0;
+  const lines = [`cleo: searchType=${data.searchType}`];
+  if (data.searchType === "fuzzy") {
+    for (const row of pickCollection(data) ?? []) {
+      if (!row || typeof row !== "object" || !("match" in row) || !("id" in row)) continue;
+      const match = row.match;
+      if (!match || typeof match !== "object" || !("kind" in match) || !("fields" in match) || !Array.isArray(match.fields))
+        continue;
+      lines.push(
+        `cleo: match id=${String(row.id)} kind=${String(match.kind)} fields=${match.fields.filter((field) => typeof field === "string").join(",")}`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+function formatTaskPopulation(data) {
+  const facts = taskPopulationFacts(data);
+  if (!facts) return void 0;
+  return `cleo: population matched=${facts.matched} returned=${facts.returned} truncated=${facts.truncated} archive=${facts.archive} limit=${facts.limit ?? "all"} offset=${facts.offset}`;
+}
+function renderTableList(tasks, identityField = DEFAULT_IDENTITY_FIELD) {
+  if (tasks.length === 0) return "";
+  const COL_TITLE_MAX = 60;
+  const rows = tasks.map((t) => ({
+    id: typeof t[identityField] === "string" ? t[identityField] : "",
+    status: typeof t["status"] === "string" ? t["status"] : "",
+    priority: typeof t["priority"] === "string" ? t["priority"] : "",
+    title: truncateString(typeof t["title"] === "string" ? t["title"] : "", COL_TITLE_MAX)
+  }));
+  const widths = {
+    id: Math.max(2, ...rows.map((r) => r.id.length)),
+    status: Math.max(6, ...rows.map((r) => r.status.length)),
+    priority: Math.max(8, ...rows.map((r) => r.priority.length)),
+    title: Math.max(5, ...rows.map((r) => r.title.length))
+  };
+  const pad = (s, w) => s + " ".repeat(Math.max(0, w - s.length));
+  const header = `${pad("id", widths.id)}  ${pad("status", widths.status)}  ${pad(
+    "priority",
+    widths.priority
+  )}  ${pad("title", widths.title)}`;
+  const sep = `${"-".repeat(widths.id)}  ${"-".repeat(widths.status)}  ${"-".repeat(
+    widths.priority
+  )}  ${"-".repeat(widths.title)}`;
+  const body = rows.map(
+    (r) => `${pad(r.id, widths.id)}  ${pad(r.status, widths.status)}  ${pad(
+      r.priority,
+      widths.priority
+    )}  ${pad(r.title, widths.title)}`
+  ).join("\n");
+  return `${header}
+${sep}
+${body}`;
+}
+function renderTableGeneric(data) {
+  const entries = Object.entries(data);
+  if (entries.length === 0) return "(empty)";
+  const rows = entries.map(([k, v]) => ({
+    field: k,
+    value: v === null || v === void 0 ? "" : typeof v === "object" ? JSON.stringify(v) : String(v)
+  }));
+  const VAL_MAX = 80;
+  for (const r of rows) r.value = truncateString(r.value, VAL_MAX);
+  const widths = {
+    field: Math.max(5, ...rows.map((r) => r.field.length)),
+    value: Math.max(5, ...rows.map((r) => r.value.length))
+  };
+  const pad = (s, w) => s + " ".repeat(Math.max(0, w - s.length));
+  const header = `${pad("field", widths.field)}  ${pad("value", widths.value)}`;
+  const sep = `${"-".repeat(widths.field)}  ${"-".repeat(widths.value)}`;
+  const body = rows.map((r) => `${pad(r.field, widths.field)}  ${pad(r.value, widths.value)}`).join("\n");
+  return `${header}
+${sep}
+${body}`;
+}
+var UnsupportedRendererError = class extends Error {
+  code = "E_RENDERER_UNSUPPORTED";
+  constructor(mode) {
+    super(`Unsupported output renderer: ${mode}`);
+    this.name = "UnsupportedRendererError";
+  }
+};
+function renderSummary(data) {
+  if (data === null || typeof data !== "object") {
+    return { text: "", emptyReason: "no-renderable-records" };
+  }
+  const rec = data;
+  const entry = pickCollectionEntry(rec);
+  if (entry) {
+    return renderSummaryList(entry.rows, identityFieldFor(entry.key));
+  }
+  const task = rec["task"];
+  if (task && typeof task === "object") {
+    return { text: renderSummaryRow(task) };
+  }
+  if (typeof rec["id"] === "string") {
+    return { text: renderSummaryRow(rec) };
+  }
+  return { text: "", emptyReason: "no-renderable-records" };
+}
+function renderSummaryRow(record, identityField = DEFAULT_IDENTITY_FIELD) {
+  const id = typeof record[identityField] === "string" ? record[identityField] : "";
+  const status = typeof record["status"] === "string" ? record["status"] : "";
+  const title = truncateString(typeof record["title"] === "string" ? record["title"] : "", 60);
+  return `${id} [${status}] ${title}`;
+}
+function renderSummaryList(rows, identityField = DEFAULT_IDENTITY_FIELD) {
+  if (rows.length === 0) return { text: "", emptyReason: "no-renderable-records" };
+  const lines = [];
+  for (const row of rows) {
+    if (!row || typeof row !== "object") continue;
+    const rec = row;
+    if (typeof rec[identityField] !== "string") continue;
+    lines.push(renderSummaryRow(rec, identityField));
+  }
+  return lines.length === 0 ? { text: "", emptyReason: "no-renderable-records" } : { text: lines.join("\n") };
+}
+function detectTruncation(data, page) {
+  const population = taskPopulationFacts(data);
+  if (population)
+    return population.truncated ? { returned: population.returned, total: population.matched } : null;
+  if (data === null || typeof data !== "object") return null;
+  const rec = data;
+  const collection = pickCollection(rec);
+  if (!collection) return null;
+  const returned = collection.length;
+  if (page !== null && typeof page === "object") {
+    const pageRec = page;
+    const total2 = pageRec["total"];
+    if (pageRec["hasMore"] === true && typeof total2 === "number" && total2 > returned) {
+      return { returned, total: total2 };
+    }
+  }
+  const filtered = rec["filtered"];
+  if (typeof filtered === "number" && filtered > returned) {
+    return { returned, total: filtered };
+  }
+  const total = rec["total"];
+  if (typeof total === "number" && total > returned && rec["filtered"] === void 0) {
+    return { returned, total };
+  }
+  return null;
+}
+function formatTruncationWarning(facts, mode, enumerateAllFlag) {
+  const surface = mode === "summary" ? "--summary" : `--output ${mode}`;
+  const head = `cleo: TRUNCATED \u2014 ${surface} returned ${facts.returned} of ${facts.total} matching rows. `;
+  if (enumerateAllFlag) {
+    return `${head}Re-run with ${enumerateAllFlag} to enumerate every match, or pass --limit/--offset to page deliberately.`;
+  }
+  return `${head}Pass --limit <n> / --offset <n> to page deliberately, or narrow the query.`;
+}
+function renderOutputMode(mode, data) {
+  switch (mode) {
+    case "id": {
+      const ids = extractIds(data);
+      if (ids.length > 0) return { text: ids.join("\n") };
+      const entry = data && typeof data === "object" ? pickCollectionEntry(data) : void 0;
+      if (entry && entry.rows.length > 0) {
+        return {
+          text: null,
+          refusal: {
+            code: "E_OUTPUT_IDENTITY_UNDECLARED",
+            message: `--output id cannot project the ${entry.rows.length} record(s) under "${entry.key}": no record carries "${identityFieldFor(entry.key)}". Refusing to emit an empty stream, which would be indistinguishable from a result set with no rows.`,
+            fix: `Declare the identity for "${entry.key}" in COLLECTION_IDENTITY_FIELDS (packages/contracts/src/collection-keys.ts), or use --field /data/${entry.key} to project the field you need.`
+          }
+        };
+      }
+      return { text: "", emptyReason: "no-renderable-ids" };
+    }
+    case "count": {
+      return { text: String(extractCount(data)) };
+    }
+    case "table": {
+      if (data && typeof data === "object") {
+        const rec = data;
+        const entry = pickCollectionEntry(rec);
+        if (entry) {
+          const text = renderTableList(
+            entry.rows,
+            identityFieldFor(entry.key)
+          );
+          return text.length === 0 ? { text: "", emptyReason: "no-renderable-records" } : { text };
+        }
+        return { text: renderTableGeneric(rec) };
+      }
+      return data === null || data === void 0 ? { text: "", emptyReason: "no-renderable-records" } : { text: String(data) };
+    }
+    case "silent": {
+      return { text: null, emptyReason: "silent-mode" };
+    }
+    case "envelope":
+      throw new UnsupportedRendererError(mode);
+    default:
+      throw new UnsupportedRendererError(String(mode));
+  }
+}
+
+// packages/cleo/src/cli/renderers/index.ts
+import {
+  renderAdd,
+  renderArchive,
+  renderComplete,
+  renderDelete,
+  renderFind,
+  renderList,
+  renderRestore,
+  renderShow,
+  renderUpdate
+} from "@cleocode/core/render/index";
+function generateRequestId() {
+  return randomUUID();
+}
+var renderers = {
+  // Task CRUD
+  show: renderShow,
+  list: renderList,
+  ls: renderList,
+  find: renderFind,
+  search: renderFind,
+  add: renderAdd,
+  update: renderUpdate,
+  complete: renderComplete,
+  done: renderComplete,
+  delete: renderDelete,
+  rm: renderDelete,
+  archive: renderArchive,
+  restore: renderRestore,
+  // Task work
+  start: renderStart,
+  stop: renderStop,
+  current: renderCurrent,
+  // System
+  doctor: renderDoctor,
+  stats: renderStats,
+  next: renderNext,
+  plan: renderPlan,
+  blockers: renderBlockers,
+  tree: renderTree,
+  depends: renderTree,
+  deps: renderTree,
+  // Orchestration — `cleo orchestrate waves` emits { waves, epicId, ... }
+  // which renderTree handles via its data.waves branch (T1194/T1195).
+  orchestrate: renderTree,
+  session: renderSession,
+  version: renderVersion,
+  // T1593 — `cleo briefing` reads tasks.db + brain.db (NEVER markdown handoffs).
+  briefing: renderBriefing,
+  // Brain subcommands (T1722)
+  "brain-maintenance": renderBrainMaintenance,
+  "brain-backfill": renderBrainBackfill,
+  "brain-purge": renderBrainPurge,
+  "brain-plasticity-stats": renderBrainPlasticityStats,
+  "brain-quality": renderBrainQuality,
+  "brain-export": renderBrainExport,
+  // Audit subcommand renderers (T1729)
+  "audit-reconstruct": renderAuditReconstruct,
+  // Schema command renderer (T1729)
+  schema: renderSchemaCommand,
+  // Nexus subcommand renderers (T1720)
+  "nexus-status": renderNexusStatus,
+  "nexus-setup": renderNexusSetup,
+  // System One (T12733): human blocks for config / status / ask / profiles.
+  "decide-config": renderDecideConfig,
+  "decide-status": renderDecideStatus,
+  "decide-ask": renderDecideAsk,
+  "decide-profiles": renderDecideProfiles,
+  "nexus-clusters": renderNexusClusters,
+  "nexus-flows": renderNexusFlows,
+  "nexus-context": renderNexusContextResult,
+  "nexus-impact": renderNexusImpact,
+  "nexus-analyze": renderNexusAnalyze,
+  "nexus-projects-list": renderNexusProjectsList,
+  "nexus-projects-register": renderNexusProjectsRegister,
+  "nexus-projects-remove": renderNexusProjectsRemove,
+  "nexus-projects-scan": renderNexusProjectsScan,
+  "nexus-projects-status": renderNexusProjectsStatus,
+  "nexus-projects-fleet": renderNexusProjectsFleet,
+  "nexus-projects-clean": renderNexusProjectsClean,
+  "nexus-projects-clean-preview": renderNexusProjectsCleanPreview,
+  "nexus-refresh-bridge": renderNexusRefreshBridge,
+  "nexus-diff": renderNexusDiff,
+  "nexus-query": renderNexusQuery,
+  "nexus-route-map": renderNexusRouteMap,
+  "nexus-shape-check": renderNexusShapeCheck,
+  "nexus-full-context": renderNexusFullContext,
+  "nexus-task-footprint": renderNexusTaskFootprint,
+  "nexus-brain-anchors": renderNexusBrainAnchors,
+  "nexus-why": renderNexusWhy,
+  "nexus-impact-full": renderNexusImpactFull,
+  "nexus-conduit-scan": renderNexusConduitScan,
+  "nexus-task-symbols": renderNexusTaskSymbols,
+  "nexus-search-code": renderNexusSearchCode,
+  "nexus-contracts-sync": renderNexusContractsSync,
+  "nexus-contracts-show": renderNexusContractsShow,
+  "nexus-contracts-link-tasks": renderNexusContractsLinkTasks,
+  "nexus-export": renderNexusExport,
+  "nexus-wiki": renderNexusWiki,
+  "nexus-hot-paths": renderNexusHotPaths,
+  "nexus-hot-nodes": renderNexusHotNodes,
+  "nexus-cold-symbols": renderNexusColdSymbols
+};
+function pickDecoratorMetaExtensionsLocal(responseMeta) {
+  if (!responseMeta) return {};
+  const out = {};
+  if (responseMeta["_nexus"] !== void 0) out["_nexus"] = responseMeta["_nexus"];
+  if (responseMeta["deprecated"] !== void 0) out["deprecated"] = responseMeta["deprecated"];
+  if (responseMeta.sessionId !== void 0) out["sessionId"] = responseMeta.sessionId;
+  if (responseMeta.originSessionId !== void 0) {
+    out["originSessionId"] = responseMeta.originSessionId;
+  }
+  if (responseMeta.executionSessionId !== void 0) {
+    out["executionSessionId"] = responseMeta.executionSessionId;
+  }
+  if (responseMeta["suggestedNext"] !== void 0) {
+    out["suggestedNext"] = responseMeta["suggestedNext"];
+  }
+  if (responseMeta["projection"] !== void 0) {
+    out["projection"] = responseMeta["projection"];
+  }
+  return out;
+}
+function buildEnvelopeForPointer(data, opts) {
+  const decoratorExt = pickDecoratorMetaExtensionsLocal(opts.responseMeta);
+  const meta = {
+    ...decoratorExt,
+    ...opts.extensions ?? {},
+    operation: opts.operation ?? "cli.output"
+  };
+  if (opts.message) meta["message"] = opts.message;
+  const envelope = {
+    success: true,
+    data,
+    meta
+  };
+  if (opts.page) envelope["page"] = opts.page;
+  return envelope;
+}
+function writeMachineOutput(text, emptyReason) {
+  if (text.length > 0) {
+    process.stdout.write(`${text}
+`);
+    return;
+  }
+  process.stderr.write(`No output (${emptyReason ?? "empty"}).
+`);
+}
+function cliOutput(data, opts) {
+  const ctx = getFormatContext();
+  const fieldCtx = getFieldContext();
+  const outputMode = getOutputMode();
+  const summary = getSummaryMode();
+  const matching = formatTaskMatching(data);
+  if (matching && (outputMode !== "envelope" || summary || fieldCtx.field || ctx.format === "human")) {
+    process.stderr.write(`${matching}
+`);
+  }
+  const population = formatTaskPopulation(data);
+  if (population && (outputMode !== "envelope" || summary || fieldCtx.field || ctx.format === "human")) {
+    process.stderr.write(`${population}
+`);
+  }
+  if (outputMode !== "envelope" && !fieldCtx.field) {
+    const out = renderOutputMode(outputMode, data);
+    if (out.refusal) {
+      cliError(
+        out.refusal.message,
+        2,
+        { name: out.refusal.code, fix: out.refusal.fix },
+        {
+          operation: opts.operation ?? opts.command
+        }
+      );
+      process.exit(2);
+    }
+    if (out.text !== null) {
+      writeMachineOutput(out.text, out.emptyReason);
+    }
+    if (outputMode === "id" || outputMode === "table") {
+      const facts = detectTruncation(data, opts.page);
+      if (facts)
+        process.stderr.write(
+          `${formatTruncationWarning(facts, outputMode, opts.enumerateAllFlag)}
+`
+        );
+    }
+    return;
+  }
+  if (summary && !fieldCtx.field) {
+    const out = renderSummary(data);
+    if (out.text !== null) {
+      writeMachineOutput(out.text, out.emptyReason);
+    }
+    const facts = detectTruncation(data, opts.page);
+    if (facts)
+      process.stderr.write(`${formatTruncationWarning(facts, "summary", opts.enumerateAllFlag)}
+`);
+    return;
+  }
+  if (fieldCtx.field && isJsonPointer(fieldCtx.field)) {
+    const envelope = buildEnvelopeForPointer(data, opts);
+    const value = extractByJsonPointer(envelope, fieldCtx.field);
+    if (value === void 0) {
+      const contract = opts.operation ? getOutputContract(opts.operation) : null;
+      const fix = contract ? `Valid pointers for ${opts.operation}: ${contract.fieldPointers.join(", ")}` + (contract.shapeNote ? ` \u2014 ${contract.shapeNote}` : "") : `Run: cleo ${opts.command} --describe`;
+      const alternatives = contract ? contract.fieldPointers.slice(0, 5).map((pointer) => ({
+        action: `extract ${pointer}`,
+        command: `cleo ${opts.command} --field ${pointer}`
+      })) : void 0;
+      if (opts.responseMeta?.gateway === "mutate") {
+        process.stderr.write(
+          `E_FIELD_NOT_FOUND: pointer "${fieldCtx.field}" did not resolve. The ${opts.operation ?? "operation"} itself SUCCEEDED \u2014 do not retry it. ${fix}
+`
+        );
+        return;
+      }
+      cliError(`Pointer "${fieldCtx.field}" did not resolve`, 4, {
+        name: "E_FIELD_NOT_FOUND",
+        fix,
+        alternatives
+      });
+      process.exit(4);
+    }
+    process.stdout.write(`${serializePointerValue(value)}
+`);
+    return;
+  }
+  if (ctx.format === "human") {
+    let dataToRender = data;
+    let fieldExtracted = false;
+    if (fieldCtx.field) {
+      const extracted = extractFieldFromResult(
+        data,
+        fieldCtx.field
+      );
+      if (extracted === void 0) {
+        cliError(`Field "${fieldCtx.field}" not found`, 4, { name: "E_NOT_FOUND" });
+        process.exit(4);
+      }
+      if (typeof extracted !== "object" || extracted === null) {
+        process.stdout.write(String(extracted) + "\n");
+        return;
+      }
+      if (Array.isArray(extracted)) {
+        dataToRender = { [fieldCtx.field]: extracted };
+      } else {
+        dataToRender = extracted;
+      }
+      fieldExtracted = true;
+    }
+    const normalized = normalizeForHuman(opts.command, dataToRender);
+    const renderer = fieldExtracted ? renderGeneric : renderers[opts.command] ?? renderGeneric;
+    const text = renderer(normalized, ctx.quiet);
+    if (text) {
+      process.stdout.write(text + "\n");
+    }
+    if (!ctx.quiet) {
+      const pagerData = data;
+      const pagerArrays = pagerData && typeof pagerData === "object" ? Object.values(pagerData).filter((v) => Array.isArray(v)) : [];
+      const shown = pagerArrays.reduce((max, arr) => Math.max(max, arr.length), 0);
+      if (shown > 0 && opts.page) {
+        const pager = pagerFooter({
+          shown,
+          page: opts.page,
+          total: pagerData?.["total"],
+          filtered: pagerData?.["filtered"]
+        });
+        if (pager) process.stdout.write(`${pager}
+`);
+      }
+      const combinedMeta = {
+        ...opts.responseMeta ?? {},
+        ...opts.extensions ?? {}
+      };
+      const footer = metaFooter(combinedMeta);
+      if (footer) process.stdout.write(`${footer}
+`);
+    }
+    return;
+  }
+  if (fieldCtx.field) {
+    const value = extractFieldFromResult(
+      data,
+      fieldCtx.field
+    );
+    if (value === void 0) {
+      cliError(`Field "${fieldCtx.field}" not found`, 4, { name: "E_NOT_FOUND" });
+      process.exit(4);
+    }
+    const out = value !== null && typeof value === "object" ? JSON.stringify(value) : String(value);
+    process.stdout.write(out + "\n");
+    return;
+  }
+  let filteredData = data;
+  if (fieldCtx.fields?.length && data !== void 0 && data !== null) {
+    try {
+      const stub = {
+        $schema: "https://lafs.dev/schemas/v1/envelope.schema.json",
+        _meta: {
+          specVersion: "",
+          schemaVersion: "",
+          timestamp: "",
+          operation: "",
+          requestId: "",
+          transport: "cli",
+          strict: false,
+          mvi: "standard",
+          contextVersion: 0
+        },
+        success: true,
+        result: data
+      };
+      const filtered = applyFieldFilter(
+        stub,
+        fieldCtx.fields
+      );
+      filteredData = filtered.result;
+    } catch {
+    }
+  }
+  const formatOpts = {};
+  if (opts.operation) formatOpts.operation = opts.operation;
+  if (opts.page) formatOpts.page = opts.page;
+  const decoratorExt = pickDecoratorMetaExtensionsLocal(opts.responseMeta);
+  const mergedExt = opts.extensions || Object.keys(decoratorExt).length > 0 ? { ...decoratorExt, ...opts.extensions ?? {} } : void 0;
+  if (mergedExt) formatOpts.extensions = mergedExt;
+  if (fieldCtx.mvi) formatOpts.mvi = fieldCtx.mvi;
+  const envelopeString = formatSuccess(
+    filteredData,
+    opts.message,
+    Object.keys(formatOpts).length > 0 ? formatOpts : opts.operation
+  );
+  if (process.env["CLEO_LAFS_VALIDATE"] !== "off") {
+    try {
+      const report = validateLafsShape(envelopeString);
+      if (report.reasons.length > 0) {
+        emitLafsViolation(
+          new LafsViolationError(`cliOutput: envelope failed LAFS shape validation`, report)
+        );
+      }
+    } catch (err) {
+      if (err instanceof LafsViolationError) {
+        emitLafsViolation(err);
+      }
+    }
+  }
+  process.stdout.write(envelopeString + "\n");
+}
+function humanEnabled() {
+  const ctx = getFormatContext();
+  return ctx.format === "human" && !ctx.quiet;
+}
+function humanInfo(message) {
+  if (!humanEnabled()) return;
+  process.stderr.write(`${message}
+`);
+}
+function humanWarn(message) {
+  if (!humanEnabled()) return;
+  process.stderr.write(`${message}
+`);
+}
+function humanLine(message) {
+  if (!humanEnabled()) return;
+  process.stdout.write(`${message}
+`);
+}
+function humanProgress(text) {
+  if (!humanEnabled() || !process.stdout.isTTY) return;
+  process.stdout.write(text);
+}
+function isHumanOutput() {
+  return humanEnabled();
+}
+function cliError(message, code, details, meta, options) {
+  const ctx = getFormatContext();
+  const outputMode = getOutputMode();
+  if (outputMode === "silent") {
+    process.stderr.write(`Error: ${message}${code ? ` (${code})` : ""}
+`);
+    return;
+  }
+  if (ctx.format === "human") {
+    process.stderr.write(`Error: ${message}${code ? ` (${code})` : ""}
+`);
+    if (typeof details?.fix === "string") {
+      process.stderr.write(`Fix: ${details.fix}
+`);
+    }
+    return;
+  }
+  const errorObj = {
+    code: code ?? 1,
+    message
+  };
+  if (details?.name !== void 0) errorObj["codeName"] = details.name;
+  if (details?.fix !== void 0) errorObj["fix"] = details.fix;
+  if (details?.alternatives !== void 0) errorObj["alternatives"] = details.alternatives;
+  if (details?.details !== void 0) errorObj["details"] = details.details;
+  const errorMeta = {
+    operation: meta?.operation ?? "cli.error",
+    requestId: meta?.requestId ?? generateRequestId(),
+    duration_ms: meta?.duration_ms ?? 0,
+    timestamp: meta?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+    ...meta
+  };
+  const drained = drainWarnings();
+  if (drained && drained.length > 0) {
+    const existing = errorMeta.warnings;
+    errorMeta.warnings = Array.isArray(existing) ? [...existing, ...drained] : drained;
+  }
+  const envelope = {
+    success: false,
+    error: errorObj,
+    meta: errorMeta
+  };
+  if (options?.stderr === true) {
+    process.stderr.write(`${JSON.stringify(envelope)}
+`);
+    return;
+  }
+  process.stdout.write(JSON.stringify(envelope) + "\n");
+}
+
+export {
+  renderWaves,
+  cliOutput,
+  humanInfo,
+  humanWarn,
+  humanLine,
+  humanProgress,
+  isHumanOutput,
+  cliError
+};
+//# sourceMappingURL=chunk-3ZO3M37V.js.map