akm-cli 0.9.15 → 0.9.16-alpha.2

package/dist/indexer/bundle-identity-guard.js

@@ -28,6 +28,7 @@
  * comparison over a non-empty index so the steady-state cost is a boolean check.
  */
 import fs from "node:fs";
+import path from "node:path";
 import { loadConfig } from "../core/config/config.js";
 import { rethrowIfTestIsolationError } from "../core/errors.js";
 import { getDbPath } from "../core/paths.js";
@@ -39,8 +40,8 @@ let guardSettled = false;
 export function resetBundleIdentityGuardForTests() {
     guardSettled = false;
 }
-/** Distinct non-empty `bundle_id` prefixes persisted in the index, or `undefined` when unreadable. */
-function indexBundlePrefixes(dbPath) {
+/** Bundle/path ownership persisted in the index, or `undefined` when unreadable. */
+function indexedBundlePaths(dbPath) {
     if (!fs.existsSync(dbPath))
         return undefined;
     let db;
@@ -51,8 +52,9 @@ function indexBundlePrefixes(dbPath) {
         if (!isCanonicalIndexGeneration(db))
             return undefined;
         return db
-            .prepare("SELECT DISTINCT bundle_id AS b FROM entries WHERE bundle_id IS NOT NULL AND bundle_id != ''")
-            .all().map((row) => row.b);
+            .prepare("SELECT DISTINCT bundle_id AS bundleId, file_path AS filePath FROM entries " +
+            "WHERE bundle_id IS NOT NULL AND bundle_id != '' AND file_path IS NOT NULL AND file_path != ''")
+            .all();
     }
     catch (error) {
         rethrowIfTestIsolationError(error);
@@ -80,20 +82,55 @@ export function warnOnBundleRenameDrift(config = loadConfig()) {
     const configIds = new Set(Object.keys(bundles));
     if (configIds.size === 0)
         return;
-    const indexIds = indexBundlePrefixes(getDbPath());
-    if (indexIds === undefined || indexIds.length === 0)
+    const indexedPaths = indexedBundlePaths(getDbPath());
+    if (indexedPaths === undefined || indexedPaths.length === 0)
         return; // nothing indexed yet — re-check later
     // A real comparison happened over a populated index: settle so the steady
     // state is one boolean check.
     guardSettled = true;
+    const indexIds = [...new Set(indexedPaths.map((row) => row.bundleId))];
     const indexIdSet = new Set(indexIds);
     const configuredMissingFromIndex = [...configIds].filter((id) => !indexIdSet.has(id));
     const indexedNotConfigured = indexIds.filter((id) => !configIds.has(id));
     if (configuredMissingFromIndex.length === 0 || indexedNotConfigured.length === 0)
         return;
+    // A mismatched id set alone is also the ordinary signature of adding a new
+    // bundle while stale rows from a removed bundle still exist. Treat it as a
+    // hand rename only when the old rows physically live beneath the newly named
+    // filesystem bundle's root. This keeps the guard useful without warning on
+    // unrelated new bundles (#971).
+    const renamedConfiguredIds = configuredMissingFromIndex.filter((configuredId) => {
+        const configuredPath = config.bundles?.[configuredId]?.path;
+        if (typeof configuredPath !== "string")
+            return false;
+        const root = path.resolve(configuredPath);
+        return indexedPaths.some((row) => {
+            if (!indexedNotConfigured.includes(row.bundleId))
+                return false;
+            const relative = path.relative(root, path.resolve(row.filePath));
+            return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+        });
+    });
+    if (renamedConfiguredIds.length === 0)
+        return;
+    const renamedOldIds = [
+        ...new Set(indexedPaths
+            .filter((row) => {
+            if (!indexedNotConfigured.includes(row.bundleId))
+                return false;
+            return renamedConfiguredIds.some((configuredId) => {
+                const configuredPath = config.bundles?.[configuredId]?.path;
+                if (typeof configuredPath !== "string")
+                    return false;
+                const relative = path.relative(path.resolve(configuredPath), path.resolve(row.filePath));
+                return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+            });
+        })
+            .map((row) => row.bundleId)),
+    ];
     warn("WARNING: bundle identity drift detected. " +
-        `Configured bundle(s) with no indexed content: ${configuredMissingFromIndex.map((id) => `"${id}"`).join(", ")}; ` +
-        `indexed content under unconfigured bundle id(s): ${indexedNotConfigured.map((id) => `"${id}"`).join(", ")}. ` +
+        `Configured bundle(s) with no indexed content: ${renamedConfiguredIds.map((id) => `"${id}"`).join(", ")}; ` +
+        `indexed content under unconfigured bundle id(s): ${renamedOldIds.map((id) => `"${id}"`).join(", ")}. ` +
         "This is the signature of a hand-renamed bundle id (spec §11.5). AKM will NOT silently re-mint fresh state " +
         "under the new id. There is no rekey command in 0.9.0: either restore the previous bundle id in config.json " +
         "to reattach the existing rows, or keep the new id and run `akm index --full` to re-mint under it, accepting " +

package/dist/indexer/indexer.js

@@ -1641,7 +1641,7 @@ function verifyIndexState(db, config, embeddableEntries, embeddingResult) {
             message: `Semantic search ready (${embeddingCount}/${embeddableEntries} embeddings, ${vecActive
                 ? "sqlite-vec active"
                 : vecAvailable
-                    ? "JS fallback active — vec fast path degraded, run 'akm index --full' to restore"
+                    ? "JS fallback active — vec fast path degraded; run 'akm index' to repair valid stored vectors or 'akm index --reembed' to regenerate incompatible ones"
                     : "JS fallback active"}).`,
             semanticSearchEnabled: true,
             semanticSearchMode: config.semanticSearchMode,

package/dist/indexer/materialize-embeddings.js

@@ -11,7 +11,8 @@ import { cosineSimilarity } from "../llm/embedders/types.js";
 import { purgeEmbeddingSalvage, relabelEmbeddingSalvageFingerprint, reuseSalvagedEmbeddings, } from "../storage/repositories/embedding-salvage-repository.js";
 import { getEmbeddableEntryCount } from "../storage/repositories/index-entries-repository.js";
 import { deleteMeta, getMeta, setMeta } from "../storage/repositories/index-meta-repository.js";
-import { getAllEntriesForEmbedding, getEmbeddingCount, isVecFastPathComplete, isVecFastPathReady, purgeEmbeddings, sampleEmbeddedEntriesForCanary, setVecFastPathReady, upsertEmbedding, } from "../storage/repositories/index-vec-repository.js";
+import { EMBEDDING_DIM } from "../storage/repositories/index-schema.js";
+import { getAllEntriesForEmbedding, getEmbeddingCount, isVecFastPathComplete, isVecFastPathReady, purgeEmbeddings, repairVecFastPath, sampleEmbeddedEntriesForCanary, setVecFastPathReady, upsertEmbedding, } from "../storage/repositories/index-vec-repository.js";
 import { reclassifyIndexDbContention } from "./index-db-contention.js";
 /** Identifies the embedding provider+model+dimension a stored vector was generated with. */
 export function deriveSemanticProviderFingerprint(embedding) {
@@ -360,6 +361,19 @@ export async function generateEmbeddingsForDb(db, config, onProgress, signal, en
     }
     try {
         throwIfAborted(signal);
+        if (entryIds === undefined && (!vecFastPathWasReady || !isVecFastPathComplete(db))) {
+            const storedDim = Number(getMeta(db, "embeddingDim"));
+            const expectedDim = Number.isInteger(storedDim) && storedDim > 0 ? storedDim : (config.embedding?.dimension ?? EMBEDDING_DIM);
+            const repair = repairVecFastPath(db, expectedDim);
+            if (repair.available &&
+                (repair.repaired > 0 || repair.removedOrphans > 0 || repair.rejected > 0 || repair.error !== undefined)) {
+                const detail = repair.error ? `; repair stopped: ${repair.error}` : "";
+                onProgress({
+                    phase: "embeddings",
+                    message: `[embed] Repaired ${repair.repaired} missing sqlite-vec row${repair.repaired === 1 ? "" : "s"}; removed ${repair.removedOrphans} orphan${repair.removedOrphans === 1 ? "" : "s"}; ${repair.rejected} rejected${detail}.`,
+                });
+            }
+        }
         const allEntries = getAllEntriesForEmbedding(db, targetEntryIds);
         let vecFailedCount = 0;
         let vecUnavailableCount = 0;

package/dist/indexer/search/search-source.js

@@ -4,7 +4,8 @@
 import fs from "node:fs";
 import path from "node:path";
 import { isWithin, resolveStashDir } from "../../core/common.js";
-import { bundleComponentConfig, bundlesToSourceEntries, getSources, loadConfig } from "../../core/config/config.js";
+import { bundleComponentConfig, bundleKeyForContentRoot, bundlesToSourceEntries, getSources, isBundleEnabled, loadConfig, } from "../../core/config/config.js";
+import { ConfigError } from "../../core/errors.js";
 import { getUnresolvedSourcesDir } from "../../core/paths.js";
 import { resolveGitContentRoot, resolveWritable } from "../../core/write-source.js";
 import { lockContentRootFor } from "../../integrations/lockfile.js";
@@ -23,7 +24,7 @@ import { warn } from "../../core/warn.js";
  *   2. The configured `defaultBundle`, after component-root validation.
  *   3. Remaining configured bundles in installation-priority order.
  *
- * Disabled entries (`enabled: false`) are filtered after deduplication.
+ * Disabled entries (`enabled: false`) are excluded before materialization.
  * Missing configured roots remain in the result so the
  * indexer can classify their scan as incomplete instead of mistaking them for
  * removed sources.
@@ -39,23 +40,39 @@ export function resolveSourceEntries(overrideStashDir, existingConfig) {
             : config.defaultBundle
                 ? undefined
                 : resolveStashDir();
+    const implicitConfiguredBundle = implicitStashDir ? bundleKeyForContentRoot(config, implicitStashDir) : undefined;
+    if (implicitConfiguredBundle && !isBundleEnabled(config, implicitConfiguredBundle)) {
+        throw new ConfigError(`The requested working source is disabled as bundle ${JSON.stringify(implicitConfiguredBundle)}.`, "INVALID_CONFIG_FILE");
+    }
     // Explicit and environment overrides stay first. Without either override,
     // the configured default enters through the validated loop below.
-    const sources = implicitStashDir ? [{ path: implicitStashDir, writable: true }] : [];
-    const seen = new Set(implicitStashDir ? [implicitStashDir] : []);
-    const addSource = (dir, registryId, writable, type, adapterId, unresolved = false) => {
+    const sources = implicitStashDir ? [{ path: implicitStashDir, writable: true, isDefault: true }] : [];
+    const sourceIdentity = (dir) => {
+        const resolved = path.resolve(dir);
+        try {
+            return fs.realpathSync.native(resolved);
+        }
+        catch {
+            return resolved;
+        }
+    };
+    const seen = new Set(implicitStashDir ? [sourceIdentity(implicitStashDir)] : []);
+    const addSource = (dir, registryId, writable, type, adapterId, unresolved = false, isDefault = false) => {
         const resolved = path.resolve(dir);
-        if (seen.has(resolved)) {
+        const identity = sourceIdentity(resolved);
+        if (seen.has(identity)) {
             // Already in the source list — typically the primary stash injected at
             // sources[0] before this loop. Enrich that entry with whatever metadata
             // the matching config source carries so `--from <config-name>` can
             // find it via registryId. Without this, the primary stash entry stays
             // identity-less and a user-named primary source ("name": "my-stash")
             // would validate but match zero entries when filtering.
-            const existing = sources.find((s) => s.path === resolved);
+            const existing = sources.find((source) => sourceIdentity(source.path) === identity);
             if (existing && existing.type === undefined) {
                 if (registryId)
                     existing.registryId = registryId;
+                if (isDefault)
+                    existing.isDefault = true;
                 existing.type = type;
                 existing.writable = writable;
                 existing.adapterId = adapterId;
@@ -64,13 +81,14 @@ export function resolveSourceEntries(overrideStashDir, existingConfig) {
                 existing.unresolved = true;
             return;
         }
-        seen.add(resolved);
+        seen.add(identity);
         if (isSuspiciousStashRoot(dir)) {
             warn(`Warning: stash root "${dir}" appears to be a system directory. This may be unintentional.`);
         }
         sources.push({
             path: resolved,
             ...(registryId ? { registryId } : {}),
+            ...(isDefault ? { isDefault: true } : {}),
             writable,
             type,
             ...(adapterId ? { adapterId } : {}),
@@ -88,17 +106,17 @@ export function resolveSourceEntries(overrideStashDir, existingConfig) {
         const contentRoot = resolveEntryContentDir(entry);
         if (contentRoot == null) {
             const unresolvedPath = path.join(getUnresolvedSourcesDir(implicitStashDir ?? process.cwd()), entry.name ?? entry.type);
-            addSource(unresolvedPath, entry.name, component?.writable ?? resolveWritable(entry), entry.type, component?.adapter, true);
+            addSource(unresolvedPath, entry.name, component?.writable ?? resolveWritable(entry), entry.type, component?.adapter, true, entry.name === config.defaultBundle);
             continue;
         }
         const dir = path.resolve(contentRoot, component?.root ?? ".");
         if (!isWithin(dir, contentRoot)) {
             warn(`Warning: component root "${component?.root}" escapes bundle "${entry.name}"; skipping source.`);
             const unresolvedPath = path.join(getUnresolvedSourcesDir(contentRoot), entry.name ?? entry.type);
-            addSource(unresolvedPath, entry.name, component?.writable ?? resolveWritable(entry), entry.type, component?.adapter, true);
+            addSource(unresolvedPath, entry.name, component?.writable ?? resolveWritable(entry), entry.type, component?.adapter, true, entry.name === config.defaultBundle);
             continue;
         }
-        addSource(dir, entry.name, component?.writable ?? resolveWritable(entry), entry.type, component?.adapter);
+        addSource(dir, entry.name, component?.writable ?? resolveWritable(entry), entry.type, component?.adapter, false, entry.name === config.defaultBundle);
     }
     return sources;
 }

package/dist/integrations/agent/execution-lowering.js

@@ -581,8 +581,9 @@ function lowerLlm(request, base) {
             (typeof tools === "object" && tools !== null && !Array.isArray(tools) && Object.keys(tools).length === 0);
         if (empty)
             translated.add("tools");
-        else
-            reject("tools");
+        else {
+            throw new ConfigError("The direct LLM transport cannot enforce the resolved tool policy.", "INVALID_CONFIG_FILE");
+        }
     }
     if (own(request.runtime, "workspace")) {
         if (request.runtime.workspace === null || request.runtime.workspace === "")

package/dist/integrations/agent/execution-preparation.js

@@ -9,6 +9,37 @@ import { loadModelMap } from "./model-map.js";
 function own(value, key) {
     return Object.hasOwn(value, key);
 }
+function requestedToolNames(tools) {
+    if (tools === null)
+        return Object.freeze([]);
+    if (typeof tools === "string") {
+        return Object.freeze(tools
+            .split(",")
+            .map((tool) => tool.trim())
+            .filter(Boolean));
+    }
+    if (Array.isArray(tools))
+        return Object.freeze(tools.map((tool) => tool.trim()).filter(Boolean));
+    const structured = tools;
+    // The portable structured spelling is a boolean allow/deny map. Opaque or
+    // nested provider policy cannot be reduced to tool names without guessing,
+    // so a host name allowlist must deny it (an explicit "*" may still allow it).
+    if (Object.values(structured).some((value) => typeof value !== "boolean"))
+        return undefined;
+    return Object.freeze(Object.keys(structured).filter((tool) => structured[tool] === true));
+}
+/** The production authorizer: executable assets may only narrow a host-owned ceiling. */
+export function toolAuthorizerFromConfig(config) {
+    const allowed = new Set(config.execution?.allowedTools ?? []);
+    return (input) => {
+        const requested = requestedToolNames(input.tools);
+        const permitted = allowed.has("*") || requested?.every((tool) => allowed.has(tool)) === true;
+        return Object.freeze({
+            status: permitted ? "allowed" : "denied",
+            policy: "config-execution-allowed-tools",
+        });
+    };
+}
 /** Pure common cascade composition once caller-specific sources are rendered. */
 export function planPreparedExecution(options) {
     return planExecutionCascade({
@@ -56,7 +87,7 @@ export function prepareResolvedExecution(options) {
         engines: executionEngineDefinitionsFromConfig(config),
         modelMap: options.modelMap ?? loadModelMap({ engines: config.engines }).map,
         invocationKind: options.invocationKind,
-        ...(options.authorizeTools ? { authorizeTools: options.authorizeTools } : {}),
+        authorizeTools: options.authorizeTools ?? toolAuthorizerFromConfig(config),
     });
     return Object.freeze({
         plan,

package/dist/integrations/agent/prompts.js

@@ -324,7 +324,7 @@ export function buildReflectPrompt(input) {
         sections.push(lines.join("\n"));
     }
     if (input.avoidPatterns && input.avoidPatterns.length > 0) {
-        sections.push(`## Avoid These Patterns\nPrevious assets in this run produced these errors — do not repeat them:\n${input.avoidPatterns.map((e) => `- ${e}`).join("\n")}`);
+        sections.push(`## Avoid These Patterns\nRun-only guidance: do not copy this heading, explanation, or any diagnostic below into the proposed asset.\nPrevious assets in this run produced these errors — do not repeat them:\n${input.avoidPatterns.map((e) => `- ${e}`).join("\n")}`);
     }
     // R-1 / #372: Self-Refine (arXiv:2303.17651) — inject prior draft as critique target.
     // On refinement iterations (iter > 0), the agent is shown its previous proposal

package/dist/integrations/agent/request-lowering.js

@@ -162,8 +162,9 @@ export function createAgentRequestLowerer(options) {
             const tools = request.tools;
             if (translatesTools(options.tools, tools))
                 translated.add("tools");
-            else
-                reject("tools");
+            else {
+                throw new ConfigError(`The ${options.adapter} transport cannot enforce the resolved tool policy.`, "INVALID_CONFIG_FILE");
+            }
             dispatch.tools = tools;
         }
         if (own(request.runtime, "settings")) {

package/dist/llm/client.js

@@ -444,11 +444,12 @@ async function chatCompletionAttemptOnce(config, messages, options, timeoutMs, i
  * attempts the schema request fresh every time and falls back once per call
  * on a 4xx — see the in-memory tracker below.
  */
-export async function probeLlmReachable(config) {
+export async function probeLlmReachable(config, timeoutMs) {
     try {
         const raw = await chatCompletion(config, [{ role: "user", content: "Respond with just the word: ok" }], {
             maxTokens: 16,
             temperature: 0,
+            ...(timeoutMs !== undefined ? { timeoutMs } : {}),
         });
         return raw.length > 0 ? { reachable: true } : { reachable: false, error: "empty response" };
     }

package/dist/output/shapes/passthrough.js

@@ -71,7 +71,9 @@ const PASSTHROUGH_COMMANDS = [
     "setup",
     "sync",
     "task-add",
+    "task-disable",
     "task-doctor",
+    "task-enable",
     "task-explain",
     "task-history",
     "task-prune",

package/dist/registry/resolve.js

@@ -11,6 +11,29 @@ import { NotFoundError, UsageError } from "../core/errors.js";
 import { asRecord, asString, GITHUB_API_BASE, githubHeaders } from "../integrations/github.js";
 import { cancelRegistryResponse, fetchRegistryResponse } from "./network.js";
 import { isExactSemver, isSemverRange, maxSatisfying } from "./semver.js";
+/**
+ * Pass an HTTPS bearer credential to Git without placing it in the remote URL
+ * or argv. The value exists only in the child-process environment and is never
+ * persisted or included in diagnostics.
+ */
+export function gitCredentialEnvironment(credential) {
+    if (!credential)
+        return { ...process.env };
+    if (/[\r\n\0]/.test(credential)) {
+        throw new UsageError("Git credential contains an invalid control character.");
+    }
+    const configuredCount = process.env.GIT_CONFIG_COUNT;
+    const nextIndex = configuredCount === undefined ? 0 : Number(configuredCount);
+    if (!Number.isSafeInteger(nextIndex) || nextIndex < 0) {
+        throw new UsageError("GIT_CONFIG_COUNT must be a non-negative integer before a Git credential can be added.");
+    }
+    return {
+        ...process.env,
+        GIT_CONFIG_COUNT: String(nextIndex + 1),
+        [`GIT_CONFIG_KEY_${nextIndex}`]: "http.extraHeader",
+        [`GIT_CONFIG_VALUE_${nextIndex}`]: `Authorization: Bearer ${credential}`,
+    };
+}
 /**
  * Validate that a URL is safe to pass to git.
  * Allowlists https:, http:, ssh:, git: schemes and git@ SSH shorthand.
@@ -122,16 +145,16 @@ function detectRegistrySearchId(ref) {
     lines.push("Or search for the installable ref:", `  akm search "${segments.length > 2 ? segments[segments.length - 1] : rest}" --from registry`, "Then install using the installRef value from the result:", "  akm bundle add github:owner/repo", "  akm bundle add npm:package-name");
     return lines.join("\n");
 }
-export async function resolveRegistryArtifact(parsed) {
+export async function resolveRegistryArtifact(parsed, options) {
     switch (parsed.source) {
         case "npm":
             return resolveNpmArtifact(parsed);
         case "local":
             return resolveLocalArtifact(parsed);
         case "git":
-            return resolveGitArtifact(parsed);
+            return resolveGitArtifact(parsed, options?.gitCredential);
         case "github":
-            return resolveGithubArtifact(parsed);
+            return resolveGithubArtifact(parsed, options?.gitCredential);
     }
 }
 function parseNpmRef(input, originalRef) {
@@ -427,12 +450,12 @@ async function resolveNpmArtifact(parsed) {
         allowPrivateRegistryOrigin: npmPolicy.allowPrivateRegistryOrigin,
     };
 }
-async function resolveGithubArtifact(parsed) {
+async function resolveGithubArtifact(parsed, credential) {
     const gitUrl = `https://github.com/${encodeURIComponent(parsed.owner)}/${encodeURIComponent(parsed.repo)}.git`;
     const repoBase = `${GITHUB_API_BASE}/repos/${encodeURIComponent(parsed.owner)}/${encodeURIComponent(parsed.repo)}`;
     // Prefer git-backed installs so private GitHub repos work with the user's
     // normal git credential helper rather than requiring API-specific auth.
-    const gitResolvedRevision = resolveGitRevisionFromRemote(gitUrl, parsed.requestedRef);
+    const gitResolvedRevision = resolveGitRevisionFromRemote(gitUrl, parsed.requestedRef, credential);
     if (gitResolvedRevision) {
         return {
             id: parsed.id,
@@ -443,7 +466,7 @@ async function resolveGithubArtifact(parsed) {
             resolvedRevision: gitResolvedRevision,
         };
     }
-    const headers = githubHeaders();
+    const headers = { ...githubHeaders(), ...(credential ? { Authorization: `Bearer ${credential}` } : {}) };
     if (parsed.requestedRef) {
         const commit = await tryFetchJson(`${repoBase}/commits/${encodeURIComponent(parsed.requestedRef)}`, headers, GITHUB_API_POLICY);
         const resolvedRevision = asString(commit?.sha) ?? parsed.requestedRef;
@@ -485,19 +508,23 @@ async function resolveGithubArtifact(parsed) {
         resolvedRevision: asString(commit?.sha) ?? defaultBranch,
     };
 }
-function resolveGitRevisionFromRemote(url, requestedRef) {
+function resolveGitRevisionFromRemote(url, requestedRef, credential) {
     validateGitUrl(url);
     const ref = requestedRef ?? "HEAD";
     if (requestedRef)
         validateGitRef(requestedRef);
-    const result = spawnSync("git", ["ls-remote", url, ref], { encoding: "utf8", timeout: 30_000 });
+    const result = spawnSync("git", ["ls-remote", url, ref], {
+        encoding: "utf8",
+        timeout: 30_000,
+        env: gitCredentialEnvironment(credential),
+    });
     if (result.status !== 0)
         return undefined;
     const firstLine = result.stdout.trim().split(/\r?\n/)[0];
     return firstLine?.split(/\s/)[0] || undefined;
 }
-async function resolveGitArtifact(parsed) {
-    const resolvedRevision = resolveGitRevisionFromRemote(parsed.url, parsed.requestedRef);
+async function resolveGitArtifact(parsed, credential) {
+    const resolvedRevision = resolveGitRevisionFromRemote(parsed.url, parsed.requestedRef, credential);
     if (!resolvedRevision) {
         // Unlike the GitHub path (which falls back to the REST API on a failed
         // `git ls-remote`), a plain git source has no fallback resolver — an