akm-cli 0.9.5 → 0.9.7

package/dist/commands/lint/base-linter.js

@@ -34,10 +34,11 @@
 import fs from "node:fs";
 import path from "node:path";
 import { isScalar, parseDocument } from "yaml";
-import { assetPathForName, stashDirFor } from "../../core/asset/asset-placement.js";
+import { assetPathCandidatesForName, assetPathForName, stashDirFor } from "../../core/asset/asset-placement.js";
 import { BUNDLE_REF_RE } from "../../core/asset/asset-ref.js";
-import { spliceFrontmatterLine } from "../../core/asset/frontmatter.js";
+import { removeFrontmatterListValues, spliceFrontmatterLine } from "../../core/asset/frontmatter.js";
 import { checkUnquotedDescriptionColon } from "../../core/asset/frontmatter-lint.js";
+import { isArchivedRelPath } from "../../core/asset/memory-archive.js";
 import { typeNameFromConceptId } from "../../core/asset/resolve-ref.js";
 import { localDateStamp } from "../../core/common.js";
 import { findFenceRegions } from "./markdown-insertion.js";
@@ -191,6 +192,37 @@ export function refExistsInAnyStash(relPath, refType, refName, stashRoots) {
         if (resolveRefPathInStash(relPath, refType, refName, root) !== null)
             return true;
     }
+    // #884: a memory pruned by `analyzeMemoryCleanup` was ARCHIVED, not deleted —
+    // its bytes and identity live on under `.akm/memory-cleanup/archive`. Inbound
+    // belief edges to it are satisfied, not dangling, so resolve the tombstone
+    // rather than reporting `missing-ref`. Checked only after every live location
+    // misses: a tombstone must never shadow a real file, and the scan then costs
+    // one directory read per root instead of one per ref.
+    //
+    // Existence ONLY. `resolveRefPathInStash` deliberately does NOT consult the
+    // archive: it hands back a path callers MUTATE (SPEC-5 `--supersedes`
+    // demotion), and writing into an archived tombstone would corrupt the audit
+    // record while leaving the live stash untouched.
+    return memoryArchiveHasRef(refType, refName, stashRoots);
+}
+/**
+ * True when `(refType, refName)` names a memory that prune archived in any
+ * root. Mirrors `resolveRefPathInStash`'s candidate set so a ref that resolved
+ * through the `.derived.md` twin (#882) still resolves once archived.
+ */
+function memoryArchiveHasRef(refType, refName, stashRoots) {
+    if (refType !== "memory")
+        return false; // only memories are ever archived
+    const typeDir = stashDirFor(refType);
+    if (typeDir === undefined)
+        return false;
+    const candidates = assetPathCandidatesForName(refType, typeDir, refName);
+    for (const root of stashRoots) {
+        for (const candidate of candidates) {
+            if (isArchivedRelPath(candidate, root))
+                return true;
+        }
+    }
     return false;
 }
 /**
@@ -198,8 +230,9 @@ export function refExistsInAnyStash(relPath, refType, refName, stashRoots) {
  * the same reachability rules (in the same order) as
  * {@link refExistsInAnyStash}, which delegates here. Returns the absolute path
  * of the file that makes the ref "exist" — for a multi-file skill directory
- * that is its `SKILL.md` primary — or `null` when the ref does not resolve in
- * this root.
+ * that is its `SKILL.md` primary, for a `memory` ref its `.derived.md` twin
+ * when the plain `.md` is absent (#882, see `assetPathCandidatesForName`) —
+ * or `null` when the ref does not resolve in this root.
  *
  * Extracted for SPEC-5 (`--supersedes` demotion): write commands need the
  * superseded asset's actual file to mutate, and forking a second resolver
@@ -207,10 +240,14 @@ export function refExistsInAnyStash(relPath, refType, refName, stashRoots) {
  * (the contract pins `refToRelPath` + `refExistsInAnyStash`; this is the
  * shared internal both build on).
  */
-export function resolveRefPathInStash(relPath, _refType, _refName, root) {
-    const absPath = path.join(root, relPath);
-    if (fs.existsSync(absPath))
-        return absPath;
+export function resolveRefPathInStash(relPath, refType, refName, root) {
+    const typeDir = stashDirFor(refType);
+    const candidates = typeDir === undefined ? [relPath] : assetPathCandidatesForName(refType, typeDir, refName);
+    for (const candidate of candidates) {
+        const absPath = path.join(root, candidate);
+        if (fs.existsSync(absPath))
+            return absPath;
+    }
     return null;
 }
 /**
@@ -281,11 +318,31 @@ function scanBundleRefs(scanBody, allRoots) {
  */
 function classifyConceptRef(rawConceptId, allRoots) {
     const conceptId = rawConceptId.split("#", 1)[0];
-    const parts = typeNameFromConceptId(conceptId);
+    const parts = typeNameFromConceptId(conceptId) ?? legacyTypeSlugParts(conceptId);
     if (parts === undefined)
         return null; // foreign type / not a local asset ref
     return localRefMissingRelPath(parts.type, parts.name, allRoots);
 }
+/**
+ * Read-only fallback for the retired `type:slug` xref grammar (see
+ * resolve-ref.ts Q-02 — the write boundary no longer emits or accepts it).
+ * Stash content written before that retirement still carries it in frontmatter
+ * `xrefs:` lists, and `typeNameFromConceptId` (conceptId-only) returns
+ * `undefined` for it, so without this it was silently skipped rather than
+ * validated (#882). `refToRelPath`/`refExistsInAnyStash` already key off a bare
+ * `(type, slug)` pair — the same shape `type:slug` already is — so this only
+ * needs to split the token; no new resolution logic.
+ */
+function legacyTypeSlugParts(rawConceptId) {
+    const colon = rawConceptId.indexOf(":");
+    if (colon <= 0)
+        return undefined;
+    const type = rawConceptId.slice(0, colon);
+    const name = rawConceptId.slice(colon + 1);
+    if (!name || name.includes("/") || name.includes(":"))
+        return undefined;
+    return stashDirFor(type) === undefined ? undefined : { type, name };
+}
 /**
  * Returns an array of {ref, resolvedRelPath} for every local AKM ref in the
  * PROSE body that does not resolve to a real file under any of the provided
@@ -364,6 +421,12 @@ function dedupeMissing(rows) {
  * excluded because it can point at merged-away or pruned assets.
  */
 const XREF_FRONTMATTER_KEYS = ["xrefs", "supersededBy", "contradictedBy"];
+/**
+ * The belief-graph subset of {@link XREF_FRONTMATTER_KEYS} — the only channels
+ * `--prune-dangling-edges` will repair (#884). Typed as `readonly string[]` so
+ * `.includes` accepts any xref key without a cast.
+ */
+const BELIEF_EDGE_KEYS = ["supersededBy", "contradictedBy"];
 /**
  * Return the `refs:` array from frontmatter when it is present and is an
  * array of strings; otherwise return `null` to signal the caller should
@@ -597,12 +660,22 @@ export function runBaseChecks(ctx) {
             });
         }
     }
-    if (modified) {
-        // Mirrors the two stub-delete call sites in `commands/lint/index.ts`
-        // (`appendMemoryStubIssue`/`appendWorkflowStubIssue`), which already report
-        // a failed mutation as `fixed: "failed"` instead of throwing. Without this
-        // the sweep aborted mid-run on the first unwritable file and the caller got
-        // an exception instead of a result naming the fixes that HAD landed.
+    /**
+     * Flush accumulated mutations to disk. Called after the fixable checks above
+     * AND again at the very end, because the `missing-ref` section below can also
+     * mutate (`--prune-dangling-edges`, #884) and used to run PAST this point —
+     * its edits were computed and then silently dropped.
+     *
+     * Mirrors the two stub-delete call sites in `commands/lint/index.ts`
+     * (`appendMemoryStubIssue`/`appendWorkflowStubIssue`), which already report
+     * a failed mutation as `fixed: "failed"` instead of throwing. Without this
+     * the sweep aborted mid-run on the first unwritable file and the caller got
+     * an exception instead of a result naming the fixes that HAD landed.
+     */
+    const flushIfModified = () => {
+        if (!modified)
+            return;
+        modified = false;
         try {
             fs.writeFileSync(ctx.filePath, currentRaw, "utf8");
             // Propagate the mutated raw back so subclasses can re-parse if needed
@@ -615,7 +688,8 @@ export function runBaseChecks(ctx) {
                 issue.detail = `${issue.detail} — could not write fix: ${reason}`;
             }
         }
-    }
+    };
+    flushIfModified();
     // ── 3. stale-path ──────────────────────────────────────────────────────
     // M3: checkStalePath returns all stale matches; push one issue per path.
     // M4: Also scan ctx.frontmatter for stale paths (absolute paths in frontmatter).
@@ -636,6 +710,26 @@ export function runBaseChecks(ctx) {
         }
     }
     // ── 4. missing-ref ─────────────────────────────────────────────────────
+    const missingRefPass = runMissingRefChecks(ctx, currentRaw, shouldRun, pendingFixes);
+    issues.push(...missingRefPass.issues);
+    if (missingRefPass.modified) {
+        currentRaw = missingRefPass.raw;
+        modified = true;
+    }
+    flushIfModified();
+    return issues;
+}
+/**
+ * The `missing-ref` pass, extracted from {@link runBaseChecks} so that function
+ * stays under the src fn-size ratchet after #884 gave this pass its own
+ * (opt-in) mutation path. Pure move plus the explicit state hand-off: `raw` in,
+ * `{raw, modified}` out, `issues`/`pendingFixes` appended in place.
+ */
+function runMissingRefChecks(ctx, raw, shouldRun, pendingFixes) {
+    const issues = [];
+    let currentRaw = raw;
+    let modified = false;
+    // ── 4. missing-ref ─────────────────────────────────────────────────────
     // Carve-out for assets that declare an explicit `refs:` array in
     // frontmatter (e.g. session-checkpoint memories captured by the
     // claude-code hook). The frontmatter array is the *authoritative*
@@ -650,7 +744,9 @@ export function runBaseChecks(ctx) {
     // still run `checkMissingRefs` against the array itself to catch
     // refs that were valid at capture time but later removed from the
     // stash.
-    if (shouldRun("missing-ref")) {
+    if (!shouldRun("missing-ref"))
+        return { issues, raw, modified };
+    {
         const explicitRefs = extractFrontmatterRefs(ctx.data, ctx.body);
         // An explicit `refs:` array is a REF LIST (each value is a whole ref —
         // short conceptIds included); a bare body is PROSE (anchored refs only).
@@ -691,6 +787,33 @@ export function runBaseChecks(ctx) {
                 if (values === null)
                     continue;
                 const missingXrefs = checkMissingRefsInList(values, ctx.stashRoot, ctx.extraStashRoots);
+                // #884 opt-in repair. Scoped to the BELIEF channels only: an edge whose
+                // target has neither a file nor a prune tombstone asserts a
+                // relationship to a memory that no longer exists in any form, and
+                // carrying it forward corrupts every belief-graph read. `xrefs` is
+                // excluded — a stale xref is an ordinary broken link (the 3 skill refs
+                // in #884), and repairing it by DELETION would throw away a pointer the
+                // author may simply need to re-target.
+                const repairable = ctx.pruneDanglingEdges === true && BELIEF_EDGE_KEYS.includes(key) && missingXrefs.length > 0;
+                if (repairable) {
+                    const dropped = missingXrefs.map(({ ref }) => ref);
+                    const rewritten = removeFrontmatterListValues(currentRaw, key, dropped);
+                    if (rewritten !== null) {
+                        currentRaw = rewritten;
+                        modified = true;
+                        for (const { ref, resolvedRelPath } of missingXrefs) {
+                            const issue = {
+                                file: ctx.relPath,
+                                issue: "missing-ref",
+                                detail: `dangling ${key} edge dropped: ${ref} (no file and no prune tombstone at ${resolvedRelPath})`,
+                                fixed: true,
+                            };
+                            issues.push(issue);
+                            pendingFixes.push(issue);
+                        }
+                        continue;
+                    }
+                }
                 for (const { ref, resolvedRelPath } of missingXrefs) {
                     issues.push({
                         file: ctx.relPath,
@@ -702,5 +825,5 @@ export function runBaseChecks(ctx) {
             }
         }
     }
-    return issues;
+    return { issues, raw: currentRaw, modified };
 }

package/dist/commands/lint/index.js

@@ -92,7 +92,7 @@ function collectWorkflowFiles(dir) {
             continue;
         const full = path.join(dir, entry.name);
         if (entry.isDirectory()) {
-            if (entry.name === ".cache" || entry.name === "registry")
+            if (isAkmRegistryCachePath(full))
                 continue;
             results.push(...collectWorkflowFiles(full));
             continue;
@@ -185,11 +185,9 @@ function collectAdapterFiles(root, extensions) {
                 walk(full);
             }
             else if (entry.isFile() && matchesAdapterExtension(entry.name, extensions)) {
-                // Compare PATH SEGMENTS, not raw substrings: `path.join` yields `\` on
-                // Windows so a `"/.cache/"` substring test never matches there, and a
-                // substring test would also skip a legitimately-named `registry` file.
-                const segments = path.relative(root, full).split(/[\\/]/);
-                if (segments.includes(".cache") || segments.includes("registry"))
+                // Skip akm's OWN resolved registry-cache copies, not any user
+                // directory that happens to be named ".cache" or "registry".
+                if (isAkmRegistryCachePath(full))
                     continue;
                 results.push(full);
             }
@@ -387,8 +385,8 @@ function assertFixTargetWritable(stashRoot, sources) {
         return;
     // Same error kind and code `write-source.ts#ensureWritable` raises for the
     // identical refusal, so a scripted caller classifies both the same way.
-    throw new UsageError(`lint --fix: bundle "${stashRoot}" is configured \`writable: false\`; refusing to modify it. ` +
-        "Run `akm lint` without --fix to report findings, or set `writable: true` on the bundle.", "INVALID_FLAG_VALUE");
+    throw new UsageError(`lint: bundle "${stashRoot}" is configured \`writable: false\`; refusing to modify it. ` +
+        "Run `akm lint` without --fix / --prune-dangling-edges to report findings, or set `writable: true` on the bundle.", "INVALID_FLAG_VALUE");
 }
 /** True when the issue represents a file deletion that was successfully applied. */
 function isFileDeletion(issue) {
@@ -525,7 +523,9 @@ export function lintAssetFile(ctx, subdir) {
  */
 function lintAkmSweep(stashRoot, extraStashRoots, cfg, sources, options) {
     const fix = options.fix === true;
-    if (fix)
+    // #884: the dangling-edge repair writes too, so it clears the same
+    // read-only gate `--fix` does.
+    if (fix || options.pruneDanglingEdges === true)
         assertFixTargetWritable(stashRoot, sources);
     const fixed = [];
     const flagged = [];
@@ -629,7 +629,18 @@ function lintAkmSweep(stashRoot, extraStashRoots, cfg, sources, options) {
             try {
                 issues = [
                     ...fileIssues,
-                    ...lintAssetFile({ filePath, relPath, raw, data, body, frontmatter, fix, stashRoot, extraStashRoots }, subdir),
+                    ...lintAssetFile({
+                        filePath,
+                        relPath,
+                        raw,
+                        data,
+                        body,
+                        frontmatter,
+                        fix,
+                        pruneDanglingEdges: options.pruneDanglingEdges === true,
+                        stashRoot,
+                        extraStashRoots,
+                    }, subdir),
                 ];
             }
             catch (e) {

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

@@ -196,13 +196,6 @@ export function hasHotCaptureMode(frontmatter) {
  * with 80-90% overlap legitimately compress to well under 50% of the larger.
  */
 export const MERGE_SHRINK_RATIO_MIN = 0.3;
-/**
- * Absolute floor (chars) for merged body.  When sources are short (<~333 chars),
- * `MERGE_SHRINK_RATIO_MIN × largerBodyLen` falls below this and the absolute
- * floor dominates — prevents false positives on very terse memory pairs.
- * Matches the existing `promote_source_too_small` floor of 100 chars.
- */
-export const MERGE_ABSOLUTE_FLOOR_CHARS = 100;
 // ── Reflect size gate ────────────────────────────────────────────────────────
 /** Ratio lower-bound: proposed body must be at least this fraction of source. */
 export const REFLECT_SHRINK_RATIO_MIN = 0.5;

package/dist/commands/read/curate.js

@@ -24,6 +24,7 @@ import { enqueueGraphExtraction, hasGraphData } from "../../indexer/db/graph-db.
 import { copySearchHitAttribution, getSearchHitAttribution, usageEventAttributionMetadata, } from "../../indexer/search/search-attribution.js";
 import { findSourceForPath, resolveSourceEntries } from "../../indexer/search/search-source.js";
 import { insertUsageEvent } from "../../indexer/usage/usage-events.js";
+import { estimateTokenCount } from "../../llm/embedders/remote.js";
 import { truncateDescription } from "../../output/shapes/helpers.js";
 import { TELEMETRY_BUSY_TIMEOUT_MS, withIndexDb } from "../../storage/repositories/index-db.js";
 import { findEntryIdByRef, getItemRefById } from "../../storage/repositories/index-entries-repository.js";
@@ -163,6 +164,52 @@ export async function curateSearchResults(query, result, limit, selectedType, ev
         ...(result.tip ? { tip: result.tip } : {}),
     };
 }
+/**
+ * Pack a curate result's stash hits into a single token-budgeted blob:
+ * resolve each hit's content via the SAME path `akm show` uses
+ * (`akmShowUnified` — this also means a `ref#fragment` hit packs just the
+ * matched section), then greedily accumulate hits, in the ranking order
+ * `curateSearchResults` already produced, until the next hit would exceed
+ * `budgetTokens`.
+ *
+ * Registry hits are never packed — only `CuratedStashItem`s (locked
+ * contract, AGENTS.md: registry results stay separate/opt-in).
+ *
+ * Truncation policy: drop whole hits from the tail of the ranked list first.
+ * The only exception is a single high-rank hit that alone exceeds the
+ * budget — that one hit is truncated to fit rather than dropping everything.
+ */
+export async function packCuratedHits(result, budgetTokens) {
+    const stashItems = result.items.filter((item) => item.source === "local");
+    const packed = [];
+    let used = 0;
+    for (const item of stashItems) {
+        let shown;
+        try {
+            shown = await akmShowUnified({ ref: item.ref, skipLogging: true });
+        }
+        catch {
+            continue;
+        }
+        const content = shown.content ?? shown.template ?? shown.prompt ?? "";
+        const tokens = estimateTokenCount(content);
+        if (used + tokens <= budgetTokens) {
+            packed.push({ ref: item.ref, tokens, content });
+            used += tokens;
+            continue;
+        }
+        if (packed.length === 0) {
+            const remaining = budgetTokens - used;
+            if (remaining > 0) {
+                const truncated = content.slice(0, remaining * 4);
+                packed.push({ ref: item.ref, tokens: estimateTokenCount(truncated), content: truncated });
+                used += estimateTokenCount(truncated);
+            }
+        }
+        break;
+    }
+    return { query: result.query, budget: budgetTokens, tokens: used, items: packed };
+}
 async function enrichCuratedStashHit(query, hit, supportRefs, selectedRefs, eventSource) {
     let shown;
     try {

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

@@ -20,7 +20,8 @@ import { parseMetaRef } from "../../core/asset/stash-meta.js";
 import { UsageError } from "../../core/errors.js";
 import { resolveUsageEventSource } from "../../indexer/usage/usage-events.js";
 import { getOutputMode } from "../../output/context.js";
-import { akmCurate } from "./curate.js";
+import { deliverRendered } from "../../output/html-render.js";
+import { akmCurate, packCuratedHits } from "./curate.js";
 import { akmSearch, parseBeliefFilterMode, parseScopeFilterFlags, parseSearchSource } from "./search.js";
 import { akmShowUnified } from "./show.js";
 /**
@@ -153,6 +154,15 @@ export const curateCommand = defineJsonCommand({
         },
         limit: { type: "string", description: "Maximum number of curated results", default: "4" },
         from: { type: "string", description: "Search source (local|registry|all)", default: "local" },
+        pack: {
+            type: "string",
+            description: "Pack the ranked stash hits' full content into a single token-budgeted blob instead of returning refs " +
+                "to follow up on individually — value is the max token budget, e.g. --pack 4000 (~4 chars/token, same " +
+                "estimator as embedding). Content is resolved the same way `akm show` resolves it, so a ref#fragment " +
+                "hit packs just that section. Registry hits (--from registry|all) are never packed. Not to be confused " +
+                "with a workflow asset's own `budget` field (a run-cost cap) — this is a context-size target for this " +
+                "one curate call.",
+        },
         // Declared as the POSITIVE name with `default: true` — see the
         // `project-context` comment on `searchCommand` above for why a flag NAME
         // must never start with `no-`.
@@ -175,6 +185,7 @@ export const curateCommand = defineJsonCommand({
         const source = parseSearchSource(args.from ?? "local");
         const skipLogging = args["track-usage"] === false;
         const outputMode = getOutputMode();
+        const packBudget = parsePositiveIntFlag(args.pack ?? undefined, "--pack");
         const curated = await akmCurate({
             query: args.query,
             type,
@@ -184,9 +195,21 @@ export const curateCommand = defineJsonCommand({
             eventSource: resolveUsageEventSource(),
             attributionProjection: outputMode.shape === "agent" ? "agent" : outputMode.detail,
         });
+        if (packBudget !== undefined) {
+            const packed = await packCuratedHits(curated, packBudget);
+            deliverRendered(outputMode.format === "text" ? formatCuratePackText(packed) : JSON.stringify(packed.items, null, 2), outputMode.outputPath);
+            return;
+        }
         output("curate", curated);
     },
 });
+/** Human-readable rendering for `akm curate --pack`: concatenated content per hit under a `## <ref>` header. */
+function formatCuratePackText(packed) {
+    if (packed.items.length === 0) {
+        return `No packed content for "${packed.query}" (budget ${packed.budget} tokens).`;
+    }
+    return packed.items.map((item) => `## ${item.ref}\n\n${item.content}`).join("\n\n");
+}
 /**
  * Reject `--scope` (either spelling) on `akm show` (E-3). `--scope` was
  * removed in favor of `--filter` (R-047, guardrail 6 — no alias, must keep

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

@@ -13,20 +13,25 @@
  * keying rules across call sites.
  */
 import path from "node:path";
-import { primaryBundlePath } from "../../core/config/config.js";
+import { bundleKeyForContentRoot, primaryBundlePath } from "../../core/config/config.js";
 import { deriveBundleId } from "../../indexer/installations.js";
 export { primaryBundlePath };
 /**
  * Upsert the primary filesystem bundle (`{ path, writable: true }`) and point
  * `defaultBundle` at it. Reuses the current default key when it already names a
- * filesystem bundle (so re-pointing the primary keeps a stable id); otherwise
- * derives a fresh slug-legal key from the path.
+ * filesystem bundle (so re-pointing the primary keeps a stable id). Otherwise,
+ * reuses whichever configured bundle ALREADY resolves to `stashDir`'s content
+ * root (issue #870 — `AKM_BUNDLE_DIR`/`--dir` pointed at a directory already
+ * configured under a different id must not mint a second bundle for it); only
+ * when no bundle owns that root yet is a fresh slug-legal key derived.
  */
 export function withPrimaryBundle(config, stashDir) {
     const bundles = { ...(config.bundles ?? {}) };
     let key = config.defaultBundle;
     if (!key || !(key in bundles) || typeof bundles[key]?.path !== "string") {
-        key = deriveBundleId(undefined, stashDir, new Set(Object.keys(bundles)));
+        key =
+            bundleKeyForContentRoot(config, path.resolve(stashDir)) ??
+                deriveBundleId(undefined, stashDir, new Set(Object.keys(bundles)));
     }
     bundles[key] = {
         ...bundles[key],

package/dist/commands/sources/info.js

@@ -8,7 +8,6 @@ import { classifyPathAccess, describeInaccessiblePath } from "../../core/path-ac
 import { getDbPath } from "../../core/paths.js";
 import { formatRegistryUrl } from "../../core/registry-url.js";
 import { error } from "../../core/warn.js";
-import { getEffectiveSemanticStatus, readSemanticStatus } from "../../indexer/search/semantic-status.js";
 import { closeDatabase, openExistingDatabase } from "../../storage/repositories/index-connection.js";
 import { getEntryCount, getEntryCountByType } from "../../storage/repositories/index-entries-repository.js";
 import { getMeta } from "../../storage/repositories/index-meta-repository.js";
@@ -29,13 +28,6 @@ export function assembleInfo(options) {
     const defaultBundle = config.defaultBundle ?? null;
     // Asset types (copy into a mutable array — `placementTypes()` returns readonly)
     const assetTypes = [...placementTypes()];
-    const semanticRuntime = readSemanticStatus();
-    const semanticStatus = getEffectiveSemanticStatus(config, semanticRuntime);
-    // Search modes
-    const searchModes = ["fts"];
-    if (semanticStatus === "ready-js" || semanticStatus === "ready-vec") {
-        searchModes.push("semantic", "hybrid");
-    }
     // Registries (strip sensitive fields like apiKey from options)
     const registries = (config.registries ?? []).map((r) => ({
         url: formatRegistryUrl(r.url),
@@ -58,6 +50,20 @@ export function assembleInfo(options) {
     // health and search use, so info reads the same database they do.
     const resolvedDbPath = options?.dbPath ?? getDbPath();
     const indexStats = readIndexStats(resolvedDbPath);
+    // Semantic status is read live from the index's own state, not a cached
+    // verdict — a failed embed attempt at search time falls back to FTS and
+    // reports that in the search response, it never disables the mode here.
+    const semanticStatus = config.semanticSearchMode === "off"
+        ? "disabled"
+        : !indexStats.hasEmbeddings
+            ? "pending"
+            : indexStats.vecAvailable
+                ? "ready-vec"
+                : "ready-js";
+    const searchModes = ["fts"];
+    if (semanticStatus === "ready-js" || semanticStatus === "ready-vec") {
+        searchModes.push("semantic", "hybrid");
+    }
     return {
         schemaVersion: 1,
         version: pkgVersion,
@@ -68,8 +74,6 @@ export function assembleInfo(options) {
         semanticSearch: {
             mode: config.semanticSearchMode,
             status: semanticStatus,
-            ...(semanticRuntime?.reason ? { reason: semanticRuntime.reason } : {}),
-            ...(semanticRuntime?.message ? { message: semanticRuntime.message } : {}),
         },
         registries,
         sourceProviders,

package/dist/commands/tasks/tasks.js

@@ -39,7 +39,6 @@ import { assertSchedulerNativeArtifactOwnership, assertSchedulerSourceSnapshot,
 import { renderSchedulerPlanPreview, renderSchedulerSyncPlanPreview, } from "../../tasks/scheduler-sync-preview.js";
 import { parseTaskSource } from "../../tasks/source/parse-task-source.js";
 import { projectTaskSourceV4 } from "../../tasks/source/project-v4.js";
-import { TASK_V3_MAX_SOURCE_BYTES } from "../../tasks/source-v3.js";
 import { normaliseTaskConceptId, normaliseTaskId } from "../../tasks/task-id.js";
 import { applyAutonomyGate, configuredDirectAutonomyLanes, describeGatedLanes } from "../improve/autonomy-gate.js";
 import { resolveImproveStrategy } from "../improve/improve-strategies.js";
@@ -971,13 +970,7 @@ function captureTaskSourceExpectation(filePathInput, rootInput) {
     if (!rootStat.isDirectory()) {
         throw new UsageError(`${root} is not a task source directory.`, "INVALID_FLAG_VALUE");
     }
-    const common = {
-        filePath,
-        rootRealPath,
-        rootPhysicalIdentity: rootStat.ino === 0n ? `path:${rootRealPath}` : `inode:${rootStat.dev}:${rootStat.ino}`,
-        rootMtimeNs: String(rootStat.mtimeNs),
-        rootCtimeNs: String(rootStat.ctimeNs),
-    };
+    const common = { filePath, rootRealPath };
     let descriptor;
     try {
         const noFollow = "O_NOFOLLOW" in fs.constants ? fs.constants.O_NOFOLLOW : 0;
@@ -986,9 +979,6 @@ function captureTaskSourceExpectation(filePathInput, rootInput) {
         if (!before.isFile()) {
             throw new UsageError(`${filePath} is not a regular task source.`, "INVALID_FLAG_VALUE");
         }
-        if (before.size > BigInt(TASK_V3_MAX_SOURCE_BYTES)) {
-            throw new UsageError(`${filePath} exceeds the 1 MiB (${TASK_V3_MAX_SOURCE_BYTES}-byte) task source limit.`, "INVALID_FLAG_VALUE");
-        }
         const bytes = fs.readFileSync(descriptor);
         const after = fs.fstatSync(descriptor, { bigint: true });
         if (!sameTaskSourceStat(before, after) || BigInt(bytes.byteLength) !== before.size) {
@@ -1010,10 +1000,7 @@ function captureTaskSourceExpectation(filePathInput, rootInput) {
             state: "present",
             ...common,
             realPath,
-            physicalIdentity: before.ino === 0n ? `path:${realPath}` : `inode:${before.dev}:${before.ino}`,
             size: bytes.byteLength,
-            mtimeNs: String(before.mtimeNs),
-            ctimeNs: String(before.ctimeNs),
             sha256: createHash("sha256").update(bytes).digest("hex"),
             bytesBase64: bytes.toString("base64"),
             content,
@@ -1035,6 +1022,11 @@ function captureTaskSourceExpectation(filePathInput, rootInput) {
             fs.closeSync(descriptor);
     }
 }
+// TOCTOU note: this compares CONTENT (state + sha256), not filesystem
+// identity (inode/mtime/ctime/directory timestamps) — the same split already
+// applied to the task migrator in 0.9.5. An unrelated touch to the file or
+// its containing directory must not trip a "changed after planning" refusal;
+// only a real content change should.
 function assertTaskSourceExpectation(expected) {
     const actual = captureTaskSourceExpectation(expected.filePath, expected.rootRealPath);
     if (!sameTaskSourceExpectation(actual, expected)) {
@@ -1042,12 +1034,16 @@ function assertTaskSourceExpectation(expected) {
     }
 }
 function sameTaskSourceExpectation(left, right) {
-    return JSON.stringify(left) === JSON.stringify(right);
+    if (left.state !== right.state || left.filePath !== right.filePath || left.rootRealPath !== right.rootRealPath) {
+        return false;
+    }
+    if (left.state === "absent")
+        return true;
+    return left.sha256 === right.sha256;
 }
 function assertTaskSourceRestored(expected) {
     const actual = captureTaskSourceExpectation(expected.filePath, expected.rootRealPath);
     const restored = actual.state === expected.state &&
-        actual.rootPhysicalIdentity === expected.rootPhysicalIdentity &&
         (actual.state === "absent" ||
             (expected.state === "present" && actual.sha256 === expected.sha256 && actual.content === expected.content));
     if (!restored) {

package/dist/commands/workflow-cli.js

@@ -20,7 +20,7 @@ import { deliverRendered } from "../output/html-render.js";
 import { shapeForCommand } from "../output/shapes.js";
 import { formatPlain } from "../output/text.js";
 import { assertWorkflowMarkdownName, createWorkflowAsset, getWorkflowTemplate } from "../workflows/authoring/authoring.js";
-import { WORKFLOW_MAX_RETRIES, WORKFLOW_MAX_TIMEOUT_MS } from "../workflows/ir/schema.js";
+import { WORKFLOW_MAX_TIMEOUT_MS } from "../workflows/ir/schema.js";
 import { abandonWorkflowRun, getWorkflowStatus, hasWorkflowRun, listWorkflowRuns, resumeWorkflowRun, } from "../workflows/runtime/runs.js";
 import { akmWorkflowPlan } from "./workflow/plan.js";
 const workflowStatusCommand = defineJsonCommand({
@@ -168,7 +168,7 @@ const workflowRunCommand = defineJsonCommand({
         const { runWorkflowSteps } = await import("../workflows/exec/run-workflow.js");
         const parameterFlags = parseWorkflowParameterFlags(rawArgs, args.target);
         const maxSteps = parseIntegerFlag(getStringArg(args, "max-steps"), "--max-steps", 1);
-        const maxRetries = parseIntegerFlag(getStringArg(args, "max-retries"), "--max-retries", 0, WORKFLOW_MAX_RETRIES);
+        const maxRetries = parseIntegerFlag(getStringArg(args, "max-retries"), "--max-retries", 0);
         const timeoutMs = parseWorkflowTimeout(getStringArg(args, "timeout"));
         const controller = new AbortController();
         let signalExitCode;

package/dist/core/asset/asset-placement.js

@@ -25,7 +25,7 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-import { SCRIPT_EXTENSIONS, WORKFLOW_EXTENSIONS } from "../recognition-util.js";
+import { DERIVED_SUFFIX, SCRIPT_EXTENSIONS, WORKFLOW_EXTENSIONS } from "../recognition-util.js";
 function toPosix(input) {
     return input.replace(/\\/g, "/");
 }
@@ -247,10 +247,21 @@ export function assetPathForName(assetType, typeRoot, name) {
  * "default" alias is genuinely dual-owned: both `<dir>/.env` and
  * `<dir>/default.env` derive the same canonical name (`toCanonicalName`
  * above), so a physical-owner lookup must consider both without reading
- * either file. Every other placement type has exactly one inverse spelling.
+ * either file. `memory` has a second, analogous duality (#882): a ref to
+ * `<name>` may own either `<name>.md` or the LLM-inferred `<name>.derived.md`
+ * twin — `.derived` is a provenance marker on the SAME identity, not part of
+ * the name (see `resolveParentRef`/`isDerivedMemory` in
+ * `commands/improve/memory/derived-ref.ts`, and the belief-edge identity
+ * channel's own `memory:<name>.derived` refs). The plain `.md` file wins when
+ * both exist, so it stays `primary` — first in the returned list — and every
+ * caller here already prefers the first candidate that exists on disk. Every
+ * other placement type has exactly one inverse spelling.
  */
 export function assetPathCandidatesForName(assetType, typeRoot, name) {
     const primary = assetPathForName(assetType, typeRoot, name);
+    if (assetType === "memory" && !name.endsWith(DERIVED_SUFFIX)) {
+        return [primary, assetPathForName(assetType, typeRoot, `${name}${DERIVED_SUFFIX}`)];
+    }
     if (assetType !== "env")
         return [primary];
     const base = name === "default" ? "" : name.endsWith("/default") ? name.slice(0, -"default".length) : undefined;