0xray 4.0.22 → 4.0.24

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,17 +21,18 @@ 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) {
         for (const p of session.patterns) {
             const existing = patternMap.get(p.name);
+            const evidence = patternEvidence(p);
             if (existing) {
                 existing.count++;
                 existing.confidence.push(p.confidence);
                 existing.sessions.push(session.sessionId);
-                for (const e of p.evidence) {
+                for (const e of evidence) {
                     if (!existing.evidence.includes(e))
                         existing.evidence.push(e);
                 }
@@ -40,7 +42,7 @@ export function accumulateCorpus(inferenceDir) {
                     count: 1,
                     confidence: [p.confidence],
                     sessions: [session.sessionId],
-                    evidence: [...p.evidence],
+                    evidence: [...evidence],
                     description: p.description,
                 });
             }
@@ -88,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 [];
@@ -95,13 +168,44 @@ export function loadSessionInferences(dir) {
         .filter((f) => f.startsWith("session-") && f.endsWith(".json"))
         .map((f) => {
         try {
-            return JSON.parse(fs.readFileSync(path.join(dir, f), "utf-8"));
+            const parsed = JSON.parse(fs.readFileSync(path.join(dir, f), "utf-8"));
+            const named = readMatchedPrimitives(parsed);
+            parsed.matched_primitives = named;
+            parsed.matchedPrimitives = named;
+            return parsed;
         }
         catch {
             return null;
         }
     })
-        .filter((s) => s !== null);
+        .filter((s) => isSessionInference(s));
+}
+/** Captured patterns sometimes omit evidence. That is an empty list, not a throw. */
+function readMatchedPrimitives(value) {
+    if (!value || typeof value !== "object")
+        return [];
+    const raw = value.matched_primitives
+        ?? value.matchedPrimitives;
+    if (!Array.isArray(raw))
+        return [];
+    return [...new Set(raw.filter((item) => typeof item === "string" && item.length > 0))];
+}
+function patternEvidence(pattern) {
+    if (!Array.isArray(pattern.evidence))
+        return [];
+    return pattern.evidence.filter((item) => typeof item === "string");
+}
+/** Notes and partial JSON under docs/inference are not sessions. */
+function isSessionInference(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const session = value;
+    return typeof session.sessionId === "string"
+        && Array.isArray(session.patterns)
+        && Array.isArray(session.problems)
+        && Array.isArray(session.approaches)
+        && Array.isArray(session.wrongTurns)
+        && typeof session.metrics?.commits === "number";
 }
 function loadLastCycleDate(filePath) {
     if (!fs.existsSync(filePath))

package/dist/inference/inference-cycle.d.ts

@@ -8,6 +8,10 @@ export interface InferenceProposal {
     confidence: number;
     source: "recurring_problem" | "recurring_pattern" | "wrong_turn";
     status: "pending" | "approved" | "rejected" | "applied" | "failed";
+    /** Repertoire signals the sessions behind this proposal already named. */
+    namedSignals?: string[];
+    /** Approaches, solutions, or the wrong turn from those sessions. */
+    lesson?: string;
 }
 export interface InferenceCycleResult {
     cycleId: string;
@@ -55,7 +59,11 @@ export declare class InferenceCycle {
     constructor(projectRoot?: string, agentInvoker?: AgentInvoker, options?: InferenceCycleOptions);
     governExternalProposals(proposals: InferenceProposal[]): Promise<InferenceCycleResult>;
     maybeRunCycle(): Promise<InferenceCycleResult>;
+    /** Approve or reject grades the signals that proposal's sessions already named. needs-revision does not write. */
+    private recordGovernedLessons;
     private governProposals;
+    /** Flag off: the local matrix is the pass. Dynamo is not called and the miss is not stored as a reject. */
+    private governWithLocalMatrix;
     private isGovernanceMcpPreferred;
     private parseGovernanceMcpResponse;
     private extractTextFromNdjson;
@@ -64,6 +72,10 @@ export declare class InferenceCycle {
     getPhase(): CyclePhase;
     private saveCycleState;
     private appendHistory;
+    /** Lesson ids that leave the 50-entry window stay covered. Empty cycles do not erase them. */
+    private retainDroppedLessonIds;
+    private readRetainedLessonIds;
+    private retainedLessonCycle;
     private loadHistory;
     private buildBlockedResult;
     private buildResult;

package/dist/inference/inference-cycle.js

@@ -8,8 +8,27 @@ import { mcpClientManager } from "../mcps/mcp-client.js";
 import { getConfigDir } from "../core/config-paths.js";
 import { generateProposals } from "./inference-proposal-generator.js";
 import { applyProposals as applyProposalsEx } from "./inference-applier.js";
+import { applyDecisionMatrix } from "../governance/governance-core.js";
+import { recordLesson } from "../memory-routing/record-lesson.js";
+import { writeLessonPickup } from "../memory-routing/lesson-pickup.js";
 const CYCLE_STATE_FILE = "inference-cycle-state.json";
 const CYCLE_HISTORY_FILE = "inference-cycle-history.json";
+const GRADED_LESSON_IDS_FILE = "inference-cycle-graded-ids.json";
+const HISTORY_CAP = 50;
+const LESSON_ID_PREFIXES = ["named:", "pattern:", "problem:", "wrong:"];
+function isLessonProposalId(id) {
+    return LESSON_ID_PREFIXES.some((prefix) => id.startsWith(prefix));
+}
+function lessonIdsFromUnknown(parsed) {
+    if (!Array.isArray(parsed))
+        return [];
+    const ids = [];
+    for (const item of parsed) {
+        if (typeof item === "string" && isLessonProposalId(item))
+            ids.push(item);
+    }
+    return ids;
+}
 function governanceToolText(result) {
     if (typeof result !== "object" || result === null || !("content" in result)) {
         return "";
@@ -18,6 +37,12 @@ function governanceToolText(result) {
     const text = content?.[0]?.text;
     return typeof text === "string" ? text : "";
 }
+function governanceToolIsError(result) {
+    if (typeof result !== "object" || result === null || !("isError" in result)) {
+        return false;
+    }
+    return result.isError === true;
+}
 export class InferenceCycle {
     static instances = new Map();
     static reEntryLock = false;
@@ -94,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);
@@ -169,6 +195,7 @@ export class InferenceCycle {
             for (const p of proposals.filter((p) => p.status !== "approved")) {
                 p.status = "rejected";
             }
+            this.recordGovernedLessons(cycleId, proposals, votes);
             if (approved.length > 0) {
                 if (!this.options.skipApply) {
                     this.setPhase("applying");
@@ -215,6 +242,39 @@ export class InferenceCycle {
             InferenceCycle.reEntryLock = false;
         }
     }
+    /** Approve or reject grades the signals that proposal's sessions already named. needs-revision does not write. */
+    recordGovernedLessons(cycleId, proposals, votes) {
+        const alreadyGraded = new Set(this.loadHistory().flatMap((cycle) => (cycle.proposals ?? []).map((proposal) => proposal.id)));
+        for (const proposal of proposals) {
+            if (alreadyGraded.has(proposal.id))
+                continue;
+            const vote = votes.find((item) => item.proposalId === proposal.id);
+            if (!vote)
+                continue;
+            if (vote.decision !== "approve" && vote.decision !== "reject")
+                continue;
+            if (vote.details.some((line) => line.includes("governance error")))
+                continue;
+            const named = proposal.namedSignals ?? [];
+            const taught = recordLesson({
+                operation: [proposal.title, proposal.description, ...proposal.evidence].join("\n"),
+                success: vote.decision === "approve",
+                taskId: proposal.id,
+                assignedAgent: "inference-cycle",
+                sessionId: cycleId,
+                signals: named,
+                lesson: proposal.lesson ?? "",
+            });
+            if (taught.length > 0) {
+                frameworkLogger.log("inference-cycle", "lesson-recorded", "info", {
+                    proposalId: proposal.id,
+                    decision: vote.decision,
+                    signals: taught,
+                });
+            }
+        }
+        writeLessonPickup(this.projectRoot);
+    }
     async governProposals(proposals) {
         // Governance MCP is the sole governance path (governance.server.ts + GovernanceService).
         // It calls individual skill MCPs (code-review, security-audit, researcher) internally
@@ -222,8 +282,9 @@ export class InferenceCycle {
         const useGovernanceMcp = process.env.XRAY_FORCE_MCP_GOVERNANCE === 'true' ||
             this.isGovernanceMcpPreferred();
         if (!useGovernanceMcp) {
-            throw new Error("Governance MCP is required but not available");
+            return this.governWithLocalMatrix(proposals);
         }
+        const governanceMcpTimeoutMs = 90_000;
         const result = await Promise.race([
             mcpClientManager.callServerTool("governance", "govern_proposals", {
                 proposals: proposals.map(p => ({
@@ -238,9 +299,12 @@ export class InferenceCycle {
                 context: { source: "inference-cycle" },
                 options: { require_external: true },
             }),
-            new Promise((_, reject) => setTimeout(() => reject(new Error("Governance MCP timed out after 8s")), 8000)),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`Governance MCP timed out after ${governanceMcpTimeoutMs / 1000}s`)), governanceMcpTimeoutMs)),
         ]);
         const text = governanceToolText(result);
+        if (governanceToolIsError(result)) {
+            throw new Error(text || "Governance MCP returned an error");
+        }
         const parsed = this.parseGovernanceMcpResponse(text, proposals);
         frameworkLogger.log("inference-cycle", "governance-mcp-primary-path", "info", {
             proposalCount: proposals.length,
@@ -248,6 +312,24 @@ export class InferenceCycle {
         });
         return parsed.votes;
     }
+    /** Flag off: the local matrix is the pass. Dynamo is not called and the miss is not stored as a reject. */
+    governWithLocalMatrix(proposals) {
+        return proposals.map((proposal) => {
+            const resonance = Number.isFinite(proposal.confidence) ? proposal.confidence : 0.8;
+            const matrix = applyDecisionMatrix({ resonance });
+            const decision = matrix.recommendation === "PASS"
+                ? "approve"
+                : matrix.recommendation === "REJECT"
+                    ? "reject"
+                    : "needs_revision";
+            return {
+                proposalId: proposal.id,
+                decision,
+                confidence: matrix.confidence,
+                details: ["local-matrix: inference_governance disabled", ...matrix.reasons],
+            };
+        });
+    }
     isGovernanceMcpPreferred() {
         try {
             const config = featuresConfigLoader.loadConfig();
@@ -275,17 +357,12 @@ export class InferenceCycle {
             return { votes, overallDecision: data.overallDecision || "needs_revision" };
         }
         catch {
+            const preview = text.substring(0, 300);
             frameworkLogger.log('inference-cycle', 'governance-mcp-parse-failed', 'warning', {
-                textPreview: text.substring(0, 200),
+                textPreview: preview,
                 proposalCount: proposals.length,
             });
-            const votes = proposals.map(p => ({
-                proposalId: p.id,
-                decision: "abstain",
-                confidence: 0.5,
-                details: ["governance-mcp: parse-failed"],
-            }));
-            return { votes, overallDecision: "needs_revision" };
+            throw new Error(`governance-mcp: unreadable vote: ${preview || "empty governance response"}`);
         }
     }
     extractTextFromNdjson(output) {
@@ -357,21 +434,87 @@ export class InferenceCycle {
             }
         }
         history.push(result);
-        if (history.length > 50)
-            history = history.slice(-50);
+        const dropped = history.length > HISTORY_CAP ? history.slice(0, history.length - HISTORY_CAP) : [];
+        if (history.length > HISTORY_CAP)
+            history = history.slice(-HISTORY_CAP);
+        this.retainDroppedLessonIds(dropped, history);
         fs.writeFileSync(historyPath, JSON.stringify(history, null, 2));
     }
-    loadHistory() {
-        const historyPath = path.join(this.stateDir, CYCLE_HISTORY_FILE);
-        if (!fs.existsSync(historyPath))
+    /** Lesson ids that leave the 50-entry window stay covered. Empty cycles do not erase them. */
+    retainDroppedLessonIds(dropped, kept) {
+        if (dropped.length === 0)
+            return;
+        const keptIds = new Set(kept.flatMap((cycle) => (cycle.proposals ?? []).map((proposal) => proposal.id)));
+        const retained = new Set(this.readRetainedLessonIds());
+        let changed = false;
+        for (const cycle of dropped) {
+            for (const proposal of cycle.proposals ?? []) {
+                if (!isLessonProposalId(proposal.id))
+                    continue;
+                if (keptIds.has(proposal.id) || retained.has(proposal.id))
+                    continue;
+                retained.add(proposal.id);
+                changed = true;
+            }
+        }
+        if (!changed)
+            return;
+        if (!fs.existsSync(this.stateDir)) {
+            fs.mkdirSync(this.stateDir, { recursive: true });
+        }
+        fs.writeFileSync(path.join(this.stateDir, GRADED_LESSON_IDS_FILE), JSON.stringify([...retained].sort(), null, 2));
+    }
+    readRetainedLessonIds() {
+        const file = path.join(this.stateDir, GRADED_LESSON_IDS_FILE);
+        if (!fs.existsSync(file))
             return [];
         try {
-            return JSON.parse(fs.readFileSync(historyPath, "utf-8"));
+            return lessonIdsFromUnknown(JSON.parse(fs.readFileSync(file, "utf-8")));
         }
         catch {
             return [];
         }
     }
+    retainedLessonCycle(ids) {
+        return {
+            cycleId: "retained-lessons",
+            triggered: false,
+            triggerReason: "lesson ids kept past the history cap",
+            corpusSummary: { sessions: 0, totalCommits: 0, recurringPatterns: 0, recurringProblems: 0 },
+            proposals: ids.map((id) => ({
+                id,
+                type: "codify",
+                title: id,
+                description: "",
+                evidence: [],
+                confidence: 0,
+                source: "recurring_pattern",
+                status: "pending",
+            })),
+            votes: [],
+            phase: "complete",
+            completedAt: "1970-01-01T00:00:00.000Z",
+            duration: 0,
+        };
+    }
+    loadHistory() {
+        const historyPath = path.join(this.stateDir, CYCLE_HISTORY_FILE);
+        let history = [];
+        if (fs.existsSync(historyPath)) {
+            try {
+                const parsed = JSON.parse(fs.readFileSync(historyPath, "utf-8"));
+                history = Array.isArray(parsed) ? parsed : [];
+            }
+            catch {
+                history = [];
+            }
+        }
+        const present = new Set(history.flatMap((cycle) => (cycle.proposals ?? []).map((proposal) => proposal.id)));
+        const missing = this.readRetainedLessonIds().filter((id) => !present.has(id));
+        if (missing.length === 0)
+            return history;
+        return [this.retainedLessonCycle(missing), ...history];
+    }
     buildBlockedResult(cycleId, reason) {
         return {
             cycleId,