peaks-loop 4.0.32 → 4.0.34

package/dist/services/recommendations/installed-capability-detector.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Read-only "is this capability already satisfied on this machine?"
+ * detector for the capability catalog (`peaks capability status` /
+ * `peaks capabilities --source ...`).
+ *
+ * Slice B1 of 2026-09-09-ecc-dynamic-and-cleanup: the previous
+ * `getInstalledCapabilityIds()` returned `[]` unconditionally, so the
+ * catalog could never report anything as installed. This module answers
+ * the question from evidence that already exists on disk — no install
+ * side effect, no network, no subprocess:
+ *
+ *   - `everything-claude-code.*` — satisfied when the ECC cache is
+ *     populated (`~/.peaks/cache/ecc-installed.json` + at least one
+ *     cached/materialized agent).
+ *   - a source that maps to an npm package — satisfied when that package
+ *     (or its `.bin` shim) is present in the project's `node_modules`.
+ *
+ * Every probe is fail-soft: a throw degrades to "not installed" so the
+ * catalog never breaks because a probe failed.
+ */
+export type InstalledCapabilityProbe = {
+    /** Project whose `node_modules` is probed. */
+    readonly projectRoot: string;
+    /** Override for tests; defaults to `<projectRoot>/node_modules`. */
+    readonly nodeModulesDir?: string;
+    /** Override for tests; defaults to a live ECC cache probe. */
+    readonly eccCacheAvailable?: boolean;
+};
+/**
+ * Return the capabilityIds whose acquisition is already satisfied.
+ * Sorted + de-duplicated so the JSON envelope is stable across runs.
+ */
+export declare function detectInstalledCapabilityIds(probe: InstalledCapabilityProbe): string[];

package/dist/services/recommendations/installed-capability-detector.js

@@ -0,0 +1,76 @@
+/**
+ * Read-only "is this capability already satisfied on this machine?"
+ * detector for the capability catalog (`peaks capability status` /
+ * `peaks capabilities --source ...`).
+ *
+ * Slice B1 of 2026-09-09-ecc-dynamic-and-cleanup: the previous
+ * `getInstalledCapabilityIds()` returned `[]` unconditionally, so the
+ * catalog could never report anything as installed. This module answers
+ * the question from evidence that already exists on disk — no install
+ * side effect, no network, no subprocess:
+ *
+ *   - `everything-claude-code.*` — satisfied when the ECC cache is
+ *     populated (`~/.peaks/cache/ecc-installed.json` + at least one
+ *     cached/materialized agent).
+ *   - a source that maps to an npm package — satisfied when that package
+ *     (or its `.bin` shim) is present in the project's `node_modules`.
+ *
+ * Every probe is fail-soft: a throw degrades to "not installed" so the
+ * catalog never breaks because a probe failed.
+ */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { hasMaterializedEccAgents, listCachedAgents } from 'peaks-loop-mut';
+import { seedCapabilityItems } from './capability-seed-items.js';
+const ECC_SOURCE_ID = 'everything-claude-code';
+/**
+ * `sourceId` → npm package whose presence in `node_modules` satisfies the
+ * item's acquisition. Deliberately explicit: the catalog mixes repos,
+ * skills packages, MCP servers, and docs, and only a small subset is
+ * actually an npm dependency we can probe. Adding an entry here is the
+ * only change needed to make that source's items detectable.
+ */
+const NPM_PACKAGE_BY_SOURCE = {
+    codegraph: 'codegraph'
+};
+function packagePresent(nodeModulesDir, packageName) {
+    try {
+        return (existsSync(join(nodeModulesDir, packageName)) ||
+            existsSync(join(nodeModulesDir, '.bin', packageName)));
+    }
+    catch {
+        return false;
+    }
+}
+function eccCacheAvailable() {
+    try {
+        // Cached agents imply the manifest + sha dir exist; the materialized
+        // plugin-free copy is checked independently so a hand-populated
+        // `~/.peaks/agents/ecc/` still counts as satisfied.
+        return listCachedAgents().length > 0 || hasMaterializedEccAgents();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Return the capabilityIds whose acquisition is already satisfied.
+ * Sorted + de-duplicated so the JSON envelope is stable across runs.
+ */
+export function detectInstalledCapabilityIds(probe) {
+    const nodeModulesDir = probe.nodeModulesDir ?? join(probe.projectRoot, 'node_modules');
+    const eccAvailable = probe.eccCacheAvailable ?? eccCacheAvailable();
+    const installed = new Set();
+    for (const item of seedCapabilityItems) {
+        if (item.sourceId === ECC_SOURCE_ID) {
+            if (eccAvailable)
+                installed.add(item.capabilityId);
+            continue;
+        }
+        const packageName = NPM_PACKAGE_BY_SOURCE[item.sourceId];
+        if (packageName !== undefined && packagePresent(nodeModulesDir, packageName)) {
+            installed.add(item.capabilityId);
+        }
+    }
+    return [...installed].sort();
+}

package/dist/services/scan/orphan-service.js

@@ -26,7 +26,7 @@ const PARENT_COMMANDS = new Set([
     'qa', 'sc', 'txt', 'code-review', 'rd', 'sh', 'config', 'audit', 'codegraph',
     'context', 'agent', 'capability', 'classify', 'gstack', 'gate',
     'hook', 'hooks', 'log', 'loop', 'memory', 'perf', 'playwright', 'preferences',
-    'project', 'retrospective', 'slice', 'statusline', 'understand', 'workflow',
+    'project', 'retrospective', 'slice', 'statusline', 'workflow',
     'migrate', 'mcp', 'doctor', 'help'
 ]);
 const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'coverage']);

package/dist/services/skills/presence-lease-service.d.ts

@@ -66,6 +66,27 @@ export interface GcPresenceLeasesInput {
     readonly trigger?: 'manual' | 'workspace-init' | 'presence-set';
 }
 export declare function setPresenceLease(input: SetPresenceLeaseInput): SetPresenceLeaseResult;
+/**
+ * Slice 2026-09-09-mode-consolidation (Slice B): stamp `mode` onto every
+ * in-flight lease of the bound session, in place.
+ *
+ * Used by the 24h auto-engage path (T3/T4, `peaks code run --24h`,
+ * `peaks session 24h-mode transition --state 24H_ACTIVE`) to record the
+ * autonomy level without re-creating the lease (a fresh `setPresenceLease`
+ * would reset `startedAt` / `status`). `lastHeartbeat` is intentionally
+ * NOT touched — stamping a mode is not a liveness signal.
+ *
+ * Returns the number of leases updated; 0 when there is nothing in flight.
+ * Callers are responsible for the "only `24h` may be auto-set" guard.
+ */
+export declare function stampPresenceLeaseMode(input: {
+    readonly projectRoot: string;
+    readonly sessionId: string;
+    readonly mode: string;
+}): {
+    updated: number;
+    leasePaths: string[];
+};
 export declare function readPresenceLease(input: ReadPresenceLeaseInput): PresenceProjection;
 export declare function markPresenceLost(input: MarkPresenceLostInput): SkillPresenceLease;
 export declare function gcStalePresenceLeases(input: GcPresenceLeasesInput): GcResult;

package/dist/services/skills/presence-lease-service.js

@@ -175,6 +175,32 @@ export function setPresenceLease(input) {
         gc,
     };
 }
+/**
+ * Slice 2026-09-09-mode-consolidation (Slice B): stamp `mode` onto every
+ * in-flight lease of the bound session, in place.
+ *
+ * Used by the 24h auto-engage path (T3/T4, `peaks code run --24h`,
+ * `peaks session 24h-mode transition --state 24H_ACTIVE`) to record the
+ * autonomy level without re-creating the lease (a fresh `setPresenceLease`
+ * would reset `startedAt` / `status`). `lastHeartbeat` is intentionally
+ * NOT touched — stamping a mode is not a liveness signal.
+ *
+ * Returns the number of leases updated; 0 when there is nothing in flight.
+ * Callers are responsible for the "only `24h` may be auto-set" guard.
+ */
+export function stampPresenceLeaseMode(input) {
+    const sessionId = validateSessionId(input.sessionId);
+    const leasePaths = [];
+    for (const lease of listPresenceLeases(input.projectRoot, sessionId)) {
+        if (lease.status !== 'preparing' && lease.status !== 'running')
+            continue;
+        const path = leaseFilePath(input.projectRoot, sessionId, lease.callerId, lease.workflowId);
+        const next = { ...lease, mode: input.mode };
+        writeAtomic(path, JSON.stringify(next, null, 2));
+        leasePaths.push(path);
+    }
+    return { updated: leasePaths.length, leasePaths };
+}
 export function readPresenceLease(input) {
     const sessionId = validateSessionId(input.sessionId ?? null);
     const callerId = validateCallerId(input.callerId);

package/dist/services/skills/skill-presence-service.d.ts

@@ -1,6 +1,15 @@
-export type SkillPresenceMode = 'full-auto' | 'assisted' | 'swarm' | 'strict';
+export type SkillPresenceMode = 'full-auto' | 'assisted' | 'strict' | '24h';
 export declare const VALID_SKILL_PRESENCE_MODES: ReadonlyArray<SkillPresenceMode>;
+export declare const LEGACY_SKILL_PRESENCE_MODE_ALIASES: Readonly<Record<string, SkillPresenceMode>>;
 export declare function isSkillPresenceMode(value: string): value is SkillPresenceMode;
+/**
+ * Normalize a raw on-disk / CLI mode token to a current
+ * `SkillPresenceMode`. Current values pass through; the legacy
+ * `'swarm'` alias maps to `'full-auto'`; anything else returns
+ * `undefined` so the caller can decide (drop the field, not the
+ * presence). Never throws.
+ */
+export declare function normalizeSkillPresenceMode(value: string | undefined | null): SkillPresenceMode | undefined;
 export type SkillPresence = {
     skill: string;
     mode?: SkillPresenceMode;

package/dist/services/skills/skill-presence-service.js

@@ -20,12 +20,33 @@ void null;
 export const VALID_SKILL_PRESENCE_MODES = [
     'full-auto',
     'assisted',
-    'swarm',
-    'strict'
+    'strict',
+    '24h'
 ];
+// Migration note (slice 2026-09-09-mode-consolidation): `swarm` was REMOVED
+// as a mode — parallel fan-out is now the default execution strategy in
+// every mode. A legacy on-disk `mode: 'swarm'` is normalized on read to
+// `'full-auto'` (never crash, never drop the presence).
+export const LEGACY_SKILL_PRESENCE_MODE_ALIASES = {
+    swarm: 'full-auto'
+};
 export function isSkillPresenceMode(value) {
     return VALID_SKILL_PRESENCE_MODES.includes(value);
 }
+/**
+ * Normalize a raw on-disk / CLI mode token to a current
+ * `SkillPresenceMode`. Current values pass through; the legacy
+ * `'swarm'` alias maps to `'full-auto'`; anything else returns
+ * `undefined` so the caller can decide (drop the field, not the
+ * presence). Never throws.
+ */
+export function normalizeSkillPresenceMode(value) {
+    if (typeof value !== 'string' || value.length === 0)
+        return undefined;
+    if (isSkillPresenceMode(value))
+        return value;
+    return LEGACY_SKILL_PRESENCE_MODE_ALIASES[value];
+}
 /**
  * The current outer session id, exposed to Bash tool calls via the
  * `PEAKS_OUTER_SESSION_ID` environment variable. Stamping it onto the
@@ -118,8 +139,15 @@ function readSkillPresenceFromLease(projectRootOverride) {
     // The lease carries `callerId` (the adapter / harness session id),
     // not the legacy `outerSessionId` field. Project it for back-compat
     // with `clearStalePresenceOnRotation`'s outer-mismatch check.
+    //
+    // Slice 2026-09-09-mode-consolidation: `mode` is projected too (it was
+    // silently dropped before, which made `getSkillPresence().mode` always
+    // undefined and left every `presence.mode` consumer dead). Normalize on
+    // read so a legacy `'swarm'` lease surfaces as `'full-auto'`.
+    const leaseMode = normalizeSkillPresenceMode(lease.mode);
     return {
         skill: lease.skill,
+        ...(leaseMode !== undefined ? { mode: leaseMode } : {}),
         sessionId,
         outerSessionId: lease.callerId,
         setAt: lease.startedAt,
@@ -208,7 +236,7 @@ function getPreviousOuterSessionId(projectRootOverride) {
  * `peakSessionId`, OR via `ensureSession` for the first-time case).
  */
 export function setSkillPresenceForCaller(projectRootOverride, callerId, peakSessionId, skill, mode, gate) {
-    const validatedMode = mode && isSkillPresenceMode(mode) ? mode : undefined;
+    const validatedMode = normalizeSkillPresenceMode(mode);
     const now = new Date().toISOString();
     const presence = {
         skill,
@@ -257,7 +285,7 @@ export function setSkillPresence(skill, mode, gate, projectRootOverride) {
     //      the old shape don't break) but we surface a warning to the
     //      CLI boundary via the `outerSessionMismatch` field.
     //   3. delegates the canonical write to `setPresenceLease`.
-    const validatedMode = mode && isSkillPresenceMode(mode) ? mode : undefined;
+    const validatedMode = normalizeSkillPresenceMode(mode);
     const sessionId = getCurrentSessionId(projectRootOverride);
     const outerSessionId = getCurrentOuterSessionId();
     const previousOuterSessionId = getPreviousOuterSessionId(projectRootOverride);

package/dist/services/skills/skill-statusline-service.js

@@ -30,6 +30,7 @@ import { readActiveDispatchIndex } from '../dispatch/dispatch-record-writer.js';
  * picks the most recent in-flight lease across all callers; this is the
  * documented back-compat path.
  */
+import { normalizeSkillPresenceMode } from './skill-presence-service.js';
 const STALE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
 /**
  * Slice rid-statusline-24h-overlay (2026-08-10): name-distinct from
@@ -245,12 +246,14 @@ function readPresenceReadOnly(projectRoot, callerId) {
     }
     // Leases on disk may carry an optional `mode` field (the lease constructor
     // spreads `input.mode` when present); the typed `SkillPresenceLease` does
-    // not declare it, so widen the read shape here.
-    const latestMode = latest.mode;
+    // not declare it, so widen the read shape here. Normalized on read: a
+    // legacy `'swarm'` lease renders as `'full-auto'` (slice
+    // 2026-09-09-mode-consolidation).
+    const latestMode = normalizeSkillPresenceMode(latest.mode);
     return {
         presence: {
             skill: latest.skill,
-            ...(typeof latestMode === 'string' && latestMode.length > 0 ? { mode: latestMode } : {}),
+            ...(latestMode !== undefined ? { mode: latestMode } : {}),
             setAt: latest.startedAt,
         },
         invalid: false,

package/dist/services/slice/multi-pass-orchestrator.js

@@ -65,7 +65,6 @@ export async function decompose(rid, prdMarkdown, projectRoot, opts = {}) {
     const wantFile = granularity === 'file' || granularity === 'both' || granularity === 'auto';
     const passes = [];
     let codegraph = zeroCodegraph();
-    let understandAnything = zeroUnderstand();
     let pass1WorkUnits = [];
     if (wantService) {
         const result1 = await decomposeSlices(rid, prdMarkdown, projectRoot, opts);
@@ -77,7 +76,6 @@ export async function decompose(rid, prdMarkdown, projectRoot, opts = {}) {
             internalEdges: v1EdgesToV2(result1.dependencyDAG.edges)
         });
         codegraph = result1.codegraph;
-        understandAnything = result1.understandAnything;
     }
     if (wantFile) {
         if (pass1WorkUnits.length > 0) {
@@ -115,7 +113,6 @@ export async function decompose(rid, prdMarkdown, projectRoot, opts = {}) {
                 internalEdges: v1EdgesToV2(result.dependencyDAG.edges)
             });
             codegraph = result.codegraph;
-            understandAnything = result.understandAnything;
         }
     }
     let crossPassEdges = [];
@@ -136,7 +133,6 @@ export async function decompose(rid, prdMarkdown, projectRoot, opts = {}) {
         crossPassEdges,
         llmArbitrations,
         codegraph,
-        understandAnything,
         partial: false
     };
 }
@@ -214,12 +210,3 @@ function zeroCodegraph() {
         note: 'no decomposition run'
     };
 }
-function zeroUnderstand() {
-    return {
-        kgNodes: 0,
-        kgEdges: 0,
-        available: false,
-        fallback: 'structural-only',
-        note: 'no decomposition run'
-    };
-}

package/dist/services/slice/slice-decompose-import-edges.d.ts

@@ -4,5 +4,5 @@
  * the 800 LOC cap (mechanical verbatim move). `buildDependencyEdges` is
  * the only exported entry point; the rest are internal helpers.
  */
-import type { DependencyEdge, ImportEdge, KnowledgeGraph, WorkUnit } from './slice-decompose-types.js';
-export declare function buildDependencyEdges(wus: readonly WorkUnit[], importEdges: readonly ImportEdge[], kg: KnowledgeGraph | null, projectRoot: string): DependencyEdge[];
+import type { DependencyEdge, ImportEdge, WorkUnit } from './slice-decompose-types.js';
+export declare function buildDependencyEdges(wus: readonly WorkUnit[], importEdges: readonly ImportEdge[], projectRoot: string): DependencyEdge[];

package/dist/services/slice/slice-decompose-import-edges.js

@@ -55,38 +55,10 @@ function collectImportEdges(importEdges, fileToWu, projectRoot, collector) {
         pushIfNew(collector, edge);
     }
 }
-function collectSemanticEdges(kg, fileToWu, collector) {
-    for (const e of kg.edges) {
-        if (e.type !== 'contains_flow' && e.type !== 'flow_step')
-            continue;
-        const fromNode = kg.nodes.find((n) => n.id === e.source);
-        const toNode = kg.nodes.find((n) => n.id === e.target);
-        if (!fromNode?.filePath || !toNode?.filePath)
-            continue;
-        const fromWu = fileToWu.get(fromNode.filePath);
-        const toWu = fileToWu.get(toNode.filePath);
-        if (!fromWu || !toWu || fromWu === toWu)
-            continue;
-        const weight = e.type === 'flow_step' ? 0.05 : 0.1;
-        const edge = {
-            from: fromWu,
-            to: toWu,
-            kind: e.type,
-            weight,
-            evidence: `understand-anything: ${e.type} ${e.source}->${e.target}`,
-            isSemantic: true,
-            confidence: 'semantic'
-        };
-        pushIfNew(collector, edge);
-    }
-}
-export function buildDependencyEdges(wus, importEdges, kg, projectRoot) {
+export function buildDependencyEdges(wus, importEdges, projectRoot) {
     const fileToWu = indexFilesToWorkUnits(wus);
     const collector = { edges: [], seen: new Set() };
     collectImportEdges(importEdges, fileToWu, projectRoot, collector);
-    if (kg !== null) {
-        collectSemanticEdges(kg, fileToWu, collector);
-    }
     return collector.edges;
 }
 function resolveRelativeImport(projectRoot, sourceFile, evidence) {

package/dist/services/slice/slice-decompose-runners.d.ts

@@ -7,17 +7,15 @@
  * does not inject fakes via `DecomposeOptions`. The 6-stage pure
  * algorithm itself lives in `slice-decompose-service.ts`.
  *
- * Public surface (3 exported factories):
+ * Public surface (2 exported factories):
  *
  *   defaultCodegraphRunner()  -- spawns `npx codegraph <cmd>`
- *   defaultUnderstandRunner() -- reads .understand-anything/knowledge-graph.json
  *   defaultImportEdgeRunner() -- reads source files for import statements
  *
  * v2.18.3 file-split: this module is the extracted sub-tree of the
  * pre-split `slice-decompose-service.ts`. Function signatures are
  * unchanged (verbatim move).
  */
-import type { CodegraphRunner, ImportEdgeRunner, UnderstandRunner } from './slice-decompose-types.js';
+import type { CodegraphRunner, ImportEdgeRunner } from './slice-decompose-types.js';
 export declare function defaultCodegraphRunner(): CodegraphRunner;
-export declare function defaultUnderstandRunner(): UnderstandRunner;
 export declare function defaultImportEdgeRunner(): ImportEdgeRunner;

package/dist/services/slice/slice-decompose-runners.js

@@ -7,10 +7,9 @@
  * does not inject fakes via `DecomposeOptions`. The 6-stage pure
  * algorithm itself lives in `slice-decompose-service.ts`.
  *
- * Public surface (3 exported factories):
+ * Public surface (2 exported factories):
  *
  *   defaultCodegraphRunner()  -- spawns `npx codegraph <cmd>`
- *   defaultUnderstandRunner() -- reads .understand-anything/knowledge-graph.json
  *   defaultImportEdgeRunner() -- reads source files for import statements
  *
  * v2.18.3 file-split: this module is the extracted sub-tree of the
@@ -121,27 +120,6 @@ function runCodegraph(args, projectRoot) {
         throw error;
     }
 }
-export function defaultUnderstandRunner() {
-    return {
-        async read(projectRoot) {
-            const kgPath = join(projectRoot, '.understand-anything', 'knowledge-graph.json');
-            if (!existsSync(kgPath))
-                return null;
-            try {
-                const raw = readFileSync(kgPath, 'utf8');
-                const parsed = JSON.parse(raw);
-                return {
-                    nodes: parsed.nodes ?? [],
-                    edges: parsed.edges ?? [],
-                    layers: parsed.layers ?? []
-                };
-            }
-            catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-                return null;
-            }
-        }
-    };
-}
 export function defaultImportEdgeRunner() {
     return {
         async importsOf(projectRoot, files) {

package/dist/services/slice/slice-decompose-service.d.ts

@@ -12,13 +12,12 @@
  * Default runners (CLI-mode, real shell-outs):
  *
  *   defaultCodegraphRunner()  -- spawns `npx codegraph <cmd>`
- *   defaultUnderstandRunner() -- reads .understand-anything/knowledge-graph.json
  *   defaultImportEdgeRunner() -- reads source files for import statements
  *
- * Tests inject fakes via the `codegraphRunner`, `understandRunner`, and
- * `importEdgeRunner` fields of `DecomposeOptions`.
+ * Tests inject fakes via the `codegraphRunner` and `importEdgeRunner`
+ * fields of `DecomposeOptions`.
  */
 import type { DecomposeOptions, DecompositionResult } from './slice-decompose-types.js';
 export type { DecomposeOptions };
 export declare function decomposeSlices(rid: string, prdMarkdown: string, projectRoot: string, options?: DecomposeOptions): Promise<DecompositionResult>;
-export { defaultCodegraphRunner, defaultUnderstandRunner, defaultImportEdgeRunner } from './slice-decompose-runners.js';
+export { defaultCodegraphRunner, defaultImportEdgeRunner } from './slice-decompose-runners.js';

package/dist/services/slice/slice-decompose-service.js

@@ -12,11 +12,10 @@
  * Default runners (CLI-mode, real shell-outs):
  *
  *   defaultCodegraphRunner()  -- spawns `npx codegraph <cmd>`
- *   defaultUnderstandRunner() -- reads .understand-anything/knowledge-graph.json
  *   defaultImportEdgeRunner() -- reads source files for import statements
  *
- * Tests inject fakes via the `codegraphRunner`, `understandRunner`, and
- * `importEdgeRunner` fields of `DecomposeOptions`.
+ * Tests inject fakes via the `codegraphRunner` and `importEdgeRunner`
+ * fields of `DecomposeOptions`.
  */
 import { basename } from 'node:path';
 import { calibrate } from './calibration-store.js';
@@ -48,8 +47,6 @@ function createInitialState(rid, prdMarkdown, projectRoot, runners) {
         cgStatus: null,
         workUnits: [],
         depEdges: [],
-        kg: null,
-        understandAvailable: false,
         codegraphAffectedCrossFile: false,
         scc: null,
         criticalPath: null,
@@ -84,7 +81,6 @@ async function runStage(state, stage) {
 function resolveRunners(options) {
     return {
         cg: options.codegraphRunner ?? defaultCodegraphRunner(),
-        ur: options.understandRunner ?? defaultUnderstandRunner(),
         ier: options.importEdgeRunner ?? defaultImportEdgeRunner()
     };
 }
@@ -172,15 +168,13 @@ function matchAcToHit(ac, hits) {
 // Stage 2: dependency DAG
 // =====================================================================
 async function buildDepDagStage(state) {
-    const kg = await state.runners.ur.read(state.projectRoot);
-    const understandAvailable = kg !== null;
     const fileSet = await collectFileSet(state.workUnits, state.runners.ier, state.projectRoot);
     const allFiles = Array.from(fileSet);
     const codegraphAffectedCrossFile = await probeCrossFileAffected(allFiles, state.runners.cg, state.projectRoot);
     const workUnits = applyImplicitWuFallback(state.workUnits, allFiles);
     const importEdges = await state.runners.ier.importsOf(state.projectRoot, allFiles);
-    const depEdges = buildDependencyEdges(workUnits, importEdges, kg, state.projectRoot);
-    return { ...state, kg, understandAvailable, codegraphAffectedCrossFile, workUnits, depEdges };
+    const depEdges = buildDependencyEdges(workUnits, importEdges, state.projectRoot);
+    return { ...state, codegraphAffectedCrossFile, workUnits, depEdges };
 }
 async function collectFileSet(workUnits, ier, projectRoot) {
     const explicitFiles = workUnits.flatMap((w) => w.files);
@@ -362,10 +356,10 @@ function backtrackPath(endNode, prev) {
 function minCutStage(state) {
     if (state.criticalPath === null)
         return state;
-    const minCut = findMinCut(state.workUnits, state.depEdges, state.criticalPath, state.kg);
+    const minCut = findMinCut(state.workUnits, state.depEdges, state.criticalPath);
     return { ...state, minCut };
 }
-function findMinCut(_wus, edges, criticalPath, _kg) {
+function findMinCut(_wus, edges, criticalPath) {
     const cpSet = new Set(criticalPath.nodes);
     const nonCpEdges = edges.filter((e) => !cpSet.has(e.from) || !cpSet.has(e.to));
     const sorted = [...nonCpEdges].sort((a, b) => a.weight - b.weight);
@@ -405,7 +399,7 @@ function partitionEstimateEmitStage(state) {
         ...b,
         slices: b.slices.map((s) => ({
             ...s,
-            estimate: estimateSlice(s, state.kg)
+            estimate: estimateSlice(s)
         }))
     }));
     const result = buildDecompositionResult(state, batchesWithEstimates);
@@ -416,12 +410,10 @@ function buildDecompositionResult(state, batchesWithEstimates) {
     const totalSlices = batchesWithEstimates.reduce((sum, b) => sum + b.slices.length, 0);
     const pickHint = buildPickHint(totalSlices);
     const codegraphEnvelope = buildCodegraphEnvelope(state);
-    const understandEnvelope = buildUnderstandEnvelope(state);
     return {
         rid: state.rid,
         generatedAt: new Date().toISOString(),
         codegraph: codegraphEnvelope,
-        understandAnything: understandEnvelope,
         workUnits: state.workUnits,
         dependencyDAG: { edges: state.depEdges },
         sccAnalysis: state.scc,
@@ -460,18 +452,7 @@ function buildCodegraphEnvelope(state) {
             : 'codegraph.affected returned 0 cross-file dependents (v0.7.10 limitation); used real import edges'
     };
 }
-function buildUnderstandEnvelope(state) {
-    return {
-        kgNodes: state.kg?.nodes.length ?? 0,
-        kgEdges: state.kg?.edges.length ?? 0,
-        available: state.understandAvailable,
-        fallback: state.understandAvailable ? 'semantic' : 'structural-only',
-        note: state.understandAvailable
-            ? 'read from .understand-anything/knowledge-graph.json'
-            : '.understand-anything/knowledge-graph.json not found; algorithm falls back to structural cuts'
-    };
-}
-function estimateSlice(slice, _kg) {
+function estimateSlice(slice) {
     const sampleSize = 0;
     const complexitySum = 0;
     return calibrate(complexitySum, slice.estimate.testCount, slice.estimate.locSum, sampleSize);
@@ -569,5 +550,5 @@ function wuToSlice(wu) {
 // `slice-decompose-runners.ts` module — see v2.18.3 file-split for
 // the rationale. Function signatures and behaviour are unchanged
 // (verbatim move).
-import { defaultCodegraphRunner, defaultUnderstandRunner, defaultImportEdgeRunner } from './slice-decompose-runners.js';
-export { defaultCodegraphRunner, defaultUnderstandRunner, defaultImportEdgeRunner } from './slice-decompose-runners.js';
+import { defaultCodegraphRunner, defaultImportEdgeRunner } from './slice-decompose-runners.js';
+export { defaultCodegraphRunner, defaultImportEdgeRunner } from './slice-decompose-runners.js';