0xray 4.0.22 → 4.0.24

package/dist/inference/inference-proposal-generator.js

@@ -1,3 +1,95 @@
+import { LESSON_TEXT_CAP } from "../memory-routing/types.js";
+function primitivesForSessions(corpus, sessionIds) {
+    const wanted = new Set(sessionIds);
+    const names = [];
+    for (const session of corpus.sessions) {
+        if (!wanted.has(session.sessionId))
+            continue;
+        const listed = session.matched_primitives ?? session.matchedPrimitives ?? [];
+        for (const name of listed)
+            names.push(name);
+    }
+    return [...new Set(names.filter((name) => name.length > 0))];
+}
+function signalsForPattern(corpus, pattern) {
+    const names = primitivesForSessions(corpus, pattern.sessions);
+    if (pattern.name.length > 0)
+        names.push(pattern.name);
+    return [...new Set(names)];
+}
+/** Solid band starts at 0.82. Landed work with no wrong turn clears it. */
+const LANDED_RESONANCE = 0.85;
+const WRONG_TURN_RESONANCE = 0.4;
+function resonanceForNamedSignal(corpus, sessionIds) {
+    const sessions = corpus.sessions.filter((session) => sessionIds.includes(session.sessionId));
+    if (sessions.some((session) => (session.wrongTurns?.length ?? 0) > 0))
+        return WRONG_TURN_RESONANCE;
+    if (sessions.some((session) => (session.approaches?.length ?? 0) > 0 || (session.solutions?.length ?? 0) > 0)) {
+        return LANDED_RESONANCE;
+    }
+    let confidence = 0.7;
+    for (const session of sessions) {
+        for (const pattern of session.patterns) {
+            if (pattern.confidence > confidence)
+                confidence = pattern.confidence;
+        }
+    }
+    return confidence;
+}
+function speechSlug(text) {
+    const words = text
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((word) => word.length >= 3)
+        .slice(0, 6);
+    return words.join("-").slice(0, 48).replace(/-+$/g, "");
+}
+function sessionsForWrongTurn(corpus, turn) {
+    return corpus.sessions
+        .filter((session) => session.wrongTurns.includes(turn))
+        .map((session) => session.sessionId);
+}
+/** The trace a graded line stores. Wrong turns, then approaches, then solutions. */
+function lessonTrace(corpus, sessionIds) {
+    const wanted = new Set(sessionIds);
+    const lines = [];
+    for (const session of corpus.sessions) {
+        if (!wanted.has(session.sessionId))
+            continue;
+        for (const turn of session.wrongTurns ?? []) {
+            if (turn.trim())
+                lines.push(turn.trim());
+        }
+        for (const line of [...(session.approaches ?? []), ...(session.solutions ?? [])]) {
+            if (line.trim())
+                lines.push(line.trim());
+        }
+    }
+    return [...new Set(lines)].join("; ").slice(0, LESSON_TEXT_CAP);
+}
+function sortedSessionIds(sessionIds) {
+    return [...new Set(sessionIds.filter((sessionId) => sessionId.length > 0))].sort();
+}
+/** Sessions already included in a prior proposal of this exact prefix. */
+function coveredSessions(history, prefix) {
+    const seen = new Set();
+    for (const cycle of history ?? []) {
+        for (const proposal of cycle.proposals) {
+            if (!proposal.id.startsWith(prefix))
+                continue;
+            for (const sessionId of proposal.id.slice(prefix.length).split(",")) {
+                if (sessionId.length > 0)
+                    seen.add(sessionId);
+            }
+        }
+    }
+    return seen;
+}
+/** Sessions that have not already been graded under this prefix. */
+function freshSessions(history, prefix, sessionIds) {
+    const covered = coveredSessions(history, prefix);
+    return sortedSessionIds(sessionIds).filter((sessionId) => !covered.has(sessionId));
+}
 function classifyProposalType(problemPattern) {
     const lower = problemPattern.toLowerCase();
     if (lower.includes("bug") || lower.includes("fix") || lower.includes("stability"))
@@ -63,6 +155,8 @@ function adjustConfidenceFromHistory(proposals, history) {
         }
     }
     for (const proposal of proposals) {
+        if (proposal.id.startsWith("named:"))
+            continue;
         const approved = approvedTypes.get(proposal.type) ?? 0;
         const rejected = rejectedTypes.get(proposal.type) ?? 0;
         const total = approved + rejected;
@@ -79,16 +173,25 @@ function adjustConfidenceFromHistory(proposals, history) {
 }
 export function generateProposals(corpus, history) {
     const proposals = [];
+    const proposalSessions = new Map();
     for (const problem of corpus.recurringProblems) {
+        const prefix = `problem:${problem.pattern}:`;
+        const sessions = freshSessions(history, prefix, problem.sessions);
+        if (sessions.length === 0)
+            continue;
+        const id = `${prefix}${sessions.join(",")}`;
+        proposalSessions.set(id, sessions);
         proposals.push({
-            id: `prop-${Date.now()}-${proposals.length}`,
+            id,
             type: classifyProposalType(problem.pattern),
             title: generateTitle(problem),
             description: `Recurring across ${problem.occurrences} sessions: ${problem.pattern}`,
-            evidence: problem.sessions.map((s) => `Seen in session ${s}`),
+            evidence: sessions.map((s) => `Seen in session ${s}`),
             confidence: Math.min(0.95, 0.5 + problem.occurrences * 0.15),
             source: "recurring_problem",
             status: "pending",
+            namedSignals: primitivesForSessions(corpus, sessions),
+            lesson: lessonTrace(corpus, sessions),
         });
     }
     const seenPatterns = new Set(corpus.recurringProblems.map((p) => p.pattern));
@@ -99,8 +202,16 @@ export function generateProposals(corpus, history) {
             continue;
         if (proposals.length >= 5)
             break;
+        const prefix = `problem:${normalized}:`;
+        const sessions = freshSessions(history, prefix, [session]);
+        if (sessions.length === 0) {
+            seenPatterns.add(normalized);
+            continue;
+        }
+        const id = `${prefix}${sessions.join(",")}`;
+        proposalSessions.set(id, sessions);
         proposals.push({
-            id: `prop-${Date.now()}-${proposals.length}`,
+            id,
             type: classifyProposalType(problem),
             title: `Investigate: ${problem.substring(0, 80)}`,
             description: `Observed in session ${session}: ${problem}`,
@@ -108,15 +219,23 @@ export function generateProposals(corpus, history) {
             confidence: 0.4,
             source: "recurring_problem",
             status: "pending",
+            namedSignals: primitivesForSessions(corpus, sessions),
+            lesson: lessonTrace(corpus, sessions),
         });
         seenPatterns.add(normalized);
     }
     for (const pattern of corpus.recurringPatterns) {
         if (pattern.occurrences < 2)
             continue;
+        const prefix = `pattern:${pattern.name}:`;
+        const sessions = freshSessions(history, prefix, pattern.sessions);
+        if (sessions.length === 0)
+            continue;
         const type = patternToProposalType(pattern);
+        const id = `${prefix}${sessions.join(",")}`;
+        proposalSessions.set(id, sessions);
         proposals.push({
-            id: `prop-${Date.now()}-${proposals.length}`,
+            id,
             type,
             title: `Codify ${pattern.name} pattern`,
             description: `${pattern.name} detected across ${pattern.occurrences} sessions (avg confidence: ${Math.round(pattern.avgConfidence * 100)}%). ${pattern.description}`,
@@ -124,13 +243,21 @@ export function generateProposals(corpus, history) {
             confidence: pattern.avgConfidence,
             source: "recurring_pattern",
             status: "pending",
+            namedSignals: signalsForPattern(corpus, { ...pattern, sessions }),
+            lesson: lessonTrace(corpus, sessions),
         });
     }
     const wrongTurns = corpus.allWrongTurns.slice(0, 2);
     for (const wt of wrongTurns) {
         const summary = wt.length > 50 ? `${wt.substring(0, 47)}...` : wt;
+        const prefix = `wrong:${wt}:`;
+        const sessions = freshSessions(history, prefix, sessionsForWrongTurn(corpus, wt));
+        if (sessions.length === 0)
+            continue;
+        const id = `${prefix}${sessions.join(",")}`;
+        proposalSessions.set(id, sessions);
         proposals.push({
-            id: `prop-${Date.now()}-${proposals.length}`,
+            id,
             type: "guard",
             title: `Guard against: ${summary}`,
             description: `Recurring wrong turn detected: ${wt}. Add a guard or validation to prevent this pattern.`,
@@ -138,9 +265,83 @@ export function generateProposals(corpus, history) {
             confidence: 0.7,
             source: "wrong_turn",
             status: "pending",
+            namedSignals: primitivesForSessions(corpus, sessions),
+            lesson: lessonTrace(corpus, sessions),
         });
     }
     const sorted = proposals.sort((a, b) => b.confidence - a.confidence).slice(0, 3);
+    const sessionsAlreadyNamed = new Map();
+    for (const proposal of sorted) {
+        const covered = proposalSessions.get(proposal.id) ?? [];
+        for (const name of proposal.namedSignals ?? []) {
+            if (name.length === 0)
+                continue;
+            const set = sessionsAlreadyNamed.get(name) ?? new Set();
+            for (const sessionId of covered)
+                set.add(sessionId);
+            sessionsAlreadyNamed.set(name, set);
+        }
+    }
+    const bySignal = new Map();
+    for (const session of corpus.sessions) {
+        const listed = session.matched_primitives ?? session.matchedPrimitives ?? [];
+        for (const name of listed) {
+            if (name.length === 0)
+                continue;
+            if (sessionsAlreadyNamed.get(name)?.has(session.sessionId))
+                continue;
+            const sessions = bySignal.get(name) ?? [];
+            if (!sessions.includes(session.sessionId))
+                sessions.push(session.sessionId);
+            bySignal.set(name, sessions);
+        }
+    }
+    const minted = new Set();
+    for (const session of corpus.sessions) {
+        if (minted.size >= 3)
+            break;
+        const listed = session.matched_primitives ?? session.matchedPrimitives ?? [];
+        if (listed.some((name) => name.length > 0))
+            continue;
+        const speech = lessonTrace(corpus, [session.sessionId]).trim();
+        const slug = speechSlug(speech);
+        if (slug.length === 0 || minted.has(slug))
+            continue;
+        const sessions = freshSessions(history, `mint:${slug}:`, [session.sessionId]);
+        if (sessions.length === 0)
+            continue;
+        minted.add(slug);
+        sorted.push({
+            id: `mint:${slug}:${sessions.join(",")}`,
+            type: "codify",
+            title: `Learn ${slug}`,
+            description: speech,
+            evidence: [speech],
+            confidence: resonanceForNamedSignal(corpus, sessions),
+            source: "recurring_pattern",
+            status: "pending",
+            namedSignals: [slug],
+            lesson: speech,
+        });
+    }
+    for (const [name, sessionIds] of bySignal) {
+        const sessions = freshSessions(history, `named:${name}:`, sessionIds);
+        if (sessions.length === 0)
+            continue;
+        const id = `named:${name}:${sessions.join(",")}`;
+        sorted.push({
+            id,
+            type: "codify",
+            title: `Grade named signal ${name}`,
+            description: `Sessions ${sessions.join(", ")} named ${name}.`,
+            evidence: sessions.map((sessionId) => `Seen in session ${sessionId}`),
+            confidence: resonanceForNamedSignal(corpus, sessions),
+            source: "recurring_pattern",
+            status: "pending",
+            namedSignals: [name],
+            lesson: lessonTrace(corpus, sessions),
+        });
+    }
     if (history && history.length > 0) {
         adjustConfidenceFromHistory(sorted, history);
         sorted.sort((a, b) => b.confidence - a.confidence);

package/dist/inference/inference-run-gate.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Whether `inference:run` may enter InferenceCycle.
+ * A missing key is on: the cycle is how a suit grows memory.
+ * Explicit `enabled: false` stays off unless the caller passes force.
+ */
+export declare function inferenceRunMayEnter(inference: {
+    enabled?: boolean;
+} | undefined, force: boolean): boolean;

package/dist/inference/inference-run-gate.js

@@ -0,0 +1,10 @@
+/**
+ * Whether `inference:run` may enter InferenceCycle.
+ * A missing key is on: the cycle is how a suit grows memory.
+ * Explicit `enabled: false` stays off unless the caller passes force.
+ */
+export function inferenceRunMayEnter(inference, force) {
+    if (force)
+        return true;
+    return inference?.enabled !== false;
+}

package/dist/inference/session-capture.d.ts

@@ -13,6 +13,12 @@ export interface SessionInference {
     reasoningChain: ReasoningLink[];
     patterns: StructuralPattern[];
     metrics: SessionMetrics;
+    /** Signals this session already named. Session JSON stores this list. */
+    matched_primitives?: string[];
+    /** Same list after load, so callers can read either field. */
+    matchedPrimitives?: string[];
+    /** Inference operation this session was captured from. A second completion of the same id does not write another file. */
+    operationId?: string;
 }
 export interface ReasoningLink {
     from: string;
@@ -28,5 +34,30 @@ export interface SessionMetrics {
     filesDeleted: number;
     uniqueDirs: number;
 }
+/** Date stamp plus the operation id. Callers do not append a HEAD suffix. */
+export declare function mintSessionId(now?: Date, distinct?: string): string;
 export declare function captureSessionInference(fromRef: string, toRef: string): SessionInference | null;
 export declare function saveSessionInference(inference: SessionInference, outputDir?: string): string;
+export interface OperationCaptureInput {
+    operationId: string;
+    promptsDir: string;
+    inferenceDir: string;
+    signalNames: readonly string[];
+}
+/**
+ * One corpus session for a finished inference operation.
+ * Speech comes from that run's prompt result text. No speech, no file.
+ * Does not grade. The caller runs the cycle before it returns.
+ */
+export declare function captureCompletedInferenceOperation(input: OperationCaptureInput): string | null;
+/** Id, or that id with hyphens read as spaces. Same hit `patternsFromGit` stores for the proposal generator. */
+export declare function reflectionSessionId(relativePath: string): string;
+/** Reflection markdown is the speech. No session file is written. */
+export declare function captureReflectionInference(input: {
+    relativePath: string;
+    text: string;
+    modifiedAt: Date;
+    signalNames: readonly string[];
+}): SessionInference | null;
+/** The gauge file. One session log per reflection, skipped when that id is already on disk. */
+export declare function saveReflectionSession(session: SessionInference, inferenceDir: string): string | null;

package/dist/inference/session-capture.js

@@ -2,6 +2,16 @@ import * as fs from "fs";
 import * as path from "path";
 import { execSync } from "child_process";
 import { analyzeStructuralPatterns } from "./semantic-patterns.js";
+/** Date stamp plus the operation id. Callers do not append a HEAD suffix. */
+export function mintSessionId(now = new Date(), distinct) {
+    const day = now.toISOString().slice(0, 10);
+    const suffix = (distinct ?? "")
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return suffix.length > 0 ? `session-${day}-${suffix}` : `session-${day}`;
+}
 export function captureSessionInference(fromRef, toRef) {
     const commits = getCommitData(fromRef, toRef);
     if (commits.length === 0)
@@ -14,7 +24,7 @@ export function captureSessionInference(fromRef, toRef) {
     const solutions = extractSolutions(commits, patterns);
     const reasoningChain = buildReasoningChain(problems, approaches, wrongTurns, solutions);
     return {
-        sessionId: `session-${new Date().toISOString().slice(0, 10)}`,
+        sessionId: mintSessionId(),
         timestamp: new Date().toISOString(),
         span: { from: fromRef, to: toRef },
         problems,
@@ -282,6 +292,272 @@ function buildReasoningChain(problems, approaches, wrongTurns, solutions) {
     }
     return chain;
 }
+/** Same cap `lessonTrace` applies before a vote can store the line. */
+const OPERATION_LESSON_CAP = 400;
+/**
+ * One corpus session for a finished inference operation.
+ * Speech comes from that run's prompt result text. No speech, no file.
+ * Does not grade. The caller runs the cycle before it returns.
+ */
+export function captureCompletedInferenceOperation(input) {
+    const operationId = input.operationId.trim();
+    if (!operationId)
+        return null;
+    if (operationAlreadyCaptured(input.inferenceDir, operationId))
+        return null;
+    const raw = readOperationSpeech(input.promptsDir, operationId);
+    const speech = parseOperationSpeech(raw);
+    const heard = speech.approaches.length + speech.solutions.length + speech.wrongTurns.length;
+    if (!raw.trim() || heard === 0)
+        return null;
+    const named = storedSignalsNamedBySpeech(raw, input.signalNames);
+    const now = new Date().toISOString();
+    const session = {
+        sessionId: mintSessionId(new Date(), operationId),
+        timestamp: now,
+        span: { from: operationId, to: operationId },
+        problems: [],
+        approaches: speech.approaches,
+        wrongTurns: speech.wrongTurns,
+        solutions: speech.solutions,
+        reasoningChain: [],
+        patterns: [],
+        metrics: {
+            commits: 0,
+            filesChanged: 0,
+            insertions: 0,
+            deletions: 0,
+            filesAdded: 0,
+            filesDeleted: 0,
+            uniqueDirs: 0,
+        },
+        matched_primitives: named,
+        matchedPrimitives: named,
+        operationId,
+    };
+    return saveSessionInference(session, input.inferenceDir);
+}
+function operationAlreadyCaptured(inferenceDir, operationId) {
+    if (!fs.existsSync(inferenceDir))
+        return false;
+    for (const name of fs.readdirSync(inferenceDir)) {
+        if (!name.startsWith("session-") || !name.endsWith(".json"))
+            continue;
+        try {
+            const parsed = JSON.parse(fs.readFileSync(path.join(inferenceDir, name), "utf8"));
+            if (parsed.operationId === operationId)
+                return true;
+        }
+        catch {
+            continue;
+        }
+    }
+    return false;
+}
+function readOperationSpeech(promptsDir, operationId) {
+    if (!fs.existsSync(promptsDir))
+        return "";
+    const chunks = [];
+    for (const name of fs.readdirSync(promptsDir).sort()) {
+        const full = path.join(promptsDir, name);
+        let stat;
+        try {
+            stat = fs.statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (!stat.isFile())
+            continue;
+        let text = "";
+        try {
+            text = fs.readFileSync(full, "utf8");
+        }
+        catch {
+            continue;
+        }
+        if (name === `${operationId}.result.md` || name === `${operationId}.result.txt`) {
+            chunks.push(text);
+            continue;
+        }
+        if (/\.result\.(md|txt)$/i.test(name) && operationDeclared(text) === operationId) {
+            chunks.push(text);
+            continue;
+        }
+        if (name.endsWith(".md") && !name.includes(".result.")) {
+            const section = resultSection(text);
+            if (section && (operationDeclared(section) === operationId || operationDeclared(text) === operationId)) {
+                chunks.push(section);
+            }
+        }
+    }
+    return chunks.join("\n").trim();
+}
+function operationDeclared(text) {
+    const match = /^operation:\s*(\S+)\s*$/im.exec(text);
+    return match?.[1] ?? null;
+}
+function resultSection(text) {
+    const parts = text.split(/\n##\s+(?:Result|Speech)\s*\n/i);
+    if (parts.length < 2)
+        return "";
+    return parts.slice(1).join("\n").trim();
+}
+function parseOperationSpeech(raw) {
+    const body = raw
+        .split("\n")
+        .filter((line) => !/^operation:\s*\S+\s*$/i.test(line.trim()))
+        .join("\n")
+        .trim();
+    const buckets = { approaches: [], solutions: [], wrongTurns: [] };
+    if (!body)
+        return buckets;
+    let current = null;
+    let labeled = false;
+    const sectionLines = [];
+    const flush = () => {
+        if (!current) {
+            sectionLines.length = 0;
+            return;
+        }
+        const text = fewSentences(sectionLines.join(" "));
+        sectionLines.length = 0;
+        if (text)
+            buckets[current].push(text);
+    };
+    for (const line of body.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const inline = /^([^:]{2,40}):\s+(.+)$/.exec(trimmed);
+        if (inline) {
+            const bucket = bucketForLabel(inline[1] ?? "");
+            if (bucket) {
+                flush();
+                current = bucket;
+                labeled = true;
+                sectionLines.push(inline[2] ?? "");
+                continue;
+            }
+        }
+        const heading = /^(?:#{1,3}\s*)(.+)$/.exec(trimmed);
+        if (heading) {
+            const bucket = bucketForLabel(heading[1] ?? "");
+            if (bucket) {
+                flush();
+                current = bucket;
+                labeled = true;
+                continue;
+            }
+        }
+        if (current)
+            sectionLines.push(trimmed);
+    }
+    flush();
+    if (!labeled) {
+        const text = fewSentences(body);
+        if (text)
+            buckets.approaches.push(text);
+    }
+    return buckets;
+}
+function bucketForLabel(label) {
+    const lower = label.toLowerCase().replace(/^#+\s*/, "").replace(/:$/, "").trim();
+    if (/^(tried|approaches?|what was tried)$/.test(lower))
+        return "approaches";
+    if (/^(worked|solutions?|what worked)$/.test(lower))
+        return "solutions";
+    if (/^(failed|wrong turns?|what failed)$/.test(lower))
+        return "wrongTurns";
+    return null;
+}
+function fewSentences(text) {
+    const flat = text.replace(/\s+/g, " ").trim();
+    if (!flat)
+        return "";
+    const sentences = flat.split(/(?<=[.!?])\s+/).filter((part) => part.length > 0).slice(0, 4);
+    const joined = sentences.join(" ");
+    if (joined.length <= OPERATION_LESSON_CAP)
+        return joined;
+    return joined.slice(0, OPERATION_LESSON_CAP);
+}
+/** Id, or that id with hyphens read as spaces. Same hit `patternsFromGit` stores for the proposal generator. */
+export function reflectionSessionId(relativePath) {
+    const slug = relativePath
+        .replace(/\.md$/i, "")
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return `session-reflection-${slug}`;
+}
+/** Reflection markdown is the speech. No session file is written. */
+export function captureReflectionInference(input) {
+    const speech = parseOperationSpeech(input.text);
+    const heard = speech.approaches.length + speech.solutions.length + speech.wrongTurns.length;
+    if (heard === 0)
+        return null;
+    const named = storedSignalsNamedBySpeech([...speech.approaches, ...speech.solutions, ...speech.wrongTurns].join(" "), input.signalNames);
+    const emptyMetrics = {
+        commits: 0,
+        filesChanged: 0,
+        insertions: 0,
+        deletions: 0,
+        filesAdded: 0,
+        filesDeleted: 0,
+        uniqueDirs: 0,
+    };
+    return {
+        sessionId: reflectionSessionId(input.relativePath),
+        timestamp: input.modifiedAt.toISOString(),
+        span: { from: "reflection", to: input.relativePath },
+        problems: [],
+        approaches: speech.approaches,
+        wrongTurns: speech.wrongTurns,
+        solutions: speech.solutions,
+        reasoningChain: [],
+        patterns: [],
+        metrics: emptyMetrics,
+        matched_primitives: named,
+        matchedPrimitives: named,
+    };
+}
+/** The gauge file. One session log per reflection, skipped when that id is already on disk. */
+export function saveReflectionSession(session, inferenceDir) {
+    if (reflectionAlreadySaved(inferenceDir, session.sessionId))
+        return null;
+    return saveSessionInference(session, inferenceDir);
+}
+function reflectionAlreadySaved(inferenceDir, sessionId) {
+    if (!fs.existsSync(inferenceDir))
+        return false;
+    for (const name of fs.readdirSync(inferenceDir)) {
+        if (!name.startsWith("session-") || !name.endsWith(".json") || name === "latest-session.json")
+            continue;
+        try {
+            const parsed = JSON.parse(fs.readFileSync(path.join(inferenceDir, name), "utf8"));
+            if (parsed.sessionId === sessionId)
+                return true;
+        }
+        catch {
+            continue;
+        }
+    }
+    return false;
+}
+function storedSignalsNamedBySpeech(speech, signalNames) {
+    const hay = speech.toLowerCase();
+    const named = [];
+    for (const name of signalNames) {
+        const id = name.trim().toLowerCase();
+        if (!id)
+            continue;
+        const spaced = id.replace(/-/g, " ");
+        if (hay.includes(id) || (spaced !== id && hay.includes(spaced)))
+            named.push(name.trim());
+    }
+    return [...new Set(named)];
+}
 function approachKeyword(approach) {
     const lower = approach.toLowerCase();
     if (lower.includes("extract"))