akm-cli 0.9.16-alpha.1 → 0.9.16

package/dist/commands/proposal/propose.js

@@ -16,6 +16,7 @@ import fs from "node:fs";
 import { placementTypes, stashDirFor } from "../../core/asset/asset-placement.js";
 import { parseRefInput } from "../../core/asset/resolve-ref.js";
 import { resolveStashDir } from "../../core/common.js";
+import { generatedContentRejection } from "../../core/content-safety.js";
 import { UsageError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
 import { resolveStandardsContext } from "../../core/standards/resolve-standards-context.js";
@@ -217,7 +218,20 @@ export async function akmPropose(options) {
                 };
             }
         }
-        payload = { ...payload, content: redactWithLoweredExecutionDispatchLease(lease, payload.content) };
+        const unsafeContent = generatedContentRejection(payload.content, redactWithLoweredExecutionDispatchLease(lease, payload.content));
+        if (unsafeContent) {
+            return {
+                schemaVersion: 2,
+                ok: false,
+                reason: "parse_error",
+                error: unsafeContent,
+                type: options.type,
+                name: options.name,
+                engine: engineName,
+                exitCode: result.exitCode,
+                ...noticeFields(notices),
+            };
+        }
         // 6. Insert the proposal. Note: we allow the agent's `ref` to normalise the
         // asset name (e.g. path-cleanup), but only after validating that the ref is
         // well-formed and the type still matches the requested type.

package/dist/commands/proposal/repository.js

@@ -1027,19 +1027,10 @@ async function finalizeProposalTransaction(txn, target, proposal, ctx) {
     }
     let accepted = getProposal(p.stashDir, p.proposalId, ctx);
     if (txn.journal.phase === "proposal-persisted") {
-        if (await indexWrittenAssets(txn.journal.root, [p.assetPath], { bundleId: target.source.name })) {
-            advanceTxn(txn, "index-finalized");
-        }
-        else {
-            // `indexWrittenAssets`'s contract (index-written-assets.ts): `false`
-            // means the asset write already stands, but the index itself needs a
-            // manual `akm index` — warn and continue, the same as `source clone`
-            // treats the same return, instead of failing the whole accept/revert.
-            // Leave the phase at "proposal-persisted" (do not advance) so a later
-            // recovery of this journal retries the index update rather than
-            // skipping it as already done.
-            warn(`${p.operation === "accept" ? "Accept" : "Revert"} of ${p.ref} succeeded, but its index update failed; run \`akm index\` to refresh it.`);
+        if (!(await indexWrittenAssets(txn.journal.root, [p.assetPath], { bundleId: target.source.name }))) {
+            throw new Error(`Proposal ${p.proposalId} index finalization failed.`);
         }
+        advanceTxn(txn, "index-finalized");
     }
     if (txn.journal.phase === "index-finalized") {
         accepted = getProposal(p.stashDir, p.proposalId, ctx);

package/dist/commands/proposal/validators/proposal-quality-validators.js

@@ -61,6 +61,7 @@
 import { parseFrontmatter } from "../../../core/asset/frontmatter.js";
 import { parseRefInput } from "../../../core/asset/resolve-ref.js";
 import { DESCRIPTION_MAX_CHARS, DESCRIPTION_MIN_CHARS, WHEN_TO_USE_MAX_CHARS, WHEN_TO_USE_MIN_CHARS, } from "../../../core/authoring-rules.js";
+import { containsRedactedContent, containsReflectPromptScaffolding, REDACTED_CONTENT_MARKER, REFLECT_AVOID_PATTERNS_HEADING, } from "../../../core/content-safety.js";
 import { proposalContent } from "../../../core/file-change.js";
 /**
  * The canonical asset NAME an inputRef names, lower-cased — the tail the
@@ -399,6 +400,40 @@ const reflectTruncationMarkerValidator = {
         ];
     },
 };
+/** Never promote proposal text that already contains an output-redaction marker (#962). */
+const redactedContentValidator = {
+    name: "redacted-content",
+    appliesTo(proposal) {
+        return typeof proposal.payload?.content === "string";
+    },
+    validate(proposal) {
+        if (!containsRedactedContent(proposalContent(proposal)))
+            return [];
+        return [
+            {
+                kind: "redacted-content",
+                message: `Proposal ${proposal.id} (${proposal.ref}) contains ${REDACTED_CONTENT_MARKER}. Restore the original non-secret prose and create a clean proposal; redacted output cannot be promoted.`,
+            },
+        ];
+    },
+};
+/** Defense in depth when a reflect proposal bypasses creation-time sanitization (#963). */
+const reflectPromptScaffoldingValidator = {
+    name: "reflect-prompt-scaffolding",
+    appliesTo(proposal) {
+        return proposal.source === "reflect" && typeof proposal.payload?.content === "string";
+    },
+    validate(proposal) {
+        if (!containsReflectPromptScaffolding(proposalContent(proposal)))
+            return [];
+        return [
+            {
+                kind: "reflect-prompt-scaffolding",
+                message: `Proposal ${proposal.id} (${proposal.ref}) still contains the run-only "${REFLECT_AVOID_PATTERNS_HEADING}" prompt section. Reflect the asset again before promotion.`,
+            },
+        ];
+    },
+};
 /**
  * Report a validator's findings as advisory.
  *
@@ -424,9 +459,9 @@ function advisory(validator) {
  * Full set of quality validators in registration order. Appended onto
  * {@link defaultProposalValidators} so they run inside `validateProposal` on
  * `proposal accept` automatically. All prose-quality checks report without
- * blocking (see {@link advisory}); {@link reflectTruncationMarkerValidator} is
- * the one exception and blocks, since it guards against data loss rather than
- * prose quality.
+ * blocking (see {@link advisory}). The truncation-marker, redacted-content,
+ * and reflected-prompt-scaffolding validators block because they protect
+ * durable content rather than judging prose quality.
  */
 export const defaultProposalQualityValidators = [
     ...[
@@ -436,4 +471,6 @@ export const defaultProposalQualityValidators = [
         reflectSizeGuardValidator,
     ].map(advisory),
     reflectTruncationMarkerValidator,
+    redactedContentValidator,
+    reflectPromptScaffoldingValidator,
 ];

package/dist/commands/proposal/validators/proposal-validators.js

@@ -131,14 +131,15 @@ export const defaultProposalValidators = [
  * and was previously safe to run in full there because every quality
  * validator was advisory (`advisory()` downgrades findings to `severity:
  * "warn"`, which {@link runProposalValidators}'s `ok` never treats as
- * failing). #952's `reflect-truncation-marker` validator is deliberately
- * NOT advisory (it guards against data loss), so running the full
- * {@link defaultProposalValidators} list at mint time would throw
+ * failing). Blocking durable-content validators (the #952 truncation marker,
+ * #962 redaction marker, and #963 reflected prompt scaffolding) deliberately
+ * remain outside this subset, so running the full
+ * {@link defaultProposalValidators} list at mint time could throw
  * `invalid_canonical_structure` for any lesson/task/workflow reflect
  * proposal whose body leaks the truncation marker — instead of letting
  * `sanitizeReflectPayload` mint the proposal and defer it with
  * `reflect-truncation-leak`, per the #952 design. Quality validators (prose
- * shape, reflect size ratio, the truncation-marker guard) belong at
+ * shape, reflect size ratio, and durable-content guards) belong at
  * `proposal accept` / drain-promotion time, which already calls
  * {@link validateProposal} (the full list) via `preflightProposalPromotion`
  * / `promoteProposalWithLease`.

package/dist/commands/read/curate.js

@@ -25,6 +25,8 @@ import { copySearchHitAttribution, getSearchHitAttribution, usageEventAttributio
 import { findSourceForPath, resolveSourceEntries } from "../../indexer/search/search-source.js";
 import { insertUsageEvent } from "../../indexer/usage/usage-events.js";
 import { estimateTokenCount } from "../../llm/embedders/remote.js";
+import { tryLlmFeature } from "../../llm/feature-gate.js";
+import { rerankDocuments } from "../../llm/rerank-client.js";
 import { truncateDescription } from "../../output/shapes/helpers.js";
 import { TELEMETRY_BUSY_TIMEOUT_MS, withIndexDb } from "../../storage/repositories/index-db.js";
 import { findEntryIdByRef, getItemRefById } from "../../storage/repositories/index-entries-repository.js";
@@ -145,7 +147,7 @@ export async function curateSearchResults(query, result, limit, selectedType, ev
     // fixtures) with a `SearchResponse` that was never type-filtered.
     const stashHits = selectedType && selectedType !== "any" ? allStashHits.filter((hit) => hit.type === selectedType) : allStashHits;
     const selected = selectCuratedStashHits(query, stashHits, limit);
-    const selectedStashHits = selected.selected;
+    const selectedStashHits = await maybeRerankCuratedStashHits(query, selected.selected);
     const supportRefsByRef = selected.supportRefsByRef;
     // F4/R-019: respect `--limit` for registry fill instead of hard-capping it
     // at a bare literal 2 — the remaining slots after stash hits ARE the cap.
@@ -169,16 +171,10 @@ export async function curateSearchResults(query, result, limit, selectedType, ev
 /**
  * Pack a curate result's stash hits into a single token-budgeted blob:
  * resolve each hit's content via the SAME path `akm show` uses
- * (`akmShowUnified`, called with `item.selectedRef ?? item.ref` — this also
- * means a hit whose search match was a Markdown fragment packs just the
- * matched section, not the whole entry `item.ref` now always addresses; see
- * index-redesign-contract.md B5f item 1), then greedily accumulate hits, in
- * the ranking order `curateSearchResults` already produced, until the next
- * hit would exceed `budgetTokens`. Each packed item's `ref` is that SAME
- * fetched ref (`item.selectedRef ?? item.ref`), mirroring
- * `enrichCuratedStashHit`'s own `contentRef` convention — labelling a packed
- * fragment with the bare entry ref would let a later `akm show <ref>` return
- * a different, larger document than what was actually packed and budgeted.
+ * (`akmShowUnified` — this also means a `ref#fragment` hit packs just the
+ * matched section), then greedily accumulate hits, in the ranking order
+ * `curateSearchResults` already produced, until the next hit would exceed
+ * `budgetTokens`.
  *
  * Registry hits are never packed — only `CuratedStashItem`s (locked
  * contract, AGENTS.md: registry results stay separate/opt-in).
@@ -192,17 +188,9 @@ export async function packCuratedHits(result, budgetTokens) {
     const packed = [];
     let used = 0;
     for (const item of stashItems) {
-        // item 4 — record the ref actually FETCHED (`contentRef`), mirroring
-        // `enrichCuratedStashHit`'s own convention: `item.ref` is now always the
-        // bare entry ref, but a body-only match's content came from the
-        // fragment-qualified `selectedRef`. Recording `item.ref` here labelled a
-        // packed fragment with the whole entry's ref, so a consumer that later
-        // ran `akm show <that ref>` got a different, larger document than what
-        // was actually packed and budgeted.
-        const contentRef = item.selectedRef ?? item.ref;
         let shown;
         try {
-            shown = await akmShowUnified({ ref: contentRef, skipLogging: true });
+            shown = await akmShowUnified({ ref: item.ref, skipLogging: true });
         }
         catch {
             continue;
@@ -210,7 +198,7 @@ export async function packCuratedHits(result, budgetTokens) {
         const content = shown.content ?? shown.template ?? shown.prompt ?? "";
         const tokens = estimateTokenCount(content);
         if (used + tokens <= budgetTokens) {
-            packed.push({ ref: contentRef, tokens, content });
+            packed.push({ ref: item.ref, tokens, content });
             used += tokens;
             continue;
         }
@@ -218,7 +206,7 @@ export async function packCuratedHits(result, budgetTokens) {
             const remaining = budgetTokens - used;
             if (remaining > 0) {
                 const truncated = content.slice(0, remaining * 4);
-                packed.push({ ref: contentRef, tokens: estimateTokenCount(truncated), content: truncated });
+                packed.push({ ref: item.ref, tokens: estimateTokenCount(truncated), content: truncated });
                 used += estimateTokenCount(truncated);
             }
         }
@@ -227,15 +215,9 @@ export async function packCuratedHits(result, budgetTokens) {
     return { query: result.query, budget: budgetTokens, tokens: used, items: packed };
 }
 async function enrichCuratedStashHit(query, hit, supportRefs, selectedRefs, eventSource) {
-    // index-redesign-contract.md B5f item 1 — `hit.ref` is always the bare entry
-    // ref now; `contentRef` is the fragment-qualified ref when the search match
-    // was a Markdown fragment (`hit.selectedRef`), so the preview/description
-    // resolved below and the curated item's own `followUp` still land on the
-    // matched section instead of regressing to the whole entry.
-    const contentRef = hit.selectedRef ?? hit.ref;
     let shown;
     try {
-        shown = await akmShowUnified({ ref: contentRef, eventSource, skipLogging: true });
+        shown = await akmShowUnified({ ref: hit.ref, eventSource, skipLogging: true });
     }
     catch {
         shown = undefined;
@@ -253,13 +235,10 @@ async function enrichCuratedStashHit(query, hit, supportRefs, selectedRefs, even
         type: shown?.type ?? hit.type,
         name: shown?.name ?? hit.name,
         ref: hit.ref,
-        ...(hit.selectedRef ? { selectedRef: hit.selectedRef } : {}),
         path: shown?.path ?? hit.path,
         editable: shown?.editable ?? hit.editable ?? false,
         ...((shown?.editable ?? hit.editable ?? false) === false
-            ? {
-                editHint: shown?.editHint ?? hit.editHint ?? `This asset is read-only. Inspect it with: akm show ${hit.ref}`,
-            }
+            ? { editHint: shown?.editHint ?? hit.editHint ?? `This asset is read-only. Inspect it with: akm show ${hit.ref}` }
             : {}),
         ...(description ? { description } : {}),
         ...(preview ? { preview } : {}),
@@ -267,7 +246,7 @@ async function enrichCuratedStashHit(query, hit, supportRefs, selectedRefs, even
         ...(shown?.parameters?.length ? { parameters: shown.parameters } : {}),
         ...(shown?.run ? { run: shown.run } : {}),
         ...(mergedSupportRefs.length > 0 ? { supportRefs: mergedSupportRefs } : {}),
-        followUp: `akm show ${contentRef}`,
+        followUp: `akm show ${hit.ref}`,
         reason: buildCuratedReason(query, shown?.type ?? hit.type),
         ...(hit.score !== undefined ? { score: hit.score } : {}),
     };
@@ -617,6 +596,37 @@ function appendCurateSupportRef(supportRefsByRef, ownerRef, supportRef) {
         return;
     supportRefsByRef.set(ownerRef, [...existing, supportRef]);
 }
+/** Default number of `selectCuratedStashHits` candidates sent to the reranker when `search.curateRerank.topN` isn't set. */
+const DEFAULT_CURATE_RERANK_TOP_N = 8;
+/**
+ * Optional cross-encoder rerank pass over curate's already-selected, already-
+ * ranked candidates (#951). Disabled by default (`search.curateRerank.enabled`
+ * is falsy) and, when enabled, best-effort: any failure (misconfigured
+ * endpoint, network error, timeout, malformed response) falls back to
+ * `selectCuratedStashHits`'s own ranking unchanged — a reranker outage must
+ * never turn into a curate failure.
+ *
+ * Only the top `topN` (default {@link DEFAULT_CURATE_RERANK_TOP_N}) already-
+ * selected hits are sent (bounded request size); anything past that keeps its
+ * original position appended after the reranked prefix.
+ */
+async function maybeRerankCuratedStashHits(query, hits) {
+    if (hits.length <= 1)
+        return hits;
+    const config = loadConfig();
+    const rerankConfig = config.search?.curateRerank;
+    return tryLlmFeature("curate_rerank", config, async () => {
+        const topN = rerankConfig?.topN ?? DEFAULT_CURATE_RERANK_TOP_N;
+        const head = hits.slice(0, topN);
+        const tail = hits.slice(topN);
+        const documents = head.map((hit) => [hit.name, hit.description].filter(Boolean).join(" — "));
+        const ranked = await rerankDocuments(rerankConfig ?? {}, query, documents);
+        const rerankedHead = ranked
+            .map(({ index }) => head[index])
+            .filter((hit) => hit !== undefined);
+        return [...rerankedHead, ...tail];
+    }, hits, { timeoutMs: rerankConfig?.timeoutMs ?? null });
+}
 function selectCuratedStashHits(query, hits, limit) {
     const intent = parseCurateIntent(query);
     const collapsed = collapseCurateFamilies(query, hits);

package/dist/commands/read/search.js

@@ -17,8 +17,6 @@ import { appendEvent } from "../../core/events.js";
 import { resolveReadSources } from "../../indexer/read-preflight.js";
 import { searchLocal } from "../../indexer/search/db-search.js";
 import { getSearchHitAttribution, usageEventAttributionMetadata, } from "../../indexer/search/search-attribution.js";
-import { tryLlmFeature } from "../../llm/feature-gate.js";
-import { rerankDocuments } from "../../llm/rerank-client.js";
 import { getEntryIdByFilePath, getItemRefById } from "../../storage/repositories/index-entries-repository.js";
 // Eagerly import source providers to trigger self-registration before the
 // indexer or path-resolution code runs.
@@ -28,6 +26,24 @@ import { insertUsageEvent } from "../../indexer/usage/usage-events.js";
 import { TELEMETRY_BUSY_TIMEOUT_MS, withIndexDb } from "../../storage/repositories/index-db.js";
 import { searchRegistry } from "./registry-search.js";
 const DEFAULT_LIMIT = 20;
+function duplicateConceptWarnings(hits, defaultBundle) {
+    const ownersByConcept = new Map();
+    for (const hit of hits) {
+        const displayRef = (hit.parentRef ?? hit.ref).split("#", 1)[0] ?? hit.ref;
+        const boundary = displayRef.indexOf("//");
+        const conceptId = boundary >= 0 ? displayRef.slice(boundary + 2) : displayRef;
+        const owner = hit.origin ?? defaultBundle ?? "working-bundle";
+        const owners = ownersByConcept.get(conceptId) ?? [];
+        if (!owners.includes(owner))
+            owners.push(owner);
+        ownersByConcept.set(conceptId, owners);
+    }
+    return [...ownersByConcept]
+        .filter(([, owners]) => owners.length > 1)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([conceptId, owners]) => `Multiple bundles provide "${conceptId}": ${owners.join(", ")}. ` +
+        "Unqualified refs resolve by configured bundle priority; use a bundle-qualified ref to select explicitly.");
+}
 export async function akmSearch(input) {
     const t0 = Date.now();
     const query = input.query.trim();
@@ -113,21 +129,12 @@ export async function akmSearch(input) {
             disableProjectContext: input.disableProjectContext === true,
             disableScopedUtility: input.disableScopedUtility === true,
         });
-    // #951 (moved from curate in 0.9.16 — the pass was always meant for
-    // search). Applied ONCE here, to LOCAL hits only, before the source
-    // branches below divide the same `localResult.hits` between the "local"
-    // and "all" responses — so both get the rerank and neither double-applies
-    // it. `localResult` is `undefined` for `source === "registry"`, so a
-    // registry-only search never reaches this call and never pays for the
-    // reranker's HTTP request; registry hits are never reranked (registry
-    // results staying separate from stash hits is a locked contract,
-    // AGENTS.md).
-    const rerankedLocalHits = localResult ? await maybeRerankSearchHits(query, localResult.hits, config) : undefined;
     const registryResult = source === "local"
         ? undefined
         : await searchRegistry(query, { limit, includeAssets: input.assets === true, registries: config.registries });
     if (source === "local") {
-        const localHits = rerankedLocalHits ?? [];
+        const localHits = localResult?.hits ?? [];
+        const warnings = [...(localResult?.warnings ?? []), ...duplicateConceptWarnings(localHits, config.defaultBundle)];
         const hasResults = localHits.length > 0;
         const response = {
             schemaVersion: 1,
@@ -135,7 +142,7 @@ export async function akmSearch(input) {
             source,
             hits: localHits,
             tip: hasResults ? undefined : localResult?.tip,
-            warnings: localResult?.warnings?.length ? localResult.warnings : undefined,
+            warnings: warnings.length ? warnings : undefined,
             searchMode: localResult?.mode ?? "keyword",
             timing: { totalMs: Date.now() - t0, rankMs: localResult?.rankMs, embedMs: localResult?.embedMs },
         };
@@ -173,8 +180,12 @@ export async function akmSearch(input) {
         return response;
     }
     // source === "all"
-    const allStashHits = (rerankedLocalHits ?? []).slice(0, limit);
-    const warnings = [...(localResult?.warnings ?? []), ...(registryResult?.warnings ?? [])];
+    const allStashHits = (localResult?.hits ?? []).slice(0, limit);
+    const warnings = [
+        ...(localResult?.warnings ?? []),
+        ...duplicateConceptWarnings(allStashHits, config.defaultBundle),
+        ...(registryResult?.warnings ?? []),
+    ];
     const hasResults = allStashHits.length > 0 || registryHits.length > 0;
     const response = {
         schemaVersion: 1,
@@ -194,42 +205,6 @@ export async function akmSearch(input) {
 function usageSearchMode(mode) {
     return mode === "semantic" ? "semantic" : "keyword";
 }
-/** Default number of `searchLocal`'s already-ranked LOCAL hits sent to the reranker when `search.rerank.topN` isn't set. */
-const DEFAULT_SEARCH_RERANK_TOP_N = 8;
-/**
- * Optional cross-encoder rerank pass over `akm search`'s already-ranked LOCAL
- * hits (#951, moved from `akm curate` in 0.9.16 — the pass was always meant
- * for search). Disabled by default (`search.rerank.enabled` is falsy) and,
- * when enabled, best-effort: any failure (misconfigured endpoint, network
- * error, timeout, malformed response, an out-of-range or duplicate index in
- * the response) falls back to `searchLocal`'s own ranking unchanged — a
- * reranker outage must never turn into a search failure.
- *
- * Only the top `topN` (default {@link DEFAULT_SEARCH_RERANK_TOP_N}) hits are
- * sent (bounded request size); anything past that keeps its original
- * position appended after the reranked prefix. The reranker changes ARRAY
- * ORDER only — each hit's own `score` is left untouched as the retrieval
- * score (see docs/reference/cli.md and docs/reference/configuration.md for
- * why: `SearchHit.score` is a locked `[0,1]` contract downstream consumers
- * compare and threshold on, while ordering is the field a rerank-aware
- * consumer reads).
- */
-async function maybeRerankSearchHits(query, hits, config) {
-    if (hits.length <= 1)
-        return hits;
-    const rerankConfig = config.search?.rerank;
-    return tryLlmFeature("search_rerank", config, async () => {
-        const topN = rerankConfig?.topN ?? DEFAULT_SEARCH_RERANK_TOP_N;
-        const head = hits.slice(0, topN);
-        const tail = hits.slice(topN);
-        const documents = head.map((hit) => [hit.name, hit.description].filter(Boolean).join(" — "));
-        const ranked = await rerankDocuments(rerankConfig ?? {}, query, documents);
-        const rerankedHead = ranked
-            .map(({ index }) => head[index])
-            .filter((hit) => hit !== undefined);
-        return [...rerankedHead, ...tail];
-    }, hits, { timeoutMs: rerankConfig?.timeoutMs ?? null });
-}
 function maybeLogSearchEvent(input, query, response, mode) {
     if (input.skipLogging)
         return;
@@ -349,9 +324,15 @@ function logSearchEvent(query, response, mode = "keyword", eventSource = "user",
  */
 function assertNamedSourceExists(config, namedSourceName) {
     const configSources = getSources(config);
-    const foundInConfig = configSources.some((s) => s.name === namedSourceName) || configSources.some((s) => s.path === namedSourceName);
+    const foundInConfig = configSources.find((source) => source.name === namedSourceName || source.path === namedSourceName);
+    if (foundInConfig?.enabled === false) {
+        throw new UsageError(`Source "${namedSourceName}" is disabled.`, "INVALID_SOURCE_VALUE");
+    }
     if (!foundInConfig) {
-        const validNames = configSources.map((s) => s.name).filter((n) => Boolean(n));
+        const validNames = configSources
+            .filter((source) => source.enabled !== false)
+            .map((source) => source.name)
+            .filter((name) => Boolean(name));
         const hint = validNames.length > 0
             ? `Known source names: ${validNames.join(", ")}`
             : "No named sources are configured. Run `akm bundle list` to see installed bundles.";

package/dist/commands/read/show.js

@@ -75,6 +75,11 @@ export async function akmShowUnified(input) {
         if (metaRef)
             return showStashMeta(metaRef);
     }
+    const legacyReplacement = legacyColonRefReplacement(ref);
+    if (legacyReplacement) {
+        throw new NotFoundError(`The legacy colon ref "${ref}" was removed in 0.9.0. Use the slash form instead: ` +
+            `akm show ${legacyReplacement}`);
+    }
     // Env/secret bodies have no safe fragment surface, and a fragment cannot
     // widen what the env/secret renderers expose: both always omit the body
     // (env — key names only; secret — never rendered), fragment or not. Warn
@@ -110,6 +115,20 @@ export async function akmShowUnified(input) {
     }
     return result;
 }
+/** Actionable migration guidance for the retired `[bundle//]type:name` spelling. */
+function legacyColonRefReplacement(ref) {
+    const match = /^(?:(?<bundle>[^/#]+)\/\/)?(?<type>[a-z][a-z0-9-]*):(?<name>[^#]+)(?<fragment>#.*)?$/i.exec(ref);
+    const type = match?.groups?.type?.toLowerCase();
+    const name = match?.groups?.name;
+    if (!type || !name)
+        return undefined;
+    const stashDir = stashDirFor(type);
+    if (!stashDir)
+        return undefined;
+    const bundle = match?.groups?.bundle;
+    const fragment = match?.groups?.fragment ?? "";
+    return `${bundle ? `${bundle}//` : ""}${stashDir}/${name}${fragment}`;
+}
 /**
  * Resolve a stash `.meta/` doc and return it as a lightweight ShowResponse.
  *
@@ -288,7 +307,7 @@ export async function showLocal(input) {
                 throw new UsageError(`Renderer "${match.renderer}" not found for asset: ${makeBundleRef(parsed.bundle, parsed.conceptId)}`);
             }
             const renderBundle = indexedEntry.bundleId;
-            const renderDefaultBundle = config.defaultBundle ?? (source?.path === allSources[0]?.path ? renderBundle : undefined);
+            const renderDefaultBundle = config.defaultBundle ?? (source?.isDefault === true ? renderBundle : undefined);
             const renderCtx = buildRenderContext(fileCtx, match, allSourceDirs, renderBundle, renderDefaultBundle);
             response = renderer.buildShowResponse(renderCtx);
             if (parsed.fragment !== undefined) {
@@ -306,7 +325,7 @@ export async function showLocal(input) {
     }
     response.type = indexedEntry.type;
     response.name = indexedEntry.name;
-    const isPrimaryStash = source !== undefined && source.path === allSources[0]?.path;
+    const isPrimaryStash = source?.isDefault === true;
     const canonicalRef = displayRef({
         type: indexedEntry.type,
         name: presentedName,

package/dist/commands/registry-cli.js

@@ -25,7 +25,7 @@ export const registryCommand = defineGroupCommand({
                 name: { type: "string", description: "Human-friendly name for the registry" },
                 provider: { type: "string", description: "Provider type (e.g. static-index, skills-sh)" },
                 options: { type: "string", description: "Provider-specific options as JSON." },
-                "allow-insecure": {
+                "allow-insecure-transport": {
                     type: "boolean",
                     description: "Allow a plain HTTP registry URL (otherwise rejected)",
                     default: false,
@@ -41,12 +41,12 @@ export const registryCommand = defineGroupCommand({
                     throw new UsageError("Registry URL must start with http:// or https://");
                 }
                 if (args.url.startsWith("http://")) {
-                    const allowInsecure = args["allow-insecure"];
-                    if (!allowInsecure) {
+                    const allowInsecureTransport = args["allow-insecure-transport"];
+                    if (!allowInsecureTransport) {
                         throw new UsageError("Registry URL uses plain HTTP (not HTTPS). An on-path attacker could substitute a malicious index. " +
-                            "Use https:// or pass --allow-insecure if you have explicitly accepted the risk.");
+                            "Use https:// or pass --allow-insecure-transport if you have explicitly accepted the risk.");
                     }
-                    warn("Warning: registry URL uses plain HTTP (not HTTPS). --allow-insecure was set; an on-path attacker could substitute a malicious index.");
+                    warn("Warning: registry URL uses plain HTTP (not HTTPS). --allow-insecure-transport was set; an on-path attacker could substitute a malicious index.");
                 }
                 const entry = { url: args.url };
                 if (args.name)