akm-cli 0.10.261012-beta → 0.10.261014-beta

package/dist/commands/read/registry-search.js

@@ -28,14 +28,13 @@ export async function searchRegistry(query, options) {
         const provider = createProvider(entry, warnings);
         if (!provider)
             return Promise.resolve(null);
-        return provider.search({ query: trimmed, limit, includeAssets: options?.includeAssets });
+        return provider.search({ query: trimmed, limit });
     }));
     // Merge results grouped by provider
     // Each provider batch is normalized to [0, 1] before merging so that raw
     // scores from different providers (e.g. static-index can exceed 1.85 while
     // skills-sh uses installs-relative scoring) are comparable in the merged list.
     const allHits = [];
-    const allAssetHits = [];
     for (let i = 0; i < results.length; i++) {
         const result = results[i];
         if (result.status === "rejected") {
@@ -61,21 +60,6 @@ export async function searchRegistry(query, options) {
         for (const hit of validHits) {
             allHits.push(hit);
         }
-        if (value.assetHits) {
-            const validAssetHits = [];
-            for (const hit of value.assetHits) {
-                if (isCompleteAssetHit(hit)) {
-                    validAssetHits.push(hit);
-                }
-                else {
-                    dropped++;
-                }
-            }
-            normalizeScores(validAssetHits);
-            for (const hit of validAssetHits) {
-                allAssetHits.push(hit);
-            }
-        }
         if (dropped > 0) {
             warnings.push(`Registry ${registryLabel} returned ${dropped} incomplete hit(s); dropped from response.`);
         }
@@ -85,14 +69,7 @@ export async function searchRegistry(query, options) {
     // Sort merged hits by normalized score descending, apply limit
     allHits.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
     const limitedHits = allHits.slice(0, limit);
-    allAssetHits.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
-    const limitedAssetHits = allAssetHits.slice(0, limit);
-    return {
-        query: trimmed,
-        hits: limitedHits,
-        warnings,
-        assetHits: limitedAssetHits.length > 0 ? limitedAssetHits : undefined,
-    };
+    return { query: trimmed, hits: limitedHits, warnings };
 }
 // ── Registry resolution ─────────────────────────────────────────────────────
 /**
@@ -216,26 +193,3 @@ function isCompleteHit(hit) {
         typeof hit.installRef === "string" &&
         hit.installRef.length > 0);
 }
-function isCompleteAssetHit(hit) {
-    if (!hit || typeof hit !== "object")
-        return false;
-    if (hit.type !== "registry-asset" ||
-        typeof hit.assetType !== "string" ||
-        hit.assetType.length === 0 ||
-        typeof hit.assetName !== "string" ||
-        hit.assetName.length === 0 ||
-        typeof hit.action !== "string") {
-        return false;
-    }
-    // `stash` is required by the consumer (output shaping + asset-action display);
-    // rejecting incomplete stashes here keeps malformed objects out of the JSON
-    // output. Flagged in PR #168 review (#9).
-    const stash = hit.stash;
-    if (!stash || typeof stash !== "object")
-        return false;
-    if (typeof stash.id !== "string" || stash.id.length === 0)
-        return false;
-    if (typeof stash.name !== "string" || stash.name.length === 0)
-        return false;
-    return true;
-}

package/dist/commands/read/search-cli.js

@@ -47,11 +47,6 @@ export const searchCommand = defineJsonCommand({
         },
         limit: { type: "string", description: "Maximum number of results" },
         from: { type: "string", description: "Search source (local|registry|all)", default: "local" },
-        assets: {
-            type: "boolean",
-            description: "Include asset-level search results (only meaningful with --from registry|all)",
-            default: false,
-        },
         filter: scopeFilterArg,
         "include-proposed": {
             type: "boolean",
@@ -77,7 +72,6 @@ export const searchCommand = defineJsonCommand({
         const includeProposed = args["include-proposed"] === true;
         const belief = parseBeliefFilterMode(typeof args.belief === "string" ? args.belief : undefined);
         const includeSessions = args["include-sessions"];
-        const assets = args.assets === true;
         const outputMode = getOutputMode();
         const result = await akmSearch({
             query,
@@ -88,7 +82,6 @@ export const searchCommand = defineJsonCommand({
             includeProposed,
             belief,
             includeSessions,
-            assets,
             eventSource: resolveUsageEventSource(),
             attributionProjection: outputMode.shape === "agent" ? "agent" : outputMode.detail,
         });
@@ -161,7 +154,7 @@ export async function runCurate(args, outputMode) {
         source: parseSearchSource(args.from ?? "local"),
         filters: parseScopeFilterFlags(args.filters ?? [], "--filter"),
         belief: parseBeliefFilterMode(args.belief ?? "current"),
-        eventSource: resolveUsageEventSource(),
+        eventSource: args.eventSource ?? resolveUsageEventSource(),
         attributionProjection: outputMode.shape === "agent" ? "agent" : outputMode.detail,
     });
 }

package/dist/commands/read/search.js

@@ -4,7 +4,7 @@
 /**
  * `akm search` — entry point.
  *
- * Spec §6.1: search consults the local FTS5 index. There is one query path
+ * Search consults the local FTS5 index. There is one query path
  * because there is one data store. Provider fan-out is gone.
  *
  * The orchestration here is thin: build the FTS query, optionally interleave
@@ -125,9 +125,7 @@ export async function akmSearch(input) {
             includeExcludedTypes: input.includeSessions === true,
             readOnly: input.readOnly,
         });
-    const registryResult = source === "local"
-        ? undefined
-        : await searchRegistry(query, { limit, includeAssets: input.assets === true, registries: config.registries });
+    const registryResult = source === "local" ? undefined : await searchRegistry(query, { limit, registries: config.registries });
     if (source === "local") {
         const localHits = localResult?.hits ?? [];
         const warnings = [...(localResult?.warnings ?? []), ...duplicateConceptWarnings(localHits, config.defaultBundle)];
@@ -154,6 +152,7 @@ export async function akmSearch(input) {
             id: hit.id,
             description: hit.description,
             action: `akm bundle add ${installRef} -> then search again`,
+            installRef,
             score: hit.score,
             registryName: hit.registryName,
             ...(hit.warnings && hit.warnings.length > 0 ? { warnings: hit.warnings } : {}),
@@ -317,8 +316,8 @@ function logSearchEvent(rawQuery, response, mode = "keyword", eventSource = "use
 }
 // ── Helpers ──────────────────────────────────────────────────────────────────
 /**
- * Validate a named `--from` against the bundle-derived source list (0.9.0
- * spec §10.1: a named source is a `bundles` key, matched via its derived
+ * Validate a named `--from` against the bundle-derived source list (a named
+ * source is a `bundles` key, matched via its derived
  * source entry's `name`, or an exact path). Throws INVALID_SOURCE_VALUE with
  * the known names before any stash access can fail differently.
  */

package/dist/commands/read/show.js

@@ -4,8 +4,6 @@
 /**
  * `akm show` — entry point.
  *
- * Spec §6.2:
- *
  *   show(ref) → indexer.lookup(ref) → readFile(entry.filePath)
  *
  * The richer presentation logic (matchers, renderers, edit-hints,
@@ -26,7 +24,7 @@ import { extractSection, markdownFragmentSlugs } from "../../core/asset/markdown
 import { buildMarkdownLeadContext, fragmentForSelector, MARKDOWN_FRAGMENT_CONTEXT_DEFAULT_MAX_CHARS, } from "../../core/asset/markdown-fragments.js";
 import { displayRef, displayRefForConceptId, typeNameFromConceptId } from "../../core/asset/resolve-ref.js";
 import { META_DIR, parseMetaRef, readMetaFile } from "../../core/asset/stash-meta.js";
-import { asNonEmptyString, isWithin } from "../../core/common.js";
+import { asNonEmptyString, isContainedResolvedPath } from "../../core/common.js";
 import { loadConfig } from "../../core/config/config.js";
 import { NotFoundError, rethrowIfDataDirUnreadable, rethrowIfTestIsolationError, UsageError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
@@ -45,13 +43,11 @@ import { withIndexDb } from "../../storage/repositories/index-db.js";
 import { getEntryById, getEntryIdByFilePath } from "../../storage/repositories/index-entries-repository.js";
 import { getIndexedMarkdownFragment } from "../../storage/repositories/index-fts-repository.js";
 import { readEntryLinks } from "../../storage/repositories/index-links-repository.js";
-import { getCurrentWorkflowScopeKey } from "../../workflows/authoring/scope-key.js";
 import { buildWorkflowAction } from "../../workflows/renderer.js";
-import { getActiveWorkflowRun } from "../../workflows/runtime/runs.js";
 /**
  * Unified show: queries the local FTS5 index, then reads that row's file path.
  * A physical owner can arbitrate collisions during lookup, but show never
- * renders an asset without an indexed row. Spec §6.2; no provider or disk
+ * renders an asset without an indexed row; no provider or disk
  * fallback.
  *
  * When `detail` is `"brief"` or `"summary"`, the response omits
@@ -381,20 +377,6 @@ export async function showLocal(input) {
     }
     if (response.type === "workflow")
         response.action = buildWorkflowAction(canonicalRef);
-    // 07 P1-D: provenance-aware toolPolicy CEILING. An agent's self-declared
-    // `tools` frontmatter is honoured ONLY for the operator's own PRIMARY stash —
-    // the assets they authored. Every other source is content pulled from
-    // elsewhere and must not name its own tool grant: registry-installed packs, a
-    // configured secondary source, and even a git source the operator marked
-    // `--writable` to contribute edits upstream (writability is "can I push", not
-    // "do I trust this content to grant itself tools"). Drop the policy so dispatch
-    // falls back to the parent/default grant. Keys off primary-stash identity —
-    // `allSources[0]` is always the primary (search-source.ts) — not a
-    // name-derived registryId or the orthogonal `writable` bit. `source` undefined
-    // (unresolved path) also fails closed.
-    if (response.toolPolicy !== undefined && !isPrimaryStash) {
-        delete response.toolPolicy;
-    }
     const editable = isEditable(assetPath, config, allSources);
     // Evidence must describe the same revision as the rendered claim: ordinary
     // Markdown show is source-live, while indexed fragment show is a snapshot.
@@ -421,10 +403,6 @@ export async function showLocal(input) {
         ...(!editable ? { editHint: buildEditHint(canonicalRef) } : {}),
         ...showLinks(indexedEntry.itemRef, displayDefaultBundle, input.readOnly === true),
     };
-    const activeRun = input.readOnly ? null : await getActiveWorkflowRun(getCurrentWorkflowScopeKey());
-    if (activeRun) {
-        fullResponse.activeRun = activeRun;
-    }
     if (input.detail === "brief") {
         return buildBriefResponse(fullResponse, assetPath);
     }
@@ -513,16 +491,15 @@ function findUnrecognizedScriptSource(assetParts, sources) {
                 continue;
             const sourceRoot = path.resolve(source.path);
             const candidate = path.resolve(assetPathForName("script", path.join(sourceRoot, scriptDir), assetParts.name));
-            if (!isWithin(candidate, sourceRoot))
+            if (!isContainedResolvedPath(candidate, sourceRoot))
                 continue;
             const authoredStat = fs.lstatSync(candidate);
             if (!authoredStat.isFile() && !authoredStat.isSymbolicLink())
                 continue;
-            const realRoot = fs.realpathSync(sourceRoot);
             const realCandidate = fs.realpathSync(candidate);
-            if (!isWithin(realCandidate, realRoot) || !fs.statSync(realCandidate).isFile())
+            if (!fs.statSync(realCandidate).isFile())
                 continue;
-            return { extension, path: realCandidate, sourceRoot: realRoot };
+            return { extension, path: realCandidate, sourceRoot: fs.realpathSync(sourceRoot) };
         }
         catch {
             // Missing, unreadable, dangling, or otherwise unsafe paths remain normal
@@ -534,7 +511,7 @@ function findUnrecognizedScriptSource(assetParts, sources) {
 /**
  * Minimal `show`: ref → indexer lookup → file contents. Used by callers that
  * just need the raw file (e.g. clone, write-source) and don't want the full
- * renderer graph. Spec §6.2's literal flow.
+ * renderer graph.
  */
 export async function showByRef(ref) {
     const parsed = parseBundleRef(ref);

package/dist/commands/remember.js

@@ -12,10 +12,12 @@ import { serializeFrontmatter } from "../core/asset/asset-serialize.js";
 import { DESCRIPTION_MAX_CHARS } from "../core/authoring-rules.js";
 import { toErrorMessage, tryReadStdinText } from "../core/common.js";
 import { loadConfig } from "../core/config/config.js";
+import { SHIPPED_ALIAS } from "../core/config/model-aliases.js";
 import { ConfigError, UsageError } from "../core/errors.js";
 import { parseEmbeddedJsonResponse } from "../core/parse.js";
 import { DURATION_UNITS, parseDuration as parseDurationSpec } from "../core/time.js";
 import { warn } from "../core/warn.js";
+import { noticeSet } from "../execution/notices.js";
 import { SCOPE_KEYS } from "../indexer/passes/metadata.js";
 import { callStructured } from "../llm/structured-call.js";
 import { withLlmStage } from "../llm/usage-telemetry.js";
@@ -222,7 +224,7 @@ export function parseEnrichObserved(parsed) {
     }
     return undefined;
 }
-/** Hard timeout for the `--enrich` LLM call. Write-path must not block on a misbehaving endpoint. */
+/** Timeout for the `--enrich` LLM call, in place of the connection's own. */
 const LLM_ENRICH_TIMEOUT_MS = 10_000;
 /**
  * Attempt LLM enrichment of memory metadata. Returns merged metadata
@@ -232,14 +234,14 @@ const LLM_ENRICH_TIMEOUT_MS = 10_000;
  */
 export async function runLlmEnrich(body) {
     const config = loadConfig();
-    const resolved = resolveImproveExecution({ config, processName: "remember-enrich" });
+    const resolved = resolveImproveExecution({ config, processName: "remember-enrich", alias: SHIPPED_ALIAS.enrich });
     if (!resolved) {
-        warn("Warning: --enrich requires an engine to be configured. Run `akm setup` to configure one.");
+        warn("Warning: --enrich requires a connection or harness to be configured. Run `akm setup` to configure one.");
         return { tags: [] };
     }
     const runner = resolved.runner;
-    const noticesByKey = new Map(resolved.notices.map((notice) => [JSON.stringify(notice), notice]));
-    const noticeFields = () => noticesByKey.size > 0 ? { notices: Object.freeze([...noticesByKey.values()]) } : {};
+    const notices = noticeSet();
+    notices.add(resolved.notices);
     const prompt = `You are a memory tagger for a developer knowledge base.
 Given the memory text below, return ONLY a JSON object with these fields:
 - "tags": array of 1-5 short lowercase keyword tags
@@ -251,53 +253,36 @@ ${body.slice(0, 2000)}
 
 Return ONLY the JSON object, no prose, no markdown fences.`;
     try {
-        let timeoutHandle;
-        const result = await (async () => {
-            try {
-                return await Promise.race([
-                    withLlmStage("remember", () => callStructured({
-                        feature: "remember_enrich",
-                        runner,
-                        messages: [
-                            { role: "system", content: "Return only valid JSON. No prose." },
-                            { role: "user", content: prompt },
-                        ],
-                        request: { maxTokens: 256, temperature: 0.1 },
-                        onNotices: (value) => {
-                            for (const notice of value)
-                                noticesByKey.set(JSON.stringify(notice), notice);
-                        },
-                        parse: (raw) => raw ?? "",
-                        onError: () => "",
-                        fallback: "",
-                    })),
-                    new Promise((_, reject) => {
-                        timeoutHandle = setTimeout(() => reject(new Error("LLM enrichment timed out")), LLM_ENRICH_TIMEOUT_MS);
-                    }),
-                ]);
-            }
-            finally {
-                if (timeoutHandle !== undefined) {
-                    clearTimeout(timeoutHandle);
-                }
-            }
-        })();
-        const parsed = parseEmbeddedJsonResponse(result);
+        const outcome = await withLlmStage("remember", () => callStructured({
+            runner,
+            messages: [
+                { role: "system", content: "Return only valid JSON. No prose." },
+                { role: "user", content: prompt },
+            ],
+            // The write path must not block on a misbehaving endpoint.
+            request: { maxTokens: 256, temperature: 0.1, timeoutMs: LLM_ENRICH_TIMEOUT_MS },
+            onNotices: notices.add,
+        }));
+        if (!outcome.ok) {
+            warn(`Warning: --enrich failed (${outcome.error}). Writing memory without enrichment.`);
+            return { tags: [], ...notices.fields() };
+        }
+        const parsed = parseEmbeddedJsonResponse(outcome.raw);
         if (!parsed) {
             warn("Warning: --enrich received invalid JSON from the LLM. Writing memory without enrichment.");
-            return { tags: [], ...noticeFields() };
+            return { tags: [], ...notices.fields() };
         }
         const tags = Array.isArray(parsed.tags)
             ? parsed.tags.filter((t) => typeof t === "string" && t.trim().length > 0)
             : [];
         const description = typeof parsed.description === "string" && parsed.description.trim() ? parsed.description.trim() : undefined;
-        return { tags, description, observed_at: parseEnrichObserved(parsed), ...noticeFields() };
+        return { tags, description, observed_at: parseEnrichObserved(parsed), ...notices.fields() };
     }
     catch (err) {
         if (err instanceof ConfigError)
             throw err;
         warn(`Warning: --enrich failed (${toErrorMessage(err)}). Writing memory without enrichment.`);
-        return { tags: [], ...noticeFields() };
+        return { tags: [], ...notices.fields() };
     }
 }
 // R-061(c): `resolveRememberContentArg` / `wasRememberFlagValueConsumedAsContent`

package/dist/commands/sources/add-cli.js

@@ -7,8 +7,7 @@ import { VALID_ADAPTER_IDS } from "../../core/adapter/adapter-ids.js";
 import { UsageError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
 import { warn } from "../../core/warn.js";
-import { auditStashForDangerousKeys } from "./dangerous-env-audit.js";
-import { akmRemove, akmUpdate } from "./installed-stashes.js";
+import { akmUpdate } from "./installed-stashes.js";
 import { akmAdd } from "./source-add.js";
 import { addStash, removeStash } from "./source-manage.js";
 // ── Shared website-options helper ──────────
@@ -36,31 +35,6 @@ export function shouldWarnOnPlainHttp(ref) {
         return true;
     }
 }
-/**
- * Audit a freshly-installed stash for dangerous env keys and decide whether the
- * install must be blocked. The scanner and decision policy are shared with
- * `bundle update` in dangerous-env-audit.ts.
- */
-export async function auditInstalledStashForDangerousKeys(opts) {
-    const { installedStashRoot, ref, allowDangerousKeys, rollbackTarget, isTTY } = opts;
-    return auditStashForDangerousKeys({
-        stashRoot: installedStashRoot,
-        ref,
-        allowDangerousKeys,
-        isTTY,
-        operation: "install",
-        rollback: async () => {
-            try {
-                await akmRemove({ target: rollbackTarget });
-                return undefined;
-            }
-            catch {
-                return (`Rollback failed — stash may still be installed at ${installedStashRoot}. ` +
-                    `Remove it manually with: akm bundle remove ${rollbackTarget}`);
-            }
-        },
-    });
-}
 // ── Command definition ────────────────────────────────────────────────────────
 export const addCommand = defineJsonCommand({
     meta: {
@@ -90,7 +64,8 @@ export const addCommand = defineJsonCommand({
         after: { type: "string", description: "Insert the new bundle after this configured bundle" },
         credential: {
             type: "string",
-            description: "Git HTTPS bearer credential reference ($VAR or secret://name); never a literal token",
+            // biome-ignore lint/suspicious/noTemplateCurlyInString: literal `${ref}` token syntax documented for users, not interpolation
+            description: "Git HTTPS bearer credential reference ($VAR or ${secrets/name}); never a literal token",
         },
         "max-pages": { type: "string", description: "Maximum pages to crawl for website sources (default: 50)" },
         "max-depth": { type: "string", description: "Maximum crawl depth for website sources (default: 3)" },
@@ -99,16 +74,18 @@ export const addCommand = defineJsonCommand({
             description: "Allow a plain HTTP source URL after explicitly accepting transport substitution risk.",
             default: false,
         },
+        // Deprecated no-op, accepted through 0.10 so scripts that pass it do not
+        // fail with UNKNOWN_FLAG. Installing a bundle is the trust decision: its
+        // env files are no longer scanned for process-hijacking keys.
         "allow-dangerous-env-keys": {
             type: "boolean",
-            description: "Allow reviewed process-hijacking env keys (e.g. LD_PRELOAD, PATH) in the installed bundle.",
+            description: "Deprecated, no effect: add no longer scans env files for process-hijacking keys. Accepted through 0.10 for existing scripts.",
             default: false,
         },
     },
     async run({ args }) {
         const ref = args.ref.trim();
         const allowInsecureTransport = args["allow-insecure-transport"];
-        const allowDangerousKeys = args["allow-dangerous-env-keys"];
         if (args.before && args.after)
             throw new UsageError("Only one of --before or --after may be used.");
         // --provider → declarative bundle source (URL for git/website; bare
@@ -153,7 +130,7 @@ export const addCommand = defineJsonCommand({
             if (args.provider === "git" && result.added && result.entry?.name) {
                 let updated;
                 try {
-                    updated = await akmUpdate({ target: result.entry.name, allowDangerousEnvKeys: allowDangerousKeys });
+                    updated = await akmUpdate({ target: result.entry.name });
                 }
                 catch (error) {
                     removeStash(result.entry.name);
@@ -204,38 +181,6 @@ export const addCommand = defineJsonCommand({
                 writable: args.writable === true,
             },
         });
-        // ── Post-install env key audit ──────────────────────────────────────────
-        // Resolve the stash root from the install result and scan any env files
-        // for dangerous env var keys.  When findings are present the install is
-        // gated: TTY → interactive confirmation prompt; non-TTY without
-        // --allow-dangerous-env-keys → hard failure (exit 1). Pass the dedicated
-        // flag to skip the prompt non-interactively.
-        const installedStashRoot = result.installed?.stashRoot ??
-            (result.sourceAdded && "stashRoot" in result.sourceAdded ? result.sourceAdded.stashRoot : undefined);
-        if (installedStashRoot) {
-            // Use the canonical installed id (most reliably resolved by akmRemove) rather
-            // than the raw user-supplied ref which may not match after URL normalisation.
-            const rollbackTarget = result.installed?.id ?? result.sourceAdded?.stashRoot ?? ref;
-            // The audit RETURNS its decision; we decide the exit outcome here,
-            // OUTSIDE any catch, so the abort cannot be lost to a swallowed
-            // exception (C3). F4: `process.exitCode = …; return;` instead of
-            // `process.exit(...)` — the DANGEROUS_ENV_KEY error envelope has
-            // already been written to stderr by the audit itself (or is about to
-            // be), so an explicit `return` here (skipping the success `output("add",
-            // …)` below) is load-bearing, not merely cosmetic: it is what stops a
-            // blocked install from ALSO printing a success envelope.
-            const decision = await auditInstalledStashForDangerousKeys({
-                installedStashRoot,
-                ref,
-                allowDangerousKeys,
-                rollbackTarget,
-                isTTY: process.stdin.isTTY === true,
-            });
-            if (decision.blocked) {
-                process.exitCode = decision.exitCode;
-                return;
-            }
-        }
         output("add", result);
     },
 });

package/dist/commands/sources/bundle-cli.js

@@ -8,9 +8,7 @@
  * group, hard break, no alias kept at the top level:
  *   - `create` (= old top-level `init`, src/commands/sources/init.ts)
  *   - `add`    (= old top-level `add`, src/commands/sources/add-cli.ts — the
- *     command definition moved here; `add-cli.ts` keeps its exported helpers,
- *     including `auditInstalledStashForDangerousKeys`, which a test imports
- *     directly)
+ *     command definition moved here; `add-cli.ts` keeps its exported helpers)
  *   - `list`   (= old top-level `list`)
  *   - `remove` (= old top-level `remove`)
  *   - `update` (= old top-level `update`)
@@ -134,18 +132,21 @@ const updateCommand = defineJsonCommand({
             description: "Exit successfully when index/state database contention shows another akm operation is active",
             default: false,
         },
+        // Deprecated no-op, accepted through 0.10 so scripts that pass it do not
+        // fail with UNKNOWN_FLAG. Installing a bundle is the trust decision: an
+        // update no longer scans env files for process-hijacking keys.
         "allow-dangerous-env-keys": {
             type: "boolean",
-            description: "Allow an update containing dangerous env keys (e.g. LD_PRELOAD, PATH). Use only after explicitly reviewing the staged bundle.",
+            description: "Deprecated, no effect: update no longer scans env files for process-hijacking keys. Accepted through 0.10 for existing scripts.",
             default: false,
         },
         // Deprecated no-op, accepted through 0.10 so scripts that pass it do not
-        // fail with UNKNOWN_FLAG. Deleting the previous directory of a read-only
-        // install whose content moved no longer asks: it is a re-fetchable cache.
+        // fail with UNKNOWN_FLAG. Pruning old install directories of a read-only
+        // bundle no longer asks: they are a re-fetchable cache.
         yes: {
             type: "boolean",
             alias: "y",
-            description: "Deprecated, no effect: update no longer asks before deleting a moved read-only install directory. Accepted through 0.10 for existing scripts.",
+            description: "Deprecated, no effect: update no longer asks before pruning old install directories of a read-only bundle. Accepted through 0.10 for existing scripts.",
             default: false,
         },
     },
@@ -156,7 +157,6 @@ const updateCommand = defineJsonCommand({
                 target: args.target,
                 all: args.all,
                 force: args.force,
-                allowDangerousEnvKeys: args["allow-dangerous-env-keys"],
             });
         }
         catch (error) {
@@ -173,7 +173,6 @@ const updateCommand = defineJsonCommand({
                 target: args.target ?? null,
                 all: args.all === true,
                 force: args.force === true,
-                allowDangerousEnvKeys: args["allow-dangerous-env-keys"] === true,
                 processed: Array.isArray(result.processed)
                     ? result.processed.length
                     : 0,

package/dist/commands/sources/bundle-config-ops.js

@@ -2,13 +2,13 @@
 // 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/.
 /**
- * Bundle-map config write helpers (0.9.0 config-shape cutover, spec §10.1).
+ * Bundle-map config write helpers.
  *
  * The `stashDir`/`sources[]`/`installed[]` trio is retired: every source is now
  * a `bundles.<slug>` entry, and the primary working stash is the `defaultBundle`.
  * These helpers give the source writers (`akm bundle create`, `akm setup`, `akm bundle add`,
  * `akm sources add/remove`) one place to derive slug-legal bundle keys (via the
- * shared {@link deriveBundleId} — D-R5), locate an existing bundle by its source
+ * shared {@link deriveBundleId}), locate an existing bundle by its source
  * descriptor, and set/repoint the primary bundle — without duplicating the
  * keying rules across call sites.
  */

package/dist/commands/sources/info.js

@@ -16,6 +16,7 @@ import { countLinksByKind } from "../../storage/repositories/index-links-reposit
 import { getMeta } from "../../storage/repositories/index-meta-repository.js";
 import { isSqliteContentionError } from "../../storage/sqlite-transaction.js";
 import { pkgVersion } from "../../version.js";
+import { targetRows } from "../targets.js";
 /**
  * Bound for `akm info`'s diagnostic index.db read — short enough that a
  * locked database never stalls the command, unlike the shared 30s
@@ -92,7 +93,7 @@ export function assembleInfo(options) {
         ...(r.provider ? { provider: r.provider } : {}),
         ...(r.enabled !== undefined ? { enabled: r.enabled } : {}),
     }));
-    // Stash providers — the unified `bundles` source list (spec §10.1), which
+    // Stash providers — the unified `bundles` source list, which
     // already includes the primary (`defaultBundle`) stash first.
     const configuredSources = getSources(config);
     const sourceProviders = configuredSources.map((s) => ({
@@ -151,10 +152,20 @@ export function assembleInfo(options) {
             status: semanticStatus,
         },
         registries,
+        connectionsAndHarnesses: safeTargets(config),
         sourceProviders,
         indexStats,
     };
 }
+/** The connections, harnesses and work table, or none when it cannot be built: `akm info` never throws. */
+function safeTargets(config) {
+    try {
+        return targetRows({ config });
+    }
+    catch {
+        return [];
+    }
+}
 /** Best-effort path resolution for a section that must degrade, not throw: an empty string in place of an exception. */
 function safePath(fn) {
     try {

package/dist/commands/sources/init.js

@@ -115,7 +115,7 @@ async function akmInitReal(options) {
     let previousStashDir;
     if (options?.persistConfig !== false) {
         const result = mutateConfig((latest) => {
-            // 0.9.0 (spec §10.1): the primary stash is the `defaultBundle`'s filesystem
+            // The primary stash is the `defaultBundle`'s filesystem
             // `path`, not the retired top-level `stashDir`.
             const currentPrimary = primaryBundlePath(latest);
             const shouldPersist = !dirExplicitlyProvided || !currentPrimary || setDefault;