akm-cli 0.9.0-rc.8 → 0.9.0

package/dist/output/text/migrate.js

@@ -0,0 +1,88 @@
+// 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";
+const ARTIFACT_ORDER = ["config", "state", "workflow", "index"];
+const ARTIFACT_LABEL = {
+    config: "config.json",
+    state: "state.db",
+    workflow: "workflow.db",
+    index: "index.db",
+};
+/** Lower rank sorts first (worse-first) via `renderStatusEntries`. */
+function artifactSeverity(status) {
+    switch (status) {
+        case "corrupt":
+        case "inconsistent":
+        case "newer":
+            return { rank: 0, glyph: "✗" };
+        case "old":
+            return { rank: 1, glyph: "⚠" };
+        case "missing":
+            return { rank: 2, glyph: "?" };
+        default: // "current"
+            return { rank: 3, glyph: "✓" };
+    }
+}
+function planGlyph(status) {
+    switch (status) {
+        case "current":
+            return "✓";
+        case "ready":
+            return "⚠";
+        case "not-applicable":
+            return "·";
+        default: // "blocked"
+            return "✗";
+    }
+}
+export function formatMigratePlain(result) {
+    if (!result || typeof result !== "object")
+        return null;
+    const plan = result;
+    if (typeof plan.status !== "string")
+        return null;
+    const lines = [`${planGlyph(plan.status)} ${plan.status}`];
+    if (plan.message)
+        lines.push(`    ${plan.message}`);
+    if (plan.activeOperation) {
+        lines.push(`    in-flight ${plan.activeOperation.kind} at ${plan.activeOperation.sentinelPath}`);
+    }
+    if (plan.artifacts) {
+        const entries = ARTIFACT_ORDER.filter((name) => plan.artifacts?.[name]).map((name) => {
+            const artifact = plan.artifacts?.[name];
+            const { rank, glyph } = artifactSeverity(artifact.status);
+            const detailLines = [];
+            if (artifact.detail)
+                detailLines.push(artifact.detail);
+            if (artifact.migrationIds?.length)
+                detailLines.push(`migrations applied: ${artifact.migrationIds.length}`);
+            return { severityRank: rank, glyph, headline: `${ARTIFACT_LABEL[name]}: ${artifact.status}`, detailLines };
+        });
+        lines.push("", "artifacts:", ...renderStatusEntries(entries).map((line) => `  ${line}`));
+    }
+    if (plan.targetConfig) {
+        const target = plan.targetConfig;
+        lines.push("", `target config: ${target.status} (source: ${target.source}${target.path ? `, ${target.path}` : ""})`);
+        if (target.detail)
+            lines.push(`  ${target.detail}`);
+    }
+    if (plan.generatedConfig) {
+        const generated = plan.generatedConfig;
+        lines.push("", `generated config: ${generated.status} at ${generated.path}`);
+        if (generated.droppedKeys.length > 0) {
+            lines.push(`  drops (add engines/defaults yourself if needed): ${generated.droppedKeys.join(", ")}`);
+        }
+    }
+    if (plan.blockers?.length) {
+        lines.push("", "blockers:", ...plan.blockers.map((blocker) => `  - ${blocker}`));
+    }
+    if (plan.backupPath) {
+        lines.push("", `backup: ${plan.backupPath}${plan.backupRunId ? ` (run ${plan.backupRunId})` : ""}`);
+    }
+    return lines.join("\n");
+}
+export const migrateFormatters = [
+    { command: "migrate-status", handler: (r) => formatMigratePlain(r) },
+    { command: "migrate-apply", handler: (r) => formatMigratePlain(r) },
+];

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

@@ -1,9 +1,11 @@
 // 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).
+// Output text formatters for `akm reflect` / `akm proposal new` (#226; the
+// latter formerly the top-level `akm propose`, moved in the 0.9 CLI
+// overhaul, S8).
 import { formatProposalProducerPlain } from "../helpers.js";
 export const proposalProducerFormatters = [
     { command: "reflect", handler: (r) => formatProposalProducerPlain("reflect", r) },
-    { command: "propose", handler: (r) => formatProposalProducerPlain("propose", r) },
+    { command: "proposal-new", handler: (r) => formatProposalProducerPlain("proposal new", r) },
 ];

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

@@ -2,16 +2,17 @@
 // 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/.
 /**
- * Plain-text renderers for `akm proposal *` and `akm distill` commands.
+ * Plain-text renderers for `akm proposal *` commands.
  *
  * Split out of `helpers.ts` (formerly 1418 lines / 59 fns) as its own
  * sibling module: proposal listing/show share the gate-decision summary
- * helpers, and distill is the producer of proposals, so the cluster stays
- * together.
+ * helpers. (`akm distill` has no registered top-level command — its former
+ * plain-text renderer, `formatDistillPlain`, was dead code; removed per
+ * R-063/B5.)
  */
 export function formatProposalProducerPlain(command, r) {
     if (r.ok === false) {
-        const reason = String(r.reason ?? "unknown");
+        const reason = String(r.reason);
         const error = typeof r.error === "string" ? r.error : "";
         const lines = [`${command}: failed (${reason})`];
         if (error)
@@ -23,16 +24,16 @@ export function formatProposalProducerPlain(command, r) {
         }
         return lines.join("\n");
     }
-    const proposal = r.proposal ?? {};
-    const id = String(proposal.id ?? "?");
-    const ref = String(r.ref ?? proposal.ref ?? "?");
-    const status = String(proposal.status ?? "pending");
+    const proposal = r.proposal;
+    const id = String(proposal.id);
+    const ref = String(r.ref);
+    const status = String(proposal.status);
     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.
+ * (#577), e.g. `gate=deferred:max-diff-lines (210 > 200)`. Returns the empty
+ * string when no well-formed decision is present.
  */
 export function formatGateDecisionSummary(raw) {
     if (typeof raw !== "object" || raw === null)
@@ -46,48 +47,43 @@ export function formatGateDecisionSummary(raw) {
     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.
+ * Reconstruct the drain threshold comparison when both operands are present.
+ * Returns the empty string when the decision lacks either operand.
  */
 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 (measured === undefined)
+        return "";
     if (typeof thresholds.maxDiffLines === "number") {
-        return measured !== undefined
-            ? `${measured} > ${thresholds.maxDiffLines}`
-            : `maxDiffLines=${thresholds.maxDiffLines}`;
+        return `${measured} > ${thresholds.maxDiffLines}`;
     }
     if (typeof thresholds.minContentLines === "number") {
-        return measured !== undefined
-            ? `${measured} < ${thresholds.minContentLines}`
-            : `minContentLines=${thresholds.minContentLines}`;
+        return `${measured} < ${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;
+    const proposals = r.proposals;
+    const total = r.totalCount;
     if (proposals.length === 0) {
-        return `${total} proposal(s).\nNo proposals.\nGenerate one with \`akm reflect <ref>\`, \`akm propose <type> <name> --task ...\`, or \`akm distill <ref>\`.`;
+        // NEW-1: `akm reflect` and `akm distill` are internal improve-pipeline
+        // process names (src/commands/improve/{reflect,distill}.ts), not
+        // registered top-level commands (see the subCommands map in src/cli.ts) —
+        // an agent following this hint would run a command that does not exist.
+        // The real ways to queue a proposal are `akm improve <ref>` (which runs
+        // the reflect/distill/consolidate pipeline internally) and
+        // `akm proposal new`.
+        return `${total} proposal(s).\nNo proposals.\nGenerate one with \`akm improve <ref>\` or \`akm proposal new <type> <name> --task ...\`.`;
     }
     const lines = [`${total} proposal(s)`, ""];
     for (const p of proposals) {
-        const id = String(p.id ?? "?");
-        const ref = String(p.ref ?? "?");
-        const status = String(p.status ?? "?");
-        const source = String(p.source ?? "?");
-        const created = String(p.createdAt ?? "?");
-        // #577: surface the gate verdict inline so the queue explains itself
-        // ("deferred: below-threshold"). Legacy proposals carry no gateDecision.
+        const id = String(p.id);
+        const ref = String(p.ref);
+        const status = String(p.status);
+        const source = String(p.source);
+        const created = String(p.createdAt);
+        // #577: surface the gate verdict inline so the queue explains itself.
         const gate = formatGateDecisionSummary(p.gateDecision);
         const gateSuffix = gate ? `  ${gate}` : "";
         lines.push(`${id}  [${status}] ${ref}  source=${source}  ${created}${gateSuffix}`);
@@ -95,12 +91,12 @@ export function formatProposalListPlain(r) {
     return lines.join("\n").trimEnd();
 }
 export function formatProposalShowPlain(r) {
-    const p = r.proposal ?? {};
+    const p = r.proposal;
     const lines = [];
-    lines.push(`# proposal ${String(p.id ?? "?")}`);
-    lines.push(`ref: ${String(p.ref ?? "?")}`);
-    lines.push(`status: ${String(p.status ?? "?")}`);
-    lines.push(`source: ${String(p.source ?? "?")}`);
+    lines.push(`# proposal ${String(p.id)}`);
+    lines.push(`ref: ${String(p.ref)}`);
+    lines.push(`status: ${String(p.status)}`);
+    lines.push(`source: ${String(p.source)}`);
     if (p.sourceRun)
         lines.push(`sourceRun: ${String(p.sourceRun)}`);
     if (p.createdAt)
@@ -110,12 +106,11 @@ export function formatProposalShowPlain(r) {
     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.
+    // thresholds), when this proposal has passed through a gate.
     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"}`);
+        lines.push(`gate.reason: ${String(gate.reason)}`);
         const cmp = formatGateThresholdComparison(gate);
         if (cmp)
             lines.push(`gate.thresholds: ${cmp}`);
@@ -124,9 +119,6 @@ export function formatProposalShowPlain(r) {
         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 ?? "?")}`);
@@ -171,11 +163,11 @@ export function formatProposalShowPlain(r) {
     return lines.join("\n").trimEnd();
 }
 export function formatProposalAcceptPlain(r) {
-    return `Accepted proposal ${String(r.id ?? "?")} → ${String(r.ref ?? "?")} at ${String(r.assetPath ?? "?")}`;
+    return `Accepted proposal ${String(r.id)} → ${String(r.ref)} at ${String(r.assetPath)}`;
 }
 export function formatProposalRejectPlain(r) {
     const reason = r.reason ? ` (${String(r.reason)})` : "";
-    return `Rejected proposal ${String(r.id ?? "?")} (${String(r.ref ?? "?")})${reason}`;
+    return `Rejected proposal ${String(r.id)} (${String(r.ref)})${reason}`;
 }
 export function formatProposalDrainPlain(r) {
     const policy = String(r.policy ?? "?");
@@ -199,30 +191,10 @@ export function formatProposalDrainPlain(r) {
     }
     return lines.join("\n").trimEnd();
 }
-export function formatDistillPlain(r) {
-    const outcome = String(r.outcome ?? "unknown");
-    const inputRef = String(r.inputRef ?? "?");
-    const lessonRef = String(r.lessonRef ?? "?");
-    if (outcome === "queued") {
-        const id = String(r.proposalId ?? "?");
-        return `Distilled ${inputRef} → proposal ${id} (${lessonRef}). Run \`akm proposal show ${id}\` to review.`;
-    }
-    if (outcome === "validation_failed") {
-        const findings = Array.isArray(r.findings) ? r.findings : [];
-        const lines = [`Distillation produced an invalid lesson for ${inputRef}; no proposal queued.`];
-        for (const f of findings) {
-            lines.push(`  - ${String(f.message ?? f.kind ?? "validation finding")}`);
-        }
-        return lines.join("\n");
-    }
-    // skipped
-    const message = typeof r.message === "string" ? r.message : "feature disabled or LLM unavailable";
-    return `Distill skipped for ${inputRef}: ${message}`;
-}
 export function formatProposalDiffPlain(r) {
     const header = r.isNew
-        ? `# proposal ${String(r.id ?? "?")} (new asset: ${String(r.ref ?? "?")})`
-        : `# proposal ${String(r.id ?? "?")} (update: ${String(r.ref ?? "?")})`;
+        ? `# proposal ${String(r.id)} (new asset: ${String(r.ref)})`
+        : `# proposal ${String(r.id)} (update: ${String(r.ref)})`;
     const unified = typeof r.unified === "string" ? r.unified : "";
     if (!unified)
         return `${header}\n(no changes)`;

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

@@ -2,11 +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 registry *` commands.
-import { formatRegistryAddPlain, formatRegistryBuildIndexPlain, formatRegistryListPlain, formatRegistryRemovePlain, formatRegistrySearchPlain, } from "./helpers.js";
+import { formatRegistryAddPlain, 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/show-directives.js

@@ -11,6 +11,7 @@
  * Directive strings are byte-identical to the pre-extraction version —
  * only the seam moved.
  */
+import { conceptIdFromTypeName } from "../../core/asset/resolve-ref.js";
 /**
  * Append the type-specific agent directive block to an in-progress
  * `formatShowPlain` render. Mutates `lines` in place (matches the original
@@ -21,7 +22,16 @@ export function appendShowDirectives(lines, r) {
     // REC-01 / REC-09: Append a type-specific directive so agents apply the
     // content rather than substituting training-data approximations.
     const assetType = typeof r.type === "string" ? r.type : null;
-    const assetRef = typeof r.name === "string" && assetType ? `${assetType}:${r.name}` : null;
+    // 0.9.0 (Q-02 / R-002): the retired `type:name` colon grammar is gone —
+    // build the slash conceptId the same way the workflow branch below does
+    // (`workflows/${name}`), via the entry's own already-computed `ref` when
+    // present (it carries correct bundle-qualification), falling back to a
+    // type-derived conceptId for callers that don't set `ref`.
+    const assetRef = typeof r.ref === "string"
+        ? r.ref
+        : typeof r.name === "string" && assetType
+            ? conceptIdFromTypeName(assetType, r.name)
+            : null;
     // Show-loop detection: if the agent has shown this asset 3+ times without
     // writing anything, surface a warning so it stops cycling and acts.
     const showLoopCount = typeof r.showLoopWarning === "number" ? r.showLoopWarning : 0;
@@ -35,9 +45,7 @@ export function appendShowDirectives(lines, r) {
     if (assetType === "skill" || assetType === "knowledge") {
         const activeRun = r.activeRun;
         if (activeRun) {
-            // Active workflow: redirect agent to workflow commands instead of direct apply
-            lines.unshift(`  akm workflow complete '${activeRun.runId}'${activeRun.stepId ? ` --step '${activeRun.stepId}'` : ""}`);
-            lines.unshift("Read this schema, then follow your workflow step's instructions to edit the workspace file. When done, mark the step complete:");
+            lines.unshift("Read this reference, follow the active unit's instructions, and return the result to the workflow runner. Step completion is automatic.");
             lines.unshift(`WORKFLOW ACTIVE — schema shown as reference (run: ${activeRun.runId})`);
             lines.unshift("---");
             lines.unshift("");
@@ -78,14 +86,14 @@ export function appendShowDirectives(lines, r) {
         const insertIdx = separatorIdx >= 0 ? separatorIdx + 1 : r.type || r.name ? 1 : 0;
         const actionDirective = [
             `ACTION REQUIRED: Do not execute steps manually from this output.`,
-            `Run \`akm workflow next '${workflowRef}'\` to get your current step with exact instructions.`,
+            `Run \`akm workflow run '${workflowRef}'\` to execute the workflow through its declared gates.`,
             "---",
         ];
         lines.splice(insertIdx, 0, "", ...actionDirective);
         lines.push("");
         lines.push("---");
-        lines.push(`NEXT STEP: Run \`akm workflow next '${workflowRef}'\` to see the current workflow step.`);
-        lines.push("Do not edit workspace files before completing each step with `akm workflow complete`.");
+        lines.push(`NEXT STEP: Run \`akm workflow run '${workflowRef}'\` to execute the workflow.`);
+        lines.push("Inspect the workflow first; the runner dispatches and completes each step automatically.");
     }
 }
 /**

package/dist/output/text/status-list.js

@@ -0,0 +1,32 @@
+// 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/.
+/**
+ * Render entries worst-first (by `severityRank`, ties keep original order),
+ * each as a glyph-prefixed headline with its optional indented detail lines.
+ */
+export function renderStatusEntries(entries) {
+    const ordered = entries
+        .map((entry, index) => ({ entry, index }))
+        .sort((a, b) => a.entry.severityRank - b.entry.severityRank || a.index - b.index)
+        .map(({ entry }) => entry);
+    const lines = [];
+    for (const entry of ordered) {
+        lines.push(`${entry.glyph} ${entry.headline}`);
+        for (const detail of entry.detailLines ?? []) {
+            lines.push(`    ${detail}`);
+        }
+    }
+    return lines;
+}
+/**
+ * Render a status→count map as `"2 fail, 1 warn, 5 pass"`, in `order` (worst
+ * first) with zero counts omitted. Shared by any section header that wants a
+ * one-line "what's in here" summary before the per-row detail.
+ */
+export function summarizeCounts(counts, order) {
+    return order
+        .filter((status) => (counts[status] ?? 0) > 0)
+        .map((status) => `${counts[status]} ${status}`)
+        .join(", ");
+}

package/dist/output/text/sync.js

@@ -0,0 +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 { formatSyncPlain } from "./helpers.js";
+export const syncFormatters = [{ command: "sync", handler: (r) => formatSyncPlain(r) }];