akm-cli 0.7.4 → 0.8.0-rc.10

package/dist/output/shapes/curate.js

@@ -0,0 +1,56 @@
+// 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";
+// 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 NORMAL_FIELDS = [
+    "source",
+    "type",
+    "name",
+    "ref",
+    "id",
+    "description",
+    "preview",
+    "keys",
+    "parameters",
+    "run",
+    "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"];
+function shapeCurateItem(item, detail, shape) {
+    if (shape === "agent") {
+        return capDescription(pickFields(item, AGENT_FIELDS), NORMAL_DESCRIPTION_LIMIT);
+    }
+    if (detail === "brief") {
+        return pickFields(item, BRIEF_FIELDS);
+    }
+    if (detail === "normal") {
+        return capDescription(pickFields(item, NORMAL_FIELDS), NORMAL_DESCRIPTION_LIMIT);
+    }
+    // full: project everything the curator emits.
+    return item;
+}
+export function shapeCurateOutput(result, detail, shape) {
+    const items = Array.isArray(result.items) ? result.items : [];
+    const shapedItems = items.map((item) => shapeCurateItem(item, detail, shape));
+    const base = {
+        // `shape`/`schemaVersion` discriminators preserve the prior passthrough
+        // envelope contract (#484) so consumers can pin a schema version.
+        schemaVersion: typeof result.schemaVersion === "number" ? result.schemaVersion : 1,
+        shape: "curate",
+        query: result.query,
+        summary: result.summary,
+        items: shapedItems,
+        ...(Array.isArray(result.warnings) && result.warnings.length > 0 ? { warnings: result.warnings } : {}),
+        ...(result.tip ? { tip: result.tip } : {}),
+    };
+    return base;
+}
+registerOutputShape("curate", (result, detail, shape) => shapeCurateOutput(result, detail, shape));

package/dist/output/shapes/distill.js

@@ -0,0 +1,10 @@
+// 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 shape registration for `akm distill <ref>` (#228). The shape is
+// 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));

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

@@ -0,0 +1,19 @@
+// 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;
+        }),
+    };
+});

package/dist/output/shapes/events.js

@@ -0,0 +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 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";
+const handler = (result, detail) => shapeEventsOutput(result, detail);
+registerOutputShape("events-list", handler);
+registerOutputShape("events-tail", handler);

package/dist/output/shapes/helpers.js

@@ -0,0 +1,424 @@
+// 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/.
+export const NORMAL_DESCRIPTION_LIMIT = 250;
+export function shapeProposalProducerOutput(result, detail) {
+    if (result.ok === false) {
+        const base = {
+            ok: false,
+            reason: result.reason,
+            error: result.error,
+            ...(result.ref !== undefined ? { ref: result.ref } : {}),
+            ...(result.type !== undefined ? { type: result.type } : {}),
+            ...(result.name !== undefined ? { name: result.name } : {}),
+            ...(result.exitCode !== undefined ? { exitCode: result.exitCode } : {}),
+        };
+        if (detail === "full") {
+            return {
+                schemaVersion: result.schemaVersion ?? 1,
+                ...base,
+                ...(result.stdout !== undefined ? { stdout: result.stdout } : {}),
+                ...(result.stderr !== undefined ? { stderr: result.stderr } : {}),
+            };
+        }
+        return base;
+    }
+    const proposal = result.proposal ?? {};
+    const base = {
+        ok: true,
+        ref: result.ref,
+        ...(result.agentProfile !== undefined ? { agentProfile: result.agentProfile } : {}),
+        ...(typeof result.durationMs === "number" ? { durationMs: result.durationMs } : {}),
+        proposal: shapeProposalEntry(proposal, detail === "brief" ? "normal" : detail),
+    };
+    if (detail === "full") {
+        return { schemaVersion: result.schemaVersion ?? 1, ...base };
+    }
+    return base;
+}
+export function shapeProposalEntry(entry, detail) {
+    if (detail === "brief") {
+        return pickFields(entry, ["id", "ref", "status", "source", "createdAt"]);
+    }
+    if (detail === "normal") {
+        return pickFields(entry, ["id", "ref", "status", "source", "sourceRun", "createdAt", "updatedAt", "review"]);
+    }
+    // full: project everything including the payload.
+    return pickFields(entry, [
+        "id",
+        "ref",
+        "status",
+        "source",
+        "sourceRun",
+        "createdAt",
+        "updatedAt",
+        "payload",
+        "review",
+    ]);
+}
+export function shapeProposalListOutput(result, detail) {
+    const proposals = Array.isArray(result.proposals) ? result.proposals : [];
+    const shaped = proposals.map((p) => shapeProposalEntry(p, detail));
+    const base = {
+        totalCount: result.totalCount ?? shaped.length,
+        proposals: shaped,
+    };
+    if (detail === "full") {
+        return { schemaVersion: result.schemaVersion ?? 1, ...base };
+    }
+    return base;
+}
+export function shapeProposalShowOutput(result, detail) {
+    const proposal = result.proposal ?? {};
+    const validation = result.validation;
+    const base = {
+        proposal: shapeProposalEntry(proposal, detail === "brief" ? "normal" : detail),
+        ...(validation ? { validation } : {}),
+    };
+    if (detail === "full") {
+        return { schemaVersion: result.schemaVersion ?? 1, ...base };
+    }
+    return base;
+}
+export function shapeProposalAcceptOutput(result, detail) {
+    const proposal = result.proposal ?? {};
+    const base = {
+        ok: result.ok ?? true,
+        id: result.id,
+        ref: result.ref,
+        assetPath: result.assetPath,
+        proposal: shapeProposalEntry(proposal, detail === "brief" ? "normal" : detail),
+    };
+    if (detail === "full") {
+        return { schemaVersion: result.schemaVersion ?? 1, ...base };
+    }
+    return base;
+}
+export function shapeProposalRejectOutput(result, detail) {
+    const proposal = result.proposal ?? {};
+    const base = {
+        ok: result.ok ?? true,
+        id: result.id,
+        ref: result.ref,
+        ...(result.reason !== undefined ? { reason: result.reason } : {}),
+        proposal: shapeProposalEntry(proposal, detail === "brief" ? "normal" : detail),
+    };
+    if (detail === "full") {
+        return { schemaVersion: result.schemaVersion ?? 1, ...base };
+    }
+    return base;
+}
+export function shapeDistillOutput(result, detail) {
+    const proposal = result.proposal;
+    if (detail === "brief") {
+        return pickFields(result, ["ok", "outcome", "inputRef", "lessonRef", "proposalId", "message"]);
+    }
+    const base = {
+        ok: result.ok ?? true,
+        outcome: result.outcome,
+        inputRef: result.inputRef,
+        lessonRef: result.lessonRef,
+        ...(result.proposalId !== undefined ? { proposalId: result.proposalId } : {}),
+        ...(result.message !== undefined ? { message: result.message } : {}),
+        ...(Array.isArray(result.findings) && result.findings.length > 0 ? { findings: result.findings } : {}),
+        ...(proposal ? { proposal: shapeProposalEntry(proposal, detail) } : {}),
+    };
+    if (detail === "full") {
+        return { schemaVersion: result.schemaVersion ?? 1, ...base };
+    }
+    return base;
+}
+export function shapeProposalDiffOutput(result, detail) {
+    const base = {
+        id: result.id,
+        ref: result.ref,
+        isNew: result.isNew,
+        unified: result.unified,
+        ...(result.targetPath !== undefined ? { targetPath: result.targetPath } : {}),
+    };
+    if (detail === "full") {
+        return { schemaVersion: result.schemaVersion ?? 1, ...base };
+    }
+    return base;
+}
+export function shapeEventsOutput(result, detail) {
+    const events = Array.isArray(result.events) ? result.events : [];
+    const shapedEvents = events.map((event) => shapeEventEntry(event, detail));
+    const base = {
+        ...(result.ref !== undefined ? { ref: result.ref } : {}),
+        ...(result.type !== undefined ? { type: result.type } : {}),
+        ...(result.since !== undefined ? { since: result.since } : {}),
+        ...(typeof result.sinceOffset === "number" ? { sinceOffset: result.sinceOffset } : {}),
+        totalCount: result.totalCount ?? shapedEvents.length,
+        events: shapedEvents,
+    };
+    if (typeof result.nextOffset === "number") {
+        base.nextOffset = result.nextOffset;
+    }
+    if (typeof result.reason === "string") {
+        base.reason = result.reason;
+    }
+    if (detail === "full") {
+        return { schemaVersion: result.schemaVersion ?? 1, ...base };
+    }
+    return base;
+}
+export function shapeEventEntry(entry, detail) {
+    if (detail === "brief") {
+        return pickFields(entry, ["eventType", "ref", "ts"]);
+    }
+    if (detail === "normal") {
+        return pickFields(entry, ["eventType", "ref", "ts"]);
+    }
+    // full: project everything the reader emits.
+    return pickFields(entry, ["id", "schemaVersion", "eventType", "ref", "ts", "metadata"]);
+}
+export function shapeHistoryOutput(result, detail) {
+    const entries = Array.isArray(result.entries) ? result.entries : [];
+    const shapedEntries = entries.map((entry) => shapeHistoryEntry(entry, detail));
+    if (detail === "full") {
+        return {
+            schemaVersion: result.schemaVersion ?? 1,
+            ...(result.ref !== undefined ? { ref: result.ref } : {}),
+            ...(result.since !== undefined ? { since: result.since } : {}),
+            totalCount: result.totalCount ?? shapedEntries.length,
+            entries: shapedEntries,
+            // `sources` lists the event sources included in this response.
+            // Always contains "usage_events"; also "events.jsonl" when
+            // --include-proposals was specified.
+            ...(Array.isArray(result.sources) ? { sources: result.sources } : {}),
+            ...(Array.isArray(result.warnings) && result.warnings.length > 0 ? { warnings: result.warnings } : {}),
+        };
+    }
+    return {
+        ...(result.ref !== undefined ? { ref: result.ref } : {}),
+        ...(result.since !== undefined ? { since: result.since } : {}),
+        totalCount: result.totalCount ?? shapedEntries.length,
+        entries: shapedEntries,
+        ...(Array.isArray(result.sources) ? { sources: result.sources } : {}),
+        ...(Array.isArray(result.warnings) && result.warnings.length > 0 ? { warnings: result.warnings } : {}),
+    };
+}
+export function shapeHistoryEntry(entry, detail) {
+    if (detail === "brief") {
+        // signal is load-bearing for feedback rows (positive/negative) so we
+        // project it even at brief — without it the entry is ambiguous.
+        // source lets callers verify filter correctness (e.g. --source user).
+        return pickFields(entry, ["eventType", "ref", "signal", "source", "createdAt"]);
+    }
+    if (detail === "normal") {
+        return pickFields(entry, ["eventType", "ref", "signal", "source", "query", "createdAt"]);
+    }
+    // full: return everything the reader emits.
+    return pickFields(entry, ["id", "eventType", "ref", "entryId", "query", "signal", "source", "metadata", "createdAt"]);
+}
+export function shapeSearchOutput(result, detail, shape = "human") {
+    const forAgent = shape === "agent";
+    const hits = Array.isArray(result.hits) ? result.hits : [];
+    const registryHits = Array.isArray(result.registryHits) ? result.registryHits : [];
+    const shapedHits = forAgent
+        ? hits.map((hit) => shapeSearchHitForAgent(hit))
+        : hits.map((hit) => shapeSearchHit(hit, detail));
+    const shapedRegistryHits = forAgent
+        ? registryHits.map((hit) => shapeSearchHitForAgent(hit))
+        : registryHits.map((hit) => shapeSearchHit(hit, detail));
+    if (forAgent) {
+        return {
+            hits: shapedHits,
+            ...(shapedRegistryHits.length > 0 ? { registryHits: shapedRegistryHits } : {}),
+            ...(result.tip ? { tip: result.tip } : {}),
+        };
+    }
+    if (detail === "full") {
+        return {
+            schemaVersion: result.schemaVersion,
+            stashDir: result.stashDir,
+            source: result.source,
+            hits: shapedHits,
+            ...(shapedRegistryHits.length > 0 ? { registryHits: shapedRegistryHits } : {}),
+            ...(result.semanticSearch ? { semanticSearch: result.semanticSearch } : {}),
+            ...(result.tip ? { tip: result.tip } : {}),
+            ...(result.warnings ? { warnings: result.warnings } : {}),
+            ...(result.timing ? { timing: result.timing } : {}),
+        };
+    }
+    return {
+        hits: shapedHits,
+        ...(shapedRegistryHits.length > 0 ? { registryHits: shapedRegistryHits } : {}),
+        ...(Array.isArray(result.warnings) && result.warnings.length > 0 ? { warnings: result.warnings } : {}),
+        ...(result.tip ? { tip: result.tip } : {}),
+    };
+}
+export function shapeRegistrySearchOutput(result, detail) {
+    const hits = Array.isArray(result.hits) ? result.hits : [];
+    const assetHits = Array.isArray(result.assetHits) ? result.assetHits : [];
+    // Shape stash hits as registry type
+    const shapedKitHits = hits.map((hit) => shapeSearchHit({ ...hit, type: "registry" }, detail));
+    // Shape asset hits by detail level
+    const shapedAssetHits = assetHits.map((hit) => shapeAssetHit(hit, detail));
+    const shaped = {
+        hits: shapedKitHits,
+        ...(shapedAssetHits.length > 0 ? { assetHits: shapedAssetHits } : {}),
+        ...(Array.isArray(result.warnings) && result.warnings.length > 0 ? { warnings: result.warnings } : {}),
+    };
+    if (detail === "full") {
+        shaped.query = result.query;
+    }
+    return shaped;
+}
+export function shapeAssetHit(hit, detail) {
+    if (detail === "brief")
+        return pickFields(hit, ["assetName", "assetType", "action", "estimatedTokens"]);
+    if (detail === "normal") {
+        return capDescription(pickFields(hit, ["assetName", "assetType", "description", "stash", "action", "estimatedTokens"]), NORMAL_DESCRIPTION_LIMIT);
+    }
+    return hit;
+}
+export function shapeSearchHit(hit, detail) {
+    if (hit.type === "registry") {
+        if (detail === "brief") {
+            // RegistrySearchHit uses `title` (not `name`); always project installRef
+            // and score so callers can use the result without --detail full (QA #28).
+            const out = pickFields(hit, ["title", "name", "installRef", "score"]);
+            // Normalise: if only title exists, expose it as `name` for consistency
+            if (out.title && !out.name)
+                out.name = out.title;
+            return out;
+        }
+        if (detail === "normal") {
+            // `curated` was removed in v1 (spec §4.2). Renderers project optional
+            // hit-level `warnings` instead so providers can surface non-fatal issues.
+            const out = capDescription(pickFields(hit, ["title", "name", "description", "action", "installRef", "score", "warnings"]), NORMAL_DESCRIPTION_LIMIT);
+            if (out.title && !out.name)
+                out.name = out.title;
+            return out;
+        }
+        return hit;
+    }
+    // Stash hit (local or remote)
+    // `ref` is included at `brief` so agents can run `akm show <ref>` without
+    // needing --detail full or --for-agent (REC-03).
+    if (detail === "brief")
+        return pickFields(hit, ["type", "name", "ref", "action", "estimatedTokens", "keys"]);
+    if (detail === "normal") {
+        // `warnings` is projected at `normal` so non-fatal hit-level issues are
+        // visible without forcing callers up to `--detail full`. Optional
+        // `quality` (v1 spec §4.2) is also surfaced when present so callers
+        // can see why a `proposed` entry showed up under `--include-proposed`.
+        const shaped = capDescription(pickFields(hit, ["type", "name", "description", "action", "score", "estimatedTokens", "warnings", "quality"]), NORMAL_DESCRIPTION_LIMIT);
+        if (Array.isArray(hit.keys) && hit.keys.length > 0)
+            shaped.keys = hit.keys;
+        return shaped;
+    }
+    return hit;
+}
+/** Agent-optimized search hit: only fields an LLM agent needs to decide and act */
+export function shapeSearchHitForAgent(hit) {
+    const picked = pickFields(hit, ["name", "ref", "type", "description", "action", "score", "estimatedTokens", "keys"]);
+    return capDescription(picked, NORMAL_DESCRIPTION_LIMIT);
+}
+export function capDescription(hit, limit) {
+    if (typeof hit.description !== "string")
+        return hit;
+    return { ...hit, description: truncateDescription(hit.description, limit) };
+}
+export function truncateDescription(description, limit) {
+    const normalized = description.replace(/\s+/g, " ").trim();
+    if (normalized.length <= limit)
+        return normalized;
+    const truncated = normalized.slice(0, limit - 1);
+    const lastSpace = truncated.lastIndexOf(" ");
+    const safe = lastSpace >= Math.floor(limit * 0.6) ? truncated.slice(0, lastSpace) : truncated;
+    return `${safe.trimEnd()}...`;
+}
+export function shapeShowOutput(result, detail, shape = "human") {
+    if (shape === "agent") {
+        return pickFields(result, [
+            "type",
+            "name",
+            "description",
+            "action",
+            "content",
+            "template",
+            "prompt",
+            "run",
+            "setup",
+            "cwd",
+            "activeRun",
+            "toolPolicy",
+            "modelHint",
+            "agent",
+            "parameters",
+            "workflowTitle",
+            "workflowParameters",
+            "steps",
+            "keys",
+            "comments",
+            "related",
+        ]);
+    }
+    if (shape === "summary") {
+        return pickFields(result, [
+            "type",
+            "name",
+            "description",
+            "tags",
+            "parameters",
+            "workflowTitle",
+            "action",
+            "run",
+            "origin",
+            "keys",
+            "comments",
+            "related",
+        ]);
+    }
+    const base = pickFields(result, [
+        "type",
+        "name",
+        "origin",
+        "action",
+        "description",
+        "tags",
+        "content",
+        "template",
+        "prompt",
+        "toolPolicy",
+        "modelHint",
+        "agent",
+        "parameters",
+        "workflowTitle",
+        "workflowParameters",
+        "steps",
+        "run",
+        "setup",
+        "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).
+        // Exception: vault assets omit path to avoid leaking absolute disk paths
+        // into structured JSON output (security fix M3).
+        ...(result.type === "vault" ? [] : ["path"]),
+        "editable",
+    ]);
+    if (detail !== "full") {
+        return base;
+    }
+    return {
+        schemaVersion: 1,
+        ...base,
+        ...pickFields(result, ["editHint"]),
+    };
+}
+export function pickFields(source, fields) {
+    const result = {};
+    for (const field of fields) {
+        if (source[field] !== undefined) {
+            result[field] = source[field];
+        }
+    }
+    return result;
+}

package/dist/output/shapes/history.js

@@ -0,0 +1,7 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+// Output shape registration for `akm history` — paired with the text renderer in text.ts.
+import { shapeHistoryOutput } from "./helpers";
+import { registerOutputShape } from "./registry";
+registerOutputShape("history", (result, detail) => shapeHistoryOutput(result, detail));

package/dist/output/shapes/passthrough.js

@@ -0,0 +1,102 @@
+// 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/.
+// Identity-passthrough commands — registered here so the registry stays
+// exhaustive (v1 spec §9). Each result object is already shaped at the
+// command boundary; the registry just confirms there's no surprise
+// command name slipping through.
+import { registerOutputShape } from "./registry";
+// #484: stamp schemaVersion + shape discriminator on passthrough envelopes so
+// third-party consumers can pin a schema version and dispatch on shape uniformly.
+// Idempotent — never overwrites an existing schemaVersion or shape field.
+function makeStampHandler(command) {
+    return (result) => {
+        if (result === null || result === undefined)
+            return result;
+        if (typeof result !== "object" || Array.isArray(result))
+            return result;
+        const obj = result;
+        if (obj.shape === undefined)
+            obj.shape = command;
+        if (obj.schemaVersion === undefined)
+            obj.schemaVersion = 1;
+        return obj;
+    };
+}
+const PASSTHROUGH_COMMANDS = [
+    "add",
+    "agent-result",
+    "clone",
+    "config",
+    "db-backups",
+    "disable",
+    "enable",
+    "env-create",
+    "env-export",
+    "env-remove",
+    "feedback",
+    "graph-entities",
+    "graph-entity",
+    "graph-export",
+    "graph-orphans",
+    "graph-related",
+    "graph-relations",
+    "graph-summary",
+    "graph-update",
+    "extract",
+    "health",
+    "improve",
+    "lessons-coverage",
+    "import",
+    "index",
+    "info",
+    "init",
+    "lint",
+    "list",
+    "proposal-accept-batch",
+    "proposal-reject-batch",
+    "proposal-revert",
+    "registry-add",
+    "registry-build-index",
+    "registry-list",
+    "registry-remove",
+    "remember",
+    "remove",
+    "save",
+    "secret-set",
+    "secret-remove",
+    "setup",
+    "tasks-add",
+    "tasks-doctor",
+    "tasks-history",
+    "tasks-list",
+    "tasks-remove",
+    "tasks-run",
+    "tasks-show",
+    "tasks-sync",
+    "update",
+    "upgrade",
+    "vault-create",
+    "vault-set",
+    "vault-unset",
+    "wiki-create",
+    "wiki-ingest",
+    "wiki-lint",
+    "wiki-list",
+    "wiki-pages",
+    "wiki-register",
+    "wiki-remove",
+    "wiki-show",
+    "wiki-stash",
+    "workflow-complete",
+    "workflow-create",
+    "workflow-list",
+    "workflow-next",
+    "workflow-resume",
+    "workflow-start",
+    "workflow-status",
+    "workflow-validate",
+];
+for (const command of PASSTHROUGH_COMMANDS) {
+    registerOutputShape(command, makeStampHandler(command));
+}

package/dist/output/shapes/proposal-accept.js

@@ -0,0 +1,7 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+// Output shape registration for `akm proposal accept` (#225).
+import { shapeProposalAcceptOutput } from "./helpers";
+import { registerOutputShape } from "./registry";
+registerOutputShape("proposal-accept", (result, detail) => shapeProposalAcceptOutput(result, detail));

package/dist/output/shapes/proposal-diff.js

@@ -0,0 +1,7 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+// Output shape registration for `akm proposal diff` (#225).
+import { shapeProposalDiffOutput } from "./helpers";
+import { registerOutputShape } from "./registry";
+registerOutputShape("proposal-diff", (result, detail) => shapeProposalDiffOutput(result, detail));

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

@@ -0,0 +1,7 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+// Output shape registration for `akm proposal list` (#225).
+import { shapeProposalListOutput } from "./helpers";
+import { registerOutputShape } from "./registry";
+registerOutputShape("proposal-list", (result, detail) => shapeProposalListOutput(result, detail));

package/dist/output/shapes/proposal-producer.js

@@ -0,0 +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 shape registration for `akm reflect` and `akm propose` (#226).
+// Both share the proposal-producer envelope shape (success carries a proposal
+// entry; failure carries an AgentFailureReason discriminant).
+import { shapeProposalProducerOutput } from "./helpers";
+import { registerOutputShape } from "./registry";
+const handler = (result, detail) => shapeProposalProducerOutput(result, detail);
+registerOutputShape("reflect", handler);
+registerOutputShape("propose", handler);