akm-cli 0.9.1 → 0.9.2-alpha.2

package/dist/commands/proposal/repository.js

@@ -52,7 +52,7 @@ import { appendEvent } from "../../core/events.js";
 import { proposalContent } from "../../core/file-change.js";
 import { _setTxnMutationHookForTests, advanceTxn, beginTxn, canonicalTxnRoot, cleanupTxn, fsyncTxnDir, fsyncTxnFile, listTxnJournals, mintTxnId, registerTxnKind, sweepJournallessTxnDir, txnDirFor, txnMutationHook, txnNamespaceDir, } from "../../core/fs-txn.js";
 import { canonicalBundleIdForTarget, resolveBundleWriteTarget } from "../../core/mutation-target.js";
-import { withImmediateTransaction, withStateDb } from "../../core/state-db.js";
+import { getStateDbPath, withImmediateTransaction, withStateDb } from "../../core/state-db.js";
 import { warn } from "../../core/warn.js";
 import { recordWrittenPath } from "../../core/write-provenance.js";
 import { assertAkmAssetWrite, assertWriteTargetPathsClean, captureGitPublication, captureWriteTargetPathSnapshot, prepareWriteTargetForMutation, publishWriteTargetTransaction, resolveWriteTarget, } from "../../core/write-source.js";
@@ -61,7 +61,8 @@ import { indexWrittenAssets } from "../../indexer/index-written-assets.js";
 import { deriveInstallations } from "../../indexer/installations.js";
 import { resolveSourceEntries } from "../../indexer/search/search-source.js";
 import { insertEventOnce } from "../../storage/repositories/events-repository.js";
-import { getStateProposal, getStateProposalLenient, listStateProposalIdsByPrefix, listStateProposals, upsertProposal, } from "../../storage/repositories/proposals-repository.js";
+import { getStateProposal, listStateProposalIdsByPrefix, listStateProposals, upsertProposal, } from "../../storage/repositories/proposals-repository.js";
+import { openSqliteReadSnapshot } from "../../storage/sqlite-read-snapshot.js";
 import { pkgVersion } from "../../version.js";
 import { runBaseChecks } from "../lint/base-linter.js";
 import { formatNewAssetDiff, formatUnifiedDiff } from "./diff-format.js";
@@ -153,46 +154,6 @@ function newId(ctx) {
 function withProposalsDb(_stashDir, ctx, fn) {
     return withStateDb(fn, { path: ctx?.dbPath });
 }
-function persistProposalUpdate(db, proposal, stashDir) {
-    // Only take the full re-serialize (upsertProposal -> proposalToRowValues)
-    // path when `changes` is well-formed enough to survive it — a non-empty
-    // path on every entry, matching proposalToRowValues' own validation. A
-    // legacy row with a present `proposedTarget` but an empty/missing
-    // `changes[].path` (e.g. a malformed 0.8-era row) would otherwise die in
-    // proposalToRowValues; falling through to the targeted UPDATE below keeps
-    // `changes`/`proposedTarget` untouched in metadata_json and only flips the
-    // status/review/etc. fields the terminal transition actually needs.
-    const changesAreWellFormed = proposal.changes.length > 0 && proposal.changes.every((change) => change.path.length > 0);
-    if (changesAreWellFormed && proposal.proposedTarget) {
-        upsertProposal(db, proposal, stashDir);
-        return;
-    }
-    const row = db
-        .prepare("SELECT metadata_json FROM proposals WHERE id = ? AND stash_dir = ?")
-        .get(proposal.id, stashDir);
-    if (!row)
-        throw new NotFoundError(`Proposal "${proposal.id}" not found.`, "PROPOSAL_NOT_FOUND");
-    const metadata = JSON.parse(row.metadata_json);
-    for (const field of [
-        "sourceRun",
-        "beforeHash",
-        "review",
-        "confidence",
-        "gateDecision",
-        "backupContent",
-        "acceptedTarget",
-        "eligibilitySource",
-    ]) {
-        const value = proposal[field];
-        if (value === undefined)
-            delete metadata[field];
-        else
-            metadata[field] = value;
-    }
-    db.prepare(`UPDATE proposals
-     SET ref = ?, status = ?, source = ?, updated_at = ?, content = ?, frontmatter_json = ?, metadata_json = ?
-     WHERE id = ? AND stash_dir = ?`).run(proposal.ref, proposal.status, proposal.source, proposal.updatedAt, proposal.payload.content, proposal.payload.frontmatter ? JSON.stringify(proposal.payload.frontmatter) : null, JSON.stringify(metadata), proposal.id, stashDir);
-}
 function proposalRefIdentity(ref) {
     try {
         const parsed = parseBundleRef(ref);
@@ -565,6 +526,50 @@ export function listProposals(stashDir, options = {}, ctx) {
         });
     });
 }
+/**
+ * Read proposal context without creating or migrating state.db.
+ *
+ * Prompt-building consumers call this before their first model dispatch. A
+ * missing proposal store is therefore an empty snapshot, not a reason to
+ * create durable state before a required symbolic credential is validated at
+ * the dispatch boundary.
+ */
+export function listProposalsReadOnly(stashDir, options = {}, ctx) {
+    const dbPath = ctx?.dbPath ?? getStateDbPath();
+    if (!fs.existsSync(dbPath))
+        return [];
+    let db;
+    try {
+        db = openSqliteReadSnapshot(dbPath);
+        if (!db)
+            return [];
+        if (!options.includeArchive && options.status !== undefined && options.status !== "pending")
+            return [];
+        const status = options.includeArchive ? options.status : "pending";
+        const wantRef = options.ref !== undefined ? filterRefIdentity(options.ref) : undefined;
+        return listStateProposals(db, {
+            stashDir,
+            ...(status !== undefined ? { status } : {}),
+        }).filter((proposal) => {
+            if (wantRef !== undefined && !proposalMatchesRef(proposal.ref, wantRef))
+                return false;
+            if (!options.type)
+                return true;
+            try {
+                return parseRefInput(proposal.ref).type === options.type;
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+    finally {
+        db?.close();
+    }
+}
 /**
  * Look up a proposal by id (live or archived).
  * Throws `NotFoundError` when no match exists in this stash.
@@ -579,25 +584,6 @@ function requireProposal(db, stashDir, id) {
     }
     return proposal;
 }
-/**
- * Lenient counterpart to {@link requireProposal} / {@link getProposal}, used
- * ONLY on the terminal-status (reject/archive) read paths — `archiveProposal`
- * and the reject-transaction machinery (`rejectProposalDurably`,
- * `finalizeRejectTransaction`). Those paths must succeed even when the row's
- * metadata fails strict decoding (see {@link proposalRowToProposalLenient});
- * every other reader (accept, revert, show, list's pending branch) keeps
- * strict decoding via `getProposal`/`requireProposal` unchanged.
- */
-function requireProposalLenient(db, stashDir, id) {
-    const proposal = getStateProposalLenient(db, id, stashDir);
-    if (!proposal) {
-        throw new NotFoundError(`Proposal "${id}" not found.`, "PROPOSAL_NOT_FOUND");
-    }
-    return proposal;
-}
-function getProposalLenient(stashDir, id, ctx) {
-    return withProposalsDb(stashDir, ctx, (db) => requireProposalLenient(db, stashDir, id));
-}
 /**
  * Resolve a proposal by full UUID, UUID prefix, or asset ref.
  *
@@ -638,22 +624,6 @@ export function resolveProposalId(stashDir, idOrRef, ctx) {
         throw new NotFoundError(`Proposal "${idOrRef}" not found.`, "PROPOSAL_NOT_FOUND");
     });
 }
-/**
- * Resolve a reject target's id, tolerating a legacy row whose metadata fails
- * strict decoding. `akm proposal reject` only needs the id — but
- * {@link resolveProposalId}'s exact-UUID fast path decodes the FULL proposal
- * just to hand it back, which throws on those rows before the
- * terminal-status machinery (which reads leniently — see
- * `requireProposalLenient`) ever runs. Falls back to `resolveProposalId`
- * unchanged for ref / uuid-prefix inputs, where existing resolution
- * (including its error semantics) is preserved.
- */
-export function resolveProposalIdForReject(stashDir, idOrRef, ctx) {
-    const exact = withProposalsDb(stashDir, ctx, (db) => getStateProposalLenient(db, idOrRef, stashDir));
-    if (exact)
-        return exact.id;
-    return resolveProposalId(stashDir, idOrRef, ctx).id;
-}
 /**
  * Archive a proposal: flip its status to `accepted` / `rejected`, bump
  * `updatedAt`, and record the review block. Used by both accept and reject
@@ -662,10 +632,7 @@ export function resolveProposalIdForReject(stashDir, idOrRef, ctx) {
 export function archiveProposal(stashDir, id, status, reason, ctx, gateDecision) {
     return withProposalsDb(stashDir, ctx, (db) => {
         return withImmediateTransaction(db, () => {
-            // Lenient: archiving (accept OR reject) a legacy row with malformed
-            // changes/proposedTarget metadata must still be able to flip status —
-            // see requireProposalLenient.
-            const existing = requireProposalLenient(db, stashDir, id);
+            const existing = requireProposal(db, stashDir, id);
             if (existing.status !== "pending") {
                 throw new UsageError(`Proposal ${id} is not pending (current status: ${existing.status}). Only pending proposals can be ${status}.`, "INVALID_FLAG_VALUE");
             }
@@ -681,7 +648,7 @@ export function archiveProposal(stashDir, id, status, reason, ctx, gateDecision)
                 },
                 ...(gateDecision ? { gateDecision: { ...gateDecision, decidedAt: gateDecision.decidedAt ?? decidedAt } } : {}),
             };
-            persistProposalUpdate(db, updated, stashDir);
+            upsertProposal(db, updated, stashDir);
             return updated;
         });
     });
@@ -711,7 +678,7 @@ export function recordGateDecision(stashDir, id, decision, ctx) {
                 ...existing,
                 gateDecision: { ...decision, decidedAt: decision.decidedAt ?? nowIso(ctx) },
             };
-            persistProposalUpdate(db, updated, stashDir);
+            upsertProposal(db, updated, stashDir);
             return updated;
         });
     });
@@ -1182,9 +1149,7 @@ const REJECT_TXN_PHASES = ["prepared", "state-persisted", "event-finalized", "co
 function finalizeRejectTransaction(txn, ctx) {
     const p = txn.journal.payload;
     const decidedAt = txn.journal.decidedAt;
-    // Lenient: a reject transaction must run to completion even on a legacy
-    // row whose metadata fails strict decoding — see requireProposalLenient.
-    let proposal = getProposalLenient(p.stashDir, p.proposalId, ctx);
+    let proposal = getProposal(p.stashDir, p.proposalId, ctx);
     if (txn.journal.phase === "prepared") {
         if (proposal.status === "pending") {
             proposal = archiveProposal(p.stashDir, p.proposalId, "rejected", p.reason, { ...ctx, now: () => Date.parse(decidedAt) }, p.gateDecision);
@@ -1196,7 +1161,7 @@ function finalizeRejectTransaction(txn, ctx) {
         txnMutationHook("reject-state-persisted");
     }
     if (txn.journal.phase === "state-persisted") {
-        proposal = getProposalLenient(p.stashDir, p.proposalId, ctx);
+        proposal = getProposal(p.stashDir, p.proposalId, ctx);
         const eventRef = proposal.ref;
         const eventMeta = {
             proposalId: proposal.id,
@@ -1250,9 +1215,7 @@ export function rejectProposalDurably(stashDir, proposalId, reason, ctx, gateDec
     const recovered = recoverRejectTransaction(stashDir, proposalId, ctx);
     if (recovered)
         return recovered;
-    // Lenient: see requireProposalLenient — the reject decision itself must not
-    // be blocked by a legacy row's malformed changes/proposedTarget metadata.
-    const proposal = getProposalLenient(stashDir, proposalId, ctx);
+    const proposal = getProposal(stashDir, proposalId, ctx);
     if (proposal.status !== "pending") {
         throw new UsageError(`Proposal ${proposalId} is not pending (current status: ${proposal.status}). Only pending proposals can be rejected.`, "INVALID_FLAG_VALUE");
     }
@@ -1700,7 +1663,7 @@ async function promoteProposalWithLease(stashDir, config, id, options, ctx) {
     // final promoted payload (not the defective original).
     if (repairedContent !== proposalContent(proposal)) {
         withProposalsDb(stashDir, ctx, (db) => {
-            persistProposalUpdate(db, proposalToValidate, stashDir);
+            upsertProposal(db, proposalToValidate, stashDir);
         });
     }
     await recoverProposalTransactionsForStash(stashDir, config, ctx, id);

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

@@ -5,8 +5,8 @@ import { parseFrontmatter } from "../../../core/asset/frontmatter.js";
 import { parseRefInput } from "../../../core/asset/resolve-ref.js";
 import { proposalContent } from "../../../core/file-change.js";
 import { lintLessonContent } from "../../../core/lesson-lint.js";
-import { parseTaskDocument } from "../../../tasks/parser.js";
-import { parseWorkflow } from "../../../workflows/parser.js";
+import { parseTaskV3Yaml } from "../../../tasks/source-v3.js";
+import { compileWorkflowSource } from "../../../workflows/source-ir/compile.js";
 import { defaultProposalQualityValidators } from "./proposal-quality-validators.js";
 const genericProposalValidator = {
     name: "generic-proposal-validator",
@@ -52,10 +52,9 @@ const canonicalProposalValidators = {
         const name = ctx.parsedRef?.name;
         if (!name)
             return [];
-        parseTaskDocument({
+        parseTaskV3Yaml({
             yaml: proposalContent(proposal),
             filePath: proposal.changes[0]?.path || proposal.ref,
-            id: name,
         });
         return [];
     },
@@ -63,13 +62,16 @@ const canonicalProposalValidators = {
         const content = proposalContent(proposal);
         if (!content.trim())
             return [];
-        const changePath = proposal.changes[0]?.path ?? "";
-        const result = parseWorkflow(content, { path: changePath || proposal.ref });
+        const sourcePath = proposal.changes[0]?.path || proposal.ref;
+        const result = compileWorkflowSource(content, {
+            path: sourcePath,
+            workspaceRoot: proposal.proposedTarget.root,
+        });
         if (result.ok)
             return [];
         return result.errors.map((error) => ({
             kind: "invalid-workflow-structure",
-            message: `Workflow proposal ${proposal.id} (${proposal.ref}) is invalid at line ${error.line}: ${error.message}`,
+            message: `Workflow proposal ${proposal.id} (${proposal.ref}) is invalid [${error.code}] at ${error.path}:${error.line}: ${error.message}`,
         }));
     },
 };

package/dist/commands/read/curate.js

@@ -159,6 +159,7 @@ export async function curateSearchResults(query, result, limit, selectedType, ev
         summary: buildCurateSummary(query, items),
         items,
         ...(result.warnings?.length ? { warnings: result.warnings } : {}),
+        ...(result.searchMode ? { searchMode: result.searchMode } : {}),
         ...(result.tip ? { tip: result.tip } : {}),
     };
 }
@@ -306,16 +307,12 @@ export function deriveCurateFallbackQueries(query) {
     return tokens;
 }
 export function mergeCurateSearchResponses(base, extras) {
-    // The base (full-query) ranking is the relevance signal — keyword fallback
-    // searches exist only to ADD recall when that ranking is thin, never to
-    // re-rank it. So we PRESERVE base order and APPEND fallback-only hits below
-    // it. A single-token fallback match on an exact title/path normalizes to a
-    // high FTS score, but those scores are not comparable to the full-query
-    // (hybrid) scores; re-sorting the union by raw score (the prior behaviour)
-    // let that keyword junk leapfrog the contextually-relevant full-query hits.
-    // Dup refs (present in both base and a fallback) keep their base POSITION but
-    // take the MAX score, since matching both the full query and a key term is a
-    // stronger relevance signal for the downstream score floor.
+    // The base (full-query) ranking is authoritative by default; keyword
+    // fallbacks add recall without comparing their raw scores to the full-query
+    // score scale. Base order is preserved and fallback-only hits append below,
+    // except for the narrow weak-provenance promotion documented below. Duplicate
+    // refs keep their base position but take the maximum score for the downstream
+    // relevance floor.
     const bestExtraStashScore = new Map();
     for (const result of extras) {
         for (const hit of result.hits.filter((entry) => entry.type !== "registry")) {
@@ -341,22 +338,39 @@ export function mergeCurateSearchResponses(base, extras) {
                 extraOnly.set(hit.ref, hit);
         }
     }
-    // Fallback-only hits must rank BELOW every full-query hit through the rest of
-    // the pipeline. The downstream selector (`selectCuratedStashHits`) RE-SORTS by
-    // score and derives its relevance floor from the top score, so preserving
-    // order here is not enough — a single-token FTS match (normalized ~0.9) would
-    // otherwise become the leader and evict the contextual full-query memories.
-    // We therefore restamp fallback-only scores into a band strictly below the
-    // minimum base score (keeping their own relative order). When there are no
-    // base hits, fallback IS the result, so scores are kept as-is.
+    // Fallback-only hits ordinarily stay below every full-query hit through the
+    // downstream selector, which re-sorts by score and derives its relevance
+    // floor from the leader. Restamping them below the minimum base score keeps a
+    // single-token score from leapfrogging contextual results. The one exception
+    // is a strong name match repairing a lexically weak base, selected below.
     const sortedExtra = [...extraOnly.values()].sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+    const lexicalAttribution = (hit) => getSearchHitAttribution(hit)?.lexical;
+    // The full-query base remains authoritative unless its lexical provenance is
+    // itself weak: relaxed recovery, or no hit whose name covers the query. In
+    // that case one fallback discovery with strong name coverage may lead. This
+    // preserves contextual base ranking while allowing measured recall to repair
+    // a thin match without comparing unrelated raw FTS score scales.
+    const weakLexicalBase = baseStash.length > 0 &&
+        baseStash.every((hit) => {
+            const lexical = lexicalAttribution(hit);
+            return lexical !== undefined && (lexical.execution === "relaxed" || lexical.nameMatchTier < 2);
+        });
+    const promotedExtraIndex = weakLexicalBase
+        ? sortedExtra.findIndex((hit) => (lexicalAttribution(hit)?.nameMatchTier ?? 0) >= 2)
+        : -1;
+    const promotedExtra = promotedExtraIndex >= 0 ? sortedExtra[promotedExtraIndex] : undefined;
+    const remainingExtra = promotedExtraIndex >= 0 ? sortedExtra.filter((_, index) => index !== promotedExtraIndex) : sortedExtra;
     const minBaseScore = baseStash.length
         ? Math.min(...baseStash.map((hit) => hit.score ?? 0))
         : Number.POSITIVE_INFINITY;
     const cappedExtra = baseStash.length
-        ? sortedExtra.map((hit, i) => ({ ...hit, score: minBaseScore - 1e-6 * (i + 1) }))
-        : sortedExtra;
-    const mergedHits = [...baseStash, ...cappedExtra];
+        ? remainingExtra.map((hit, i) => ({ ...hit, score: minBaseScore - 1e-6 * (i + 1) }))
+        : remainingExtra;
+    const mergedHits = [
+        ...(promotedExtra ? [{ ...promotedExtra, score: minBaseScore }] : []),
+        ...baseStash,
+        ...cappedExtra,
+    ];
     // Registry hits are supplemental fill — same rule: base first (max score on
     // dups), then fallback-only registry hits appended by score.
     const bestExtraRegScore = new Map();
@@ -389,11 +403,20 @@ export function mergeCurateSearchResponses(base, extras) {
         ...baseReg,
         ...[...extraRegOnly.values()].sort((a, b) => (b.score ?? 0) - (a.score ?? 0)),
     ];
+    const modes = [base.searchMode, ...extras.map((result) => result.searchMode)].filter((mode) => mode !== undefined);
+    const searchMode = modes.includes("fts-fallback")
+        ? "fts-fallback"
+        : modes.includes("semantic")
+            ? "semantic"
+            : modes.includes("keyword")
+                ? "keyword"
+                : undefined;
     return {
         ...base,
         hits: mergedHits,
         ...(mergedRegistryHits.length > 0 ? { registryHits: mergedRegistryHits } : {}),
         ...(warnings.length > 0 ? { warnings } : {}),
+        ...(searchMode ? { searchMode } : {}),
         ...(mergedHits.length > 0 || mergedRegistryHits.length > 0 ? { tip: undefined } : {}),
     };
 }
@@ -575,8 +598,16 @@ function collapseCurateFamilies(query, hits) {
         if (!representative)
             continue;
         collapsedFamilies.push(representative);
-        const supportCandidates = [group.root, ...group.references].filter((entry) => {
+        const supportCandidates = [group.root, ...group.references]
+            .filter((entry) => {
             return entry !== undefined && entry.hit.ref !== representative.hit.ref;
+        })
+            .sort((a, b) => {
+            if (a === group.root)
+                return -1;
+            if (b === group.root)
+                return 1;
+            return a.hit.ref.localeCompare(b.hit.ref);
         });
         for (const support of supportCandidates) {
             appendCurateSupportRef(supportRefsByRef, representative.hit.ref, {

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

@@ -1,8 +1,8 @@
 // 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 { toErrorMessage } from "../../core/common.js";
 import { DEFAULT_CONFIG } from "../../core/config/config.js";
+import { formatRegistryCredentialWarning, formatRegistryError, formatRegistryLabel, hasRegistryUrlCredentials, redactCredentialBearingUrls, } from "../../core/registry-url.js";
 import { warn } from "../../core/warn.js";
 import { resolveRegistryProviderFactory } from "../../registry/factory.js";
 // ── Eagerly import providers to trigger self-registration ───────────────────
@@ -16,8 +16,13 @@ export async function searchRegistry(query, options) {
     const limit = clampLimit(options?.limit);
     // resolveRegistries() already filters by enabled; explicit registries are filtered here
     const raw = options?.registries ?? resolveRegistries();
-    const entries = options?.registries ? raw.filter((r) => r.enabled !== false) : raw;
     const warnings = [];
+    const entries = (options?.registries ? raw.filter((r) => r.enabled !== false) : raw).filter((entry) => {
+        if (!hasRegistryUrlCredentials(entry.url))
+            return true;
+        warnings.push(formatRegistryCredentialWarning(entry));
+        return false;
+    });
     // Resolve and search all providers concurrently
     const results = await Promise.allSettled(entries.map((entry) => {
         const provider = createProvider(entry, warnings);
@@ -34,13 +39,13 @@ export async function searchRegistry(query, options) {
     for (let i = 0; i < results.length; i++) {
         const result = results[i];
         if (result.status === "rejected") {
-            warnings.push(toErrorMessage(result.reason));
+            warnings.push(`Registry ${formatRegistryLabel(entries[i])}: ${formatRegistryError(result.reason)}`);
             continue;
         }
         const value = result.value;
         if (!value)
             continue;
-        const registryLabel = entries[i].name ? `"${entries[i].name}"` : entries[i].url;
+        const registryLabel = formatRegistryLabel(entries[i]);
         let dropped = 0;
         const validHits = [];
         for (const hit of value.hits) {
@@ -75,7 +80,7 @@ export async function searchRegistry(query, options) {
             warnings.push(`Registry ${registryLabel} returned ${dropped} incomplete hit(s); dropped from response.`);
         }
         if (value.warnings)
-            warnings.push(...value.warnings);
+            warnings.push(...value.warnings.map(redactCredentialBearingUrls));
     }
     // Sort merged hits by normalized score descending, apply limit
     allHits.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
@@ -121,7 +126,7 @@ export function resolveRegistries(configRegistries) {
                 provider = trimmed.slice(0, colonColonIdx).trim();
                 url = trimmed.slice(colonColonIdx + 2).trim();
                 if (!provider) {
-                    warn(`[akm] Ignoring AKM_REGISTRY_URL entry: empty provider type before "::" in "${trimmed}"`);
+                    warn('[akm] Ignoring AKM_REGISTRY_URL entry: empty provider type before "::".');
                     continue;
                 }
             }
@@ -129,7 +134,11 @@ export function resolveRegistries(configRegistries) {
                 url = trimmed;
             }
             if (!url.startsWith("http://") && !url.startsWith("https://")) {
-                warn(`[akm] Ignoring AKM_REGISTRY_URL entry: must start with http:// or https://, got "${url}"`);
+                warn("[akm] Ignoring AKM_REGISTRY_URL entry: URL must start with http:// or https://.");
+                continue;
+            }
+            if (hasRegistryUrlCredentials(url)) {
+                warn(`[akm] ${formatRegistryCredentialWarning({ url })}`);
                 continue;
             }
             entries.push(provider ? { url, provider } : { url });
@@ -137,14 +146,21 @@ export function resolveRegistries(configRegistries) {
         return entries;
     }
     const registries = configRegistries ?? DEFAULT_CONFIG.registries ?? [];
-    return registries.filter((r) => r.enabled !== false);
+    return registries.filter((entry) => {
+        if (entry.enabled === false)
+            return false;
+        if (!hasRegistryUrlCredentials(entry.url))
+            return true;
+        warn(`[akm] ${formatRegistryCredentialWarning(entry)}`);
+        return false;
+    });
 }
 // ── Provider resolution ─────────────────────────────────────────────────────
 function createProvider(entry, warnings) {
     const providerType = entry.provider ?? "static-index";
     const factory = resolveRegistryProviderFactory(providerType);
     if (!factory) {
-        const label = entry.name ? `${entry.name} (${entry.url})` : entry.url;
+        const label = formatRegistryLabel(entry);
         warnings.push(`Registry ${label}: unknown provider type "${providerType}"`);
         return null;
     }

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

@@ -230,6 +230,7 @@ export const rememberCommand = defineJsonCommand({
         let observed_at;
         let expires;
         let subjective;
+        let executionNotices;
         // Resolve --expires to an ISO date string
         if (args.expires) {
             const durationMs = parseDuration(args.expires);
@@ -261,6 +262,7 @@ export const rememberCommand = defineJsonCommand({
                 description = enriched.description;
             if (!observed_at && enriched.observed_at)
                 observed_at = enriched.observed_at;
+            executionNotices = enriched.notices;
         }
         // ── Required-field check (before any write) ───────────────────────────
         // Tags remain required when the user explicitly asked for tag-bearing
@@ -318,15 +320,25 @@ export const rememberCommand = defineJsonCommand({
                 tagCount: tags.length,
                 enriched: args.enrich === true,
                 auto: args.auto === true,
+                ...(executionNotices && executionNotices.length > 0 ? { notices: executionNotices } : {}),
                 ...(hasScope ? { scope: scopeFields } : {}),
             },
         });
         if (args.showSimilar) {
             const similar = await fetchSimilarMemories((body ?? args.content ?? "").slice(0, 500), result.ref, eventSource);
-            output("remember", { ok: true, ...result, similar });
+            output("remember", {
+                ok: true,
+                ...result,
+                similar,
+                ...(executionNotices && executionNotices.length > 0 ? { notices: executionNotices } : {}),
+            });
         }
         else {
-            output("remember", { ok: true, ...result });
+            output("remember", {
+                ok: true,
+                ...result,
+                ...(executionNotices && executionNotices.length > 0 ? { notices: executionNotices } : {}),
+            });
         }
     },
 });

package/dist/commands/read/search.js

@@ -127,9 +127,10 @@ export async function akmSearch(input) {
             hits: localHits,
             tip: hasResults ? undefined : localResult?.tip,
             warnings: localResult?.warnings?.length ? localResult.warnings : undefined,
+            searchMode: localResult?.mode ?? "keyword",
             timing: { totalMs: Date.now() - t0, rankMs: localResult?.rankMs, embedMs: localResult?.embedMs },
         };
-        maybeLogSearchEvent(input, query, response, localResult?.mode ?? "keyword");
+        maybeLogSearchEvent(input, query, response, usageSearchMode(localResult?.mode));
         return response;
     }
     const registryHits = (registryResult?.hits ?? []).map((hit) => {
@@ -174,11 +175,16 @@ export async function akmSearch(input) {
         registryHits,
         tip: hasResults ? undefined : "No matching stash assets or registry entries were found.",
         warnings: warnings.length ? warnings : undefined,
+        searchMode: localResult?.mode ?? "keyword",
         timing: { totalMs: Date.now() - t0 },
     };
-    maybeLogSearchEvent(input, query, response);
+    maybeLogSearchEvent(input, query, response, usageSearchMode(localResult?.mode));
     return response;
 }
+/** Usage telemetry retains its historical semantic|keyword vocabulary. */
+function usageSearchMode(mode) {
+    return mode === "semantic" ? "semantic" : "keyword";
+}
 function maybeLogSearchEvent(input, query, response, mode) {
     if (input.skipLogging)
         return;
@@ -327,8 +333,8 @@ function normalizeLimit(limit) {
  *   - `local` (default) — search the local stash index only
  *   - `registry`        — search remote registries only
  *   - `all`             — search local and registries
- *   - Any named source from `config.sources[].name` — filters stash results to
- *     that single source only. The named-source path is detected and resolved
+ *   - Any named configured bundle — filters local results to that bundle only.
+ *     The named-source path is detected and resolved
  *     inside `akmSearch`; this function returns the raw name so the caller can
  *     pass it through to `akmSearch` which accepts `SearchSource | string`.
  *