0xray 4.0.23 → 4.0.25

package/dist/inference/inference-accumulator.js

@@ -1,7 +1,8 @@
 import * as fs from "fs";
 import * as path from "path";
+import { captureReflectionInference } from "./session-capture.js";
 export function shouldTriggerCycle(inferenceDir, lastCycleFile) {
-    const sessions = loadSessionInferences(inferenceDir);
+    const sessions = loadCorpusSessions(inferenceDir);
     if (sessions.length < 1) {
         return { trigger: false, reason: `no session files collected` };
     }
@@ -20,7 +21,7 @@ export function shouldTriggerCycle(inferenceDir, lastCycleFile) {
     };
 }
 export function accumulateCorpus(inferenceDir) {
-    const sessions = loadSessionInferences(inferenceDir);
+    const sessions = loadCorpusSessions(inferenceDir);
     const totalCommits = sessions.reduce((sum, s) => sum + s.metrics.commits, 0);
     const patternMap = new Map();
     for (const session of sessions) {
@@ -89,6 +90,77 @@ export function accumulateCorpus(inferenceDir) {
         collectedAt: new Date().toISOString(),
     };
 }
+function loadCorpusSessions(inferenceDir) {
+    return [...loadSessionInferences(inferenceDir), ...loadReflectionInferences(inferenceDir)];
+}
+/** Reflection files are graded in memory. They are not copied into session-*.json. */
+export function loadReflectionInferences(inferenceDir) {
+    const projectRoot = path.resolve(inferenceDir, "..", "..");
+    const signalNames = readDestSignalNames(projectRoot);
+    const root = path.join(projectRoot, "docs", "reflections");
+    const sessions = [];
+    for (const file of listMarkdown(root)) {
+        const relativePath = path.relative(root, file);
+        if (/template/i.test(path.basename(file)))
+            continue;
+        let text = "";
+        try {
+            text = fs.readFileSync(file, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        const modifiedAt = fs.statSync(file).mtime;
+        const session = captureReflectionInference({ relativePath, text, modifiedAt, signalNames });
+        if (session)
+            sessions.push(session);
+    }
+    return sessions;
+}
+function listMarkdown(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    const found = [];
+    for (const name of fs.readdirSync(dir)) {
+        const full = path.join(dir, name);
+        let stat;
+        try {
+            stat = fs.statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (stat.isDirectory()) {
+            found.push(...listMarkdown(full));
+            continue;
+        }
+        if (name.endsWith(".md"))
+            found.push(full);
+    }
+    return found;
+}
+function readDestSignalNames(projectRoot) {
+    const dest = path.join(projectRoot, ".xray", "state", "repertoire", "curated_signals.json");
+    if (!fs.existsSync(dest))
+        return [];
+    try {
+        const parsed = JSON.parse(fs.readFileSync(dest, "utf-8"));
+        if (!Array.isArray(parsed.signals))
+            return [];
+        const names = [];
+        for (const signal of parsed.signals) {
+            if (!signal || typeof signal !== "object")
+                continue;
+            const name = signal.name;
+            if (typeof name === "string" && name.trim().length > 0)
+                names.push(name.trim());
+        }
+        return names;
+    }
+    catch {
+        return [];
+    }
+}
 export function loadSessionInferences(dir) {
     if (!fs.existsSync(dir))
         return [];

package/dist/inference/inference-cycle.js

@@ -119,6 +119,7 @@ export class InferenceCycle {
                 p.status = "rejected";
             for (const p of proposals)
                 InferenceCycle.governedProposalIds.add(p.id);
+            this.recordGovernedLessons(cycleId, proposals, votes);
             this.setPhase("complete");
             this.saveCycleState(cycleId);
             const result = this.buildResult(cycleId, true, "external proposals", startTime, undefined, proposals, votes);

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

@@ -1,3 +1,4 @@
+import { LESSON_TEXT_CAP } from "../memory-routing/types.js";
 function primitivesForSessions(corpus, sessionIds) {
     const wanted = new Set(sessionIds);
     const names = [];
@@ -35,12 +36,19 @@ function resonanceForNamedSignal(corpus, sessionIds) {
     }
     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);
 }
-const LESSON_TEXT_CAP = 400;
 /** The trace a graded line stores. Wrong turns, then approaches, then solutions. */
 function lessonTrace(corpus, sessionIds) {
     const wanted = new Set(sessionIds);
@@ -165,13 +173,16 @@ 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: `${prefix}${sessions.join(",")}`,
+            id,
             type: classifyProposalType(problem.pattern),
             title: generateTitle(problem),
             description: `Recurring across ${problem.occurrences} sessions: ${problem.pattern}`,
@@ -197,8 +208,10 @@ export function generateProposals(corpus, history) {
             seenPatterns.add(normalized);
             continue;
         }
+        const id = `${prefix}${sessions.join(",")}`;
+        proposalSessions.set(id, sessions);
         proposals.push({
-            id: `${prefix}${sessions.join(",")}`,
+            id,
             type: classifyProposalType(problem),
             title: `Investigate: ${problem.substring(0, 80)}`,
             description: `Observed in session ${session}: ${problem}`,
@@ -219,8 +232,10 @@ export function generateProposals(corpus, history) {
         if (sessions.length === 0)
             continue;
         const type = patternToProposalType(pattern);
+        const id = `${prefix}${sessions.join(",")}`;
+        proposalSessions.set(id, sessions);
         proposals.push({
-            id: `${prefix}${sessions.join(",")}`,
+            id,
             type,
             title: `Codify ${pattern.name} pattern`,
             description: `${pattern.name} detected across ${pattern.occurrences} sessions (avg confidence: ${Math.round(pattern.avgConfidence * 100)}%). ${pattern.description}`,
@@ -239,8 +254,10 @@ export function generateProposals(corpus, history) {
         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: `${prefix}${sessions.join(",")}`,
+            id,
             type: "guard",
             title: `Guard against: ${summary}`,
             description: `Recurring wrong turn detected: ${wt}. Add a guard or validation to prevent this pattern.`,
@@ -253,12 +270,25 @@ export function generateProposals(corpus, history) {
         });
     }
     const sorted = proposals.sort((a, b) => b.confidence - a.confidence).slice(0, 3);
-    const alreadyNamed = new Set(sorted.flatMap((proposal) => proposal.namedSignals ?? []));
+    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 || alreadyNamed.has(name))
+            if (name.length === 0)
+                continue;
+            if (sessionsAlreadyNamed.get(name)?.has(session.sessionId))
                 continue;
             const sessions = bySignal.get(name) ?? [];
             if (!sessions.includes(session.sessionId))
@@ -266,6 +296,34 @@ export function generateProposals(corpus, history) {
             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)

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

@@ -17,6 +17,8 @@ export interface SessionInference {
     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;
@@ -32,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"))