akm-cli 0.9.0-beta.9 → 0.9.0-rc.1

package/dist/output/renderers.js

@@ -18,7 +18,7 @@ import { asNonEmptyString, hasErrnoCode } from "../core/common.js";
 import { extractCommentMetadata, extractDescriptionFromComments } from "../indexer/passes/metadata.js";
 import { registerMetadataContributor } from "../indexer/passes/metadata-contributors.js";
 import { registerRenderer } from "../indexer/walk/file-context.js";
-import { buildWorkflowAction, workflowMdRenderer } from "../workflows/renderer.js";
+import { buildWorkflowAction, workflowMdRenderer, workflowProgramRenderer } from "../workflows/renderer.js";
 // ── Interpreter auto-detection map ───────────────────────────────────────────
 const INTERPRETER_MAP = {
     ".sh": "bash",
@@ -210,6 +210,10 @@ const agentMdRenderer = {
             action: "Dispatch using the prompt below verbatim. Use modelHint and toolPolicy if present.",
             description: asNonEmptyString(parsedMd.data.description),
             prompt: parsedMd.content,
+            // `tools` is self-declared frontmatter. The provenance CEILING that decides
+            // whether this self-declared policy is honoured is applied at the show
+            // layer (`akmShowUnified`), which knows whether the source is the operator's
+            // own writable stash vs a read-only third-party source (07 P1-D).
             toolPolicy: parsedMd.data.tools,
             modelHint: typeof parsedMd.data.model === "string" ? parsedMd.data.model : undefined,
         };
@@ -364,23 +368,21 @@ const scriptSourceRenderer = {
 };
 // ── 8. env-file ───────────────────────────────────────────────────────────────
 /**
- * Env renderer. Returns ONLY key names and start-of-line comments — never
- * values. Deliberately omits content/template/prompt so env values cannot leak
- * through `akm show`.
+ * Env renderer. Returns ONLY key names — never values, and never comment
+ * text (comments routinely contain commented-out credentials). Deliberately
+ * omits content/template/prompt so env values cannot leak through `akm show`.
  */
 const envFileRenderer = {
     name: "env-file",
     buildShowResponse(ctx) {
         const name = deriveName(ctx);
-        const { keys, comments } = listVaultKeys(ctx.absPath);
+        const { keys } = listVaultKeys(ctx.absPath);
         return {
             type: "env",
             name,
             path: ctx.absPath,
-            action: "Environment — keys + comments only. Use `akm env run <ref> -- <command>` to run with the whole .env injected (the safe path — values never reach stdout). `akm env export <ref> --out <file>` writes a sourceable script to a file. Never `source` the raw file. Values stay on disk and are never written to akm's stdout.",
-            description: comments.length > 0 ? comments.join("\n") : undefined,
+            action: "Environment — key names only. Use `akm env run <ref> -- <command>` to run with the whole .env injected; prefer `--clean` to minimize inherited parent env. AKM itself does not print values, but child stdout/stderr is not redacted. `akm env export <ref> --out <file>` writes a sourceable script to a file. Never `source` the raw file. Values stay on disk and are never written to akm's stdout.",
             keys,
-            comments,
         };
     },
     enrichSearchHit(hit, _stashDir) {
@@ -468,6 +470,44 @@ const sessionMdRenderer = {
         };
     },
 };
+// ── 9. fact-md ───────────────────────────────────────────────────────────────
+/**
+ * Renderer for the `fact` asset type. A fact is durable stash-level semantic
+ * knowledge (personal/team/project details, coding conventions, stash-meta).
+ * It carries `category` (personal|team|project|convention|meta) and an
+ * optional `pinned` flag marking it as part of the always-injected core. The
+ * renderer surfaces a one-liner (category + pinned marker) so an agent can tell
+ * at a glance what kind of fact it is and whether it is core context.
+ */
+const factMdRenderer = {
+    name: "fact-md",
+    buildShowResponse(ctx) {
+        const name = deriveName(ctx);
+        const parsed = parseFrontmatter(ctx.content());
+        const fm = parsed.data;
+        const category = asNonEmptyString(fm.category);
+        const description = asNonEmptyString(fm.description);
+        const pinned = fm.pinned === true;
+        const headerParts = [
+            category ? `category: ${category}` : undefined,
+            pinned ? "pinned (core context)" : undefined,
+        ].filter((p) => !!p);
+        const action = [
+            "Durable stash fact — apply it as background context.",
+            headerParts.length > 0 ? headerParts.join("  ") : undefined,
+        ]
+            .filter((p) => !!p)
+            .join("\n");
+        return {
+            type: "fact",
+            name,
+            path: ctx.absPath,
+            action,
+            description,
+            content: parsed.content,
+        };
+    },
+};
 function applySessionMetadata(entry, ctx) {
     try {
         const fm = applyFrontmatterDescriptionAndTags(entry, ctx);
@@ -501,6 +541,34 @@ function applyTocMetadata(entry, ctx) {
         // Non-fatal: skip TOC if file can't be read
     }
 }
+/**
+ * Fact metadata: surface `category` and the `pinned` core marker as tags +
+ * search hints (no dedicated DB columns — same encoding pattern as session /
+ * task). `pinned` is mirrored to both a `pinned` tag and a `pinned` search
+ * hint so the ranking contributor can detect it and queries can target it.
+ */
+function applyFactMetadata(entry, ctx) {
+    try {
+        const fm = applyFrontmatterDescriptionAndTags(entry, ctx);
+        const tags = new Set([...(entry.tags ?? []), "fact"]);
+        const hints = new Set(entry.searchHints ?? []);
+        const category = asNonEmptyString(fm.category);
+        if (category) {
+            tags.add(category);
+            hints.add(`category:${category}`);
+        }
+        if (fm.pinned === true) {
+            tags.add("pinned");
+            hints.add("pinned");
+        }
+        entry.tags = Array.from(tags).filter(Boolean);
+        if (hints.size > 0)
+            entry.searchHints = Array.from(hints).filter(Boolean);
+    }
+    catch {
+        // Non-fatal: skip metadata extraction on parse error
+    }
+}
 /**
  * Parse frontmatter, apply description (if not already set) and merge tags
  * into `entry`. Returns the raw frontmatter data object so callers can access
@@ -581,12 +649,9 @@ function applyScriptMetadata(entry, ctx) {
     }
 }
 function applyEnvMetadata(entry, ctx) {
-    const { keys, comments } = listVaultKeys(ctx.absPath);
-    if (comments.length > 0 && !entry.description) {
-        entry.description = comments.join(" ").slice(0, 500);
-        entry.source = "comments";
-        entry.confidence = 0.7;
-    }
+    // Key names only — comment text must never reach description/search_text
+    // (comments routinely contain commented-out credentials).
+    const { keys } = listVaultKeys(ctx.absPath);
     if (keys.length > 0) {
         entry.searchHints = keys;
     }
@@ -660,6 +725,11 @@ registerMetadataContributor({
     appliesTo: ({ rendererName }) => rendererName === "session-md",
     contribute: (entry, ctx) => applySessionMetadata(entry, ctx.renderContext),
 });
+registerMetadataContributor({
+    name: "fact-md-metadata",
+    appliesTo: ({ rendererName }) => rendererName === "fact-md",
+    contribute: (entry, ctx) => applyFactMetadata(entry, ctx.renderContext),
+});
 // ── Registration ─────────────────────────────────────────────────────────────
 /** All built-in renderers. */
 const builtinRenderers = [
@@ -671,11 +741,13 @@ const builtinRenderers = [
     lessonMdRenderer,
     memoryMdRenderer,
     workflowMdRenderer,
+    workflowProgramRenderer,
     scriptSourceRenderer,
     envFileRenderer,
     secretFileRenderer,
     taskMdRenderer,
     sessionMdRenderer,
+    factMdRenderer,
 ];
 /**
  * Register all built-in renderers with the file-context registry.
@@ -687,4 +759,4 @@ export function registerBuiltinRenderers() {
     }
 }
 // ── Named exports for testing ────────────────────────────────────────────────
-export { agentMdRenderer, commandMdRenderer, envFileRenderer, INTERPRETER_MAP, knowledgeMdRenderer, lessonMdRenderer, memoryMdRenderer, SETUP_SIGNALS, scriptSourceRenderer, secretFileRenderer, skillMdRenderer, wikiMdRenderer, workflowMdRenderer, };
+export { agentMdRenderer, commandMdRenderer, envFileRenderer, factMdRenderer, INTERPRETER_MAP, knowledgeMdRenderer, lessonMdRenderer, memoryMdRenderer, SETUP_SIGNALS, scriptSourceRenderer, secretFileRenderer, skillMdRenderer, wikiMdRenderer, workflowMdRenderer, workflowProgramRenderer, };

package/dist/output/shapes/curate.js

@@ -5,7 +5,7 @@ import { capDescription, NORMAL_DESCRIPTION_LIMIT, pickFields } from "./helpers.
 // Curation is a small, high-signal top-N. Even at `brief` we keep `followUp`
 // (the actionable `akm show <ref>` command) and `reason` (why this asset was
 // selected) — these are the point of curate, unlike a bulk search listing.
-const BRIEF_FIELDS = ["source", "type", "name", "ref", "id", "followUp", "reason"];
+const BRIEF_FIELDS = ["source", "type", "name", "ref", "id", "supportRefs", "followUp", "reason"];
 const NORMAL_FIELDS = [
     "source",
     "type",
@@ -17,12 +17,24 @@ const NORMAL_FIELDS = [
     "keys",
     "parameters",
     "run",
+    "supportRefs",
     "followUp",
     "reason",
     "score",
 ];
 // Agent shape: the minimal field set an LLM needs to decide and act.
-const AGENT_FIELDS = ["source", "type", "name", "ref", "id", "description", "followUp", "reason", "score"];
+const AGENT_FIELDS = [
+    "source",
+    "type",
+    "name",
+    "ref",
+    "id",
+    "description",
+    "supportRefs",
+    "followUp",
+    "reason",
+    "score",
+];
 function shapeCurateItem(item, detail, shape) {
     if (shape === "agent") {
         return capDescription(pickFields(item, AGENT_FIELDS), NORMAL_DESCRIPTION_LIMIT);

package/dist/output/shapes/helpers.js

@@ -369,7 +369,6 @@ export function shapeShowOutput(result, detail, shape = "human") {
             "workflowParameters",
             "steps",
             "keys",
-            "comments",
             "related",
         ]);
     }
@@ -385,7 +384,6 @@ export function shapeShowOutput(result, detail, shape = "human") {
             "run",
             "origin",
             "keys",
-            "comments",
             "related",
         ]);
     }
@@ -411,7 +409,6 @@ export function shapeShowOutput(result, detail, shape = "human") {
         "cwd",
         "activeRun",
         "keys",
-        "comments",
         "related",
         // path and editable are always projected so JSON consumers can locate and
         // edit the asset without needing --detail full (QA #7).

package/dist/output/shapes/passthrough.js

@@ -23,7 +23,6 @@ const PASSTHROUGH_COMMANDS = [
     "agent-result",
     "clone",
     "config",
-    "db-backups",
     "disable",
     "enable",
     "env-create",
@@ -43,6 +42,7 @@ const PASSTHROUGH_COMMANDS = [
     "extract",
     "health",
     "improve",
+    "improve-canary",
     "lessons-coverage",
     "import",
     "index",
@@ -86,15 +86,20 @@ const PASSTHROUGH_COMMANDS = [
     "wiki-remove",
     "wiki-show",
     "wiki-stash",
+    "workflow-abandon",
+    "workflow-brief",
     "workflow-complete",
     "workflow-complete-rejected",
     "workflow-create",
     "workflow-list",
     "workflow-next",
+    "workflow-report",
     "workflow-resume",
+    "workflow-run",
     "workflow-start",
     "workflow-status",
     "workflow-validate",
+    "workflow-watch",
 ];
 export const passthroughShapes = PASSTHROUGH_COMMANDS.map((command) => ({
     command,

package/dist/output/text/helpers.js

@@ -194,7 +194,18 @@ export function formatWorkflowValidatePlain(r) {
         return `workflow validate: failed (${pathValue})`;
     const title = typeof r.title === "string" ? r.title : "";
     const stepCount = typeof r.stepCount === "number" ? r.stepCount : 0;
-    return `workflow validate: ok — ${title || pathValue} (${stepCount} step(s))`;
+    const lines = [`workflow validate: ok — ${title || pathValue} (${stepCount} step(s))`];
+    // Non-fatal advisories: clearly marked, printed after the ok line so `ok`
+    // is never in doubt. Absent/empty for markdown and fully-typed programs.
+    const warnings = Array.isArray(r.warnings) ? r.warnings : [];
+    if (warnings.length > 0) {
+        lines.push(`  ${warnings.length} warning(s):`);
+        for (const w of warnings) {
+            const line = typeof w.line === "number" ? w.line : "?";
+            lines.push(`    warning: ${pathValue}:${line} — ${String(w.message ?? "")}`);
+        }
+    }
+    return lines.join("\n");
 }
 /**
  * Plain-text rendering for a step-completion that was rejected by the
@@ -722,8 +733,59 @@ export function formatWorkflowStatusPlain(result) {
             }
         }
     }
+    // `workflow status --units` (#22): the honest per-unit diagnostic surface —
+    // failure_reason plus any journaled result/error text. Diagnostics only; the
+    // deterministic step evidence above is unaffected.
+    const units = Array.isArray(result.units) ? result.units : undefined;
+    if (units) {
+        lines.push("");
+        lines.push(units.length > 0 ? "units:" : "units: (none journaled)");
+        for (const unit of units) {
+            const id = typeof unit.unitId === "string" ? unit.unitId : "unknown";
+            const status = typeof unit.status === "string" ? unit.status : "unknown";
+            const node = typeof unit.nodeId === "string" ? unit.nodeId : "";
+            const attempts = typeof unit.attempts === "number" ? unit.attempts : undefined;
+            const suffix = attempts !== undefined && attempts > 1 ? `, attempt ${attempts}` : "";
+            lines.push(`  - ${id} [${node}] (${status}${suffix})`);
+            // Codex round-3 finding B: a `running` claim gone silent past the check-in
+            // window — the driver likely died. Surface it (with the claim holder) so a
+            // human can reclaim/re-run the unit, matching what `brief` reports.
+            if (unit.stale === true) {
+                const holder = typeof unit.claimHolder === "string" && unit.claimHolder.trim() ? ` claimed by ${unit.claimHolder}` : "";
+                lines.push(`    stale: claim went silent past the check-in window${holder} — its driver may have died`);
+            }
+            if (typeof unit.failureReason === "string" && unit.failureReason.trim()) {
+                lines.push(`    failure_reason: ${unit.failureReason}`);
+            }
+            if (typeof unit.diagnostic === "string" && unit.diagnostic.trim()) {
+                const diagLines = unit.diagnostic.split("\n");
+                lines.push(`    diagnostic: ${diagLines[0]}`);
+                for (const diagLine of diagLines.slice(1))
+                    lines.push(`      ${diagLine}`);
+            }
+        }
+    }
+    // Review C2: the check-in `continue` directive must survive plain-text
+    // rendering — JSON consumers saw `checkin` but the text path dropped it.
+    const checkinLine = formatWorkflowCheckinLine(result);
+    if (checkinLine) {
+        lines.push("");
+        lines.push(checkinLine);
+    }
     return lines.join("\n");
 }
+/**
+ * Render the stalled-run check-in directive (#506) when present on a
+ * workflow-next/status result. Returns null when the run is healthy.
+ */
+function formatWorkflowCheckinLine(result) {
+    const checkin = typeof result.checkin === "object" && result.checkin !== null
+        ? result.checkin
+        : undefined;
+    if (!checkin || typeof checkin.directive !== "string" || !checkin.directive.trim())
+        return null;
+    return checkin.directive.trim();
+}
 export function formatWorkflowNextPlain(result) {
     const base = formatWorkflowStatusPlain(result);
     const step = typeof result.step === "object" && result.step !== null ? result.step : undefined;
@@ -765,6 +827,155 @@ export function formatWorkflowNextPlain(result) {
     }
     return lines.join("\n");
 }
+export function formatWorkflowRunPlain(result) {
+    const run = typeof result.run === "object" && result.run !== null ? result.run : undefined;
+    if (!run)
+        return null;
+    const lines = [`run: ${String(run.id ?? "unknown")}`, `status: ${String(run.status ?? "unknown")}`];
+    const executed = Array.isArray(result.executed) ? result.executed : [];
+    if (executed.length === 0) {
+        lines.push("executed: (no steps — run was already done or blocked)");
+    }
+    else {
+        lines.push("executed:");
+        for (const step of executed) {
+            const marker = step.ok === true ? "ok" : "FAILED";
+            lines.push(`  - ${String(step.stepId ?? "?")} [${marker}] units: ${String(step.unitCount ?? 0)}` +
+                (Number(step.failedUnits ?? 0) > 0 ? ` (${String(step.failedUnits)} failed)` : ""));
+            if (typeof step.summary === "string" && step.summary.trim()) {
+                lines.push(`    ${step.summary}`);
+            }
+        }
+    }
+    const gate = typeof result.gateRejection === "object" && result.gateRejection !== null
+        ? result.gateRejection
+        : undefined;
+    if (gate) {
+        lines.push(`gate rejected step ${String(gate.stepId ?? "?")}: ${String(gate.feedback ?? "")}`);
+        const missing = Array.isArray(gate.missing) ? gate.missing : [];
+        for (const item of missing)
+            lines.push(`  missing: ${String(item)}`);
+    }
+    if (result.done === true)
+        lines.push("workflow completed.");
+    return lines.join("\n");
+}
+export function formatWorkflowBriefPlain(result) {
+    const run = typeof result.run === "object" && result.run !== null ? result.run : undefined;
+    if (!run)
+        return null;
+    const lines = [];
+    lines.push(`# Workflow brief: ${String(run.id ?? "unknown")}`);
+    lines.push(`workflow: ${String(run.workflowRef ?? "?")}  (${String(run.workflowTitle ?? "")})`);
+    lines.push(`status: ${String(run.status ?? "?")}`);
+    if (typeof result.message === "string")
+        lines.push(result.message);
+    const lease = typeof result.engineLease === "object" && result.engineLease !== null
+        ? result.engineLease
+        : undefined;
+    if (lease) {
+        const live = lease.live === true ? "LIVE" : "expired";
+        lines.push(`engine lease: ${String(lease.holder ?? "?")} (until ${String(lease.until ?? "?")}) [${live}]`);
+    }
+    const warnings = Array.isArray(result.warnings) ? result.warnings : [];
+    for (const w of warnings)
+        lines.push(`! ${String(w)}`);
+    if (result.done === true) {
+        lines.push("");
+        lines.push("This run is completed — no work remains.");
+        return lines.join("\n");
+    }
+    const step = typeof result.step === "object" && result.step !== null ? result.step : undefined;
+    if (!step) {
+        return lines.join("\n");
+    }
+    const gate = typeof step.gate === "object" && step.gate !== null ? step.gate : undefined;
+    lines.push("");
+    lines.push(`## Active step: ${String(step.stepId ?? "?")} — ${String(step.title ?? "")}  [${String(step.kind ?? "execute")}]`);
+    if (gate) {
+        const criteria = Array.isArray(gate.criteria) ? gate.criteria : [];
+        lines.push(`gate: loop ${String(gate.currentLoop ?? 1)} of max ${String(gate.maxLoops ?? 1)}` +
+            (criteria.length > 0 ? `; criteria: ${criteria.map(String).join("; ")}` : "; no completion criteria") +
+            (gate.judgesArtifact === true ? " (artifact-judged)" : ""));
+    }
+    if (step.outputSchema !== undefined)
+        lines.push("outputSchema: declared (see JSON output)");
+    const feedback = typeof result.gateFeedback === "object" && result.gateFeedback !== null
+        ? result.gateFeedback
+        : undefined;
+    if (feedback) {
+        lines.push(`gate feedback (previous loop rejected): ${String(feedback.feedback ?? "")}`);
+        const missing = Array.isArray(feedback.missing) ? feedback.missing : [];
+        for (const m of missing)
+            lines.push(`  - missing: ${String(m)}`);
+    }
+    const route = typeof result.route === "object" && result.route !== null ? result.route : undefined;
+    if (route) {
+        lines.push("");
+        lines.push(`## Route contract on ${String(route.input ?? "?")}`);
+        const when = typeof route.when === "object" && route.when !== null ? route.when : {};
+        for (const [value, target] of Object.entries(when))
+            lines.push(`  when "${value}" → ${String(target)}`);
+        if (route.defaultStepId !== undefined)
+            lines.push(`  default → ${String(route.defaultStepId)}`);
+        const decision = typeof route.decision === "object" && route.decision !== null
+            ? route.decision
+            : undefined;
+        if (decision)
+            lines.push(`  decision NOW: value "${String(decision.value)}" → ${String(decision.selected)}`);
+        else if (typeof route.decisionError === "string")
+            lines.push(`  decision error: ${route.decisionError}`);
+        else
+            lines.push("  decision: pending this step's output (evaluated after units complete)");
+    }
+    const workList = typeof result.workList === "object" && result.workList !== null
+        ? result.workList
+        : undefined;
+    const units = workList && Array.isArray(workList.units) ? workList.units : [];
+    if (workList?.error) {
+        lines.push("");
+        lines.push(`work-list error: ${String(workList.error)}`);
+    }
+    else if (units.length > 0) {
+        lines.push("");
+        lines.push(`## Units (${units.length})`);
+        for (const u of units) {
+            const model = u.model ? ` model=${String(u.model)}` : "";
+            const journaled = typeof u.journaled === "object" && u.journaled !== null ? u.journaled : undefined;
+            const jstatus = journaled ? ` [journaled: ${String(journaled.status)}]` : "";
+            lines.push(`- ${String(u.unitId)}  (runner=${String(u.runner)}${model})${jstatus}`);
+            const env = Array.isArray(u.env) ? u.env : [];
+            if (env.length > 0)
+                lines.push(`    env (names): ${env.map(String).join(", ")}`);
+            if (u.outputSchema !== undefined)
+                lines.push("    outputSchema: declared (see JSON output)");
+            const resolved = typeof u.resolved === "object" && u.resolved !== null ? u.resolved : undefined;
+            if (resolved && resolved.ok === false)
+                lines.push(`    RESOLUTION ERROR: ${String(resolved.error)}`);
+            if (typeof u.report === "string")
+                lines.push(`    report: ${u.report}`);
+        }
+    }
+    // Finding D: a non-dispatching step (route-only / empty / all-unresolvable)
+    // advances via the `--settle` verb, surfaced so a driver can advance the spine.
+    if (typeof result.settleCommand === "string") {
+        lines.push("");
+        lines.push("## Advance (no reportable units)");
+        lines.push(`settle: ${result.settleCommand}`);
+    }
+    const guidance = typeof result.reportGuidance === "object" && result.reportGuidance !== null
+        ? result.reportGuidance
+        : undefined;
+    if (guidance) {
+        lines.push("");
+        lines.push("## Reporting");
+        if (typeof guidance.checkin === "string")
+            lines.push(`heartbeat: ${guidance.checkin}`);
+        if (typeof guidance.failure === "string")
+            lines.push(`on failure: ${guidance.failure}`);
+    }
+    return lines.join("\n");
+}
 export function formatSearchPlain(r, detail) {
     const hits = r.hits ?? [];
     const registryHits = r.registryHits ?? [];
@@ -1005,6 +1216,15 @@ export function formatCuratePlain(r, detail) {
             lines.push(`  run: ${String(item.run)}`);
         if (item.followUp)
             lines.push(`  show: ${String(item.followUp)}`);
+        if (Array.isArray(item.supportRefs) && item.supportRefs.length > 0) {
+            for (const support of item.supportRefs) {
+                if (!support.ref)
+                    continue;
+                const label = typeof support.type === "string" ? `[${support.type}] ` : "";
+                const why = typeof support.reason === "string" ? ` — ${support.reason}` : "";
+                lines.push(`  support: ${label}${String(support.ref)}${why}`);
+            }
+        }
         if (detail !== "brief" && item.reason)
             lines.push(`  why: ${String(item.reason)}`);
     }
@@ -1026,8 +1246,14 @@ export function formatCuratePlain(r, detail) {
 }
 export function formatInitPlain(r) {
     let out = `Stash initialized at ${r.stashDir ?? "unknown"}`;
-    if (r.configPath)
+    // When --dir scaffolded a secondary stash 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.`;
+    }
+    else if (r.configPath) {
         out += `\nConfig saved to ${r.configPath}`;
+    }
     return out;
 }
 export function formatIndexPlain(r) {
@@ -1043,6 +1269,19 @@ export function formatIndexPlain(r) {
     if (verification?.ok === false && verification.message) {
         out += `\nVerification: ${String(verification.message)}`;
     }
+    const timing = indexResult.timing;
+    if (timing) {
+        out +=
+            `\nTiming: total ${timing.totalMs}ms` +
+                `, preflight ${timing.preflightMs}ms` +
+                `, walk ${timing.walkMs}ms` +
+                `, llm ${timing.llmMs}ms` +
+                `, embeddings ${timing.embedMs}ms` +
+                `, fts ${timing.ftsMs}ms` +
+                `, finalize ${timing.finalizeMs}ms` +
+                `, clean ${timing.cleanMs}ms` +
+                `, end-to-end ${timing.endToEndMs}ms`;
+    }
     return out;
 }
 export function formatListPlain(r) {

package/dist/output/text/workflow.js

@@ -2,7 +2,7 @@
 // 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 { formatWorkflowCompleteRejectedPlain, formatWorkflowCreatePlain, formatWorkflowListPlain, formatWorkflowNextPlain, formatWorkflowResumePlain, formatWorkflowStatusPlain, formatWorkflowValidatePlain, } from "./helpers.js";
+import { formatWorkflowBriefPlain, formatWorkflowCompleteRejectedPlain, formatWorkflowCreatePlain, formatWorkflowListPlain, formatWorkflowNextPlain, formatWorkflowResumePlain, formatWorkflowRunPlain, formatWorkflowStatusPlain, formatWorkflowValidatePlain, } from "./helpers.js";
 export const workflowFormatters = [
     { command: "workflow-start", handler: (r) => formatWorkflowStatusPlain(r) },
     { command: "workflow-status", handler: (r) => formatWorkflowStatusPlain(r) },
@@ -13,4 +13,7 @@ export const workflowFormatters = [
     { command: "workflow-create", handler: (r) => formatWorkflowCreatePlain(r) },
     { command: "workflow-validate", handler: (r) => formatWorkflowValidatePlain(r) },
     { command: "workflow-resume", handler: (r) => formatWorkflowResumePlain(r) },
+    { command: "workflow-abandon", handler: (r) => formatWorkflowStatusPlain(r) },
+    { command: "workflow-run", handler: (r) => formatWorkflowRunPlain(r) },
+    { command: "workflow-brief", handler: (r) => formatWorkflowBriefPlain(r) },
 ];