akm-cli 0.9.17-alpha.2 → 0.9.17-alpha.4

package/dist/commands/improve/memory/memory-contradiction-detect.js

@@ -1,291 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * LLM-based contradiction-detection pass for derived memories (M-1 / #367).
- *
- * Runs BEFORE `analyzeMemoryCleanup` to populate `contradictedBy` frontmatter
- * edges so the existing `resolveFamilyContradictions` SCC resolver has real
- * input to work on. Without this pass the SCC resolver operates on a nearly
- * empty edge graph because no automated subsystem was previously generating
- * contradiction edges — the elegant Tarjan implementation in memory-improve.ts
- * had no input.
- *
- * # Algorithm
- *
- *   1. Collect all derived memories grouped by `parentRef` family.
- *   2. For each family, enumerate candidate pairs.
- *   3. For each pair, call the LLM to judge whether the two memories are in
- *      direct factual conflict.
- *   4. For confirmed contradictions, append a `contradictedBy` edge to the
- *      losing memory's frontmatter via `writeContradictEdge`
- *      (`./memory-belief.ts`).
- *
- * That last step used to call a private near-copy of `writeContradictEdge`
- * living in this file. The copy had drifted (#885): it read `contradictedBy`
- * with `Array.isArray` only, so a SCALAR edge — live data the indexer accepts
- * and lint never flags — read as "no edges" and was overwritten out of
- * existence; and it set `beliefState: "contradicted"` unconditionally,
- * promoting an `archived` memory back up (archived ranks BELOW contradicted).
- * Both behaviors had tests, but the tests exercised the shared primitive,
- * which nothing called — so they guarded dead code while the live path
- * carried the bugs.
- *
- * # LLM Feature Gate
- *
- * The pass is gated by the selected strategy's consolidate contradiction setting.
- * When the gate is disabled or no LLM is configured,
- * the pass is a no-op and `analyzeMemoryCleanup` proceeds with only manually
- * annotated edges.
- *
- * # References
- *
- * - Zep / Graphiti (arXiv:2501.13956): writes contradiction edges at detection time.
- * - ATMS (de Kleer 1986): assumption-based truth maintenance via edge propagation.
- * - mem0 contradiction probe (arXiv:2504.19413): pairwise LLM-judge pattern.
- */
-import fs from "node:fs";
-import path from "node:path";
-import contradictionJudgeTemplate from "../../../assets/prompts/contradiction-judge.md" with { type: "text" };
-import { parseFrontmatter } from "../../../core/asset/frontmatter.js";
-import { parseEmbeddedJsonResponse } from "../../../core/parse.js";
-import { disposeLoweredExecutionDispatchLease } from "../../../integrations/agent/execution-lowering.js";
-import { callStructured, preflightStructuredLlmRunner } from "../../../llm/structured-call.js";
-import { resolveImproveLlmExecution } from "../execution.js";
-import { isDerivedMemory, memoryIdentityRef, resolveParentRef } from "./derived-ref.js";
-import { writeContradictEdge } from "./memory-belief.js";
-// ── Constants ────────────────────────────────────────────────────────────────
-/**
- * Minimum confidence required to write a contradiction edge. Below this
- * threshold the LLM may be flagging topic-overlap rather than genuine logical
- * exclusivity (investigation 2026-06-18).
- */
-const CONTRADICT_CONFIDENCE_THRESHOLD = 0.92;
-/**
- * Truncation limit for memory body content sent to the LLM judge.
- * Keeps prompts compact while preserving the key factual claims.
- */
-const BODY_TRUNCATION = 800;
-// ── Prompt builder ────────────────────────────────────────────────────────────
-function buildContradictionJudgePrompt(a, b) {
-    return contradictionJudgeTemplate
-        .replace("{{A_REF}}", a.ref)
-        .replace("{{A_DESCRIPTION}}", a.description || "(none)")
-        .replace("{{A_BODY}}", a.body.slice(0, BODY_TRUNCATION))
-        .replace("{{B_REF}}", b.ref)
-        .replace("{{B_DESCRIPTION}}", b.description || "(none)")
-        .replace("{{B_BODY}}", b.body.slice(0, BODY_TRUNCATION));
-}
-// ── Filesystem helpers ────────────────────────────────────────────────────────
-function* walkMarkdownFilesLocal(root) {
-    if (!fs.existsSync(root))
-        return;
-    for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
-        const full = path.join(root, entry.name);
-        if (entry.isDirectory())
-            yield* walkMarkdownFilesLocal(full);
-        else if (entry.isFile() && entry.name.endsWith(".md"))
-            yield full;
-    }
-}
-// Build the derived memory's own belief-edge IDENTITY ref from its file path.
-// Emits through the shared {@link memoryIdentityRef} so this — the former THIRD
-// hand-rolled copy of the identity-channel spelling — no longer diverges from
-// memory-improve's `refArray` (ref-grammar decision D-R3 identity-channel
-// exception, documented at `memoryIdentityRef`).
-function toMemoryRef(memoriesDir, filePath) {
-    const rel = path.relative(memoriesDir, filePath);
-    if (!rel || rel.startsWith(".."))
-        return undefined;
-    const name = rel.replace(/\\/g, "/").replace(/\.md$/i, "");
-    return memoryIdentityRef(name);
-}
-// ── Edge writing ─────────────────────────────────────────────────────────────
-/**
- * Deterministically pick, for a confirmed-contradiction pair, the LOSER memory
- * that receives the single directed `contradictedBy` edge (SCC-resolved to
- * `contradicted`) and the WINNER ref that survives as the current belief.
- *
- * A SINGLE directed edge is essential. Writing mutual A↔B edges forms a 2-cycle
- * that {@link resolveFamilyContradictions} collapses into one strongly-connected
- * SINK component and refreshes BOTH members back to active — erasing the
- * contradiction on every run (the self-erasing bug this fix removes).
- *
- * Direction = lexicographic ref order: the ref that sorts LATER is the loser.
- * This is a **total order** over the family's (distinct) refs, so the induced
- * edges are always acyclic — a family of any size resolves to a DAG with a
- * single sink, never a cycle that the resolver would refresh back to active.
- * It is also immutable across runs (unlike file mtime, which the resolver
- * bumps when it rewrites loser files), so detection is idempotent. Ref order
- * carries no recency meaning — no derived-memory writer sets a `createdAt`/
- * timestamp today — but the mechanism only needs a stable, acyclic direction;
- * eliminating worst-case self-erasure, not ranking by recency, is the goal.
- */
-function pickContradictionLoser(a, b) {
-    return a.ref < b.ref ? { loser: b, winnerRef: a.ref } : { loser: a, winnerRef: b.ref };
-}
-// ── Main entry point ──────────────────────────────────────────────────────────
-/**
- * Run the LLM-based contradiction-detection pass on derived memories in
- * `<stashDir>/memories/`. Writes `contradictedBy` frontmatter edges for
- * confirmed contradiction pairs so the subsequent `resolveFamilyContradictions`
- * SCC pass has edges to work on.
- *
- * @param stashDir - Root stash directory.
- * @param config   - Loaded AKM config (used to access LLM settings).
- * @param chat     - Optional test-only chat seam.
- */
-export async function detectAndWriteContradictions(stashDir, config, chat, strategy, resolvedRunner) {
-    const result = {
-        familiesExamined: 0,
-        pairsChecked: 0,
-        edgesWritten: 0,
-        warnings: [],
-    };
-    if (!(strategy?.processes?.consolidate?.contradictionDetection?.enabled ?? false))
-        return result;
-    const noticesByKey = new Map();
-    const resolvedExecution = resolvedRunner === undefined
-        ? resolveImproveLlmExecution({
-            config,
-            profile: strategy,
-            process: strategy?.processes?.consolidate,
-            processName: "memory-contradiction-detection",
-        })
-        : null;
-    for (const notice of resolvedExecution?.notices ?? [])
-        noticesByKey.set(JSON.stringify(notice), notice);
-    const contradictionRunner = resolvedRunner === null ? undefined : (resolvedRunner ?? resolvedExecution?.runner);
-    if (!contradictionRunner)
-        return result;
-    // Collect derived memories grouped by parent.
-    const memoriesDir = path.join(stashDir, "memories");
-    const byParent = new Map();
-    for (const filePath of walkMarkdownFilesLocal(memoriesDir)) {
-        let raw;
-        try {
-            raw = fs.readFileSync(filePath, "utf8");
-        }
-        catch {
-            continue;
-        }
-        const parsed = parseFrontmatter(raw);
-        const ref = toMemoryRef(memoriesDir, filePath);
-        if (!ref)
-            continue;
-        // Key the shared derived-ref helpers on the memory NAME (stash-relative, no
-        // extension) — the same key the consumer uses — so producer and consumer
-        // resolve the identical parent (R12). This intentionally widens the producer
-        // to honour `derivedFrom` and normalised `source:` values it previously
-        // dropped (pinned by derived-ref.test.ts).
-        const name = ref.slice("memory:".length);
-        if (!isDerivedMemory(name, parsed.data))
-            continue;
-        const parentRef = resolveParentRef(name, parsed.data);
-        if (!parentRef)
-            continue;
-        const entry = {
-            filePath,
-            ref,
-            parentRef,
-            body: parsed.content.trim(),
-            description: typeof parsed.data.description === "string" ? parsed.data.description : "",
-        };
-        const family = byParent.get(parentRef) ?? [];
-        family.push(entry);
-        byParent.set(parentRef, family);
-    }
-    const candidatePairs = [];
-    for (const [, family] of byParent) {
-        if (family.length < 2)
-            continue;
-        result.familiesExamined++;
-        for (let i = 0; i < family.length - 1; i++) {
-            for (let j = i + 1; j < family.length; j++) {
-                const a = family[i];
-                const b = family[j];
-                if (!a || !b)
-                    continue;
-                // Resolve the directed edge up front (independent of the judge — it is
-                // decided by lexicographic ref order). Skip when that single loser→winner
-                // edge already exists (no new information; avoids re-judging resolved
-                // pairs across runs).
-                //
-                const aParsed = parseFrontmatter(fs.readFileSync(a.filePath, "utf8"));
-                const bParsed = parseFrontmatter(fs.readFileSync(b.filePath, "utf8"));
-                const { loser, winnerRef } = pickContradictionLoser(a, b);
-                const loserData = loser === a ? aParsed.data : bParsed.data;
-                const loserCB = Array.isArray(loserData.contradictedBy) ? loserData.contradictedBy : [];
-                if (loserCB.includes(winnerRef))
-                    continue;
-                candidatePairs.push({ a, b, loser, winnerRef });
-            }
-        }
-    }
-    if (candidatePairs.length === 0) {
-        const notices = Object.freeze([...noticesByKey.values()]);
-        return notices.length > 0 ? { ...result, notices } : result;
-    }
-    const dispatchLease = await preflightStructuredLlmRunner(contradictionRunner);
-    try {
-        for (const { a, b, loser, winnerRef } of candidatePairs) {
-            const prompt = buildContradictionJudgePrompt(a, b);
-            const judgeResult = await callStructured({
-                feature: "memory_contradiction_detection",
-                akmConfig: config,
-                // Resolver-less key: the strategy decision IS the gate (default-off).
-                enabled: true,
-                runner: contradictionRunner,
-                lease: dispatchLease,
-                messages: [
-                    { role: "system", content: "Return only valid JSON. No prose." },
-                    { role: "user", content: prompt },
-                ],
-                ...(chat ? { request: { chat } } : {}),
-                onNotices: (notices) => {
-                    for (const notice of notices)
-                        noticesByKey.set(JSON.stringify(notice), notice);
-                },
-                parse: (raw) => raw ?? null,
-                // A transport throw used to escape the gated fn into the gate's
-                // catch and take the null fallback ("skip"); onError reproduces it.
-                onError: () => null,
-                fallback: null, // null means "skip" — gate disabled or LLM call failed.
-            });
-            result.pairsChecked++;
-            if (!judgeResult)
-                continue; // Feature gate disabled or LLM call failed.
-            let parsed = null;
-            try {
-                parsed = parseEmbeddedJsonResponse(judgeResult);
-            }
-            catch {
-                result.warnings.push(`Could not parse contradiction judge response for pair ${a.ref} / ${b.ref}`);
-                continue;
-            }
-            if (!parsed?.contradicts)
-                continue;
-            const confidence = typeof parsed.confidence === "number" ? parsed.confidence : 0;
-            if (confidence < CONTRADICT_CONFIDENCE_THRESHOLD) {
-                result.warnings.push(`Pair ${a.ref} / ${b.ref}: confidence ${confidence.toFixed(2)} below ${CONTRADICT_CONFIDENCE_THRESHOLD} threshold — skipped.`);
-                continue;
-            }
-            // Write a SINGLE directed contradiction edge: the losing (older) memory
-            // gets `contradictedBy` pointing to the winner. A mutual A↔B pair forms
-            // a 2-cycle that the SCC resolver refreshes back to active, erasing the
-            // contradiction every run (see pickContradictionLoser).
-            try {
-                const wrote = writeContradictEdge(loser.filePath, winnerRef);
-                result.edgesWritten += wrote ? 1 : 0;
-            }
-            catch (err) {
-                result.warnings.push(`Failed to write contradiction edge ${loser.ref} -> ${winnerRef}: ${err instanceof Error ? err.message : String(err)}`);
-            }
-        }
-    }
-    finally {
-        disposeLoweredExecutionDispatchLease(dispatchLease);
-    }
-    const notices = Object.freeze([...noticesByKey.values()]);
-    return notices.length > 0 ? { ...result, notices } : result;
-}

package/dist/commands/improve/proposal-envelope.js

@@ -1,31 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * `emitProposal` — the proposal-envelope facade (D10 / R7).
- *
- * Every improve verb that raises a proposal (revise = reflect, learn =
- * distill/promote/extract, consolidate = the merge/promote ops) routes it
- * through this single seam instead of calling {@link createProposal} directly.
- *
- * Since WI-6.2 the envelope carries `changes: FileChange[]` + `beforeHash`:
- * `createProposal` derives a single-entry change set (whose `after` IS
- * `payload.content`) and the mint-time before-state hash for every proposal
- * emitted through this seam — producers stay payload-shaped and get the
- * envelope for free. The facade remains a pass-through: it does NOT synthesise
- * `sourceRun` or mutate the input — each emit site owns its own
- * `source`/`sourceRun`/attribution.
- *
- * Pinned by `tests/commands/improve/proposal-envelope.test.ts`.
- */
-import { createProposal, } from "../proposal/repository.js";
-/**
- * Emit a proposal through the single improve envelope seam. Equivalent to
- * `createProposal(ctx.stashDir, input, ctx.proposalsCtx)`; returns either the
- * persisted {@link import("../proposal/repository.js").Proposal} or a
- * {@link import("../proposal/repository.js").CreateProposalSkipped} record when a
- * dedup/cooldown guard fires (detect with `isProposalSkipped`).
- */
-export function emitProposal(ctx, input) {
-    return createProposal(ctx.stashDir, input, ctx.proposalsCtx);
-}

package/dist/commands/improve/run-context.js

@@ -1,123 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * `RunContext` — the shared, run-scoped carrier for the three improve verbs
- * (revise = reflect, learn = extract/distill/inference, consolidate = the
- * memory-tier ops; D17). WI-7.5–7.8 decompose the improve god-functions into
- * named passes that thread a `RunContext` instead of long positional argument
- * lists.
- *
- * ## The D6 read-once seam
- *
- * `readAsset` is a memoizing file-read seam whose memo is **NEVER run-wide**
- * (D6 / top-risk #7: a run-wide memo would serve prep-time bytes after a mid-run
- * write). The guarantee is structural here, not merely conventional:
- *
- *   - The **base** context returned by {@link createRunContext} has NO active
- *     memo. `readAsset` on it always reads through to disk, so it can never go
- *     stale — the safe default.
- *   - {@link RunContext.withFreshAssetMemo} mints a sibling context that shares
- *     every run-scoped carrier but owns a FRESH, empty memo. Memoization is
- *     therefore opt-in per scope:
- *       * prep's stage-body passes share ONE memo, forked only AFTER the
- *         mutating pre-loop passes have written their ops to disk, then
- *         discarded at stage end;
- *       * reflect and distill each fork their own memo per verb invocation, so
- *         their reads still happen at invoke time (not prep time).
- *   - Within a memo scope, {@link RunContext.writeAsset} writes through to disk
- *     AND refreshes the memo, and {@link RunContext.noteAssetWrite} drops a memo
- *     entry for a path written out-of-band, so a subsequent `readAsset` of the
- *     same path returns POST-write bytes (e.g. the distill in-loop salience
- *     stamp at `distill.ts:816`).
- *
- * The contract is pinned by `tests/commands/improve/run-context.test.ts`.
- *
- * This module deliberately mints only the carrier + seam. Adoption at the verb
- * call sites lands in WI-7.5 (reflect/distill), WI-7.6 (preparation), and
- * WI-7.7 (akmImprove/extract). It does NOT change `EventsContext` shape and does
- * NOT thread a db handle into `ProposalsContext` (D14).
- */
-import fs from "node:fs";
-import path from "node:path";
-import { resolveStashDir } from "../../core/common.js";
-import { recordWrittenPath } from "../../core/write-provenance.js";
-/**
- * Build a `RunContext` over the given carriers with the supplied memo (or `null`
- * for the non-memoizing base context). Kept private so the only way to obtain a
- * memoizing context is {@link RunContext.withFreshAssetMemo}.
- */
-function buildRunContext(carriers, memo) {
-    const memoKey = (filePath) => path.resolve(filePath);
-    return {
-        stashDir: carriers.stashDir,
-        config: carriers.config,
-        eventsCtx: carriers.eventsCtx,
-        proposalsCtx: carriers.proposalsCtx,
-        chat: carriers.chat,
-        getLlmRunner: carriers.getLlmRunner,
-        sourceRun: carriers.sourceRun,
-        dryRun: carriers.dryRun,
-        signal: carriers.signal,
-        now: carriers.now,
-        readAsset(filePath) {
-            if (!memo)
-                return carriers.readFile(filePath);
-            const key = memoKey(filePath);
-            const cached = memo.get(key);
-            if (cached !== undefined)
-                return cached;
-            const bytes = carriers.readFile(filePath);
-            memo.set(key, bytes);
-            return bytes;
-        },
-        writeAsset(filePath, content) {
-            carriers.writeFile(filePath, content);
-            // #652: journal the write for the run's write-provenance set. Recorded
-            // here (not in the default `writeFile` carrier) so an injected IO seam is
-            // attributed identically to a real `fs` write.
-            recordWrittenPath(filePath);
-            memo?.set(memoKey(filePath), content);
-        },
-        noteAssetWrite(filePath) {
-            memo?.delete(memoKey(filePath));
-        },
-        withFreshAssetMemo() {
-            return buildRunContext(carriers, new Map());
-        },
-    };
-}
-/**
- * Create the base `RunContext` for an improve run. Its `readAsset` is
- * non-memoizing (always fresh); call {@link RunContext.withFreshAssetMemo} to
- * enter a memoized pass/invocation scope.
- */
-export function createRunContext(init) {
-    const carriers = {
-        stashDir: init.stashDir,
-        config: init.config,
-        eventsCtx: init.eventsCtx,
-        proposalsCtx: init.proposalsCtx,
-        chat: init.chat,
-        getLlmRunner: init.getLlmRunner ?? (() => null),
-        sourceRun: init.sourceRun,
-        dryRun: init.dryRun,
-        signal: init.signal,
-        now: init.now ?? Date.now,
-        readFile: init.io?.readFile ?? ((filePath) => fs.readFileSync(filePath, "utf8")),
-        writeFile: init.io?.writeFile ?? ((filePath, content) => fs.writeFileSync(filePath, content, "utf8")),
-    };
-    return buildRunContext(carriers, null);
-}
-/**
- * Resolve the run's stash directory at the improve builder boundary: the
- * explicit `options.stashDir` when the caller passed one, else the ambient
- * resolveStashDir() fallback. WI-9.10d: this is the SINGLE resolveStashDir
- * call site on the improve path — the verb entries call THIS instead of
- * resolveStashDir directly, so the ambient read lives only in the builder
- * module. (The CLI-wide resolveStashDir sweep for non-improve commands is a
- * deferred follow-on — see the chunk-9 ledger WI-9.10d entry.)
- */
-export function resolveRunStashDir(explicitStashDir) {
-    return explicitStashDir ?? resolveStashDir();
-}

package/dist/commands/improve/shared.js

@@ -1,21 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * Small pure helpers shared across the improve command family. Extracted to
- * delete byte-identical duplication that previously lived inline in the
- * per-process passes (the whole-corpus synthesis pass removed in 0.9.0 and
- * the procedural-compilation pass removed in 0.9.0). Keep this file free of
- * I/O and of any improve-specific state — these are leaf utilities.
- */
-/**
- * Cap on how many prior rejected proposals for a ref are injected as
- * Reflexion-style verbal-RL context so the LLM avoids regenerating refusals.
- * Shared by both the revise (reflect) and learn (distill) verbs, which
- * previously declared this constant independently.
- */
-export const MAX_REJECTED_PROPOSALS = 3;
-/** Normalize an unknown thrown value to a human-readable message string. */
-export function errMessage(e) {
-    return e instanceof Error ? e.message : String(e);
-}

package/dist/commands/improve/source-identity.js

@@ -1,28 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-// ── Durable improve-state keys ───────────────────────────────────────────────
-//
-// Every improve ref uses the current grammar (a short conceptId), and the durable
-// state key is the resolved index entry's `item_ref` when the planner supplied
-// one, else the conceptId `ref` itself (`preparation.ts`
-// `salienceWriteKey`/`outcomeWriteKey` = `itemRef ?? ref`).
-/**
- * The durable improve-state key for a ref with no resolved `item_ref` — the
- * conceptId `ref` itself.
- */
-export function durableImproveRef(ref) {
-    return ref;
-}
-/** Return the conceptId portion of a durable improve-state key. */
-export function bareImproveRef(ref) {
-    const boundary = ref.indexOf("//");
-    return boundary >= 0 ? ref.slice(boundary + 2) : ref;
-}
-/**
- * The single durable improve-state key used by both readers and writers.
- * Indexed entries use item_ref; direct or provenance-free refs use conceptId.
- */
-export function improveStateReadRefs(ref, itemRef) {
-    return [itemRef ?? ref];
-}

package/dist/commands/improve/triage.js

@@ -1,96 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * Default minimum total score a session must reach to PASS the gate. Tuned
- * conservatively: a single real narrative-lesson session, or a procedurally
- * dense session, clears it — but pure read-only Q&A does not. Config-overridable
- * via `processes.extract.triage.minScore`.
- */
-export const DEFAULT_TRIAGE_MIN_SCORE = 2;
-// Decision / outcome / error narrative markers. Case-insensitive, word-bounded.
-const MARKER_RE = /\b(error|failed|fix(?:ed)?|root cause|turns out|because|decided|instead|gotcha|workaround|regress(?:ed)?|broke|TIL)\b/i;
-// Edit / commit / file-write markers in tool event text.
-const EDIT_COMMIT_RE = /\b(Edit|Write|MultiEdit|git commit|diff)\b/i;
-// A substantive turn is an assistant or tool turn whose text is non-trivial.
-const SUBSTANTIVE_MIN_CHARS = 40;
-/**
- * Pure heuristic scorer. Operates only on `data.events`. Each sub-signal is
- * normalized to a small bounded contribution; `score` is their sum and
- * `pass = score >= minScore`.
- *
- * Sub-signals:
- *   - markers: presence of decision/outcome/error keywords across event text
- *     (capped, narrative-lesson signal).
- *   - toolDensity: bounded contribution from tool-use events.
- *   - editCommit: bounded contribution from edit/write/commit events.
- *   - substantiveRatio: scaled fraction of non-trivial assistant+tool turns,
- *     filtering pure short Q&A.
- *
- * toolDensity + editCommit alone can clear DEFAULT_TRIAGE_MIN_SCORE so
- * high-action / no-narrative sessions are KEPT.
- */
-export function scoreSessionTriage(data, minScore) {
-    const events = data.events;
-    const total = events.length;
-    // (a) markers — count word-bounded marker hits across all event text, capped.
-    let markerHits = 0;
-    for (const e of events) {
-        if (MARKER_RE.test(e.text))
-            markerHits += 1;
-    }
-    // Each marker-bearing event contributes 1 point, capped at 2 (a single real
-    // narrative session clears the bar on markers alone).
-    const markers = Math.min(markerHits, 2);
-    // (b) toolDensity — bounded contribution from tool-use events.
-    let toolEvents = 0;
-    for (const e of events) {
-        if (e.role === "tool")
-            toolEvents += 1;
-    }
-    // 0.25 per tool event, capped at 1.5.
-    const toolDensity = Math.min(toolEvents * 0.25, 1.5);
-    // (c) editCommit — bounded contribution from edit/write/commit markers on
-    // events (filePath present, or text matching the edit/commit regex).
-    let editCommitEvents = 0;
-    for (const e of events) {
-        if (e.filePath || EDIT_COMMIT_RE.test(e.text))
-            editCommitEvents += 1;
-    }
-    // 0.25 per edit/commit event, capped at 1.5. Together with toolDensity a
-    // procedurally dense session reaches well above the default threshold.
-    const editCommit = Math.min(editCommitEvents * 0.25, 1.5);
-    // (d) substantiveRatio — scaled fraction of non-trivial assistant+tool turns.
-    let substantive = 0;
-    for (const e of events) {
-        if ((e.role === "assistant" || e.role === "tool") && e.text.length >= SUBSTANTIVE_MIN_CHARS) {
-            substantive += 1;
-        }
-    }
-    const ratio = total > 0 ? substantive / total : 0;
-    // Scale to a bounded [0,1] contribution.
-    const substantiveRatio = Math.min(ratio, 1);
-    const subscores = { markers, toolDensity, editCommit, substantiveRatio };
-    const score = markers + toolDensity + editCommit + substantiveRatio;
-    // Base gate: score must clear the floor.
-    const pass = score >= minScore;
-    return {
-        pass,
-        score,
-        subscores,
-        ...(pass ? {} : { reason: "low_signal" }),
-    };
-}
-/**
- * Resolve the effective triage config from the extract process config. Mirrors
- * the minContentChars resolution style in akmExtract.
- *
- * Default-off: `enabled` is FALSE unless `triage.enabled === true`. `minScore`
- * defaults to {@link DEFAULT_TRIAGE_MIN_SCORE}.
- */
-export function resolveTriageConfig(extractProcess) {
-    const triage = extractProcess?.triage;
-    const enabled = triage?.enabled === true;
-    const minScore = typeof triage?.minScore === "number" ? triage.minScore : DEFAULT_TRIAGE_MIN_SCORE;
-    return { enabled, minScore };
-}