akm-cli 0.9.0-rc.8 → 0.9.0

package/dist/output/text/command-format.js

@@ -1,30 +1,83 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * `akm info`'s real result (`InfoResponse`, `src/sources/types.ts`) carries
+ * `defaultBundle`/`assetTypes`/`searchModes`/`semanticSearch`/`registries`/
+ * `sourceProviders`/`indexStats` — this formatter used to check for
+ * `configPath`/`cacheDir`/`dbPath`/`capabilities`/`index` instead, none of
+ * which `InfoResponse` has ever had, so every one of those `if` guards was
+ * always false and those five real fields silently never appeared in
+ * `--format text` output (the plain fallthrough JSON check three lines below
+ * papered over it: `lines` was never empty because `version`/`bundleDir`
+ * always matched, so the "render everything" escape hatch never fired
+ * either — same class of bug as `akm health`/`akm lint`'s raw-JSON-array
+ * dump: `--format text` claiming to render a shape it wasn't actually
+ * rendering). The legacy field checks stay (harmless no-ops on the current
+ * shape) in case another producer still emits them; the real fields are
+ * added alongside.
+ */
 export function formatInfoPlain(r) {
     const lines = [];
     if (r.version)
         lines.push(`version: ${String(r.version)}`);
-    if (r.stashDir)
-        lines.push(`stashDir: ${String(r.stashDir)}`);
+    if (r.bundleDir)
+        lines.push(`bundleDir: ${String(r.bundleDir)}`);
+    if (r.defaultBundle !== undefined) {
+        lines.push(`defaultBundle: ${r.defaultBundle === null ? "(none)" : String(r.defaultBundle)}`);
+    }
     if (r.configPath)
         lines.push(`configPath: ${String(r.configPath)}`);
     if (r.cacheDir)
         lines.push(`cacheDir: ${String(r.cacheDir)}`);
     if (r.dbPath)
         lines.push(`dbPath: ${String(r.dbPath)}`);
+    if (Array.isArray(r.assetTypes) && r.assetTypes.length > 0) {
+        lines.push(`assetTypes: ${r.assetTypes.join(", ")}`);
+    }
+    if (Array.isArray(r.searchModes) && r.searchModes.length > 0) {
+        lines.push(`searchModes: ${r.searchModes.join(", ")}`);
+    }
+    const semanticSearch = r.semanticSearch;
+    if (semanticSearch) {
+        lines.push("semanticSearch:");
+        for (const [k, v] of Object.entries(semanticSearch)) {
+            lines.push(`  ${k}: ${String(v)}`);
+        }
+    }
+    const registries = Array.isArray(r.registries) ? r.registries : undefined;
+    if (registries) {
+        lines.push(`registries (${registries.length}):`);
+        for (const reg of registries) {
+            const name = typeof reg.name === "string" ? `${reg.name}: ` : "";
+            const provider = typeof reg.provider === "string" ? ` (${reg.provider})` : "";
+            const disabled = reg.enabled === false ? " [disabled]" : "";
+            lines.push(`  ${name}${String(reg.url ?? "?")}${provider}${disabled}`);
+        }
+    }
+    const sourceProviders = Array.isArray(r.sourceProviders)
+        ? r.sourceProviders
+        : undefined;
+    if (sourceProviders) {
+        lines.push(`sourceProviders (${sourceProviders.length}):`);
+        for (const source of sourceProviders) {
+            const label = source.name ?? source.path ?? source.url ?? source.type ?? "?";
+            const disabled = source.enabled === false ? " [disabled]" : "";
+            lines.push(`  [${String(source.type ?? "?")}] ${String(label)}${disabled}`);
+        }
+    }
     const capabilities = r.capabilities;
     if (capabilities) {
         lines.push("capabilities:");
         for (const [k, v] of Object.entries(capabilities)) {
-            lines.push(`  ${k}: ${typeof v === "object" ? JSON.stringify(v) : String(v)}`);
+            lines.push(`  ${k}: ${typeof v === "object" && v !== null ? JSON.stringify(v) : String(v)}`);
         }
     }
-    const indexStats = r.index;
+    const indexStats = (r.indexStats ?? r.index);
     if (indexStats) {
-        lines.push("index:");
+        lines.push("indexStats:");
         for (const [k, v] of Object.entries(indexStats)) {
-            lines.push(`  ${k}: ${typeof v === "object" ? JSON.stringify(v) : String(v)}`);
+            lines.push(`  ${k}: ${typeof v === "object" && v !== null ? JSON.stringify(v) : String(v)}`);
         }
     }
     if (lines.length === 0)
@@ -74,26 +127,20 @@ export function formatImportPlain(r) {
     const pathValue = String(r.path ?? "?");
     return `Imported ${source} → ${ref} at ${pathValue}`;
 }
-export function formatSavePlain(r) {
+export function formatSyncPlain(r) {
     if (r.ok === false) {
         const reason = typeof r.reason === "string" ? r.reason : "unknown";
-        return `save: failed (${reason})`;
+        return `sync: failed (${reason})`;
     }
-    const name = typeof r.name === "string" ? r.name : "primary stash";
+    const name = typeof r.name === "string" ? r.name : "primary bundle";
     const committed = r.committed === true;
     const pushed = r.pushed === true;
-    const parts = [`save: ${name}`];
+    const parts = [`sync: ${name}`];
     parts.push(committed ? "committed" : "no changes");
     if (pushed)
         parts.push("pushed");
     return parts.join(" — ");
 }
-export function formatToggleComponentPlain(command, r) {
-    const verb = command === "enable" ? "Enabled" : "Disabled";
-    const component = String(r.component ?? "?");
-    const changed = r.changed === true;
-    return changed ? `${verb} ${component}` : `${component} was already ${command}d`;
-}
 export function formatRegistryListPlain(r) {
     const registries = Array.isArray(r.registries) ? r.registries : [];
     if (registries.length === 0) {
@@ -129,12 +176,6 @@ export function formatRegistrySearchPlain(r, detail) {
     // Reuse the same renderer as `search` — both share `hits` / `registryHits`.
     return formatSearchPlain(r, detail);
 }
-export function formatRegistryBuildIndexPlain(r) {
-    const outPath = String(r.outPath ?? "?");
-    const total = typeof r.totalKits === "number" ? r.totalKits : 0;
-    const version = typeof r.version === "number" ? `v${r.version}` : "";
-    return `Wrote registry index ${version} (${total} kits) → ${outPath}`.replace(/\s+/g, " ").trim();
-}
 export function formatEnvListPlain(r) {
     // Multi-env listing: { envs: [{ ref, path, keys }, ...] }
     const envs = Array.isArray(r.envs) ? r.envs : [];
@@ -168,20 +209,6 @@ export function formatEnvRemovePlain(r) {
     const removed = r.removed === true;
     return removed ? `Removed env ${String(r.ref ?? "?")}` : `Env ${String(r.ref ?? "?")} was not present`;
 }
-export function formatEnvSetPlain(r) {
-    return `Set ${String(r.key ?? "?")} in env ${String(r.ref ?? "?")} (value not displayed)`;
-}
-export function formatEnvUnsetPlain(r) {
-    const removed = Array.isArray(r.removed) ? r.removed.map(String) : [];
-    const missing = Array.isArray(r.missing) ? r.missing.map(String) : [];
-    const ref = String(r.ref ?? "?");
-    const parts = [];
-    if (removed.length > 0)
-        parts.push(`Removed ${removed.join(", ")} from env ${ref}`);
-    if (missing.length > 0)
-        parts.push(`Not present in env ${ref}: ${missing.join(", ")}`);
-    return parts.join("\n") || `No keys changed in env ${ref}`;
-}
 export function formatEventsPlain(r) {
     const events = Array.isArray(r.events) ? r.events : [];
     const headerParts = [];
@@ -214,56 +241,18 @@ export function formatEventLine(event) {
     }
     return head;
 }
-export function formatHistoryPlain(r) {
-    const entries = Array.isArray(r.entries) ? r.entries : [];
-    const headerParts = [];
-    if (typeof r.ref === "string" && r.ref)
-        headerParts.push(`ref: ${r.ref}`);
-    if (typeof r.since === "string" && r.since)
-        headerParts.push(`since: ${r.since}`);
-    const totalCount = typeof r.totalCount === "number" ? r.totalCount : entries.length;
-    headerParts.push(`${totalCount} event(s)`);
-    // Show active event sources so operators know which streams were consulted.
-    if (Array.isArray(r.sources) && r.sources.length > 0) {
-        headerParts.push(`sources: ${r.sources.join(", ")}`);
-    }
-    const header = headerParts.join("  ");
-    if (entries.length === 0) {
-        const scope = typeof r.ref === "string" && r.ref ? ` for ${r.ref}` : "";
-        return `${header}\nNo history${scope}.`;
-    }
-    const lines = [header, ""];
-    for (const entry of entries) {
-        const created = String(entry.createdAt ?? "?");
-        const eventType = String(entry.eventType ?? "?");
-        const ref = entry.ref ? String(entry.ref) : null;
-        const signal = entry.signal ? String(entry.signal) : null;
-        const query = entry.query ? String(entry.query) : null;
-        const head = ref ? `${created}  [${eventType}] ${ref}` : `${created}  [${eventType}]`;
-        lines.push(head);
-        if (signal)
-            lines.push(`  signal: ${signal}`);
-        if (query)
-            lines.push(`  query: ${query}`);
-        if (entry.metadata != null && entry.metadata !== "") {
-            const meta = typeof entry.metadata === "string" ? entry.metadata : JSON.stringify(entry.metadata);
-            lines.push(`  metadata: ${meta}`);
-        }
-    }
-    return lines.join("\n").trimEnd();
-}
 export function formatSearchPlain(r, detail) {
     const hits = r.hits ?? [];
     const registryHits = r.registryHits ?? [];
     const allHits = [...hits, ...registryHits];
     if (allHits.length === 0) {
         const warnings = Array.isArray(r.warnings) ? r.warnings : [];
-        const hasSetupWarning = warnings.some((w) => String(w).toLowerCase().includes("no stash") || String(w).toLowerCase().includes("not configured"));
+        const hasSetupWarning = warnings.some((w) => String(w).toLowerCase().includes("no bundle") || String(w).toLowerCase().includes("not configured"));
         if (hasSetupWarning) {
-            return "No stash configured. Run `akm init` to create your working stash, then `akm index` to build the search index.";
+            return "No bundle configured. Run `akm bundle create` to create your working bundle, then `akm index` to build the search index.";
         }
         const base = r.tip ? String(r.tip) : "No matches found.";
-        return `${base}\nTry:\n  akm search '<broader-term>'          # fewer keywords\n  akm list                             # see all configured sources\n  akm curate '<query>'                 # let akm select the best match`;
+        return `${base}\nTry:\n  akm search '<broader-term>'          # fewer keywords\n  akm bundle list                      # see all configured sources\n  akm curate '<query>'                 # let akm select the best match`;
     }
     const lines = [];
     for (const hit of allHits) {
@@ -293,8 +282,7 @@ export function formatSearchPlain(r, detail) {
         // Optional v1 spec §4.2 quality marker (e.g. "curated" / "proposed").
         if (typeof hit.quality === "string" && hit.quality)
             lines.push(`  quality: ${hit.quality}`);
-        // Surface optional hit-level warnings (v1 spec §4.2). The legacy
-        // `curated` boolean was removed in v1.
+        // Surface optional hit-level warnings (v1 spec §4.2).
         if (Array.isArray(hit.warnings) && hit.warnings.length > 0) {
             lines.push(`  warnings: ${hit.warnings.join("; ")}`);
         }
@@ -354,12 +342,12 @@ export function formatSearchPlain(r, detail) {
             if (hasWorkflowHit) {
                 const workflowRef = hits.find((h) => h.type === "workflow");
                 const wfRef = workflowRef && typeof workflowRef.ref === "string" ? workflowRef.ref : topRef;
-                lines.push(`Next: akm show '${topRef}'  |  To start a workflow: akm workflow next '${wfRef}'`);
-                lines.push("After running workflow next: follow each step and run `akm workflow complete <run-id> --step <step-id>` when done.");
+                lines.push(`Next: akm show '${topRef}'  |  To execute a workflow: akm workflow run '${wfRef}'`);
+                lines.push("Inspect the workflow before running it; `workflow run` executes and verifies its steps automatically.");
             }
             else {
                 lines.push(`Next: akm show '${topRef}'`);
-                lines.push("After reading the asset: check whether a workflow applies before editing — if so, use `akm workflow next` instead.");
+                lines.push("After reading the asset: check whether a workflow applies before editing — if so, inspect it and use `akm workflow run`.");
             }
         }
     }
@@ -429,11 +417,11 @@ export function formatCuratePlain(r, detail) {
     return lines.join("\n");
 }
 export function formatInitPlain(r) {
-    let out = `Stash initialized at ${r.stashDir ?? "unknown"}`;
-    // When --dir scaffolded a secondary stash but the default was deliberately
+    let out = `Bundle initialized at ${r.bundleDir ?? "unknown"}`;
+    // When --dir scaffolded a secondary bundle but the default was deliberately
     // left untouched, tell the user instead of silently repointing their default.
-    if (r.defaultStashUpdated === false && typeof r.previousStashDir === "string" && r.previousStashDir) {
-        out += `\nYour default stash is unchanged (${r.previousStashDir}). Re-run with --set-default to make ${r.stashDir} the default.`;
+    if (r.defaultBundleUpdated === false && typeof r.previousBundleDir === "string" && r.previousBundleDir) {
+        out += `\nYour default bundle is unchanged (${r.previousBundleDir}). Re-run with --set-default to make ${r.bundleDir} the default.`;
     }
     else if (r.configPath) {
         out += `\nConfig saved to ${r.configPath}`;
@@ -471,7 +459,7 @@ export function formatIndexPlain(r) {
 export function formatListPlain(r) {
     const sources = Array.isArray(r.sources) ? r.sources : [];
     if (sources.length === 0)
-        return "No sources configured. Use `akm add` to add a source.";
+        return "No sources configured. Use `akm bundle add` to add a source.";
     const lines = [];
     for (const src of sources) {
         const kind = typeof src.kind === "string" ? src.kind : "unknown";
@@ -479,8 +467,8 @@ export function formatListPlain(r) {
         const ver = typeof src.version === "string" ? ` v${src.version}` : "";
         const prov = typeof src.provider === "string" ? ` (${src.provider})` : "";
         const flags = [];
-        if (src.updatable === true)
-            flags.push("updatable");
+        if (src.default === true)
+            flags.push("default");
         if (src.writable === true)
             flags.push("writable");
         const flagText = flags.length > 0 ? ` [${flags.join(", ")}]` : "";
@@ -490,7 +478,52 @@ export function formatListPlain(r) {
     lines.push("To search: akm search '<query>'  |  To view an asset: akm show <ref>");
     return lines.join("\n");
 }
+/** Render a single `SourceEntry` — `akm bundle show <name>`'s detail view of one `list` row. */
+export function formatBundleShowPlain(r) {
+    const name = typeof r.name === "string" ? r.name : "unknown";
+    const kind = typeof r.kind === "string" ? r.kind : "unknown";
+    const lines = [`${name} [${kind}]`];
+    if (r.default === true)
+        lines.push("  default: true");
+    if (r.writable === true)
+        lines.push("  writable: true");
+    if (typeof r.version === "string")
+        lines.push(`  version: ${r.version}`);
+    if (typeof r.provider === "string")
+        lines.push(`  provider: ${r.provider}`);
+    if (typeof r.path === "string")
+        lines.push(`  path: ${r.path}`);
+    if (typeof r.ref === "string")
+        lines.push(`  ref: ${r.ref}`);
+    if (typeof r.registryId === "string")
+        lines.push(`  registryId: ${r.registryId}`);
+    lines.push(`  items: ${typeof r.itemCount === "number" ? r.itemCount : 0}`);
+    const byType = r.byType;
+    if (byType && Object.keys(byType).length > 0) {
+        lines.push(`  byType: ${Object.entries(byType)
+            .map(([t, n]) => `${t}=${n}`)
+            .join(", ")}`);
+    }
+    const status = r.status;
+    if (status?.exists === false)
+        lines.push("  status: MISSING on disk");
+    return lines.join("\n");
+}
 export function formatAddPlain(r) {
+    // `akm bundle add <ref>` (source-add.ts `AddResponse`) and `akm bundle add
+    // <target> --provider <kind>` (source-manage.ts `SourceAddResult`) are
+    // genuinely different operations that happen to share the "add" command
+    // name: the former eagerly fetches and indexes content, the latter only
+    // writes a desired locator to config — nothing is synced until a later
+    // `akm bundle update`. Force-fitting the declarative shape's `added`/`entry`/`message`
+    // fields into the "Installed <ref> (N scanned...)" wording produced
+    // "Installed undefined (0 directories scanned...)" (R-014) because it
+    // implied a sync that never happened. `AddResponse` always carries an
+    // `index` block (even when zero entries were scanned); `SourceAddResult`
+    // never does — that is the reliable shape discriminator used below to
+    // render each honestly instead of unifying them.
+    if (!("index" in r))
+        return formatDeclarativeAddPlain(r);
     const index = r.index;
     const scanned = index?.directoriesScanned ?? 0;
     const total = index?.totalEntries ?? 0;
@@ -503,27 +536,62 @@ export function formatAddPlain(r) {
     }
     return lines.join("\n");
 }
+/** Render a `SourceAddResult` (declarative `--provider` add) — see {@link formatAddPlain}. */
+function formatDeclarativeAddPlain(r) {
+    if (r.added !== true) {
+        return typeof r.message === "string" ? r.message : "add: no changes";
+    }
+    const entry = r.entry;
+    const kind = typeof entry?.type === "string" ? entry.type : "source";
+    const name = (typeof entry?.name === "string" && entry.name) ||
+        (typeof entry?.path === "string" && entry.path) ||
+        (typeof entry?.url === "string" && entry.url) ||
+        "source";
+    // A filesystem bundle reflects files already on disk — nothing to fetch,
+    // just index it. Every other declarative kind (git/website/npm) is a
+    // locator only; its content is not materialized until `akm bundle update`.
+    if (kind === "filesystem") {
+        return `Added ${name} (filesystem) — run \`akm index\` to index it.`;
+    }
+    return `Added ${name} (${kind}) — not yet synced; run \`akm bundle update ${name}\` to fetch it.`;
+}
 export function formatRemovePlain(r) {
     const target = r.target ?? r.ref ?? "";
     const ok = r.ok !== false ? "OK" : "FAILED";
     return `remove: ${target} ${ok}`;
 }
 export function formatUpdatePlain(r) {
+    // R-015: `processed` alone conflated three cases into one empty array —
+    // a true no-op (--all with nothing configured), a source this call flatly
+    // never looked at (a plain source under --all), and a plain git/website
+    // source that WAS just synced successfully but has no `UpdateResultItem`
+    // shape to report (no version/lock to diff). All three rendered as the
+    // same misleading "nothing to update". `plainSynced` and `skipped` (see
+    // sources/types.ts) cover the other two so this can report accurately.
     const processed = r.processed;
-    if (!processed?.length)
-        return `update: nothing to update`;
-    const lines = processed.map((item) => {
+    const plainSynced = r.plainSynced;
+    const skipped = r.skipped;
+    const lines = [];
+    for (const item of processed ?? []) {
         const changed = item.changed;
         const installed = item.installed;
         const previous = item.previous;
         if (changed?.any) {
             const prev = previous?.resolvedVersion ?? "unknown";
             const next = installed?.resolvedVersion ?? "unknown";
-            return `update: ${item.id} v${prev} → v${next}`;
+            lines.push(`update: ${item.id} v${prev} → v${next}`);
         }
-        return `update: ${item.id} (unchanged)`;
-    });
-    return lines.join("\n");
+        else {
+            lines.push(`update: ${item.id} (unchanged)`);
+        }
+    }
+    for (const item of plainSynced ?? []) {
+        lines.push(`update: ${item.id} synced (${item.kind})`);
+    }
+    for (const item of skipped ?? []) {
+        lines.push(`update: ${item.id} skipped — ${item.reason}`);
+    }
+    return lines.length > 0 ? lines.join("\n") : `update: nothing to update`;
 }
 export function formatUpgradePlain(r) {
     if (r.upgraded === true) {

package/dist/output/text/env.js

@@ -2,12 +2,10 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 // Output text formatters for `akm env *` commands.
-import { formatEnvCreatePlain, formatEnvExportPlain, formatEnvListPlain, formatEnvRemovePlain, formatEnvSetPlain, formatEnvUnsetPlain, } from "./helpers.js";
+import { formatEnvCreatePlain, formatEnvExportPlain, formatEnvListPlain, formatEnvRemovePlain } from "./helpers.js";
 export const envFormatters = [
     { command: "env-list", handler: (r) => formatEnvListPlain(r) },
     { command: "env-create", handler: (r) => formatEnvCreatePlain(r) },
     { command: "env-export", handler: (r) => formatEnvExportPlain(r) },
     { command: "env-remove", handler: (r) => formatEnvRemovePlain(r) },
-    { command: "env-set", handler: (r) => formatEnvSetPlain(r) },
-    { command: "env-unset", handler: (r) => formatEnvUnsetPlain(r) },
 ];

package/dist/output/text/events.js

@@ -1,11 +1,12 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-// Output text formatters for `akm events list` / `akm events tail` (#204).
-// Both share a renderer; `events-tail` is also called per-event by the streaming
-// code path via `formatEventLine`.
+// Output text formatter for `akm log` (#204).
+//
+// R-060: renamed from `events-list` to `log-list` — see
+// src/output/shapes/events.ts for the full rationale.
+//
+// 0.9.0 CLI overhaul (S3): `log tail` (and its `log-tail` formatter entry)
+// was dropped along with the command.
 import { formatEventsPlain } from "./helpers.js";
-export const eventsFormatters = [
-    { command: "events-list", handler: (r) => formatEventsPlain(r) },
-    { command: "events-tail", handler: (r) => formatEventsPlain(r) },
-];
+export const eventsFormatters = [{ command: "log-list", handler: (r) => formatEventsPlain(r) }];

package/dist/output/text/health-format.js

@@ -0,0 +1,103 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { flattenForText } from "../generic-render.js";
+import { renderStatusEntries, summarizeCounts } from "./status-list.js";
+const STATUS_GLYPH = { fail: "✗", warn: "⚠", unknown: "?", pass: "✓" };
+const STATUS_RANK = { fail: 0, warn: 1, unknown: 2, pass: 3 };
+/** Worst-first, for both the section summary and (via `STATUS_RANK`) row order. */
+const STATUS_ORDER = ["fail", "warn", "unknown", "pass"];
+/** One evidence field per line, `key: value` — objects/arrays JSON-compact, matching `formatInfoPlain`'s nested-field convention. */
+function evidenceLines(evidence) {
+    if (!evidence)
+        return [];
+    return Object.entries(evidence).map(([key, value]) => `${key}: ${value !== null && typeof value === "object" ? JSON.stringify(value) : String(value)}`);
+}
+function checkStatusEntry(check, detail) {
+    const status = check.status ?? "unknown";
+    const meta = [check.kind, check.confidence].filter((v) => !!v).join(", ");
+    return {
+        severityRank: STATUS_RANK[status] ?? 9,
+        glyph: STATUS_GLYPH[status] ?? "?",
+        headline: `${check.name}  [${status}${meta ? `, ${meta}` : ""}]  ${check.message ?? ""}`.trimEnd(),
+        // Evidence is diagnostic detail, not the headline signal — gated behind
+        // --detail the same way `formatSearchPlain`/`formatCuratePlain` gate
+        // their own verbose fields (full path/editHint/whyMatched, "why" reasoning).
+        detailLines: detail === "brief" ? [] : evidenceLines(check.evidence),
+    };
+}
+/** Render one `hardChecks`/`advisories` section: a count summary header, then worst-first rows. */
+function renderCheckSection(title, checks, detail) {
+    if (checks.length === 0)
+        return [`${title}: (none)`];
+    const counts = {};
+    for (const check of checks) {
+        const status = check.status ?? "unknown";
+        counts[status] = (counts[status] ?? 0) + 1;
+    }
+    const summary = summarizeCounts(counts, STATUS_ORDER);
+    const header = `${title} (${checks.length}${summary ? ` — ${summary}` : ""})`;
+    return [header, ...renderStatusEntries(checks.map((check) => checkStatusEntry(check, detail)))];
+}
+function sessionAdvisoryEntry(advisory) {
+    const isFailure = advisory.isFailurePattern === true;
+    return {
+        severityRank: isFailure ? 0 : 1,
+        glyph: (isFailure ? STATUS_GLYPH.warn : STATUS_GLYPH.pass) ?? "?",
+        headline: `${advisory.topic ?? "?"}  (x${advisory.frequency ?? 0}, source: ${advisory.source ?? "?"})`,
+    };
+}
+function renderSessionLogAdvisories(advisories) {
+    if (advisories.length === 0)
+        return [];
+    return [`sessionLogAdvisories (${advisories.length})`, ...renderStatusEntries(advisories.map(sessionAdvisoryEntry))];
+}
+/** Fields already rendered explicitly above — everything else in `r` falls to the `flattenForText` sweep below. */
+const HANDLED_KEYS = new Set([
+    "ok",
+    "status",
+    "since",
+    "hardChecks",
+    "advisories",
+    "sessionLogAdvisories",
+    "shape",
+    "schemaVersion",
+]);
+export function formatHealthPlain(r, detail) {
+    if (r === null || typeof r !== "object")
+        return null;
+    const lines = [];
+    if (typeof r.ok === "boolean")
+        lines.push(`ok: ${r.ok}`);
+    if (typeof r.status === "string")
+        lines.push(`status: ${r.status}`);
+    if (typeof r.since === "string")
+        lines.push(`since: ${r.since}`);
+    const hardChecks = Array.isArray(r.hardChecks) ? r.hardChecks : [];
+    const advisories = Array.isArray(r.advisories) ? r.advisories : [];
+    const sessionLogAdvisories = Array.isArray(r.sessionLogAdvisories)
+        ? r.sessionLogAdvisories
+        : [];
+    lines.push("", ...renderCheckSection("hardChecks", hardChecks, detail));
+    lines.push("", ...renderCheckSection("advisories", advisories, detail));
+    const sessionLines = renderSessionLogAdvisories(sessionLogAdvisories);
+    if (sessionLines.length > 0)
+        lines.push("", ...sessionLines);
+    if (detail === "brief" &&
+        [...hardChecks, ...advisories].some((c) => c.evidence && Object.keys(c.evidence).length > 0)) {
+        lines.push("", "(evidence omitted at --detail brief; re-run with --detail normal or --detail full to see it)");
+    }
+    // Everything else (metrics, improve, and the optional runs/windows/deltas/
+    // report datasets) is a nested scalar tree, not the array-of-records shape
+    // this formatter exists to fix — keep the existing dotted-path convention
+    // for it rather than inventing a second one.
+    for (const [key, value] of Object.entries(r)) {
+        if (HANDLED_KEYS.has(key) || value === undefined)
+            continue;
+        const fieldLines = [];
+        flattenForText(value, key, fieldLines);
+        if (fieldLines.length > 0)
+            lines.push("", ...fieldLines);
+    }
+    return lines.join("\n").trim();
+}

package/dist/output/text/health.js

@@ -0,0 +1,7 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { formatHealthPlain } from "./helpers.js";
+export const healthFormatters = [
+    { command: "health", handler: (r, detail) => formatHealthPlain(r, detail) },
+];

package/dist/output/text/helpers.js

@@ -7,15 +7,17 @@
  *
  * This module is a re-export BARREL: the actual implementations live in
  * cohesive sibling modules (`show-format.ts`, `show-directives.ts`,
- * `workflow-format.ts`, `proposal-format.ts`, `command-format.ts`) split out
- * of what used to be a single 1418-line / 59-function file. Every name that
- * was previously importable from `"./helpers"` (directly, or transitively via
- * `../text.ts`) stays importable from here unchanged — no import site needed
- * to move.
+ * `workflow-format.ts`, `proposal-format.ts`, `command-format.ts`,
+ * `health-format.ts`, `lint-format.ts`) split out of what used to be a
+ * single 1418-line / 59-function file. Every name that was previously
+ * importable from `"./helpers"` (directly, or transitively via `../text.ts`)
+ * stays importable from here unchanged — no import site needed to move.
  *
  * No registry imports — no circular dependencies.
  */
-export { formatAddPlain, formatClonePlain, formatConfigPlain, formatCuratePlain, formatEnvCreatePlain, formatEnvExportPlain, formatEnvListPlain, formatEnvRemovePlain, formatEnvSetPlain, formatEnvUnsetPlain, formatEventLine, formatEventsPlain, formatFeedbackPlain, formatHistoryPlain, formatImportPlain, formatIndexPlain, formatInfoPlain, formatInitPlain, formatListPlain, formatRegistryAddPlain, formatRegistryBuildIndexPlain, formatRegistryListPlain, formatRegistryRemovePlain, formatRegistrySearchPlain, formatRememberPlain, formatRemovePlain, formatSavePlain, formatSearchPlain, formatToggleComponentPlain, formatUpdatePlain, formatUpgradePlain, } from "./command-format.js";
-export { formatDistillPlain, formatGateDecisionSummary, formatProposalAcceptPlain, formatProposalDiffPlain, formatProposalDrainPlain, formatProposalListPlain, formatProposalProducerPlain, formatProposalRejectPlain, formatProposalShowPlain, } from "./proposal-format.js";
+export { formatAddPlain, formatBundleShowPlain, formatClonePlain, formatConfigPlain, formatCuratePlain, formatEnvCreatePlain, formatEnvExportPlain, formatEnvListPlain, formatEnvRemovePlain, formatEventLine, formatEventsPlain, formatFeedbackPlain, formatImportPlain, formatIndexPlain, formatInfoPlain, formatInitPlain, formatListPlain, formatRegistryAddPlain, formatRegistryListPlain, formatRegistryRemovePlain, formatRegistrySearchPlain, formatRememberPlain, formatRemovePlain, formatSearchPlain, formatSyncPlain, formatUpdatePlain, formatUpgradePlain, } from "./command-format.js";
+export { formatHealthPlain } from "./health-format.js";
+export { formatLintPlain } from "./lint-format.js";
+export { formatGateDecisionSummary, formatProposalAcceptPlain, formatProposalDiffPlain, formatProposalDrainPlain, formatProposalListPlain, formatProposalProducerPlain, formatProposalRejectPlain, formatProposalShowPlain, } from "./proposal-format.js";
 export { formatShowPlain } from "./show-format.js";
-export { formatWorkflowBriefPlain, formatWorkflowCompleteRejectedPlain, formatWorkflowCreatePlain, formatWorkflowListPlain, formatWorkflowNextPlain, formatWorkflowResumePlain, formatWorkflowRunPlain, formatWorkflowStatusPlain, formatWorkflowValidatePlain, } from "./workflow-format.js";
+export { formatWorkflowCreatePlain, formatWorkflowListPlain, formatWorkflowResumePlain, formatWorkflowRunPlain, formatWorkflowStatusPlain, } from "./workflow-format.js";

package/dist/output/text/lint-format.js

@@ -0,0 +1,43 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { renderStatusEntries } from "./status-list.js";
+/**
+ * `fixed === true` succeeded; `"failed"` is an attempted-and-failed fix (worse
+ * than an unfixed, merely-flagged issue, which in turn is worse than a clean
+ * success). `severityRank` ascends from most urgent — see
+ * {@link renderStatusEntries} — so the three states must get three DISTINCT
+ * ranks or a failed fix can sort behind a successful one in the same section.
+ */
+function glyphFor(fixed) {
+    if (fixed === "failed")
+        return { glyph: "✗", severityRank: 0 };
+    if (fixed === true)
+        return { glyph: "✓", severityRank: 2 };
+    return { glyph: "⚠", severityRank: 1 };
+}
+function issueEntry(issue) {
+    const { glyph, severityRank } = glyphFor(issue.fixed);
+    return { severityRank, glyph, headline: `${issue.file}  [${issue.issue}]  ${issue.detail}` };
+}
+function renderIssueSection(title, issues) {
+    if (issues.length === 0)
+        return [`${title}: (none)`];
+    return [`${title} (${issues.length})`, ...renderStatusEntries(issues.map(issueEntry))];
+}
+export function formatLintPlain(r) {
+    if (r === null || typeof r !== "object")
+        return null;
+    const fixed = Array.isArray(r.fixed) ? r.fixed : [];
+    const flagged = Array.isArray(r.flagged) ? r.flagged : [];
+    const summary = r.summary;
+    const lines = [];
+    if (typeof r.ok === "boolean")
+        lines.push(`ok: ${r.ok}`);
+    lines.push(`summary: fixed=${summary?.fixed ?? fixed.length} flagged=${summary?.flagged ?? flagged.length}`);
+    // Flagged (still needs attention) surfaces before fixed (already handled)
+    // so a scan of the output hits the actionable items first.
+    lines.push("", ...renderIssueSection("flagged", flagged));
+    lines.push("", ...renderIssueSection("fixed", fixed));
+    return lines.join("\n").trim();
+}

package/dist/output/text/{save.js → lint.js}

@@ -1,5 +1,5 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-import { formatSavePlain } from "./helpers.js";
-export const saveFormatters = [{ command: "save", handler: (r) => formatSavePlain(r) }];
+import { formatLintPlain } from "./helpers.js";
+export const lintFormatters = [{ command: "lint", handler: (r) => formatLintPlain(r) }];