akm-cli 0.10.261012-beta → 0.10.261013-beta

package/dist/core/paths.js

@@ -311,12 +311,7 @@ export function getStateDir(env = process.env, platform = process.platform) {
  * its `stash_dir` column — so two stashes on one machine never collide.
  *
  * Reuses {@link shortHash} (bundle-id.ts) rather than growing a second
- * sha256-truncated-hex helper. (The other existing option,
- * `getCurrentWorkflowScopeKey`'s `dir:v1:<sha256>` in
- * `src/workflows/authoring/scope-key.ts`, is a state.db column value for a
- * different subsystem — full untruncated hex plus a `dir:v1:` prefix, which
- * is neither filesystem-safe as a directory segment on Windows (`:`) nor
- * short, so it is not a fit here.) `shortHash` trims to 8 hex chars (32
+ * sha256-truncated-hex helper. `shortHash` trims to 8 hex chars (32
  * bits) — fine at its original call site because a collision only ever
  * shortens a batch-unique slug suffix that a retry loop immediately
  * re-disambiguates. Here there is no such retry loop, but a machine

package/dist/core/redaction.js

@@ -499,10 +499,23 @@ export function redactErrorBody(input) {
     }
     return out;
 }
+/**
+ * The spellings a JSON encoder gives a value inside a string literal: the
+ * `JSON.stringify` form, and the ASCII-only form with non-ASCII as `\uXXXX`
+ * (what Python's `json.dumps` writes). Empty for a value that needs no escaping.
+ */
+function jsonEscapedSpellings(value) {
+    const json = JSON.stringify(value).slice(1, -1);
+    // ASCII-only encoders (Python's ensure_ascii) also escape DEL; some (Java's) write uppercase hex.
+    const ascii = json.replace(/[\u007f-\uffff]/g, (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`);
+    const upper = ascii.replace(/\\u([0-9a-f]{4})/g, (_match, hex) => `\\u${hex.toUpperCase()}`);
+    return [...new Set([json, ascii, upper])].filter((spelling) => spelling !== value);
+}
 export function redactSensitiveText(text, sensitiveValues) {
-    const values = [...new Set(sensitiveValues)]
-        .filter((value) => value.length > 0)
-        .sort((a, b) => b.length - a.length || a.localeCompare(b));
+    const exact = [...sensitiveValues].filter((value) => value.length > 0);
+    // A child that prints JSON writes a secret's escaped spelling (`\"`, `\\`, `\n`, `\uXXXX`),
+    // which the exact value never matches. Each escaped spelling is just another needle.
+    const values = [...new Set([...exact, ...exact.flatMap(jsonEscapedSpellings)])].sort((a, b) => b.length - a.length || a.localeCompare(b));
     if (values.length === 0)
         return text;
     const coverageDelta = new Int32Array(text.length + 1);

package/dist/core/ref-token.js

@@ -0,0 +1,82 @@
+// 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/.
+/**
+ * The one substitution token akm hands to a process or a provider: `${ref}`,
+ * where `ref` is an akm ref (`[bundle//]conceptId`). A `secrets/…` ref stands
+ * for the secret's value; any other asset ref stands for the asset's absolute
+ * path. A `${…}` body that is not an akm ref (`${HOME}`, `${PATH//:/ }`,
+ * `${v//-/_}`, `${x/a/b}`: not led by a native type and not qualified by an
+ * installed bundle) is plain text and is left alone.
+ *
+ * Kept free of the commands layer so config credentials and env values share
+ * this one function.
+ */
+import { parseBundleRef } from "./asset/asset-ref.js";
+import { typeNameFromConceptId } from "./asset/resolve-ref.js";
+export const REF_TOKEN_RE = /\$\{([^}\s]+)\}/g;
+/**
+ * Does a `${…}` body parse as an akm ref (no export fragment) that either
+ * leads with a native asset type (bundle-qualified or not) or is bundle-qualified
+ * with a bundle `isBundleInstalled` accepts? Anything else stays text, so shell
+ * syntax (`${v//-/_}`, `${x/a/b}`) is never read as a ref. A qualified opaque body
+ * follows the core ref grammar and the owner walk, whatever adapter owns it, but
+ * only for an installed bundle; with no predicate no bundle is installed.
+ */
+function isRefBody(body, isBundleInstalled) {
+    try {
+        const ref = parseBundleRef(body);
+        if (ref.fragment !== undefined)
+            return false;
+        if (typeNameFromConceptId(ref.conceptId) !== undefined)
+            return true;
+        return ref.bundle !== undefined && isBundleInstalled?.(ref.bundle) === true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Is the whole string exactly one `${ref}` token? */
+export function isRefToken(value) {
+    const body = /^\$\{([^}\s]+)\}$/.exec(value)?.[1];
+    return body !== undefined && isRefBody(body);
+}
+/** Is the whole string exactly one `${ref}` token whose ref names a `secrets/` asset? */
+export function isSecretRefToken(value) {
+    const body = /^\$\{([^}\s]+)\}$/.exec(value)?.[1];
+    return (body !== undefined && isRefBody(body) && typeNameFromConceptId(parseBundleRef(body).conceptId)?.type === "secret");
+}
+/**
+ * Replace every `${ref}` token in each value. Keys are never touched, and
+ * tokens embedded in larger strings are all substituted. `isBundleInstalled`
+ * lets a bundle-qualified body that is not led by a native type be a ref when
+ * its bundle is installed. An unresolved ref is
+ * collected in `missing` and its token left in place. Resolved secret values
+ * must never be logged or printed by callers.
+ */
+export function substituteRefTokens(values, resolve, isBundleInstalled) {
+    const missing = [];
+    const secretValues = new Set();
+    const cache = new Map();
+    const out = {};
+    for (const [key, value] of Object.entries(values)) {
+        out[key] = value.replace(REF_TOKEN_RE, (token, body) => {
+            if (!isRefBody(body, isBundleInstalled))
+                return token;
+            if (!cache.has(body))
+                cache.set(body, resolve(body));
+            const resolved = cache.get(body);
+            if (resolved === undefined) {
+                if (!missing.includes(body))
+                    missing.push(body);
+                return token;
+            }
+            if (resolved.kind === "path")
+                return resolved.path;
+            if (resolved.value)
+                secretValues.add(resolved.value);
+            return resolved.value;
+        });
+    }
+    return { values: out, missing, secretValues: [...secretValues] };
+}

package/dist/core/secret-value.js

@@ -0,0 +1,14 @@
+// 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 fs from "node:fs";
+/**
+ * Read a secret's value: the file content as UTF-8 with surrounding whitespace
+ * trimmed. The one read every consumer uses (`secret run`, env `${ref}`
+ * tokens, config credentials, website fetchers), so a hand-written file's
+ * trailing newline never lands in an HTTP header. Callers MUST NOT write the
+ * returned value to stdout or any log.
+ */
+export function readValue(secretPath) {
+    return fs.readFileSync(secretPath, "utf8").trim();
+}

package/dist/core/write-source.js

@@ -49,26 +49,42 @@ export function resolveWritable(entry) {
         return entry.writable;
     return entry.type === "filesystem";
 }
+/**
+ * Whether a resolved source is write-activated. Only the primary stash and
+ * sources explicitly marked `writable: true` are writable; registry-cached
+ * (installed, read-only) sources are never written in place because
+ * `akm update` overwrites them.
+ */
+export function isSourceWriteActivated(source) {
+    return source.writable === true;
+}
 /** The two kinds writes are defined for; scheduler state binds only to these. */
 export function isWriteCapableSourceKind(kind) {
     return kind === "filesystem" || kind === "git";
 }
+/**
+ * Throw when `name` is a configured bundle that is disabled. Callers run it
+ * after a name failed to resolve against the active set, so a disabled bundle
+ * is reported as disabled rather than as not configured.
+ */
+export function assertBundleNotDisabled(akmConfig, name) {
+    if (resolveConfiguredSources(akmConfig).some((source) => source.name === name)) {
+        throw new UsageError(`Bundle "${name}" is disabled.`, "INVALID_FLAG_VALUE");
+    }
+}
 /**
  * Resolve the destination for a write: explicit `--bundle`, then
  * `defaultWriteTarget`, then the working stash (`defaultBundle`). There is no
  * fallback to the first writable source.
  */
 export function resolveWriteTarget(akmConfig, explicitTarget, options = {}) {
-    const allConfiguredSources = resolveConfiguredSources(akmConfig);
     const configuredSources = resolveActiveConfiguredSources(akmConfig);
     const requireWritable = options.requireWritable !== false;
     const flag = options.flag ?? "--bundle";
     if (explicitTarget) {
         const match = configuredSources.find((s) => s.name === explicitTarget);
         if (!match) {
-            if (allConfiguredSources.some((source) => source.name === explicitTarget)) {
-                throw new UsageError(`Bundle "${explicitTarget}" is disabled.`, "INVALID_FLAG_VALUE");
-            }
+            assertBundleNotDisabled(akmConfig, explicitTarget);
             throw new UsageError(`${flag} must reference a source name from your config. No source named "${explicitTarget}" is configured. Run \`akm bundle list\` to see available sources.`, "INVALID_FLAG_VALUE");
         }
         if (requireWritable && !resolveWritable({ type: match.type, writable: match.writable })) {

package/dist/indexer/indexer.js

@@ -25,7 +25,7 @@ import { INDEX_DB_VACUUMED_EVENT, readFreelistInfo, vacuumIfReclaimable } from "
 import { assertIndexedWorkflowSourceIdentity, WorkflowSourceIdentityError } from "../workflows/source-files.js";
 import { reclassifyIndexDbContention } from "./index-db-contention.js";
 import { deriveEntryProvenance, deriveInstallations } from "./installations.js";
-import { indexedPathMatchesOwner, resolveAdapterConceptOwner, } from "./lookup/adapter-concept-owner.js";
+import { indexedPathMatchesOwner, resolveConceptOwner } from "./lookup/adapter-concept-owner.js";
 import { generateEmbeddingsForDb } from "./materialize-embeddings.js";
 import { canUseIncrementalSkip, computeDirFingerprint, getCachedDirState, getDirIndexState, inferZeroRowReason, } from "./passes/dir-staleness.js";
 import { isWorkflowSkipWarning, withFileSize } from "./passes/metadata.js";
@@ -669,9 +669,6 @@ function buildSourceScanPlans(db, allSourceEntries, isIncremental, reconcileMiss
         }
         const walked = walkStashFlatWithStatus(currentStashDir, {
             includeAllDirectories: component.adapter === "okf",
-            ...(component.adapter === "akm" || component.adapter === "akm-workflow"
-                ? { workflowSymlinkAdapter: component.adapter }
-                : {}),
         });
         const dirGroups = groupFileContextsByDir(walked.files);
         const adapter = adapterForId(component.adapter);
@@ -1132,10 +1129,8 @@ borrowed = false) {
     const sources = await resolveLookupSources();
     if (sources.length === 0)
         return { entry: null };
-    const bundleBySourcePath = new Map(sourceComponents(sources).map((component, index) => [path.resolve(sources[index].path), component.id]));
     const qualified = Boolean(ref.bundle);
-    const candidateSources = ref.bundle ? resolveSourcesForOrigin(ref.bundle, sources) : sources;
-    if (candidateSources.length === 0)
+    if ((ref.bundle ? resolveSourcesForOrigin(ref.bundle, sources) : sources).length === 0)
         return { entry: null };
     let db;
     let indexError;
@@ -1151,42 +1146,38 @@ borrowed = false) {
         ...(indexError === undefined ? {} : { indexError }),
     });
     try {
-        for (const source of candidateSources) {
-            const adapterId = source.adapterId ?? detectAdapterId(source.path);
-            const owner = resolveAdapterConceptOwner(source.path, adapterId, ref.conceptId);
-            const lookupConceptId = owner?.conceptId ?? ref.conceptId;
-            const inputRef = makeBundleRef(qualified ? ref.bundle : undefined, lookupConceptId);
-            const sourceBundleId = bundleBySourcePath.get(path.resolve(source.path));
-            const id = db && sourceBundleId ? findEntryIdByRef(db, inputRef, sourceBundleId) : undefined;
-            if (id !== undefined && owner && db) {
-                const entry = readLookupEntry(db, id, ref.conceptId, source.path);
-                if (entry) {
-                    if (owner.workflowSource) {
-                        try {
-                            assertIndexedWorkflowSourceIdentity(inputRef, entry.filePath, owner.workflowSource);
-                            if (entry.adapterId !== adapterId) {
-                                throw new WorkflowSourceIdentityError(inputRef, entry.filePath, owner.path);
-                            }
-                        }
-                        catch (error) {
-                            if (!(error instanceof WorkflowSourceIdentityError))
-                                throw error;
-                            warn(`${error.message} Falling back to the physical owner.`);
-                            return resolved(null, owner);
+        const match = resolveConceptOwner(ref, sources);
+        if (!match)
+            return resolved(null);
+        const { owner, source, bundleId, adapterId } = match;
+        const inputRef = makeBundleRef(qualified ? ref.bundle : undefined, owner.conceptId);
+        const id = db ? findEntryIdByRef(db, inputRef, bundleId) : undefined;
+        if (id !== undefined && db) {
+            const entry = readLookupEntry(db, id, ref.conceptId, source.path);
+            if (entry) {
+                if (owner.workflowSource) {
+                    try {
+                        assertIndexedWorkflowSourceIdentity(inputRef, entry.filePath, owner.workflowSource);
+                        if (entry.adapterId !== adapterId) {
+                            throw new WorkflowSourceIdentityError(inputRef, entry.filePath, owner.path);
                         }
                     }
-                    else if (entry.adapterId !== adapterId || !indexedPathMatchesOwner(entry.filePath, owner)) {
+                    catch (error) {
+                        if (!(error instanceof WorkflowSourceIdentityError))
+                            throw error;
+                        warn(`${error.message} Falling back to the physical owner.`);
                         return resolved(null, owner);
                     }
-                    return resolved(entry, owner);
                 }
+                else if (entry.adapterId !== adapterId || !indexedPathMatchesOwner(entry.filePath, owner)) {
+                    return resolved(null, owner);
+                }
+                return resolved(entry, owner);
             }
-            // A physical owner with a missing/incomplete index row still owns this
-            // unqualified concept. Stop here so a later source cannot retarget it.
-            if (owner)
-                return resolved(null, owner);
         }
-        return resolved(null);
+        // A physical owner with a missing/incomplete index row still owns this
+        // concept: no later source can retarget it.
+        return resolved(null, owner);
     }
     finally {
         if (db && !borrowed)

package/dist/indexer/installations.js

@@ -19,12 +19,6 @@
  *                  spec §1.3). Slugs are made unique WITHIN a derivation batch
  *                  by appending a short path-hash suffix on collision, so two
  *                  sources sharing a basename never mint the same bundle id.
- *   - `trusted`  = `source.writable === true`. 0.9.0 ships no first-class trust
- *                  record (spec §1.3 — "no new trust machinery"); the writable
- *                  primary/config stashes are the user's own and count as
- *                  trusted, read-only registry caches do not. Nothing consumes
- *                  `trusted` in the live path yet (installation grants nothing,
- *                  History D8) — this is the Tier-A placeholder mapping.
  *   - components = ONE component for the current single-root akm layout
  *                  (spec §1.2 rule 5): `{ id, root: source.path, adapter }`. The
  *                  akm layout's type dirs (`knowledge/`, `skills/`, …) are NOT
@@ -56,10 +50,10 @@
  * fallback is **`akm`** (see {@link FALLBACK_ADAPTER_ID}), preserving workspace
  * root behavior. Explicit configured ownership always wins over probing.
  */
-import { isSourceWriteActivated } from "../core/activation-policy.js";
 import { detectAdapterId } from "../core/adapter/detect-adapter.js";
 import { stashDirFor } from "../core/asset/asset-placement.js";
 import { deriveBundleId, deriveBundleIds, slugForPath } from "../core/bundle-id.js";
+import { isSourceWriteActivated } from "../core/write-source.js";
 export { deriveBundleId, deriveBundleIds, slugForPath };
 /**
  * The no-probe-match fallback adapter id.
@@ -98,7 +92,6 @@ export function deriveInstallations(sources) {
         const adapter = source.adapterId ?? detectAdapterId(source.path, FALLBACK_ADAPTER_ID);
         installations.push({
             id,
-            trusted: writable,
             components: [
                 {
                     // Single-component akm layout: the component id == the bundle id so

package/dist/indexer/lookup/adapter-concept-owner.js

@@ -3,12 +3,15 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import fs from "node:fs";
 import path from "node:path";
+import { detectAdapterId } from "../../core/adapter/detect-adapter.js";
 import { adapterForId } from "../../core/adapter/registry.js";
-import { compareCodePoints, hasErrnoCode, isWithin } from "../../core/common.js";
+import { compareCodePoints, hasErrnoCode } from "../../core/common.js";
 import { ConfigError, UsageError } from "../../core/errors.js";
 import { canonicalizeWorkflowName } from "../../core/recognition-util.js";
+import { sensitiveMarkerPath } from "../../core/sensitive-marker-path.js";
 import { warnOnce } from "../../core/warn.js";
 import { resolveUniqueWorkflowSource, workflowNameForConceptId, } from "../../workflows/source-files.js";
+import { deriveInstallations } from "../installations.js";
 import { buildFileContext } from "../walk/file-context.js";
 const CONTENT_READ_REQUIRED = Symbol("adapter ownership probe requires content");
 export class AdapterConceptOwnershipError extends UsageError {
@@ -40,22 +43,18 @@ function lexicallyWithin(candidate, root) {
     return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative));
 }
 /** Add case-only suffix spellings beside an adapter-authored read candidate. */
-function candidateSpellings(candidate, sourcePath, realRoot) {
+function candidateSpellings(candidate, sourcePath) {
     const authored = path.resolve(candidate.path);
     if (!lexicallyWithin(authored, sourcePath))
         return [{ ...candidate, path: authored }];
     const parent = path.dirname(authored);
-    let realParent;
     let entries;
     try {
-        realParent = fs.realpathSync(parent);
         entries = fs.readdirSync(parent, { withFileTypes: true });
     }
     catch {
         return [{ ...candidate, path: authored }];
     }
-    if (!isWithin(realParent, realRoot))
-        return [{ ...candidate, path: authored }];
     const extension = path.extname(authored);
     if (!extension)
         return [{ ...candidate, path: authored }];
@@ -67,7 +66,7 @@ function candidateSpellings(candidate, sourcePath, realRoot) {
     })
         .map((entry) => ({ ...candidate, path: path.join(parent, entry.name) }));
 }
-function inspectCandidate(sourcePath, realRoot, adapterId, candidate) {
+function inspectCandidate(sourcePath, adapterId, candidate) {
     const authoredPath = path.resolve(candidate.path);
     if (!lexicallyWithin(authoredPath, sourcePath))
         return undefined;
@@ -87,8 +86,6 @@ function inspectCandidate(sourcePath, realRoot, adapterId, candidate) {
     catch {
         return undefined;
     }
-    if (!isWithin(realPath, realRoot))
-        return undefined;
     try {
         if (!fs.statSync(realPath).isFile())
             return undefined;
@@ -118,6 +115,14 @@ function claimsWithoutContent(adapter, component, owner) {
         throw error;
     }
 }
+/** True for an env/secret file that a sibling `.sensitive` marker hides from the index. */
+function isMarkedSensitive(owner) {
+    const head = owner.conceptId.split("/")[0];
+    if (head !== "env" && head !== "secrets")
+        return false;
+    const marker = sensitiveMarkerPath(owner.path, head === "env" ? "env" : "secret");
+    return marker !== owner.path && fs.existsSync(marker);
+}
 /**
  * Resolve one adapter/component's exact physical concept owner without reading
  * authored bytes. Native workflow arbitration is reused verbatim; every other
@@ -129,9 +134,8 @@ export function resolveAdapterConceptOwner(sourcePath, adapterId, conceptId, opt
     const normalized = normalizedConceptId(conceptId);
     if (!adapter || !normalized)
         return undefined;
-    let realRoot;
     try {
-        realRoot = fs.realpathSync(sourcePath);
+        fs.realpathSync(sourcePath);
     }
     catch (error) {
         // Genuinely absent — "no owner" is correct. Any other failure (e.g.
@@ -168,13 +172,13 @@ export function resolveAdapterConceptOwner(sourcePath, adapterId, conceptId, opt
     // — see each adapter's own doc comment for its candidate classes), and
     // `candidateSpellings` adds case-only siblings via one `readdirSync` of
     // each candidate's own parent directory.
-    const spellings = (adapter.readCandidates?.(component, resolutionConceptId) ?? []).flatMap((candidate) => candidateSpellings(candidate, sourcePath, realRoot));
+    const spellings = (adapter.readCandidates?.(component, resolutionConceptId) ?? []).flatMap((candidate) => candidateSpellings(candidate, sourcePath));
     const inspected = [
         ...new Map(spellings.map((candidate) => [`${path.resolve(candidate.path)}\0${candidate.conceptId}`, candidate])).values(),
     ]
         .sort((left, right) => compareCodePoints(left.path, right.path))
         .flatMap((candidate) => {
-        const owner = inspectCandidate(sourcePath, realRoot, adapterId, candidate);
+        const owner = inspectCandidate(sourcePath, adapterId, candidate);
         return owner ? [owner] : [];
     });
     for (const candidate of inspected) {
@@ -183,8 +187,10 @@ export function resolveAdapterConceptOwner(sourcePath, adapterId, conceptId, opt
         const identity = `${path.resolve(candidate.path)}\0${candidate.conceptId}`;
         if (ownersByIdentity.has(identity))
             continue;
-        if (claimsWithoutContent(adapter, component, candidate))
+        if (claimsWithoutContent(adapter, component, candidate) ||
+            (options?.includeSensitive && isMarkedSensitive(candidate))) {
             ownersByIdentity.set(identity, candidate);
+        }
     }
     const owners = [...ownersByIdentity.values()]
         .filter((owner) => owner.conceptId === resolutionConceptId)
@@ -202,6 +208,26 @@ export function resolveAdapterConceptOwner(sourcePath, adapterId, conceptId, opt
     }
     return owners[0];
 }
+/**
+ * The one "where is asset X right now?" walk. `sources` is the ordered source
+ * list (`resolveSourceEntries`: default bundle first, then installation
+ * priority). The first source with a physical owner for the ref ends the
+ * walk; a qualified ref only considers its own bundle. Synchronous and
+ * index-free: it never opens a database, so a caller may use it at dispatch.
+ */
+export function resolveConceptOwner(ref, sources, options) {
+    const installations = deriveInstallations([...sources]);
+    for (const [index, source] of sources.entries()) {
+        const bundleId = installations[index]?.id;
+        if (!bundleId || (ref.bundle !== undefined && bundleId !== ref.bundle))
+            continue;
+        const adapterId = source.adapterId ?? detectAdapterId(source.path);
+        const owner = resolveAdapterConceptOwner(source.path, adapterId, ref.conceptId, options);
+        if (owner)
+            return { owner, source, bundleId, adapterId };
+    }
+    return undefined;
+}
 export function indexedPathMatchesOwner(indexedPath, owner) {
     if (path.resolve(indexedPath) !== path.resolve(owner.path))
         return false;

package/dist/indexer/materialize-embeddings.js

@@ -81,7 +81,7 @@ export async function generateEmbeddingsForDb(db, config, onProgress, signal, en
         return { success: false, message: "Semantic search is disabled." };
     }
     // #953 field gap: the actionable outcome is a self-diagnosing run, not a
-    // fix (every RemoteEmbedder path already resolves secret:// through one
+    // fix (every RemoteEmbedder path already resolves `${ref}` credentials through one
     // boundary — a keyless request can only mean embedding.apiKey was absent
     // from the config THIS run loaded). One default-level line, before the
     // first provider request of the phase, naming the endpoint/model/credential

package/dist/indexer/scan/drain-dir.js

@@ -98,7 +98,7 @@ export function drainDirDocuments(adapter, component, fileContexts) {
         const entry = indexDocumentToStashEntry(doc);
         // Workflow docs: drop-with-warning if broken; otherwise cache a lossless
         // runtime projection when the current executor can represent the source.
-        const dropWarning = handleWorkflowDoc(doc, file, component.root);
+        const dropWarning = handleWorkflowDoc(doc, file);
         if (dropWarning !== null) {
             warnings.push(dropWarning);
             if (workflowName !== undefined)
@@ -138,13 +138,13 @@ export function recognizeStashEntries(stashRoot, files) {
  * `Skipped workflow …` drop warning when it is broken, or return `null` when
  * it compiles. Non-workflow docs return `null` immediately.
  */
-function handleWorkflowDoc(doc, file, workspaceRoot) {
+function handleWorkflowDoc(doc, file) {
     if (doc.type !== "workflow" ||
         (doc.adapterId !== "akm" && doc.adapterId !== "akm-workflow") ||
         (docRenderer(doc) !== WORKFLOW_MD_RENDERER && doc.adapterId !== "akm-workflow")) {
         return null;
     }
-    const result = compileWorkflowSource(file.content(), { path: file.relPath, workspaceRoot });
+    const result = compileWorkflowSource(file.content(), { path: file.relPath });
     if (!result.ok)
         return workflowDropWarning(file, result.errors);
     return null;

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

@@ -43,7 +43,9 @@ export function resolveSourceEntries(overrideStashDir, existingConfig) {
     }
     // 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, isDefault: true }] : [];
+    const sources = implicitStashDir
+        ? [{ path: implicitStashDir, writable: true, isDefault: true, type: "filesystem" }]
+        : [];
     const sourceIdentity = (dir) => {
         const resolved = path.resolve(dir);
         try {
@@ -65,7 +67,7 @@ export function resolveSourceEntries(overrideStashDir, existingConfig) {
             // identity-less and a user-named primary source ("name": "my-stash")
             // would validate but match zero entries when filtering.
             const existing = sources.find((source) => sourceIdentity(source.path) === identity);
-            if (existing && existing.type === undefined) {
+            if (existing && existing.registryId === undefined) {
                 if (registryId)
                     existing.registryId = registryId;
                 if (isDefault)

package/dist/indexer/walk/path-resolver.js

@@ -1,55 +1,15 @@
 // 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 fs from "node:fs";
-import path from "node:path";
-import { assetPathForName, stashDirFor } from "../../core/asset/asset-placement.js";
-import { parseRefInput } from "../../core/asset/resolve-ref.js";
-import { isWithin } from "../../core/common.js";
-import { resolveSourcesForOrigin } from "../../registry/origin-resolve.js";
+import { conceptIdFromTypeName, parseRefInput } from "../../core/asset/resolve-ref.js";
 import { lookup } from "../indexer.js";
 import { deriveInstallations } from "../installations.js";
+import { resolveConceptOwner } from "../lookup/adapter-concept-owner.js";
 import { resolveSourceEntries } from "../search/search-source.js";
 function normalizeRef(ref) {
     // String inputs use the current `[bundle//]conceptId` grammar.
     return typeof ref === "string" ? parseRefInput(ref) : ref;
 }
-function buildDiskCandidates(sourcePath, ref, preserveDirectNameFallback) {
-    const placementStashDir = stashDirFor(ref.type);
-    // Opaque adapter conceptIds are index-resolved. Core cannot infer their
-    // adapter-owned serialization or path extension before indexing.
-    if (placementStashDir === undefined)
-        return [];
-    const typeDir = path.join(sourcePath, placementStashDir);
-    const candidates = [
-        assetPathForName(ref.type, typeDir, ref.name),
-        path.join(sourcePath, ref.type, `${ref.name}.md`),
-        path.join(sourcePath, ref.type, ref.name),
-    ];
-    if (preserveDirectNameFallback) {
-        candidates.push(path.join(sourcePath, `${ref.name}.md`), path.join(sourcePath, ref.name));
-    }
-    return candidates;
-}
-function resolveDirectoryEntry(filePath, directoryIndexNames) {
-    let stat;
-    try {
-        stat = fs.statSync(filePath);
-    }
-    catch {
-        return null;
-    }
-    if (stat.isFile())
-        return filePath;
-    if (!stat.isDirectory())
-        return null;
-    for (const indexName of directoryIndexNames) {
-        const candidate = path.join(filePath, indexName);
-        if (fs.existsSync(candidate) && fs.statSync(candidate).isFile())
-            return candidate;
-    }
-    return null;
-}
 async function resolveViaIndex(ref) {
     try {
         const entry = await lookup(ref);
@@ -60,32 +20,17 @@ async function resolveViaIndex(ref) {
     }
 }
 function resolveViaDisk(ref, options) {
-    let sources = resolveSourceEntries(options.stashDir);
-    if (options.honorOrigin !== false) {
-        sources = resolveSourcesForOrigin(ref.origin, sources);
-    }
-    const directoryIndexNames = options.directoryIndexNames ?? ["SKILL.md"];
-    const preserveDirectNameFallback = options.preserveDirectNameFallback ?? true;
-    const installations = deriveInstallations(sources);
-    for (const [index, source] of sources.entries()) {
-        const bundleId = installations[index]?.id;
-        if (options.writableBundleIds && (!bundleId || !options.writableBundleIds.has(bundleId)))
-            continue;
-        const candidates = buildDiskCandidates(source.path, ref, preserveDirectNameFallback);
-        for (const candidate of candidates) {
-            if (!fs.existsSync(candidate))
-                continue;
-            const resolved = resolveDirectoryEntry(candidate, directoryIndexNames);
-            if (!resolved)
-                continue;
-            const resolvedRoot = fs.realpathSync(source.path);
-            const realTarget = fs.realpathSync(resolved);
-            if (!isWithin(realTarget, resolvedRoot))
-                continue;
-            return realTarget;
-        }
-    }
-    return null;
+    const allSources = resolveSourceEntries(options.stashDir);
+    const installations = deriveInstallations(allSources);
+    const sources = options.writableBundleIds
+        ? allSources.filter((_, index) => {
+            const bundleId = installations[index]?.id;
+            return bundleId !== undefined && options.writableBundleIds?.has(bundleId);
+        })
+        : allSources;
+    const bundle = options.honorOrigin !== false ? ref.origin : undefined;
+    return (resolveConceptOwner({ bundle, conceptId: conceptIdFromTypeName(ref.type, ref.name) }, sources)?.owner.realPath ??
+        null);
 }
 export async function resolveAssetPath(ref, options = {}) {
     const parsed = normalizeRef(ref);