0xray 4.0.23 → 4.0.24

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"))

package/dist/integrations/cursor/hooks/pre-compact.js

@@ -22,6 +22,74 @@ import {
   writeCursorUsageReceipt,
 } from './cursor-usage-receipt.js';
 
+async function loadPlates() {
+  const { existsSync } = await import('node:fs');
+  const { dirname, join } = await import('node:path');
+  const { fileURLToPath, pathToFileURL } = await import('node:url');
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join(here, '../../hooks/plates.cjs'),
+    join(here, '../../../integrations/hooks/plates.cjs'),
+  ];
+  const found = candidates.find((candidate) => existsSync(candidate));
+  if (!found) return null;
+  const loaded = await import(pathToFileURL(found).href);
+  if (typeof loaded.recallPlate === 'function') return loaded;
+  if (loaded.default && typeof loaded.default.recallPlate === 'function') return loaded.default;
+  return null;
+}
+
+async function memoryRoutingModule() {
+  const { existsSync } = await import('node:fs');
+  const { dirname, join } = await import('node:path');
+  const { fileURLToPath, pathToFileURL } = await import('node:url');
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join(here, '../../../memory-routing/index.js'),
+    join(here, '../../../../dist/memory-routing/index.js'),
+  ];
+  const found = candidates.find((candidate) => existsSync(candidate));
+  if (!found) throw new Error('memory-routing module missing');
+  return pathToFileURL(found).href;
+}
+
+async function lessonSpeechForIntent(root, intent) {
+  if (!intent) return [];
+  try {
+    const { readFileSync, existsSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const { loadMemoryRoutingProvider } = await import(await memoryRoutingModule());
+    let routing = { enabled: false, provider: 'null' };
+    const featuresPath = join(root, '.xray', 'features.json');
+    if (existsSync(featuresPath)) {
+      try {
+        routing = JSON.parse(readFileSync(featuresPath, 'utf8')).memory_routing || routing;
+      } catch {
+        /* leftover default */
+      }
+    }
+    const provider = await loadMemoryRoutingProvider(routing, root);
+    if (!provider || provider.id === 'null' || typeof provider.buildRoutingContext !== 'function') {
+      return [];
+    }
+    const context = provider.buildRoutingContext(String(intent));
+    const matched = new Set(Array.isArray(context.matchedSignals) ? context.matchedSignals : []);
+    const lines = [];
+    for (const lesson of context.lessons || []) {
+      if (!matched.has(lesson.name)) continue;
+      for (const line of lesson.lines || []) {
+        const text = String(line.text || '').trim().slice(0, 400);
+        if (text.length === 0) continue;
+        lines.push(`${lesson.name}: ${text}`);
+        if (lines.length >= 4) return lines;
+      }
+    }
+    return lines;
+  } catch {
+    return [];
+  }
+}
+
 function extractIntent(event) {
   return (
     event.prompt ||
@@ -47,6 +115,13 @@ async function main() {
     let receiptPath = null;
     let usagePath = null;
     let stationLine = null;
+    let plates = null;
+    let plateBody = '';
+    try {
+      plates = await loadPlates();
+    } catch {
+      plates = null;
+    }
     for (const root of cursorHeatRoots(event)) {
       const payload = buildSessionBootPayload(root, '0xray/cursor-compact', {
         host: 'cursor',
@@ -77,6 +152,17 @@ async function main() {
         sessionId,
         usage: hostUsageFromPreCompactEvent(event),
       });
+      if (plates) {
+        try {
+          const named = plates.recallPlate(payload.intent || intent || '');
+          if (named) {
+            plates.stampPlateIfMissing(root, named.id);
+            if (!plateBody) plateBody = `\n\n${String(named.body || '').trim()}`;
+          }
+        } catch {
+          /* plate stamp is observational */
+        }
+      }
     }
     appendHookActivity(eventRoot, 'cursor-pre-compact', 'station-written', 'success', {
       bootPath,
@@ -85,10 +171,12 @@ async function main() {
       event_class: eventClass,
       stationLine,
     });
+    const lessonLines = await lessonSpeechForIntent(eventRoot, intent);
+    const lessonNote = lessonLines.length > 0 ? ` Lessons: ${lessonLines.join(' | ')}` : '';
     console.log(
       JSON.stringify({
         user_message:
-          `0xRay Station written. Read .xray/state/STATION.md — do not cold-start. event_class=${eventClass}`,
+          `0xRay Station written. Read .xray/state/STATION.md — do not cold-start. event_class=${eventClass}${lessonNote}${plateBody}`,
       }),
     );
     process.exit(0);