akm-cli 0.10.261004-beta → 0.10.261006-beta

package/dist/commands/proposal/repository.js

@@ -436,34 +436,36 @@ function requireProposal(db, stashDir, id) {
  * proposal (then most recent archived); else by a unique pending id prefix.
  */
 export function resolveProposalId(stashDir, idOrRef, ctx) {
-    return withProposalsDb(ctx, (db) => {
-        const exact = getStateProposal(db, idOrRef, stashDir);
-        if (exact)
-            return exact;
-        if (idOrRef.includes(":") || idOrRef.includes("/")) {
-            const wantRef = filterRefIdentity(idOrRef);
-            // Should-fix 7: by-ref resolution never picks a retire proposal — the
-            // newest pending proposal for a ref could be a `consolidate-pair`
-            // retirement rather than the reflect/distill edit a person typed the
-            // ref to accept, and accepting it archives the asset instead. A retire
-            // is reached by its own proposal id, or by the explicit generator
-            // `consolidate-pair` (bulk accept/reject).
-            const newest = (status) => listStateProposals(db, { stashDir, ...(status !== undefined ? { status } : {}) })
-                .filter((p) => proposalMatchesRef(p.ref, wantRef) && !isRetireProposal(p))
-                .sort((a, b) => new Date(b.createdAt ?? 0).getTime() - new Date(a.createdAt ?? 0).getTime())[0];
-            const found = newest("pending") ?? newest();
-            if (found)
-                return found;
-            throw new NotFoundError(`No proposal found for ref "${idOrRef}".`, "PROPOSAL_NOT_FOUND");
-        }
-        const prefixMatches = listStateProposalIdsByPrefix(db, stashDir, idOrRef);
-        if (prefixMatches.length === 1)
-            return requireProposal(db, stashDir, prefixMatches[0]);
-        if (prefixMatches.length > 1) {
-            throw new UsageError(`Ambiguous prefix "${idOrRef}" — matches: ${prefixMatches.join(", ")}`, "INVALID_FLAG_VALUE");
-        }
-        throw new NotFoundError(`Proposal "${idOrRef}" not found.`, "PROPOSAL_NOT_FOUND");
-    });
+    return withProposalsDb(ctx, (db) => resolveProposalIdIn(db, stashDir, idOrRef));
+}
+/** {@link resolveProposalId} over a connection the caller holds (`akm ui` reads state.db read-only). */
+export function resolveProposalIdIn(db, stashDir, idOrRef) {
+    const exact = getStateProposal(db, idOrRef, stashDir);
+    if (exact)
+        return exact;
+    if (idOrRef.includes(":") || idOrRef.includes("/")) {
+        const wantRef = filterRefIdentity(idOrRef);
+        // Should-fix 7: by-ref resolution never picks a retire proposal — the
+        // newest pending proposal for a ref could be a `consolidate-pair`
+        // retirement rather than the reflect/distill edit a person typed the
+        // ref to accept, and accepting it archives the asset instead. A retire
+        // is reached by its own proposal id, or by the explicit generator
+        // `consolidate-pair` (bulk accept/reject).
+        const newest = (status) => listStateProposals(db, { stashDir, ...(status !== undefined ? { status } : {}) })
+            .filter((p) => proposalMatchesRef(p.ref, wantRef) && !isRetireProposal(p))
+            .sort((a, b) => new Date(b.createdAt ?? 0).getTime() - new Date(a.createdAt ?? 0).getTime())[0];
+        const found = newest("pending") ?? newest();
+        if (found)
+            return found;
+        throw new NotFoundError(`No proposal found for ref "${idOrRef}".`, "PROPOSAL_NOT_FOUND");
+    }
+    const prefixMatches = listStateProposalIdsByPrefix(db, stashDir, idOrRef);
+    if (prefixMatches.length === 1)
+        return requireProposal(db, stashDir, prefixMatches[0]);
+    if (prefixMatches.length > 1) {
+        throw new UsageError(`Ambiguous prefix "${idOrRef}" — matches: ${prefixMatches.join(", ")}`, "INVALID_FLAG_VALUE");
+    }
+    throw new NotFoundError(`Proposal "${idOrRef}" not found.`, "PROPOSAL_NOT_FOUND");
 }
 /**
  * The ledger outcome of a decision. A procedural refusal (retention expiry, a
@@ -1060,6 +1062,37 @@ function requireAcceptedTarget(proposal) {
 function acceptCommitMessage(proposal) {
     return `akm accept: ${proposal.source} ${proposal.id.slice(0, 8)} ${proposal.ref}`;
 }
+function commitAccept(collector, target, proposal, paths) {
+    if (collector)
+        collector.push({ target, proposal, paths });
+    else
+        commitAcceptedPaths(target, acceptCommitMessage(proposal), paths);
+}
+/**
+ * Commit everything `collector` holds, one commit per target repository: a lone
+ * accept keeps its own subject; several get `<label>: N accepted (source count,
+ * ...)` with one `<id8> <source> <ref>` body line per proposal. Empties the
+ * collector. A failed commit only warns, as for a single accept.
+ */
+export function commitCollectedAccepts(collector, label) {
+    const byRepo = new Map();
+    for (const entry of collector.splice(0)) {
+        const key = path.resolve(entry.target.source.repoPath ?? entry.target.source.path);
+        byRepo.set(key, [...(byRepo.get(key) ?? []), entry]);
+    }
+    for (const entries of byRepo.values()) {
+        const first = entries[0];
+        if (entries.length === 1) {
+            commitAcceptedPaths(first.target, acceptCommitMessage(first.proposal), first.paths);
+            continue;
+        }
+        const counts = new Map();
+        for (const { proposal } of entries)
+            counts.set(proposal.source, (counts.get(proposal.source) ?? 0) + 1);
+        const bySource = [...counts].sort((a, b) => b[1] - a[1]).map(([source, count]) => `${source} ${count}`);
+        commitAcceptedPaths(first.target, `${label}: ${entries.length} accepted (${bySource.join(", ")})`, entries.flatMap((entry) => entry.paths), entries.map(({ proposal }) => `${proposal.id.slice(0, 8)} ${proposal.source} ${proposal.ref}`));
+    }
+}
 /**
  * O1 (alpha.9): an accepted consolidate PROMOTION retires its source memory
  * (and its `.derived` twin), so promotion no longer leaves a memory/
@@ -1163,7 +1196,7 @@ async function promoteProposalWithLease(stashDir, config, id, options, ctx) {
     const paths = [assetPath];
     if (accepted.status === "accepted" && accepted.source === "consolidate")
         retirePromotionSource(mutationTarget, accepted, paths);
-    commitAcceptedPaths(mutationTarget, acceptCommitMessage(accepted), paths);
+    commitAccept(options.commitCollector, mutationTarget, accepted, paths);
     return { proposal: accepted, assetPath, ref: accepted.ref };
 }
 /**
@@ -1422,7 +1455,7 @@ async function retireProposalWithLease(stashDir, config, proposal, options, ctx)
         paths.push(twinPath, path.join(mutationTarget.source.path, twinRecord.archivedPath), path.join(mutationTarget.source.path, twinRecord.auditPath));
     }
     if (paths.length > 0)
-        commitAcceptedPaths(mutationTarget, acceptCommitMessage(proposal), paths);
+        commitAccept(options.commitCollector, mutationTarget, proposal, paths);
     if (archiveDirs.length === 0) {
         // Recorded intent, but neither file is at its original location NOR
         // archived under this proposal's id: something else removed the target
@@ -1838,7 +1871,10 @@ export function reopenProposals(stashDir, config, ids, options = {}, ctx) {
 }
 /** The proposal against the asset its accept would overwrite (same target resolution as accept). */
 export function diffProposal(stashDir, config, id, options = {}, ctx) {
-    const proposal = getProposal(stashDir, id, ctx);
+    return diffLoadedProposal(config, getProposal(stashDir, id, ctx), options);
+}
+/** {@link diffProposal} for a proposal the caller already read (`akm ui` reads state.db read-only). */
+export function diffLoadedProposal(config, proposal, options = {}) {
     const target = resolveProposalWriteTarget(config, proposal, options.target, options.queueTarget);
     const targetPath = resolveAssetFilePathSafe(target.source, parseRefInput(proposal.ref));
     const existing = targetPath && fs.existsSync(targetPath) ? fs.readFileSync(targetPath, "utf8") : null;

package/dist/commands/read/search.js

@@ -123,6 +123,7 @@ export async function akmSearch(input) {
             // would leak hits from sources the caller did not request.
             restrictToSources: namedSourceName !== undefined,
             includeExcludedTypes: input.includeSessions === true,
+            readOnly: input.readOnly,
         });
     const registryResult = source === "local"
         ? undefined
@@ -201,7 +202,7 @@ function usageSearchMode(mode) {
     return mode === "semantic" ? "semantic" : "keyword";
 }
 function maybeLogSearchEvent(input, query, response, mode) {
-    if (input.skipLogging)
+    if (input.skipLogging || input.readOnly)
         return;
     logSearchEvent(query, response, mode, input.eventSource, input.attributionProjection);
 }

package/dist/commands/read/show.js

@@ -65,7 +65,7 @@ export async function akmShowUnified(input) {
     {
         const metaRef = parseMetaRef(ref);
         if (metaRef)
-            return showStashMeta(metaRef);
+            return showStashMeta(metaRef, input.readOnly === true);
     }
     // Env/secret bodies have no safe fragment surface, and a fragment cannot
     // widen what the env/secret renderers expose: both always omit the body
@@ -77,7 +77,7 @@ export async function akmShowUnified(input) {
     // safe substrate below is its source of truth. Friendly heading selectors
     // intentionally retain the normal source-live read behavior.
     const parsedRef = parseBundleRef(ref);
-    if (!parsedRef.fragment?.startsWith("akm-fragment-")) {
+    if (!input.readOnly && !parsedRef.fragment?.startsWith("akm-fragment-")) {
         const { primarySource } = resolveReadSources();
         await ensurePrimaryIndexForRead(primarySource);
     }
@@ -91,7 +91,7 @@ export async function akmShowUnified(input) {
         enforceScopeOrThrow(result.path, ref, input.scope);
     }
     // Count prior shows of this ref before logging the current one.
-    if (!input.skipLogging) {
+    if (!input.skipLogging && !input.readOnly) {
         const consumedRef = result.ref ?? makeBundleRef(undefined, parseBundleRef(ref).conceptId);
         const priorShowCount = recentShowCount(consumedRef);
         recordShowUsage(consumedRef, result.type, result.name, input.eventSource, result.path);
@@ -110,7 +110,7 @@ export async function akmShowUnified(input) {
  * to that stash; an uninstalled origin yields an actionable "not installed"
  * error. The file is read directly from disk — `.meta/` is never indexed.
  */
-async function showStashMeta(metaRef) {
+async function showStashMeta(metaRef, readOnly = false) {
     const allSources = resolveSourceEntries();
     const sources = resolveSourcesForOrigin(metaRef.origin, allSources);
     if (metaRef.origin && sources.length === 0) {
@@ -123,7 +123,9 @@ async function showStashMeta(metaRef) {
         if (!metaFile)
             continue;
         const editable = isEditable(metaFile.path, config, allSources);
-        appendEvent({ eventType: "show", ref: `meta:${metaRef.name}`, metadata: { type: "meta", name: metaRef.name } });
+        if (!readOnly) {
+            appendEvent({ eventType: "show", ref: `meta:${metaRef.name}`, metadata: { type: "meta", name: metaRef.name } });
+        }
         return {
             type: "meta",
             name: metaRef.name,
@@ -366,7 +368,7 @@ export async function showLocal(input) {
         ...(!editable ? { editHint: buildEditHint(canonicalRef) } : {}),
         ...showLinks(indexedEntry.itemRef, displayDefaultBundle),
     };
-    const activeRun = await getActiveWorkflowRun(getCurrentWorkflowScopeKey());
+    const activeRun = input.readOnly ? null : await getActiveWorkflowRun(getCurrentWorkflowScopeKey());
     if (activeRun) {
         fullResponse.activeRun = activeRun;
     }