akm-cli 0.9.17-alpha.8 → 0.9.17-alpha.9

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

@@ -4,12 +4,21 @@
 /** Proposal validation and the one content repair applied before promotion. */
 import { repairTruncatedDescription } from "../../../core/text-truncation.js";
 import { splitFrontmatter } from "../../improve/reflect-noise.js";
+import { isRetireProposal } from "../proposal-types.js";
 import { runProposalValidators } from "./proposal-validators.js";
 /**
  * Validate a proposal before promotion: it must parse and carry a body, and a
  * type with a canonical validator runs it.
+ *
+ * A retire proposal (alpha.9 consolidate pair pass) writes no new content —
+ * it deletes an asset that already passed validation when IT was created —
+ * so the content-quality validators (built for new/updated bodies: a
+ * description, lesson shape, reflect size ratio, …) do not apply and are
+ * skipped entirely rather than misreading the empty body as a defect.
  */
 export function validateProposal(proposal) {
+    if (isRetireProposal(proposal))
+        return { ok: true, findings: [] };
     return runProposalValidators(proposal);
 }
 /**

package/dist/commands/read/knowledge.js

@@ -612,8 +612,9 @@ export async function writeMarkdownAsset(options) {
     // no longer trigger reindexes, so keeping the index current is the writer's
     // job. Demoted files reindex under their own containing root (usually the
     // write target itself; the working stash when writing to a --target) so
-    // `--belief current` filtering and the beliefState ranking demotion take
-    // effect without waiting for the next full index.
+    // `--belief current` filtering takes effect without waiting for the next
+    // full index. (alpha.4 removed belief weights from ranking; `--belief` is
+    // the only reader of `beliefState` today.)
     const demotedInTargetRoot = demotedByRoot.get(source.path) ?? [];
     demotedByRoot.delete(source.path);
     await indexWrittenAssets(source.path, [result.path, ...demotedInTargetRoot], { bundleId: resolved.ref.origin });

package/dist/commands/read/show.js

@@ -33,7 +33,6 @@ import { appendEvent } from "../../core/events.js";
 import { SCRIPT_EXTENSIONS } from "../../core/recognition-util.js";
 import { presentationFor } from "../../core/type-presentation.js";
 import { warn, warnOnce } from "../../core/warn.js";
-import { listRelatedPathsForFile } from "../../indexer/graph/graph-related.js";
 import { lookupBundleRef, lookupBundleRefWithResolution } from "../../indexer/indexer.js";
 import { projectMarkdownFragmentContent } from "../../indexer/passes/metadata.js";
 import { ensurePrimaryIndexForRead, resolveReadSources } from "../../indexer/read-preflight.js";
@@ -384,19 +383,6 @@ export async function showLocal(input) {
         origin: source?.registryId ?? null,
         editable,
         ...(!editable ? { editHint: buildEditHint(canonicalRef) } : {}),
-        related: (() => {
-            try {
-                return withIndexDb((db) => {
-                    const related = listRelatedPathsForFile(sourceStashDir, assetPath, 5, db);
-                    return { total: related.length, hits: related };
-                });
-            }
-            catch (err) {
-                rethrowIfTestIsolationError(err);
-                rethrowIfDataDirUnreadable(err);
-                return { total: 0, hits: [] };
-            }
-        })(),
         ...showLinks(indexedEntry.itemRef, displayDefaultBundle),
     };
     const activeRun = await getActiveWorkflowRun(getCurrentWorkflowScopeKey());

package/dist/commands/sources/stash-cli.js

@@ -83,10 +83,10 @@ export const indexCommand = defineCommand({
     async run({ args }) {
         await runWithJsonErrors(async () => {
             if (getHyphenatedBoolean(args, "enrich") || getParsedInvocation().getFlagValue("--enrich") !== undefined) {
-                throw new UsageError("`akm index --enrich` has been removed. Plain `akm index` now performs metadata enrichment by default.");
+                throw new UsageError("`akm index --enrich` has been removed. Metadata enrichment during indexing is retired; it never runs.");
             }
             if (getHyphenatedBoolean(args, "re-enrich") || getParsedInvocation().getFlagValue("--re-enrich") !== undefined) {
-                throw new UsageError("`akm index --re-enrich` has been removed. Re-enrichment of index-time LLM passes is not exposed in this slice.");
+                throw new UsageError("`akm index --re-enrich` has been removed. Metadata enrichment during indexing is retired; there is nothing to re-enrich.");
             }
             // #956: opt-in, non-blocking rebuild lock — never gates a human-typed
             // `akm index` (it only warns and contends), but a scheduled/opportunistic

package/dist/core/bundle-rename.js

@@ -30,7 +30,6 @@ import fs from "node:fs";
 import { readLockfile, renameLockEntry } from "../integrations/lockfile.js";
 import { closeDatabase, openIndexDatabase, openReadonlyExistingDatabase, } from "../storage/repositories/index-connection.js";
 import { getFilePathsByBundle, renameEntriesBundleId } from "../storage/repositories/index-entries-repository.js";
-import { renameLlmCacheAssetRefs } from "../storage/repositories/index-llm-cache-repository.js";
 import { countProposalsForBundleRename, renameProposalsBundleRef } from "../storage/repositories/proposals-repository.js";
 import { countTaskHistoryTargetRefs, renameTaskHistoryTargetRefs, } from "../storage/repositories/task-history-repository.js";
 import { selectBackend } from "../tasks/backends/index.js";
@@ -243,18 +242,13 @@ export async function renameBundle(oldId, newId, options = {}, deps) {
     // e.g. a plain filesystem bundle).
     await renameLockEntry(oldId, newId);
     // Index: bundle_id/item_ref on every entry row (see index-entries-repository's
-    // renameEntriesBundleId docstring for why no FTS/vector rebuild is needed),
-    // and the metadata-enrichment LLM cache keyed by the same canonical
-    // item_ref — in the SAME write, so a rename can never land between the two
-    // and leave the cache stranded under the old prefix (the next `akm index`'s
-    // clearStaleCacheEntries would then delete it, forcing a full re-enrich).
+    // renameEntriesBundleId docstring for why no FTS/vector rebuild is needed).
     const readIndexDb = openReadonlyExistingDatabase(getDbPath());
     if (readIndexDb) {
         closeDatabase(readIndexDb);
         const writeIndexDb = openIndexDatabase(getDbPath());
         try {
             renameEntriesBundleId(writeIndexDb, oldId, newId);
-            renameLlmCacheAssetRefs(writeIndexDb, oldId, newId);
         }
         finally {
             closeDatabase(writeIndexDb);

package/dist/core/config/config-schema.js

@@ -60,7 +60,7 @@ export { EngineConfigSchema, EnginesSchema, LlmConnectionConfigSchema, LlmProfil
 export { ExperimentalConfigSchema } from "./schema/experimental.js";
 export { FEEDBACK_FAILURE_MODES, FeedbackConfigSchema } from "./schema/feedback.js";
 export { ImproveConfigSchema } from "./schema/improve.js";
-export { ConsolidateProcessConfigSchema, DistillProcessConfigSchema, ExtractProcessConfigSchema, GraphExtractionProcessConfigSchema, ImproveProcessConfigSchema, ImproveProfileConfigSchema, MemoryInferenceProcessConfigSchema, ProactiveMaintenanceProcessConfigSchema, ReflectProcessConfigSchema, TriageProcessConfigSchema, ValidationProcessConfigSchema, } from "./schema/improve-processes.js";
+export { ConsolidateProcessConfigSchema, DistillProcessConfigSchema, ExtractProcessConfigSchema, ImproveProcessConfigSchema, ImproveProfileConfigSchema, MemoryInferenceProcessConfigSchema, ProactiveMaintenanceProcessConfigSchema, ReflectProcessConfigSchema, TriageProcessConfigSchema, ValidationProcessConfigSchema, } from "./schema/improve-processes.js";
 export { IndexConfigSchema, IndexPassConfigSchema } from "./schema/index-config.js";
 export { OutputConfigSchema } from "./schema/output.js";
 export { CURRENT_CONFIG_VERSION, LlmInvocationOverridesSchema } from "./schema/primitives.js";
@@ -240,6 +240,13 @@ export const AkmConfigSchema = AkmConfigBaseSchema.superRefine((config, ctx) =>
     }
     const defaultStrategy = config.defaults?.improveStrategy;
     if (defaultStrategy &&
+        // graph-refresh is exempt from this eager, config-load-time check: unlike
+        // a plain typo, it is a specific, known retirement, and refusing it here
+        // would fail every command's config load (including `akm migrate apply`,
+        // the one that fixes this). `resolveImproveStrategy`
+        // (src/commands/improve/improve-strategies.ts) refuses it lazily, at
+        // improve-invocation time, with the same message either way.
+        defaultStrategy !== "graph-refresh" &&
         !BUILTIN_IMPROVE_STRATEGY_NAMES.includes(defaultStrategy) &&
         !config.improve?.strategies?.[defaultStrategy]) {
         ctx.addIssue({

package/dist/core/config/config.js

@@ -27,36 +27,6 @@ export { VALID_HARNESS_IDS } from "./config-types.js";
 // Canonical taxonomy lives in the schema/validator layer; re-exported here so
 // existing `../core/config/config` import sites keep working.
 export { FEEDBACK_FAILURE_MODES } from "./config-schema.js";
-/**
- * Default value for {@link IndexPassConfig.graphExtractionBatchSize}. Chosen
- * empirically: 4 amortises the per-call HTTP overhead 4× while keeping the
- * combined prompt size well under common 8K/16K context windows (each body is
- * sliced to ~500 chars in the graph-extract prompt builder).
- */
-const DEFAULT_GRAPH_EXTRACTION_BATCH_SIZE = 4;
-/**
- * Approximate character budget per asset body inside a batched
- * graph-extraction prompt — used by {@link resolveBatchSize} to derive a
- * context-window ceiling when `llm.contextLength` is configured. This accounts
- * for the actual `MAX_BODY_CHARS` (500) in graph-extract.ts plus the system
- * prompt, user prompt wrapper, and expected JSON response overhead.
- */
-const GRAPH_EXTRACTION_CHARS_PER_BODY = 1500;
-/**
- * Clamp a configured batch size against the model's known context window.
- *
- * `configured` defaults to {@link DEFAULT_GRAPH_EXTRACTION_BATCH_SIZE} when
- * `undefined`. When `contextLength` is provided, the result is the smaller of
- * `configured` and `floor(contextLength / GRAPH_EXTRACTION_CHARS_PER_BODY)`,
- * with a floor of 1 so the batched path always processes at least one body.
- */
-export function resolveBatchSize(configured, contextLength) {
-    const base = configured && configured > 0 ? configured : DEFAULT_GRAPH_EXTRACTION_BATCH_SIZE;
-    if (!contextLength || contextLength <= 0)
-        return base;
-    const ceiling = Math.max(1, Math.floor(contextLength / GRAPH_EXTRACTION_CHARS_PER_BODY));
-    return Math.max(1, Math.min(base, ceiling));
-}
 // ── Defaults ────────────────────────────────────────────────────────────────
 export const DEFAULT_CONFIG = {
     configVersion: "0.9.0",
@@ -210,6 +180,18 @@ function buildEffectiveConfig(liftedLocalRaw, sourcePath) {
     assertUniquePhysicalBundleRoots(finalResult.data, sourcePath);
     return finalResult.data;
 }
+/**
+ * Retired `index.<passName>` keys that still validate against the generic
+ * per-pass catchall schema (`IndexPassConfigSchema`), so `resolveSchemaAt`
+ * below never returns `undefined` for them and the walk would otherwise
+ * treat them as a live, ordinary pass. Named here so the same three
+ * guarantees apply as any other retired config key (AGENTS.md "Reading
+ * persisted data"): a config setting one keeps loading, is named once by
+ * the unknown-key warning, and is dropped only by `akm migrate apply`.
+ * Both were retired in 0.9.17-alpha.9: `index.graph` (the LLM entity-graph
+ * extraction pass) and `index.metadataEnhance` (LLM metadata enrichment).
+ */
+const RETIRED_CATCHALL_KEY_PATHS = new Set(["index.graph", "index.metadataEnhance"]);
 /**
  * Every dotted key in `raw` the schema does not know, at any depth (arrays
  * are not descended). Unknown keys are never an error: they are a typo, or a
@@ -221,7 +203,7 @@ export function unknownConfigKeyPaths(root, node = root, prefix = []) {
     const found = [];
     for (const key of Object.keys(node).sort()) {
         const keyPath = [...prefix, key];
-        if (resolveSchemaAt(keyPath, root) === undefined) {
+        if (RETIRED_CATCHALL_KEY_PATHS.has(keyPath.join(".")) || resolveSchemaAt(keyPath, root) === undefined) {
             found.push(keyPath);
             continue;
         }
@@ -695,6 +677,16 @@ export function normalizeConfigFile(configPath, options) {
         const body = withSchedulerOnDisk(configWriteBody(localRaw, current, next), next);
         for (const keyPath of unknownConfigKeyPaths(body))
             deleteConfigPath(body, keyPath);
+        // `improve.strategies["graph-refresh"]` is schema-valid (any name is a
+        // legal custom-strategy key), so it never reaches the unknown-key sweep
+        // above. It can only be a leftover override of the deleted graph-refresh
+        // built-in (0.9.17-alpha.9) — resolveImproveStrategy now refuses that
+        // name unconditionally, so the override can never apply again. Drop it
+        // the same way any other retired key is dropped: only by `akm migrate
+        // apply`, never by an ordinary write.
+        const strategies = body.improve?.strategies;
+        if (strategies && Object.hasOwn(strategies, "graph-refresh"))
+            delete strategies["graph-refresh"];
         const keys = [...new Set([...Object.keys(raw), ...Object.keys(body)])]
             .filter((key) => JSON.stringify(raw[key]) !== JSON.stringify(body[key]))
             .sort();
@@ -928,23 +920,6 @@ export function resolveSecret(value, resolveFromStore) {
         return resolved ?? "";
     });
 }
-/**
- * Read a per-pass {@link IndexPassConfig} entry from {@link IndexConfig},
- * filtering out the reserved feature-section keys so callers don't mistake
- * `metadataEnhance` for a pass.
- */
-/** Reserved well-known keys on IndexConfig that are NOT per-pass entries. */
-const INDEX_RESERVED_KEYS = new Set(["metadataEnhance"]);
-export function getIndexPassConfig(config, passName) {
-    if (!config)
-        return undefined;
-    if (INDEX_RESERVED_KEYS.has(passName))
-        return undefined;
-    const entry = config[passName];
-    if (!entry || typeof entry !== "object")
-        return undefined;
-    return entry;
-}
 // Re-export source runtime helpers — implementation lives in config-sources.ts.
 export { bundleComponentConfig, bundleContentRoot, bundleContentRoots, bundleEntryToSourceEntry, bundleKeyForContentRoot, bundlePhysicalContentRoot, bundleSourceId, bundlesToSourceEntries, installedSourceDescriptor, isBundleEnabled, parseSourceSpec, primaryBundlePath, resolveActiveConfiguredSources, resolveConfiguredSources, } from "./config-sources.js";
 /**

package/dist/core/config/engine-semantics.js

@@ -6,7 +6,6 @@ export const BUILTIN_IMPROVE_STRATEGY_NAMES = [
     "default",
     "quick",
     "thorough",
-    "graph-refresh",
     "consolidate",
     "catchup",
     "reflect-distill",
@@ -18,7 +17,6 @@ export const IMPROVE_PROCESS_ENGINE_CAPABILITIES = {
     distill: "llm",
     consolidate: "llm",
     memoryInference: "llm",
-    graphExtraction: "llm",
     extract: "llm",
     validation: "llm",
     triage: "runner",

package/dist/core/config/schema/improve-processes.js

@@ -10,13 +10,14 @@ import { IMPROVE_PROCESS_ENGINE_CAPABILITIES } from "../engine-semantics.js";
 import { engineName, LlmInvocationOverridesSchema, nonEmptyString, positiveInt } from "./primitives.js";
 // ── Improve profile / process ──────────────────────────────────────────────
 //
-// WI-9.6 (§4.2/§10.2): each of the 9 improve processes (reflect, distill,
-// consolidate, memoryInference, graphExtraction, extract, validation, triage,
-// proactiveMaintenance) gets its OWN schema below — a shared base (engine,
-// model, llm, enabled, timeoutMs) extended with only the fields meaningful on
-// that process — replacing the prior single ImproveProcessConfigSchema reused
-// via `.optional()` for all 9 keys (which accepted, and silently ignored, any
-// field on any process). Field→process assignment is derived from each
+// WI-9.6 (§4.2/§10.2): each of the improve processes (reflect, distill,
+// consolidate, memoryInference, extract, validation, triage,
+// proactiveMaintenance — graphExtraction had one too, until the LLM
+// entity-graph it ran was retired in 0.9.17-alpha.9) gets its OWN schema
+// below — a shared base (engine, model, llm, enabled, timeoutMs) extended
+// with only the fields meaningful on that process — replacing the prior
+// single ImproveProcessConfigSchema reused via `.optional()` for all of them
+// (which accepted, and silently ignored, any field on any process). Field→process assignment is derived from each
 // field's original "only meaningful on X" doc comment, cross-checked against
 // its actual runtime consumers and the built-in strategy assets
 // (src/assets/improve-strategies/*.json).
@@ -164,12 +165,6 @@ const CONSOLIDATE_PROCESS_FIELDS = {
     // entirely (emits `pool_below_min_size`). 0 disables the guard. Default 500.
     minPoolSize: z.number().int().min(0).optional(),
     maxChunkSize: z.number().int().min(1).max(50).optional(),
-    // Narrow candidate pool to memories modified within this duration window
-    // plus their graph neighbours. Absent = full-pool sweep.
-    incrementalSince: z.string().optional(),
-    // Graph neighbours per changed memory during incremental consolidation.
-    // Default 5. Only meaningful with incrementalSince.
-    neighborsPerChanged: z.number().int().min(1).optional(),
     // Fallback p90 wall-clock time per consolidation chunk in seconds, used for
     // cold-start budget estimation when no telemetry history exists. The actual
     // p90 is derived from observed run durations once sufficient history
@@ -182,29 +177,6 @@ const MEMORY_INFERENCE_PROCESS_FIELDS = {
     minPendingCount: z.number().int().min(0).optional(),
     cls: clsField,
 };
-/**
- * GraphExtraction process fields: one strategy's graph extraction scope and
- * batching. `includeTypes` and `batchSize` override `index.graph`'s
- * `graphExtractionIncludeTypes` and `graphExtractionBatchSize`; unset, the
- * pass reads those.
- */
-const GRAPH_EXTRACTION_PROCESS_FIELDS = {
-    // #624 P2: when set, rank eligible files by utility_scores DESC and process
-    // only the top-N per run (incremental high-signal-first sweep). Unset =
-    // process all eligible (current behavior).
-    topN: positiveInt.optional(),
-    includeTypes: z.array(z.string().min(1)).min(1).optional(),
-    batchSize: positiveInt.optional(),
-    // Full-corpus scan. When true, graph extraction runs on ALL stash files
-    // instead of only files touched by actionable refs in the current run.
-    // Used by the `graph-refresh` built-in profile / a scheduled weekly task.
-    fullScan: z.boolean().optional(),
-    // R12b + R20: cap on chunks processed per asset. A body chunked beyond this
-    // is truncated to the first N chunks instead of paying for unbounded
-    // per-asset LLM calls; the coverage loss is recorded as truncatedChunks.
-    // Absent = default 8 (src/llm/graph-extract.ts DEFAULT_MAX_CHUNKS_PER_ASSET).
-    maxChunksPerAsset: positiveInt.optional(),
-};
 const EXTRACT_PROCESS_FIELDS = {
     defaultSince: z.string().min(1).optional(),
     maxTotalChars: positiveInt.optional(),
@@ -264,7 +236,6 @@ export const ImproveProcessConfigSchema = z
     ...DISTILL_PROCESS_FIELDS,
     ...CONSOLIDATE_PROCESS_FIELDS,
     ...MEMORY_INFERENCE_PROCESS_FIELDS,
-    ...GRAPH_EXTRACTION_PROCESS_FIELDS,
     ...EXTRACT_PROCESS_FIELDS,
     ...TRIAGE_PROCESS_FIELDS,
     ...PROACTIVE_MAINTENANCE_PROCESS_FIELDS,
@@ -288,10 +259,6 @@ export const ConsolidateProcessConfigSchema = z
 export const MemoryInferenceProcessConfigSchema = z
     .object({ ...IMPROVE_PROCESS_BASE_FIELDS, ...MEMORY_INFERENCE_PROCESS_FIELDS })
     .passthrough();
-/** `processes.graphExtraction` — narrow per-process schema (WI-9.6). */
-export const GraphExtractionProcessConfigSchema = z
-    .object({ ...IMPROVE_PROCESS_BASE_FIELDS, ...GRAPH_EXTRACTION_PROCESS_FIELDS })
-    .passthrough();
 /** `processes.extract` — narrow per-process schema (WI-9.6). */
 export const ExtractProcessConfigSchema = z
     .object({ ...IMPROVE_PROCESS_BASE_FIELDS, ...EXTRACT_PROCESS_FIELDS })
@@ -306,13 +273,20 @@ export const TriageProcessConfigSchema = z
 export const ProactiveMaintenanceProcessConfigSchema = z
     .object({ ...IMPROVE_PROCESS_BASE_FIELDS, ...PROACTIVE_MAINTENANCE_PROCESS_FIELDS })
     .passthrough();
+/**
+ * Process names that once had a dedicated schema and are now gone. Setting
+ * one, even with `enabled: true`, is tolerated rather than rejected by the
+ * "unknown enabled process" check below — an old config must keep loading
+ * (AGENTS.md "Reading persisted data"). `graphExtraction`: the LLM
+ * entity-graph extraction it ran was retired in 0.9.17-alpha.9.
+ */
+const RETIRED_PROCESS_NAMES = new Set(["graphExtraction"]);
 const ImproveProfileProcessesSchema = z
     .object({
     reflect: ReflectProcessConfigSchema.optional(),
     distill: DistillProcessConfigSchema.optional(),
     consolidate: ConsolidateProcessConfigSchema.optional(),
     memoryInference: MemoryInferenceProcessConfigSchema.optional(),
-    graphExtraction: GraphExtractionProcessConfigSchema.optional(),
     extract: ExtractProcessConfigSchema.optional(),
     validation: ValidationProcessConfigSchema.optional(),
     triage: TriageProcessConfigSchema.optional(),
@@ -335,6 +309,7 @@ const ImproveProfileProcessesSchema = z
     }
     for (const [name, process] of Object.entries(val)) {
         if (!(name in IMPROVE_PROCESS_ENGINE_CAPABILITIES) &&
+            !RETIRED_PROCESS_NAMES.has(name) &&
             process !== null &&
             typeof process === "object" &&
             process.enabled === true) {

package/dist/core/config/schema/index-config.js

@@ -10,19 +10,6 @@ import { z } from "zod";
 import { warnOnce } from "../../warn.js";
 import { engineName, LlmInvocationOverridesSchema, nonEmptyString, positiveInt } from "./primitives.js";
 // ── Index / per-pass ────────────────────────────────────────────────────────
-//
-// WI-9.6c: `graphExtractionIncludeTypes` is no longer validated against a
-// hardcoded allowlist (the prior GRAPH_EXTRACTION_INCLUDE_TYPES_ALLOWED,
-// which included a stale `wiki` entry and was already missing `fact` from the
-// runtime consumer's own list — the schema-level allowlist had drifted from
-// reality). Accept-any until Chunk 2 sources a real type list from adapter
-// metadata: the field is now an array of arbitrary non-empty strings.
-// Runtime consumers already handle unknown/unsupported type strings
-// gracefully — src/indexer/graph/graph-extraction.ts's
-// `SUPPORTED_GRAPH_EXTRACTION_INCLUDE_TYPES` set (and `collectEligibleFiles`)
-// silently skips any type it doesn't recognize (no placement entry ⇒ zero
-// eligible files for that type; no crash). This is a permissive-direction
-// behavior change: configs with a previously-rejected type string now parse.
 const INDEX_PASS_RETIRED_KEYS = new Set([
     "endpoint",
     "provider",
@@ -60,12 +47,8 @@ export const IndexPassConfigSchema = z.preprocess((raw, ctx) => {
     timeoutMs: z.union([positiveInt, z.null()]).optional(),
     enabled: z.boolean().optional(),
     llm: LlmInvocationOverridesSchema.optional(),
-    graphExtractionBatchSize: positiveInt.optional(),
-    // Accept-any until Chunk 2 (WI-9.6c) — no longer enum-restricted.
-    graphExtractionIncludeTypes: z.array(z.string().min(1)).nonempty().optional(),
 })
     .passthrough());
-const MetadataEnhanceSchema = z.object({ enabled: z.boolean().optional() }).passthrough();
 const IndexDefaultsSchema = z
     .object({
     engine: engineName.optional(),
@@ -76,16 +59,14 @@ const IndexDefaultsSchema = z
     .passthrough();
 /**
  * Index config is a union of reserved feature sections and per-pass entries.
- * Passthrough so per-pass entries (keyed by arbitrary pass names like `graph`,
- * `enrichment`) can live next to the reserved keys.
+ * Passthrough so per-pass entries (keyed by arbitrary pass names like
+ * `memory`, or a retired one like `graph`) can live next to the reserved keys.
  * The outer preprocess emits the legacy parser's actionable error messages
  * for the two most common type-shape mistakes:
  *   - An array at the `index` block.
  *   - A non-object at `index.<passName>`.
- * Inner field validation (graphExtractionIncludeTypes shape, invocation
- * overrides, provider-key rejection) is delegated to {@link IndexPassConfigSchema}.
- * `graphExtractionIncludeTypes` accepts arbitrary non-empty strings
- * (WI-9.6c — no hardcoded type allowlist; accept-any until Chunk 2).
+ * Inner field validation (invocation overrides, provider-key rejection) is
+ * delegated to {@link IndexPassConfigSchema}.
  */
 const IndexConfigRuntimeSchema = z.preprocess((raw, ctx) => {
     if (raw === undefined || raw === null)
@@ -93,7 +74,7 @@ const IndexConfigRuntimeSchema = z.preprocess((raw, ctx) => {
     if (Array.isArray(raw)) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            message: 'Invalid `index` config: expected an object keyed by pass name (e.g. `{ "enrichment": { "enabled": false } }`).',
+            message: 'Invalid `index` config: expected an object keyed by pass name (e.g. `{ "memory": { "enabled": false } }`).',
         });
         return raw;
     }
@@ -119,7 +100,6 @@ const IndexConfigRuntimeSchema = z.preprocess((raw, ctx) => {
 }, z
     .object({
     defaults: IndexDefaultsSchema.optional(),
-    metadataEnhance: MetadataEnhanceSchema.optional(),
 })
     .catchall(IndexPassConfigSchema));
 // The runtime catchall correctly validates arbitrary pass objects, but its

package/dist/core/file-change.js

@@ -4,13 +4,21 @@
 /**
  * The content of a proposal's PRIMARY change (WI-6.2 envelope read path).
  *
- * By construction `changes[0].after === payload.content`; consumers read
- * through this accessor so the single-content assumption lives in ONE place
- * once multi-file proposals (consolidate ops) ride the envelope. Typed
- * structurally (not against `Proposal`) so this module stays dependency-free.
+ * By construction `changes[0].after === payload.content` for a `create` or
+ * `update` change; consumers read through this accessor so the
+ * single-content assumption lives in ONE place. A `delete` primary change (a
+ * consolidate retire proposal, alpha.9) writes no content by definition, so
+ * it reads as `""` here rather than throwing — every generic proposal scan
+ * (dedup-by-body-hash, the triage drain's diff-size filter, the quality
+ * validators) can call this on ANY pending proposal, retire included,
+ * without special-casing the op first. Typed structurally (not against
+ * `Proposal`) so this module stays dependency-free.
  */
 export function proposalContent(p) {
-    const content = p.changes[0]?.after;
+    const primary = p.changes[0];
+    if (primary?.op === "delete")
+        return "";
+    const content = primary?.after;
     if (content === undefined)
         throw new Error("Proposal primary change has no content.");
     return content;

package/dist/core/improve-result.js

@@ -37,6 +37,9 @@ const COMMON_FIELDS = [
     "deadUrlCoverage",
     "reflectsWithErrorContext",
     "memoryInference",
+    // 0.9.17-alpha.9: no longer written (the LLM entity-graph extraction that
+    // wrote these was retired), kept readable for the same reason as
+    // `evalCasesWritten` above.
     "graphExtraction",
     "memoryInferenceDurationMs",
     "graphExtractionDurationMs",
@@ -119,7 +122,7 @@ function validateConsolidationPlan(value) {
     ]));
     if (!isRecord(value.configured))
         fail("plan.consolidation.configured must be an object");
-    requireExactFields(value.configured, new Set(["enabled", "minPoolSize", "limit", "maxChunkSize", "incrementalSince"]));
+    requireExactFields(value.configured, new Set(["enabled", "minPoolSize", "limit", "maxChunkSize"]));
     if (value.configured.enabled !== undefined && typeof value.configured.enabled !== "boolean") {
         fail("plan.consolidation.configured.enabled must be a boolean");
     }
@@ -128,9 +131,6 @@ function validateConsolidationPlan(value) {
             fail(`plan.consolidation.configured.${field} must be a number`);
         }
     }
-    if (value.configured.incrementalSince !== undefined && typeof value.configured.incrementalSince !== "string") {
-        fail("plan.consolidation.configured.incrementalSince must be a string");
-    }
     if (!isRecord(value.effective))
         fail("plan.consolidation.effective must be an object");
     requireExactFields(value.effective, new Set(["enabled", "minPoolSize", "limit", "chunkSize"]));
@@ -200,7 +200,15 @@ function validateProcessRoutingRows(value) {
             fail("plan.processes entries must be objects");
         requireExactFields(row, new Set(["process", "enabled", "engine", "model", "engineKind", "notices", "unavailable", "eligibleRefs"]));
         if (typeof row.process !== "string" ||
-            !(canonicalNames.includes(row.process) || row.process === "triage.judgment")) {
+            !(canonicalNames.includes(row.process) ||
+                row.process === "triage.judgment" ||
+                // 0.9.17-alpha.9: "graphExtraction" is no longer a process a fresh
+                // plan can route (the LLM entity-graph extraction it named was
+                // retired), but every pre-alpha.9 run recorded one here — kept
+                // readable, same as `stageNames`' "graph-extraction" above and
+                // `graphExtraction` in COMMON_FIELDS, so a historical run still
+                // decodes for `akm health` instead of failing this row outright.
+                row.process === "graphExtraction")) {
             fail("plan.processes.process is invalid");
         }
         if (seen.has(row.process))
@@ -389,6 +397,9 @@ function validateImprovePlan(value, dryRun, plannedRefNames) {
     if (value.proactive !== undefined)
         validateProactivePlan(value.proactive);
     validateConsolidationPlan(value.consolidation);
+    // "graph-extraction" is no longer a stage a fresh plan can name — retired
+    // 0.9.17-alpha.9 — but stays here so a historical envelope that captured a
+    // dry-run plan before the retirement still decodes.
     const stageNames = new Set(["consolidation", "extract", "graph-extraction", "memory-inference"]);
     if (!Array.isArray(value.stages))
         fail("plan.stages must be an array");

package/dist/core/improve-types.js

@@ -32,7 +32,6 @@ export function classifyImproveAction(mode) {
         case "reflect":
         case "distill":
         case "memory-inference":
-        case "graph-extraction":
             return "accepted";
         case "reflect-cooldown":
         case "reflect-skipped":

package/dist/core/loopback.js

@@ -20,10 +20,11 @@
  *
  * The ONE local-vs-remote answer for concurrency defaults — the workflow
  * engine's frozen engine concurrency (`workflows/concurrency-policy.ts`) and
- * the indexer's LLM pool (`indexer/indexer.ts` `getDefaultLlmConcurrency`)
- * both classify through here. NOT shared with the website snapshot fetcher's
- * SSRF policy (`sources/snapshot-fetchers/host-guard.ts`), which deliberately
- * draws different lines for a different threat model.
+ * the embedding pool (`resolveEmbeddingConcurrency`,
+ * `src/llm/embedders/remote.ts`) both classify through here. NOT shared with
+ * the website snapshot fetcher's SSRF policy
+ * (`sources/snapshot-fetchers/host-guard.ts`), which deliberately draws
+ * different lines for a different threat model.
  *
  * @module core/loopback
  */
@@ -92,14 +93,8 @@ export function isLoopbackEndpoint(endpoint) {
  * endpoint: 1 for a loopback endpoint (a local model server serves one
  * inference at a time; concurrent requests thrash it — reload thrash, HTTP
  * 500 "Model reloaded"), 2 for a remote one (enough to overlap request
- * latency without hammering a rate-limited API). A leaf helper so both
- * callers — the indexer's LLM enrichment pool (`getDefaultLlmConcurrency`,
- * `src/indexer/indexer.ts`) and the embedding pool
- * (`resolveEmbeddingConcurrency`, `src/llm/embedders/remote.ts`) — share one
- * definition instead of mirroring it; `src/llm/embedders/remote.ts` cannot
- * import `getDefaultLlmConcurrency` directly (`src/indexer/indexer.ts`
- * already depends on this module transitively through
- * materialize-embeddings.ts).
+ * latency without hammering a rate-limited API). Used by the embedding pool
+ * (`resolveEmbeddingConcurrency`, `src/llm/embedders/remote.ts`).
  */
 export function defaultConcurrencyForEndpoint(endpoint) {
     return isLoopbackEndpoint(endpoint) ? 1 : 2;

package/dist/core/parse.js

@@ -101,24 +101,24 @@ export function parseJsonResponse(raw) {
  * balanced `{ }` or `[ ]` structure in the text and attempts to parse that
  * substring. Returns `undefined` if no valid JSON structure is found.
  *
- * Shape preference is controlled by {@link ParseEmbeddedJsonOptions.expect}:
- * - `"any"` (default): non-array results are preferred — a `{…}` object found
- *   first is returned immediately; arrays (`[…]`) are a fallback.
- * - `"array"`: only top-level arrays are returned. The direct parse is
- *   accepted only if it is an array, and the scanner returns the first
- *   balanced `[…]` while skipping `{…}` openers entirely.
+ * Object-preferring: a `{…}` object found first is returned immediately;
+ * a top-level array (`[…]`) is only a fallback, returned if no object is
+ * found. Preserves the historical behaviour every current caller (all in
+ * `src/`) relies on.
+ *
+ * An array-preferring mode (`expect: "array"`, for callers that specifically
+ * expect a JSON array) existed here for batched LLM entity-graph extraction
+ * (#635) and was removed with it in 0.9.17-alpha.9 — every remaining caller
+ * calls this with no options, so it was dead weight, not a live choice.
  */
-export function parseEmbeddedJsonResponse(raw, options) {
-    const expectArray = options?.expect === "array";
+export function parseEmbeddedJsonResponse(raw) {
     const direct = parseJsonResponse(raw);
-    if (direct !== undefined && (!expectArray || Array.isArray(direct)))
+    if (direct !== undefined)
         return direct;
     const text = escapeJsonStringControls(stripCodeFences(stripThinkBlocks(raw)));
     let arrayFallback;
     // Scan only *top-level* balanced structures: once a `{…}`/`[…]` is matched we
     // jump `start` past its closing bracket rather than re-scanning its interior.
-    // This keeps array mode from salvaging an array *nested inside* a leading
-    // object (e.g. the `entities` array of a bare `{entities,relations}` object).
     for (let start = 0; start < text.length; start++) {
         const opener = text[start];
         if (opener !== "{" && opener !== "[")
@@ -161,13 +161,10 @@ export function parseEmbeddedJsonResponse(raw, options) {
         try {
             const parsed = JSON.parse(text.slice(start, end + 1));
             if (Array.isArray(parsed)) {
-                // First valid array wins in array mode; in "any" mode it is the
-                // fallback returned only if no object is found.
-                if (expectArray)
-                    return parsed;
+                // Fallback, returned only if no object is found.
                 arrayFallback ??= parsed;
             }
-            else if (!expectArray) {
+            else {
                 return parsed;
             }
             // Skip past this balanced structure so we don't descend into it.