akm-cli 0.8.7 → 0.8.14

package/dist/llm/usage-persist.js

@@ -0,0 +1,77 @@
+// 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/.
+/**
+ * Bridge per-call LLM usage telemetry (#576) to the events stream.
+ *
+ * `usage-telemetry.ts` stays dependency-free of the events/db layer so the
+ * low-level `client.ts` never imports persistence. This module is the wiring:
+ * it installs a {@link LlmUsageSink} that persists each {@link LlmUsageRecord}
+ * as one `llm_usage` event.
+ *
+ * Why reuse the events table (vs a dedicated table): volume is low (~100
+ * calls/day), the records are append-only and time-windowed exactly like every
+ * other event, and `akm health` already aggregates per-window event reads — a
+ * separate table would duplicate retention (`purgeOldEvents`), reads, and
+ * migration surface for no benefit. See the commit message for #576.
+ *
+ * Every record is written through `appendEvent`, which is itself best-effort
+ * (a write failure logs once and never throws). Combined with the sink-error
+ * swallowing in `emitLlmUsage`, telemetry can never break a real run.
+ */
+import { appendEvent } from "../core/events.js";
+import { clearLlmUsageSink, hasLlmUsageSink, setLlmUsageSink } from "./usage-telemetry.js";
+/** Event type for persisted per-call LLM usage telemetry. */
+export const LLM_USAGE_EVENT = "llm_usage";
+/**
+ * Project a usage record into event metadata, dropping `undefined` token
+ * fields so an absent-usage call records only `{stage, model, durationMs}`.
+ */
+function toEventMetadata(record) {
+    const metadata = { durationMs: record.durationMs };
+    if (record.stage !== undefined)
+        metadata.stage = record.stage;
+    if (record.model !== undefined)
+        metadata.model = record.model;
+    if (record.finishReason !== undefined)
+        metadata.finishReason = record.finishReason;
+    if (record.promptTokens !== undefined)
+        metadata.promptTokens = record.promptTokens;
+    if (record.completionTokens !== undefined)
+        metadata.completionTokens = record.completionTokens;
+    if (record.totalTokens !== undefined)
+        metadata.totalTokens = record.totalTokens;
+    if (record.reasoningTokens !== undefined)
+        metadata.reasoningTokens = record.reasoningTokens;
+    return metadata;
+}
+/**
+ * Install a usage sink that persists each LLM call as an `llm_usage` event via
+ * `appendEvent`. Returns a disposer that clears the sink — call it in a
+ * `finally` block so per-run wiring does not leak across runs (and so the
+ * test-isolation harness sees a clean sink between tests).
+ *
+ * `ctx` should carry the same long-lived `state.db` handle the caller already
+ * opened for its other events; when omitted, `appendEvent` falls back to its
+ * default open-insert-close path.
+ */
+export function installLlmUsagePersistence(ctx) {
+    setLlmUsageSink((record) => {
+        appendEvent({ eventType: LLM_USAGE_EVENT, metadata: toEventMetadata(record) }, ctx);
+    });
+    return () => {
+        clearLlmUsageSink();
+    };
+}
+/**
+ * Like {@link installLlmUsagePersistence}, but a no-op when a sink is already
+ * installed — used by standalone entry points (`akm consolidate`, `akm drain`)
+ * that may also run as a sub-step of `akm improve`. When invoked inside an
+ * enclosing run the existing per-run sink keeps ownership; the returned
+ * disposer then does nothing, so the enclosing run's `finally` still clears it.
+ */
+export function installLlmUsagePersistenceIfAbsent(ctx) {
+    if (hasLlmUsageSink())
+        return () => { };
+    return installLlmUsagePersistence(ctx);
+}

package/dist/llm/usage-telemetry.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/.
+/**
+ * Per-call LLM usage telemetry (#576).
+ *
+ * `chatCompletion` captures usage + model + finish_reason + wall-time for
+ * EVERY OpenAI-compatible call and emits one {@link LlmUsageRecord} through a
+ * module-level sink. The sink indirection keeps `client.ts` free of any
+ * dependency on the events/db layer: the application wires the sink to
+ * persistence at startup / per improve run, and tests can inspect records in
+ * memory.
+ *
+ * The pipeline *stage* that made the call is ambient, not threaded through
+ * call sites. A param-threading prototype was deliberately discarded in 0.8.5
+ * (every call site would have to forward a `stage` argument it does not care
+ * about). Instead callers wrap a well-delimited phase once with
+ * {@link withLlmStage}; any `chatCompletion` invoked inside that async region —
+ * however deeply nested — is attributed to that stage via `AsyncLocalStorage`.
+ *
+ * EVERYTHING here is best-effort. Telemetry must NEVER break a real LLM call:
+ * a sink that throws, an unset stage, or a malformed usage block all degrade
+ * silently. `emitLlmUsage` swallows sink errors; `currentLlmStage` returns
+ * `undefined` outside any `withLlmStage` scope.
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
+const stageStorage = new AsyncLocalStorage();
+let usageSink;
+/**
+ * Run `fn` with `stage` as the ambient LLM stage. Any `chatCompletion` call
+ * made synchronously or asynchronously within `fn` (including through awaited
+ * helpers and nested `withLlmStage` calls — the innermost wins) is attributed
+ * to `stage`. Returns whatever `fn` returns; never alters control flow.
+ */
+export function withLlmStage(stage, fn) {
+    return stageStorage.run(stage, fn);
+}
+/** The ambient LLM stage for the current async context, or `undefined` outside any {@link withLlmStage} scope. */
+export function currentLlmStage() {
+    return stageStorage.getStore();
+}
+/**
+ * Install the process-wide usage sink. Replaces any previously installed sink.
+ * The application wires this to persistence; tests install an in-memory
+ * collector. Pair with {@link clearLlmUsageSink} in a `finally` block.
+ */
+export function setLlmUsageSink(sink) {
+    usageSink = sink;
+}
+/** Remove the installed sink so subsequent calls emit nowhere. Idempotent. */
+export function clearLlmUsageSink() {
+    usageSink = undefined;
+}
+/**
+ * Whether a usage sink is currently installed. Standalone entry points use
+ * this to avoid clobbering a sink an enclosing run (e.g. `akm improve`) already
+ * installed: they install their own only when none is active.
+ */
+export function hasLlmUsageSink() {
+    return usageSink !== undefined;
+}
+/**
+ * Emit one usage record to the installed sink, stamping the ambient stage.
+ * Best-effort: no sink is a no-op, and a sink that throws is swallowed so
+ * telemetry can never fail the LLM call that produced it.
+ */
+export function emitLlmUsage(record) {
+    const sink = usageSink;
+    if (!sink)
+        return;
+    try {
+        sink({ ...record, stage: record.stage ?? currentLlmStage() });
+    }
+    catch {
+        // Telemetry must never break a real run.
+    }
+}
+function asFiniteNonNegative(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+/**
+ * Project a provider `usage` block into the token fields of an
+ * {@link LlmUsageRecord}. Missing or garbled values are omitted (not zeroed)
+ * so a best-effort record still distinguishes "0 tokens" from "unknown".
+ */
+export function extractUsageTokens(usage) {
+    if (!usage || typeof usage !== "object")
+        return {};
+    const out = {};
+    const prompt = asFiniteNonNegative(usage.prompt_tokens);
+    const completion = asFiniteNonNegative(usage.completion_tokens);
+    const total = asFiniteNonNegative(usage.total_tokens);
+    const reasoning = asFiniteNonNegative(usage.completion_tokens_details?.reasoning_tokens);
+    if (prompt !== undefined)
+        out.promptTokens = prompt;
+    if (completion !== undefined)
+        out.completionTokens = completion;
+    if (total !== undefined)
+        out.totalTokens = total;
+    if (reasoning !== undefined)
+        out.reasoningTokens = reasoning;
+    return out;
+}

package/dist/output/context.js

@@ -11,8 +11,8 @@
  *
  * Initialized from `cli.ts` before `runMain`.
  */
-import { UsageError } from "../core/errors";
-export const OUTPUT_FORMATS = ["json", "yaml", "text", "jsonl", "md"];
+import { UsageError } from "../core/errors.js";
+export const OUTPUT_FORMATS = ["json", "yaml", "text", "jsonl", "md", "html"];
 export const DETAIL_LEVELS = ["brief", "normal", "full"];
 export const SHAPE_MODES = ["human", "agent", "summary"];
 export function parseOutputFormat(value) {
@@ -75,50 +75,13 @@ export function resolveOutputMode(argv, defaults = {}) {
     const format = parseOutputFormat(parseFlagValue(argv, "--format")) ?? defaults?.format ?? "json";
     const rawDetail = parseFlagValue(argv, "--detail");
     const rawShape = parseFlagValue(argv, "--shape");
-    const usedForAgent = hasBooleanFlag(argv, "--for-agent");
-    // Back-compat: the projection presets `summary`/`agent` used to live on
-    // `--detail`. They moved to `--shape` in 0.8 (removed from `--detail` in
-    // 0.9.0). Map the legacy spellings onto `--shape` + warn, and treat the
-    // verbosity axis as `normal` (the prior effective behaviour).
-    let detailForVerbosity = rawDetail;
-    let shapeFromLegacyDetail;
-    if (rawDetail === "summary" || rawDetail === "agent") {
-        // Only nudge toward `--shape` when the caller did not already pass an
-        // explicit `--shape` (which wins below). Otherwise the "use --shape <x>"
-        // advice would name a projection the caller did not request.
-        if (rawShape === undefined)
-            emitDetailShapeDeprecation(rawDetail);
-        shapeFromLegacyDetail = rawDetail;
-        detailForVerbosity = "normal";
-    }
-    else if (rawDetail === "per-run") {
-        // Legacy `akm health --detail per-run` (→ `--group-by run`). The health
-        // command owns the back-compat warning + mapping; the global singleton must
-        // not reject the value here, so fall through to the default verbosity.
-        detailForVerbosity = undefined;
-    }
-    if (usedForAgent) {
-        emitForAgentDeprecation();
-    }
-    const detail = parseDetailLevel(detailForVerbosity) ?? defaults?.detail ?? "brief";
-    // Precedence: explicit `--shape` wins; then legacy `--detail summary|agent`;
-    // then legacy `--for-agent`; default `human`.
-    const shape = parseShapeMode(rawShape) ?? shapeFromLegacyDetail ?? (usedForAgent ? "agent" : "human");
-    return { format, detail, shape, forAgent: shape === "agent" };
-}
-/** Suppress deprecation warnings under `--quiet` (mirrors the rest of the CLI). */
-function isQuietArgv() {
-    return process.argv.includes("--quiet") || process.argv.includes("-q");
-}
-function emitDetailShapeDeprecation(value) {
-    if (isQuietArgv())
-        return;
-    process.stderr.write(`warning: '--detail ${value}' is deprecated; use '--shape ${value}'. Removed in 0.9.0.\n`);
-}
-function emitForAgentDeprecation() {
-    if (isQuietArgv())
-        return;
-    process.stderr.write("warning: '--for-agent' is deprecated; use '--shape agent'. Removed in 0.9.0.\n");
+    // `--detail` is verbosity only (brief|normal|full); the projection presets
+    // (`summary`/`agent`) and the `--for-agent` boolean were removed in 0.9.0 —
+    // use `--shape`. Unknown `--detail` values fall through to the default.
+    const detail = parseDetailLevel(rawDetail) ?? defaults?.detail ?? "brief";
+    const shape = parseShapeMode(rawShape) ?? "human";
+    const outputPath = parseFlagValue(argv, "--output");
+    return { format, detail, shape, forAgent: shape === "agent", ...(outputPath ? { outputPath } : {}) };
 }
 let _mode;
 /**

package/dist/output/html-render.js

@@ -0,0 +1,73 @@
+// 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/.
+/**
+ * `--format html` rendering primitives (#582).
+ *
+ * Templates live in `src/assets/templates/html/` (mirrored to
+ * `dist/assets/templates/html/` by `scripts/copy-assets.ts`). A command with a
+ * bespoke template ships `<command>.html`; every other command falls back to
+ * `default.html`, which renders the command's JSON envelope in a `<pre>`
+ * block. Substitution is plain `%%TOKEN%%` string replacement — no template
+ * engine, by design.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { getDirname } from "../runtime.js";
+const TEMPLATES_DIR = path.join(getDirname(import.meta.url), "../assets/templates/html");
+/** Template used by every command without a bespoke `<command>.html`. */
+export const DEFAULT_TEMPLATE = "default";
+/**
+ * Resolve the on-disk template path for a command. `<command>.html` when the
+ * command ships a bespoke template (today: `health`), otherwise
+ * `default.html`. Command names are sanitized to a bare basename so a hostile
+ * command string can never escape the templates directory.
+ */
+export function resolveTemplatePath(command) {
+    const name = path.basename(command.trim());
+    const candidate = path.join(TEMPLATES_DIR, `${name}.html`);
+    if (name !== DEFAULT_TEMPLATE && fs.existsSync(candidate))
+        return candidate;
+    return path.join(TEMPLATES_DIR, `${DEFAULT_TEMPLATE}.html`);
+}
+/** Matches a `%%TOKEN%%` placeholder (uppercase + underscore key). */
+const TOKEN_RE = /%%[A-Z_]+%%/g;
+/**
+ * Read a template and substitute every `%%TOKEN%%` in `replacements` in a
+ * single pass. Substitution is order-independent: a value that happens to
+ * contain another token's literal text is never re-processed (the pass scans
+ * the original template, not the growing output). Unknown tokens in the
+ * template are left in place (the health template is verified token-complete by
+ * tests); replacement keys missing from the template are silently ignored,
+ * matching the skill renderer's behaviour.
+ */
+export function renderHtml(templatePath, replacements) {
+    const html = fs.readFileSync(templatePath, "utf8");
+    return html.replace(TOKEN_RE, (token) => (token in replacements ? replacements[token] : token));
+}
+/**
+ * Minimal HTML entity escaping for text interpolated into templates. Escapes
+ * the single quote as well as the double quote so escaped values are safe in
+ * both `"…"` and `'…'` attribute contexts, not only the double-quoted
+ * attributes the bundled templates use today.
+ */
+export function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+/**
+ * Deliver a rendered document: write to `outputPath` when set (`--output`),
+ * otherwise print to stdout.
+ */
+export function deliverRendered(content, outputPath) {
+    if (outputPath) {
+        fs.mkdirSync(path.dirname(path.resolve(outputPath)), { recursive: true });
+        fs.writeFileSync(outputPath, content.endsWith("\n") ? content : `${content}\n`);
+        return;
+    }
+    console.log(content);
+}

package/dist/output/renderers.js

@@ -11,14 +11,14 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-import { listKeys as listVaultKeys } from "../commands/env";
-import { asNonEmptyString, hasErrnoCode } from "../core/common";
-import { parseFrontmatter } from "../core/frontmatter";
-import { extractFrontmatterOnly, extractLineRange, extractSection, formatToc, parseMarkdownToc, } from "../core/markdown";
-import { registerRenderer } from "../indexer/file-context";
-import { extractCommentMetadata, extractDescriptionFromComments } from "../indexer/metadata";
-import { registerMetadataContributor } from "../indexer/metadata-contributors";
-import { buildWorkflowAction, workflowMdRenderer } from "../workflows/renderer";
+import { listKeys as listVaultKeys } from "../commands/env/env.js";
+import { parseFrontmatter } from "../core/asset/frontmatter.js";
+import { extractFrontmatterOnly, extractLineRange, extractSection, formatToc, parseMarkdownToc, } from "../core/asset/markdown.js";
+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";
 // ── Interpreter auto-detection map ───────────────────────────────────────────
 const INTERPRETER_MAP = {
     ".sh": "bash",
@@ -362,38 +362,11 @@ const scriptSourceRenderer = {
         }
     },
 };
-// ── 8. vault-env ─────────────────────────────────────────────────────────────
+// ── 8. env-file ───────────────────────────────────────────────────────────────
 /**
- * Vault renderer. Returns ONLY key names and start-of-line comments — never
- * values. Deliberately omits content/template/prompt so vault values cannot
- * leak through `akm show`.
- */
-const vaultEnvRenderer = {
-    name: "vault-env",
-    buildShowResponse(ctx) {
-        const name = deriveName(ctx);
-        const { keys, comments } = listVaultKeys(ctx.absPath);
-        return {
-            type: "vault",
-            name,
-            path: ctx.absPath,
-            action: 'Vault — keys + comments only. Use `source "$(akm vault path <ref>)"` to load values into the current shell, or `akm vault run <ref[/KEY]> -- <command>` to run with injected env. Values stay on disk and are never written to akm\'s stdout.',
-            description: comments.length > 0 ? comments.join("\n") : undefined,
-            keys,
-            comments,
-        };
-    },
-    enrichSearchHit(hit, _stashDir) {
-        const { keys } = listVaultKeys(hit.path);
-        if (keys.length > 0)
-            hit.keys = keys;
-    },
-};
-// ── 8b. env-file ───────────────────────────────────────────────────────────────
-/**
- * Env renderer. Like the (deprecated) vault 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 and start-of-line comments — never
+ * values. Deliberately omits content/template/prompt so env values cannot leak
+ * through `akm show`.
  */
 const envFileRenderer = {
     name: "env-file",
@@ -449,6 +422,75 @@ const taskMdRenderer = {
         };
     },
 };
+// ── 8. session-md (#561) ─────────────────────────────────────────────────────
+/**
+ * Renderer for the `session` asset type (#561). A session asset is generated by
+ * the `extract` pass and carries `harness`, `started_at`/`ended_at`, `project`,
+ * `log_path`, and `access` frontmatter plus an LLM `## Summary` / `## Key topics`
+ * body. The renderer surfaces a human-readable one-liner (harness + date +
+ * project) and concrete `access` instructions rather than dumping raw
+ * frontmatter, so an agent can decide whether to open the raw log.
+ */
+const sessionMdRenderer = {
+    name: "session-md",
+    buildShowResponse(ctx) {
+        const name = deriveName(ctx);
+        const parsed = parseFrontmatter(ctx.content());
+        const fm = parsed.data;
+        const harness = asNonEmptyString(fm.harness);
+        const project = asNonEmptyString(fm.project);
+        const startedAt = asNonEmptyString(fm.started_at);
+        const endedAt = asNonEmptyString(fm.ended_at);
+        const logPath = asNonEmptyString(fm.log_path);
+        const access = asNonEmptyString(fm.access);
+        const description = asNonEmptyString(fm.description);
+        const dateRange = startedAt ? (endedAt ? `${startedAt} – ${endedAt}` : startedAt) : undefined;
+        const headerParts = [
+            harness ? `harness: ${harness}` : undefined,
+            project ? `project: ${project}` : undefined,
+            dateRange,
+        ].filter((p) => !!p);
+        const accessLine = [logPath ? `log: ${logPath}` : undefined, access].filter((p) => !!p).join("\n");
+        const action = [
+            "Prior agent session — read the summary below.",
+            headerParts.length > 0 ? headerParts.join("  ") : undefined,
+            accessLine ? `Open the raw log:\n${accessLine}` : undefined,
+        ]
+            .filter((p) => !!p)
+            .join("\n");
+        return {
+            type: "session",
+            name,
+            path: ctx.absPath,
+            action,
+            description,
+            content: parsed.content,
+        };
+    },
+};
+function applySessionMetadata(entry, ctx) {
+    try {
+        const fm = applyFrontmatterDescriptionAndTags(entry, ctx);
+        entry.tags = Array.from(new Set([...(entry.tags ?? []), "session"]));
+        const hints = new Set(entry.searchHints ?? []);
+        const harness = asNonEmptyString(fm.harness);
+        if (harness)
+            hints.add(`harness:${harness}`);
+        const project = asNonEmptyString(fm.project);
+        if (project)
+            hints.add(`project:${project}`);
+        // log_path is the durable correlation key — keep it discoverable as a hint
+        // so it survives in the index even when the body is re-derived.
+        const logPath = asNonEmptyString(fm.log_path);
+        if (logPath)
+            hints.add(`log_path:${logPath}`);
+        if (hints.size > 0)
+            entry.searchHints = Array.from(hints).filter(Boolean);
+    }
+    catch {
+        // Non-fatal: skip metadata extraction on parse error
+    }
+}
 function applyTocMetadata(entry, ctx) {
     try {
         const toc = parseMarkdownToc(ctx.content());
@@ -538,18 +580,6 @@ function applyScriptMetadata(entry, ctx) {
         entry.confidence = 0.7;
     }
 }
-function applyVaultMetadata(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;
-    }
-    if (keys.length > 0) {
-        entry.searchHints = keys;
-    }
-    entry.tags = Array.from(new Set([...(entry.tags ?? []), "vault", "secrets"]));
-}
 function applyEnvMetadata(entry, ctx) {
     const { keys, comments } = listVaultKeys(ctx.absPath);
     if (comments.length > 0 && !entry.description) {
@@ -610,11 +640,6 @@ registerMetadataContributor({
     appliesTo: ({ rendererName }) => rendererName === "script-source",
     contribute: (entry, ctx) => applyScriptMetadata(entry, ctx.renderContext),
 });
-registerMetadataContributor({
-    name: "vault-secret-metadata",
-    appliesTo: ({ rendererName }) => rendererName === "vault-env",
-    contribute: (entry, ctx) => applyVaultMetadata(entry, ctx.renderContext),
-});
 registerMetadataContributor({
     name: "env-file-metadata",
     appliesTo: ({ rendererName }) => rendererName === "env-file",
@@ -630,6 +655,11 @@ registerMetadataContributor({
     appliesTo: ({ rendererName }) => rendererName === "task-yaml",
     contribute: (entry, ctx) => applyTaskMetadata(entry, ctx.renderContext),
 });
+registerMetadataContributor({
+    name: "session-md-metadata",
+    appliesTo: ({ rendererName }) => rendererName === "session-md",
+    contribute: (entry, ctx) => applySessionMetadata(entry, ctx.renderContext),
+});
 // ── Registration ─────────────────────────────────────────────────────────────
 /** All built-in renderers. */
 const builtinRenderers = [
@@ -643,9 +673,9 @@ const builtinRenderers = [
     workflowMdRenderer,
     scriptSourceRenderer,
     envFileRenderer,
-    vaultEnvRenderer,
     secretFileRenderer,
     taskMdRenderer,
+    sessionMdRenderer,
 ];
 /**
  * Register all built-in renderers with the file-context registry.
@@ -657,4 +687,4 @@ export function registerBuiltinRenderers() {
     }
 }
 // ── Named exports for testing ────────────────────────────────────────────────
-export { agentMdRenderer, commandMdRenderer, envFileRenderer, INTERPRETER_MAP, knowledgeMdRenderer, lessonMdRenderer, memoryMdRenderer, SETUP_SIGNALS, scriptSourceRenderer, secretFileRenderer, skillMdRenderer, vaultEnvRenderer, wikiMdRenderer, workflowMdRenderer, };
+export { agentMdRenderer, commandMdRenderer, envFileRenderer, INTERPRETER_MAP, knowledgeMdRenderer, lessonMdRenderer, memoryMdRenderer, SETUP_SIGNALS, scriptSourceRenderer, secretFileRenderer, skillMdRenderer, wikiMdRenderer, workflowMdRenderer, };

package/dist/output/shapes/curate.js

@@ -1,8 +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 { capDescription, NORMAL_DESCRIPTION_LIMIT, pickFields } from "./helpers";
-import { registerOutputShape } from "./registry";
+import { capDescription, NORMAL_DESCRIPTION_LIMIT, pickFields } from "./helpers.js";
 // 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.
@@ -53,4 +52,9 @@ export function shapeCurateOutput(result, detail, shape) {
     };
     return base;
 }
-registerOutputShape("curate", (result, detail, shape) => shapeCurateOutput(result, detail, shape));
+export const curateShapes = [
+    {
+        command: "curate",
+        handler: (result, detail, shape) => shapeCurateOutput(result, detail, shape),
+    },
+];

package/dist/output/shapes/distill.js

@@ -5,6 +5,10 @@
 // simple — outcome + ids + optional payload — so `brief` strips the full
 // proposal blob, `normal` keeps the headline fields, and `full` projects
 // everything for downstream automation.
-import { shapeDistillOutput } from "./helpers";
-import { registerOutputShape } from "./registry";
-registerOutputShape("distill", (result, detail) => shapeDistillOutput(result, detail));
+import { shapeDistillOutput } from "./helpers.js";
+export const distillShapes = [
+    {
+        command: "distill",
+        handler: (result, detail) => shapeDistillOutput(result, detail),
+    },
+];

package/dist/output/shapes/env-list.js

@@ -1,19 +1,21 @@
 // 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/.
-// env-list strips `path` from each env object (security: avoid leaking
-// absolute disk paths) then stamps the envelope.
-import { registerOutputShape } from "./registry";
-registerOutputShape("env-list", (result) => {
-    const r = result;
-    const envs = Array.isArray(r.envs) ? r.envs : [];
-    return {
-        ...r,
-        shape: r.shape ?? "env-list",
-        schemaVersion: r.schemaVersion ?? 1,
-        envs: envs.map((v) => {
-            const { path: _path, ...rest } = v;
-            return rest;
-        }),
-    };
-});
+export const envListShapes = [
+    {
+        command: "env-list",
+        handler: (result) => {
+            const r = result;
+            const envs = Array.isArray(r.envs) ? r.envs : [];
+            return {
+                ...r,
+                shape: r.shape ?? "env-list",
+                schemaVersion: r.schemaVersion ?? 1,
+                envs: envs.map((v) => {
+                    const { path: _path, ...rest } = v;
+                    return rest;
+                }),
+            };
+        },
+    },
+];

package/dist/output/shapes/events.js

@@ -4,8 +4,9 @@
 // Output shape registration for `akm events list` and `akm events tail` (#204).
 // Both share the same envelope; the renderer in text.ts uses distinct command
 // names so it can format streaming differently.
-import { shapeEventsOutput } from "./helpers";
-import { registerOutputShape } from "./registry";
+import { shapeEventsOutput } from "./helpers.js";
 const handler = (result, detail) => shapeEventsOutput(result, detail);
-registerOutputShape("events-list", handler);
-registerOutputShape("events-tail", handler);
+export const eventsShapes = [
+    { command: "events-list", handler },
+    { command: "events-tail", handler },
+];