akm-cli 0.8.6 → 0.8.14

package/dist/output/text/helpers.js

@@ -135,29 +135,6 @@ export function formatRegistryBuildIndexPlain(r) {
     const version = typeof r.version === "number" ? `v${r.version}` : "";
     return `Wrote registry index ${version} (${total} kits) → ${outPath}`.replace(/\s+/g, " ").trim();
 }
-export function formatVaultListPlain(r) {
-    // Multi-vault listing: { vaults: [{ ref, path, keys }, ...] }
-    const vaults = Array.isArray(r.vaults) ? r.vaults : [];
-    if (vaults.length === 0) {
-        return "No vaults. Create one with `akm vault create <name>` then `akm vault set vault:<name> KEY=VALUE`.";
-    }
-    const lines = [];
-    for (const v of vaults) {
-        const ref = String(v.ref ?? "?");
-        const keys = Array.isArray(v.keys) ? v.keys.map(String) : [];
-        if (lines.length > 0)
-            lines.push("");
-        lines.push(`## ${ref}`);
-        if (keys.length === 0) {
-            lines.push("- (no keys)");
-            continue;
-        }
-        for (const key of keys) {
-            lines.push(`- ${key}`);
-        }
-    }
-    return lines.join("\n");
-}
 export function formatEnvListPlain(r) {
     // Multi-env listing: { envs: [{ ref, path, keys }, ...] }
     const envs = Array.isArray(r.envs) ? r.envs : [];
@@ -191,6 +168,20 @@ 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 formatWikiRegisterPlain(r) {
     const name = String(r.name ?? r.wiki ?? "?");
     const ref = String(r.ref ?? r.path ?? r.url ?? "?");
@@ -205,6 +196,25 @@ export function formatWorkflowValidatePlain(r) {
     const stepCount = typeof r.stepCount === "number" ? r.stepCount : 0;
     return `workflow validate: ok — ${title || pathValue} (${stepCount} step(s))`;
 }
+/**
+ * Plain-text rendering for a step-completion that was rejected by the
+ * summary-validation gate (#506): the step stays pending and the agent gets
+ * corrective feedback on what to finish/fix.
+ */
+export function formatWorkflowCompleteRejectedPlain(r) {
+    const stepId = String(r.stepId ?? "?");
+    const feedback = typeof r.feedback === "string" ? r.feedback : "";
+    const missing = Array.isArray(r.missing) ? r.missing.map((m) => String(m)) : [];
+    const lines = [`workflow complete: rejected — step "${stepId}" does not meet its completion criteria`];
+    if (feedback)
+        lines.push(`  feedback: ${feedback}`);
+    if (missing.length > 0) {
+        lines.push("  outstanding:");
+        for (const m of missing)
+            lines.push(`    - ${m}`);
+    }
+    return lines.join("\n");
+}
 export function formatProposalProducerPlain(command, r) {
     if (r.ok === false) {
         const reason = String(r.reason ?? "unknown");
@@ -225,6 +235,50 @@ export function formatProposalProducerPlain(command, r) {
     const status = String(proposal.status ?? "pending");
     return `${command}: queued proposal ${id} (${ref}) [${status}]`;
 }
+/**
+ * Render a one-line gate-decision summary for the proposal list / show surfaces
+ * (#577), e.g. `gate=deferred:below-threshold (0.72 < 0.90)`. Returns the empty
+ * string for a missing or malformed decision so legacy proposals render cleanly.
+ */
+export function formatGateDecisionSummary(raw) {
+    if (typeof raw !== "object" || raw === null)
+        return "";
+    const d = raw;
+    const outcome = typeof d.outcome === "string" ? d.outcome : undefined;
+    if (!outcome)
+        return "";
+    const reason = typeof d.reason === "string" && d.reason.length > 0 ? `:${d.reason}` : "";
+    const cmp = formatGateThresholdComparison(d);
+    return `gate=${outcome}${reason}${cmp ? ` (${cmp})` : ""}`;
+}
+/**
+ * Reconstruct the threshold comparison the gate applied, when both sides are
+ * present (e.g. confidence 0.72 vs. autoAccept 0.90 → "0.72 < 0.90"). Returns
+ * the empty string when the decision lacks the operands.
+ */
+function formatGateThresholdComparison(d) {
+    const thresholds = (typeof d.thresholds === "object" && d.thresholds !== null ? d.thresholds : {});
+    const confidence = typeof d.confidence === "number" ? d.confidence : undefined;
+    const autoAccept = typeof thresholds.autoAccept === "number" ? thresholds.autoAccept : undefined;
+    if (confidence !== undefined && autoAccept !== undefined) {
+        const op = confidence >= autoAccept ? ">=" : "<";
+        return `${confidence.toFixed(2)} ${op} ${autoAccept.toFixed(2)}`;
+    }
+    // Drain bands: when the measured value is present, render the full comparison
+    // ("210 > 200" / "1 < 5"); otherwise fall back to the bound alone (#577).
+    const measured = typeof d.measured === "number" ? d.measured : undefined;
+    if (typeof thresholds.maxDiffLines === "number") {
+        return measured !== undefined
+            ? `${measured} > ${thresholds.maxDiffLines}`
+            : `maxDiffLines=${thresholds.maxDiffLines}`;
+    }
+    if (typeof thresholds.minContentLines === "number") {
+        return measured !== undefined
+            ? `${measured} < ${thresholds.minContentLines}`
+            : `minContentLines=${thresholds.minContentLines}`;
+    }
+    return "";
+}
 export function formatProposalListPlain(r) {
     const proposals = Array.isArray(r.proposals) ? r.proposals : [];
     const total = typeof r.totalCount === "number" ? r.totalCount : proposals.length;
@@ -238,7 +292,11 @@ export function formatProposalListPlain(r) {
         const status = String(p.status ?? "?");
         const source = String(p.source ?? "?");
         const created = String(p.createdAt ?? "?");
-        lines.push(`${id}  [${status}] ${ref}  source=${source}  ${created}`);
+        // #577: surface the gate verdict inline so the queue explains itself
+        // ("deferred: below-threshold"). Legacy proposals carry no gateDecision.
+        const gate = formatGateDecisionSummary(p.gateDecision);
+        const gateSuffix = gate ? `  ${gate}` : "";
+        lines.push(`${id}  [${status}] ${ref}  source=${source}  ${created}${gateSuffix}`);
     }
     return lines.join("\n").trimEnd();
 }
@@ -255,6 +313,26 @@ export function formatProposalShowPlain(r) {
         lines.push(`createdAt: ${String(p.createdAt)}`);
     if (p.updatedAt)
         lines.push(`updatedAt: ${String(p.updatedAt)}`);
+    if (typeof p.confidence === "number")
+        lines.push(`confidence: ${p.confidence.toFixed(2)}`);
+    // #577: gate decision (auto-accepted / deferred / auto-rejected + reason +
+    // thresholds). Absent on legacy proposals — render "unknown" so the field is
+    // always present and the operator never sees a silent gap.
+    const gate = p.gateDecision;
+    if (gate && typeof gate.outcome === "string") {
+        lines.push(`gate.decision: ${String(gate.outcome)}`);
+        lines.push(`gate.reason: ${gate.reason ? String(gate.reason) : "unknown"}`);
+        const cmp = formatGateThresholdComparison(gate);
+        if (cmp)
+            lines.push(`gate.thresholds: ${cmp}`);
+        if (gate.gate)
+            lines.push(`gate.by: ${String(gate.gate)}`);
+        if (gate.decidedAt)
+            lines.push(`gate.decidedAt: ${String(gate.decidedAt)}`);
+    }
+    else {
+        lines.push("gate.decision: unknown");
+    }
     const review = p.review;
     if (review) {
         lines.push(`review.outcome: ${String(review.outcome ?? "?")}`);
@@ -265,12 +343,29 @@ export function formatProposalShowPlain(r) {
     }
     const validation = r.validation;
     if (validation) {
-        const ok = validation.ok === true;
         const findings = Array.isArray(validation.findings) ? validation.findings : [];
+        // Partition findings by severity. `severity: "warn"` findings are
+        // non-blocking (the validator reports `ok: true` for a warn-only proposal),
+        // so they must read as advisory — a distinct icon/label from blocking errors.
+        const warnings = findings.filter((f) => f.severity === "warn");
+        const errors = findings.filter((f) => f.severity !== "warn");
         lines.push("");
-        lines.push(`validation: ${ok ? "ok" : `${findings.length} finding(s)`}`);
-        for (const f of findings) {
-            lines.push(`  - [${String(f.kind)}] ${String(f.message)}`);
+        if (errors.length > 0) {
+            const warnSuffix = warnings.length > 0 ? `, ${warnings.length} warning(s)` : "";
+            lines.push(`✗ invalid (${errors.length} error(s)${warnSuffix})`);
+        }
+        else if (warnings.length > 0) {
+            lines.push(`✓ valid (${warnings.length} warning(s))`);
+        }
+        else {
+            lines.push("✓ valid");
+        }
+        // Errors first (blocking), then warnings (advisory, non-blocking).
+        for (const f of errors) {
+            lines.push(`  ✗ error  [${String(f.kind)}] ${String(f.message)}`);
+        }
+        for (const f of warnings) {
+            lines.push(`  ⚠ warning  [${String(f.kind)}] ${String(f.message)} (non-blocking)`);
         }
     }
     const payload = p.payload;
@@ -1035,18 +1130,6 @@ export function formatWorkflowCreatePlain(r) {
     }
     return null;
 }
-export function formatVaultCreatePlain(r) {
-    return `Created vault ${String(r.ref ?? "?")} at ${String(r.path ?? "?")}`;
-}
-export function formatVaultSetPlain(r) {
-    return `Set ${String(r.key ?? "?")} in ${String(r.ref ?? "?")} (value not displayed)`;
-}
-export function formatVaultUnsetPlain(r) {
-    const removed = r.removed === true;
-    return removed
-        ? `Removed ${String(r.key ?? "?")} from ${String(r.ref ?? "?")}`
-        : `Key ${String(r.key ?? "?")} was not present in ${String(r.ref ?? "?")}`;
-}
 export function formatWorkflowResumePlain(r) {
     return formatWorkflowStatusPlain(r) ?? `Resumed workflow run ${String(r.id ?? r.runId ?? "?")}`;
 }

package/dist/output/text/history.js

@@ -2,6 +2,5 @@
 // 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 formatter for `akm history` — paired with the shape in shapes/history.ts.
-import { formatHistoryPlain } from "./helpers";
-import { registerTextFormatter } from "./registry";
-registerTextFormatter("history", (r) => formatHistoryPlain(r));
+import { formatHistoryPlain } from "./helpers.js";
+export const historyFormatters = [{ command: "history", handler: (r) => formatHistoryPlain(r) }];

package/dist/output/text/import.js

@@ -1,6 +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 { formatImportPlain } from "./helpers";
-import { registerTextFormatter } from "./registry";
-registerTextFormatter("import", (r) => formatImportPlain(r));
+import { formatImportPlain } from "./helpers.js";
+export const importFormatters = [{ command: "import", handler: (r) => formatImportPlain(r) }];

package/dist/output/text/index.js

@@ -1,6 +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 { formatIndexPlain } from "./helpers";
-import { registerTextFormatter } from "./registry";
-registerTextFormatter("index", (r) => formatIndexPlain(r));
+import { formatIndexPlain } from "./helpers.js";
+export const indexFormatters = [{ command: "index", handler: (r) => formatIndexPlain(r) }];

package/dist/output/text/info.js

@@ -1,6 +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 { formatInfoPlain } from "./helpers";
-import { registerTextFormatter } from "./registry";
-registerTextFormatter("info", (r) => formatInfoPlain(r));
+import { formatInfoPlain } from "./helpers.js";
+export const infoFormatters = [{ command: "info", handler: (r) => formatInfoPlain(r) }];

package/dist/output/text/init.js

@@ -1,6 +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 { formatInitPlain } from "./helpers";
-import { registerTextFormatter } from "./registry";
-registerTextFormatter("init", (r) => formatInitPlain(r));
+import { formatInitPlain } from "./helpers.js";
+export const initFormatters = [{ command: "init", handler: (r) => formatInitPlain(r) }];

package/dist/output/text/list.js

@@ -1,6 +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 { formatListPlain } from "./helpers";
-import { registerTextFormatter } from "./registry";
-registerTextFormatter("list", (r) => formatListPlain(r));
+import { formatListPlain } from "./helpers.js";
+export const listFormatters = [{ command: "list", handler: (r) => formatListPlain(r) }];

package/dist/output/text/proposal/producer.js

@@ -0,0 +1,9 @@
+// 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 reflect` / `akm propose` (#226).
+import { formatProposalProducerPlain } from "../helpers.js";
+export const proposalProducerFormatters = [
+    { command: "reflect", handler: (r) => formatProposalProducerPlain("reflect", r) },
+    { command: "propose", handler: (r) => formatProposalProducerPlain("propose", r) },
+];

package/dist/output/text/proposal/proposal.js

@@ -0,0 +1,13 @@
+// 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 proposal *` (#225).
+import { formatProposalAcceptPlain, formatProposalDiffPlain, formatProposalDrainPlain, formatProposalListPlain, formatProposalRejectPlain, formatProposalShowPlain, } from "../helpers.js";
+export const proposalFormatters = [
+    { command: "proposal-list", handler: (r) => formatProposalListPlain(r) },
+    { command: "proposal-show", handler: (r) => formatProposalShowPlain(r) },
+    { command: "proposal-accept", handler: (r) => formatProposalAcceptPlain(r) },
+    { command: "proposal-reject", handler: (r) => formatProposalRejectPlain(r) },
+    { command: "proposal-diff", handler: (r) => formatProposalDiffPlain(r) },
+    { command: "proposal-drain", handler: (r) => formatProposalDrainPlain(r) },
+];

package/dist/output/text/registry-commands.js

@@ -2,10 +2,11 @@
 // 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 registry *` commands.
-import { formatRegistryAddPlain, formatRegistryBuildIndexPlain, formatRegistryListPlain, formatRegistryRemovePlain, formatRegistrySearchPlain, } from "./helpers";
-import { registerTextFormatter } from "./registry";
-registerTextFormatter("registry-list", (r) => formatRegistryListPlain(r));
-registerTextFormatter("registry-add", (r) => formatRegistryAddPlain(r));
-registerTextFormatter("registry-remove", (r) => formatRegistryRemovePlain(r));
-registerTextFormatter("registry-search", (r, detail) => formatRegistrySearchPlain(r, detail));
-registerTextFormatter("registry-build-index", (r) => formatRegistryBuildIndexPlain(r));
+import { formatRegistryAddPlain, formatRegistryBuildIndexPlain, formatRegistryListPlain, formatRegistryRemovePlain, formatRegistrySearchPlain, } from "./helpers.js";
+export const registryCommandFormatters = [
+    { command: "registry-list", handler: (r) => formatRegistryListPlain(r) },
+    { command: "registry-add", handler: (r) => formatRegistryAddPlain(r) },
+    { command: "registry-remove", handler: (r) => formatRegistryRemovePlain(r) },
+    { command: "registry-search", handler: (r, detail) => formatRegistrySearchPlain(r, detail) },
+    { command: "registry-build-index", handler: (r) => formatRegistryBuildIndexPlain(r) },
+];

package/dist/output/text/registry.js

@@ -15,6 +15,18 @@ const TEXT_FORMATTER_REGISTRY = new Map();
 export function registerTextFormatter(command, handler) {
     TEXT_FORMATTER_REGISTRY.set(command, handler);
 }
+/**
+ * Register a batch of {@link TextFormatterEntry} definitions in iteration order.
+ *
+ * This is the explicit-assembly entry point used by `text.ts`: the built-in
+ * formatter set is registered by iterating a single explicit list exactly once,
+ * with no reliance on module import order.
+ */
+export function registerTextFormatters(entries) {
+    for (const { command, handler } of entries) {
+        TEXT_FORMATTER_REGISTRY.set(command, handler);
+    }
+}
 /**
  * Remove a previously-registered text formatter. Test-only utility.
  */

package/dist/output/text/remember.js

@@ -1,6 +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 { formatRememberPlain } from "./helpers";
-import { registerTextFormatter } from "./registry";
-registerTextFormatter("remember", (r) => formatRememberPlain(r));
+import { formatRememberPlain } from "./helpers.js";
+export const rememberFormatters = [
+    { command: "remember", handler: (r) => formatRememberPlain(r) },
+];

package/dist/output/text/remove.js

@@ -1,6 +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 { formatRemovePlain } from "./helpers";
-import { registerTextFormatter } from "./registry";
-registerTextFormatter("remove", (r) => formatRemovePlain(r));
+import { formatRemovePlain } from "./helpers.js";
+export const removeFormatters = [{ command: "remove", handler: (r) => formatRemovePlain(r) }];

package/dist/output/text/save.js

@@ -1,6 +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";
-import { registerTextFormatter } from "./registry";
-registerTextFormatter("save", (r) => formatSavePlain(r));
+import { formatSavePlain } from "./helpers.js";
+export const saveFormatters = [{ command: "save", handler: (r) => formatSavePlain(r) }];

package/dist/output/text/search.js

@@ -1,6 +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 { formatSearchPlain } from "./helpers";
-import { registerTextFormatter } from "./registry";
-registerTextFormatter("search", (r, detail) => formatSearchPlain(r, detail));
+import { formatSearchPlain } from "./helpers.js";
+export const searchFormatters = [
+    { command: "search", handler: (r, detail) => formatSearchPlain(r, detail) },
+];

package/dist/output/text/show.js

@@ -1,6 +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 { formatShowPlain } from "./helpers";
-import { registerTextFormatter } from "./registry";
-registerTextFormatter("show", (r, detail) => formatShowPlain(r, detail));
+import { formatShowPlain } from "./helpers.js";
+export const showFormatters = [
+    { command: "show", handler: (r, detail) => formatShowPlain(r, detail) },
+];

package/dist/output/text/update.js

@@ -1,6 +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 { formatUpdatePlain } from "./helpers";
-import { registerTextFormatter } from "./registry";
-registerTextFormatter("update", (r) => formatUpdatePlain(r));
+import { formatUpdatePlain } from "./helpers.js";
+export const updateFormatters = [{ command: "update", handler: (r) => formatUpdatePlain(r) }];

package/dist/output/text/upgrade.js

@@ -1,6 +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 { formatUpgradePlain } from "./helpers";
-import { registerTextFormatter } from "./registry";
-registerTextFormatter("upgrade", (r) => formatUpgradePlain(r));
+import { formatUpgradePlain } from "./helpers.js";
+export const upgradeFormatters = [{ command: "upgrade", handler: (r) => formatUpgradePlain(r) }];

package/dist/output/text/wiki.js

@@ -2,14 +2,15 @@
 // 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 all `akm wiki *` commands.
-import { formatWikiCreatePlain, formatWikiIngestPlain, formatWikiLintPlain, formatWikiListPlain, formatWikiPagesPlain, formatWikiRegisterPlain, formatWikiRemovePlain, formatWikiShowPlain, formatWikiStashPlain, } from "./helpers";
-import { registerTextFormatter } from "./registry";
-registerTextFormatter("wiki-list", (r) => formatWikiListPlain(r));
-registerTextFormatter("wiki-show", (r) => formatWikiShowPlain(r));
-registerTextFormatter("wiki-create", (r) => formatWikiCreatePlain(r));
-registerTextFormatter("wiki-remove", (r) => formatWikiRemovePlain(r));
-registerTextFormatter("wiki-pages", (r) => formatWikiPagesPlain(r));
-registerTextFormatter("wiki-stash", (r) => formatWikiStashPlain(r));
-registerTextFormatter("wiki-lint", (r) => formatWikiLintPlain(r));
-registerTextFormatter("wiki-ingest", (r) => formatWikiIngestPlain(r));
-registerTextFormatter("wiki-register", (r) => formatWikiRegisterPlain(r));
+import { formatWikiCreatePlain, formatWikiIngestPlain, formatWikiLintPlain, formatWikiListPlain, formatWikiPagesPlain, formatWikiRegisterPlain, formatWikiRemovePlain, formatWikiShowPlain, formatWikiStashPlain, } from "./helpers.js";
+export const wikiFormatters = [
+    { command: "wiki-list", handler: (r) => formatWikiListPlain(r) },
+    { command: "wiki-show", handler: (r) => formatWikiShowPlain(r) },
+    { command: "wiki-create", handler: (r) => formatWikiCreatePlain(r) },
+    { command: "wiki-remove", handler: (r) => formatWikiRemovePlain(r) },
+    { command: "wiki-pages", handler: (r) => formatWikiPagesPlain(r) },
+    { command: "wiki-stash", handler: (r) => formatWikiStashPlain(r) },
+    { command: "wiki-lint", handler: (r) => formatWikiLintPlain(r) },
+    { command: "wiki-ingest", handler: (r) => formatWikiIngestPlain(r) },
+    { command: "wiki-register", handler: (r) => formatWikiRegisterPlain(r) },
+];

package/dist/output/text/workflow.js

@@ -2,13 +2,15 @@
 // 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 all `akm workflow *` commands.
-import { formatWorkflowCreatePlain, formatWorkflowListPlain, formatWorkflowNextPlain, formatWorkflowResumePlain, formatWorkflowStatusPlain, formatWorkflowValidatePlain, } from "./helpers";
-import { registerTextFormatter } from "./registry";
-registerTextFormatter("workflow-start", (r) => formatWorkflowStatusPlain(r));
-registerTextFormatter("workflow-status", (r) => formatWorkflowStatusPlain(r));
-registerTextFormatter("workflow-complete", (r) => formatWorkflowStatusPlain(r));
-registerTextFormatter("workflow-next", (r) => formatWorkflowNextPlain(r));
-registerTextFormatter("workflow-list", (r) => formatWorkflowListPlain(r));
-registerTextFormatter("workflow-create", (r) => formatWorkflowCreatePlain(r));
-registerTextFormatter("workflow-validate", (r) => formatWorkflowValidatePlain(r));
-registerTextFormatter("workflow-resume", (r) => formatWorkflowResumePlain(r));
+import { formatWorkflowCompleteRejectedPlain, formatWorkflowCreatePlain, formatWorkflowListPlain, formatWorkflowNextPlain, formatWorkflowResumePlain, formatWorkflowStatusPlain, formatWorkflowValidatePlain, } from "./helpers.js";
+export const workflowFormatters = [
+    { command: "workflow-start", handler: (r) => formatWorkflowStatusPlain(r) },
+    { command: "workflow-status", handler: (r) => formatWorkflowStatusPlain(r) },
+    { command: "workflow-complete", handler: (r) => formatWorkflowStatusPlain(r) },
+    { command: "workflow-complete-rejected", handler: (r) => formatWorkflowCompleteRejectedPlain(r) },
+    { command: "workflow-next", handler: (r) => formatWorkflowNextPlain(r) },
+    { command: "workflow-list", handler: (r) => formatWorkflowListPlain(r) },
+    { command: "workflow-create", handler: (r) => formatWorkflowCreatePlain(r) },
+    { command: "workflow-validate", handler: (r) => formatWorkflowValidatePlain(r) },
+    { command: "workflow-resume", handler: (r) => formatWorkflowResumePlain(r) },
+];

package/dist/output/text.js

@@ -1,41 +1,75 @@
 // 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 { getTextFormatterHandler } from "./text/registry";
+import { addFormatters } from "./text/add.js";
+import { cloneFormatters } from "./text/clone.js";
+import { configFormatters } from "./text/config.js";
+import { curateFormatters } from "./text/curate.js";
+import { distillFormatters } from "./text/distill.js";
+import { enableDisableFormatters } from "./text/enable-disable.js";
+import { envFormatters } from "./text/env.js";
+import { eventsFormatters } from "./text/events.js";
+import { feedbackFormatters } from "./text/feedback.js";
+import { historyFormatters } from "./text/history.js";
+import { importFormatters } from "./text/import.js";
+import { indexFormatters } from "./text/index.js";
+import { infoFormatters } from "./text/info.js";
+import { initFormatters } from "./text/init.js";
+import { listFormatters } from "./text/list.js";
+import { proposalProducerFormatters } from "./text/proposal/producer.js";
+import { proposalFormatters } from "./text/proposal/proposal.js";
+import { getTextFormatterHandler, registerTextFormatters } from "./text/registry.js";
+import { registryCommandFormatters } from "./text/registry-commands.js";
+import { rememberFormatters } from "./text/remember.js";
+import { removeFormatters } from "./text/remove.js";
+import { saveFormatters } from "./text/save.js";
+import { searchFormatters } from "./text/search.js";
+import { showFormatters } from "./text/show.js";
+import { updateFormatters } from "./text/update.js";
+import { upgradeFormatters } from "./text/upgrade.js";
+import { wikiFormatters } from "./text/wiki.js";
+import { workflowFormatters } from "./text/workflow.js";
 // Re-export helpers so existing imports from `text.ts` keep working.
-export { formatAddPlain, formatClonePlain, formatConfigPlain, formatCuratePlain, formatDistillPlain, formatEventLine, formatEventsPlain, formatFeedbackPlain, formatHistoryPlain, formatImportPlain, formatIndexPlain, formatInfoPlain, formatInitPlain, formatListPlain, formatProposalAcceptPlain, formatProposalDiffPlain, formatProposalListPlain, formatProposalProducerPlain, formatProposalRejectPlain, formatProposalShowPlain, formatRegistryAddPlain, formatRegistryBuildIndexPlain, formatRegistryListPlain, formatRegistryRemovePlain, formatRegistrySearchPlain, formatRememberPlain, formatRemovePlain, formatSavePlain, formatSearchPlain, formatShowPlain, formatToggleComponentPlain, formatUpdatePlain, formatUpgradePlain, formatVaultCreatePlain, formatVaultListPlain, formatVaultSetPlain, formatVaultUnsetPlain, formatWikiCreatePlain, formatWikiIngestPlain, formatWikiLintPlain, formatWikiListPlain, formatWikiPagesPlain, formatWikiRegisterPlain, formatWikiRemovePlain, formatWikiShowPlain, formatWikiStashPlain, formatWorkflowCreatePlain, formatWorkflowListPlain, formatWorkflowNextPlain, formatWorkflowResumePlain, formatWorkflowStatusPlain, formatWorkflowValidatePlain, } from "./text/helpers";
+export { formatAddPlain, formatClonePlain, formatConfigPlain, formatCuratePlain, formatDistillPlain, formatEventLine, formatEventsPlain, formatFeedbackPlain, formatHistoryPlain, formatImportPlain, formatIndexPlain, formatInfoPlain, formatInitPlain, formatListPlain, formatProposalAcceptPlain, formatProposalDiffPlain, formatProposalListPlain, formatProposalProducerPlain, formatProposalRejectPlain, formatProposalShowPlain, formatRegistryAddPlain, formatRegistryBuildIndexPlain, formatRegistryListPlain, formatRegistryRemovePlain, formatRegistrySearchPlain, formatRememberPlain, formatRemovePlain, formatSavePlain, formatSearchPlain, formatShowPlain, formatToggleComponentPlain, formatUpdatePlain, formatUpgradePlain, formatWikiCreatePlain, formatWikiIngestPlain, formatWikiLintPlain, formatWikiListPlain, formatWikiPagesPlain, formatWikiRegisterPlain, formatWikiRemovePlain, formatWikiShowPlain, formatWikiStashPlain, formatWorkflowCreatePlain, formatWorkflowListPlain, formatWorkflowNextPlain, formatWorkflowResumePlain, formatWorkflowStatusPlain, formatWorkflowValidatePlain, } from "./text/helpers.js";
 // Re-export registry API so callers can use this module as the single entry
 // point (backward compat).
-export { deregisterTextFormatter, registerTextFormatter } from "./text/registry";
-// ── Per-command text formatter modules (self-register at import time) ─────────
-// Importing these modules triggers their `registerTextFormatter(...)` calls.
-import "./text/init";
-import "./text/index";
-import "./text/show";
-import "./text/search";
-import "./text/curate";
-import "./text/wiki";
-import "./text/workflow";
-import "./text/list";
-import "./text/add";
-import "./text/remove";
-import "./text/update";
-import "./text/upgrade";
-import "./text/clone";
-import "./text/history";
-import "./text/events";
-import "./text/proposal";
-import "./text/proposal-producer";
-import "./text/distill";
-import "./text/info";
-import "./text/config";
-import "./text/feedback";
-import "./text/remember";
-import "./text/import";
-import "./text/save";
-import "./text/enable-disable";
-import "./text/registry-commands";
-import "./text/vault";
+export { deregisterTextFormatter, registerTextFormatter } from "./text/registry.js";
+// ── Explicit built-in formatter assembly ──────────────────────────────────────
+// Each entry below is a pure exported `TextFormatterEntry[]` from a per-command
+// module. The set is registered ONCE, deterministically, with no reliance on
+// import order. Removing a module from this list removes its registration —
+// and because each name is referenced statically, a deleted export fails to
+// compile instead of silently disappearing at runtime.
+const BUILT_IN_TEXT_FORMATTERS = [
+    ...initFormatters,
+    ...indexFormatters,
+    ...showFormatters,
+    ...searchFormatters,
+    ...curateFormatters,
+    ...wikiFormatters,
+    ...workflowFormatters,
+    ...listFormatters,
+    ...addFormatters,
+    ...removeFormatters,
+    ...updateFormatters,
+    ...upgradeFormatters,
+    ...cloneFormatters,
+    ...historyFormatters,
+    ...eventsFormatters,
+    ...proposalFormatters,
+    ...proposalProducerFormatters,
+    ...distillFormatters,
+    ...infoFormatters,
+    ...configFormatters,
+    ...feedbackFormatters,
+    ...rememberFormatters,
+    ...importFormatters,
+    ...saveFormatters,
+    ...enableDisableFormatters,
+    ...registryCommandFormatters,
+    ...envFormatters,
+];
+registerTextFormatters(BUILT_IN_TEXT_FORMATTERS);
 // ── JSONL output (unchanged — not part of the formatPlain dispatch) ───────────
 export function outputJsonl(command, shaped) {
     if (command === "search" || command === "registry-search") {