0xray 4.0.21 → 4.0.23

package/dist/inference/inference-accumulator.js

@@ -26,11 +26,12 @@ export function accumulateCorpus(inferenceDir) {
     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 +41,7 @@ export function accumulateCorpus(inferenceDir) {
                     count: 1,
                     confidence: [p.confidence],
                     sessions: [session.sessionId],
-                    evidence: [...p.evidence],
+                    evidence: [...evidence],
                     description: p.description,
                 });
             }
@@ -95,13 +96,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,18 +8,57 @@ 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 "";
+    }
+    const content = result.content;
+    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;
     static governedProposalIds = new Set();
     static getInstance(projectRoot, options) {
         const root = path.resolve(projectRoot || process.cwd());
-        if (!InferenceCycle.instances.has(root)) {
-            InferenceCycle.instances.set(root, new InferenceCycle(root, undefined, options));
+        const existing = InferenceCycle.instances.get(root);
+        if (existing) {
+            if (options) {
+                existing.options = { ...existing.options, ...options };
+            }
+            return existing;
         }
-        return InferenceCycle.instances.get(root);
+        const created = new InferenceCycle(root, undefined, options);
+        InferenceCycle.instances.set(root, created);
+        return created;
     }
     static resetInstance() {
         InferenceCycle.instances.clear();
@@ -121,7 +160,10 @@ export class InferenceCycle {
             const proposals = generateProposals(corpus, this.loadHistory());
             if (proposals.length === 0) {
                 this.setPhase("complete");
-                return this.buildResult(cycleId, true, threshold.reason, startTime, corpus, proposals);
+                this.saveCycleState(cycleId);
+                const emptyResult = this.buildResult(cycleId, true, threshold.reason, startTime, corpus, proposals);
+                this.appendHistory(emptyResult);
+                return emptyResult;
             }
             this.setPhase("governing");
             let votes = [];
@@ -152,6 +194,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");
@@ -198,6 +241,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
@@ -205,8 +281,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 => ({
@@ -221,9 +298,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 = result?.content?.[0]?.text || "";
+        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,
@@ -231,6 +311,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();
@@ -258,17 +356,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) {
@@ -340,21 +433,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,

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

@@ -1,3 +1,87 @@
+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 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);
+    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 +147,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;
@@ -80,15 +166,21 @@ function adjustConfidenceFromHistory(proposals, history) {
 export function generateProposals(corpus, history) {
     const proposals = [];
     for (const problem of corpus.recurringProblems) {
+        const prefix = `problem:${problem.pattern}:`;
+        const sessions = freshSessions(history, prefix, problem.sessions);
+        if (sessions.length === 0)
+            continue;
         proposals.push({
-            id: `prop-${Date.now()}-${proposals.length}`,
+            id: `${prefix}${sessions.join(",")}`,
             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 +191,14 @@ 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;
+        }
         proposals.push({
-            id: `prop-${Date.now()}-${proposals.length}`,
+            id: `${prefix}${sessions.join(",")}`,
             type: classifyProposalType(problem),
             title: `Investigate: ${problem.substring(0, 80)}`,
             description: `Observed in session ${session}: ${problem}`,
@@ -108,15 +206,21 @@ 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);
         proposals.push({
-            id: `prop-${Date.now()}-${proposals.length}`,
+            id: `${prefix}${sessions.join(",")}`,
             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 +228,19 @@ 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;
         proposals.push({
-            id: `prop-${Date.now()}-${proposals.length}`,
+            id: `${prefix}${sessions.join(",")}`,
             type: "guard",
             title: `Guard against: ${summary}`,
             description: `Recurring wrong turn detected: ${wt}. Add a guard or validation to prevent this pattern.`,
@@ -138,9 +248,42 @@ 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 alreadyNamed = new Set(sorted.flatMap((proposal) => proposal.namedSignals ?? []));
+    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))
+                continue;
+            const sessions = bySignal.get(name) ?? [];
+            if (!sessions.includes(session.sessionId))
+                sessions.push(session.sessionId);
+            bySignal.set(name, sessions);
+        }
+    }
+    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/session-capture.d.ts

@@ -13,6 +13,10 @@ 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[];
 }
 export interface ReasoningLink {
     from: string;

package/dist/integrations/cursor/README.md

@@ -2,7 +2,7 @@
 
 Thin adapter. Repo `.cursor/hooks.json` (schema **version 1**) calls 0xRay gates and the Station PreCompact writer. **sessionStart is not used** — managed Cursor cloud does not fire it.
 
-Repertoire MCP is optional. Station + gates work without a full memory-routing rewire.
+Repertoire is preferred (vendored, dest = named laws). Station + Codex gates still run if memory-routing is explicitly off — that is fallback, not the preferred brain.
 
 ## How cloud picks up project hooks
 

package/dist/integrations/cursor/hooks/cursor-hook-utils.js

@@ -182,6 +182,25 @@ export function cursorHeatRoots(event = {}) {
   return out;
 }
 
+function packageNameAt(root) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+    return typeof pkg.name === 'string' ? pkg.name : '';
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Constitution follows the suit mill when that package is in the heat set.
+ * A sibling repo's leftover synthesis checkpoint must not deny the host.
+ */
+export function cursorGateRoot(heatRoots, eventRoot) {
+  const mill = heatRoots.find((root) => packageNameAt(root) === '0xray');
+  if (mill) return mill;
+  return heatRoots[0] || eventRoot;
+}
+
 export function cursorSessionId(event = {}) {
   return (
     event.conversation_id ||

package/dist/integrations/cursor/hooks/pre-tool-use.js

@@ -9,6 +9,7 @@ import {
   appendHookActivity,
   checkCodexPatterns,
   checkFullTestSuite,
+  cursorGateRoot,
   cursorHeatRoots,
   cursorSessionId,
   cursorToolContext,
@@ -53,7 +54,7 @@ async function main() {
     for (const root of heatRoots) {
       ensureCursorSessionBoot(root, '0xray/cursor-pre-tool-use-boot', { sessionId });
     }
-    const gateRoot = heatRoots[0] || eventRoot;
+    const gateRoot = cursorGateRoot(heatRoots, eventRoot);
 
     const features = loadFeatures(gateRoot);
     const gateFeatures = loadDelegationGateFeatures(gateRoot, 'cursor');