0xray 4.0.12 → 4.0.13

package/dist/nucleus/synthesis.js

@@ -1,196 +0,0 @@
-/**
- * Synthesis — periodic reflect & realign checkpoint SSOT.
- * Slice counter + feature flag + `.xray/state/synthesis-checkpoint.json`.
- * PR2 wires pre-tool gate deny via delegation-gate.ts.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-export const SYNTHESIS_PRIMITIVE = 'synthesis';
-const STATE_VERSION = 1;
-export function synthesisCheckpointPath(projectRoot = process.cwd()) {
-    return path.join(projectRoot, '.xray', 'state', 'synthesis-checkpoint.json');
-}
-export function defaultSynthesisConfig() {
-    return {
-        enabled: false,
-        every_n_gates: 12,
-        every_n_turns: 0,
-        every_n_todos_completed: 0,
-    };
-}
-export function loadSynthesisConfig(projectRoot = process.cwd()) {
-    const featuresPath = path.join(projectRoot, '.xray', 'features.json');
-    if (!fs.existsSync(featuresPath)) {
-        return defaultSynthesisConfig();
-    }
-    try {
-        const data = JSON.parse(fs.readFileSync(featuresPath, 'utf8'));
-        const raw = data.synthesis ?? {};
-        const defaults = defaultSynthesisConfig();
-        return {
-            enabled: raw.enabled === true,
-            every_n_gates: normalizeThreshold(raw.every_n_gates, defaults.every_n_gates),
-            every_n_turns: normalizeThreshold(raw.every_n_turns, defaults.every_n_turns),
-            every_n_todos_completed: normalizeThreshold(raw.every_n_todos_completed, defaults.every_n_todos_completed),
-        };
-    }
-    catch {
-        return defaultSynthesisConfig();
-    }
-}
-function normalizeThreshold(value, fallback) {
-    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
-        return fallback;
-    }
-    return Math.floor(value);
-}
-function emptyCounters() {
-    return { gates: 0, turns: 0, todosCompleted: 0 };
-}
-export function createInitialSynthesisState(sessionId) {
-    const now = new Date().toISOString();
-    return {
-        version: STATE_VERSION,
-        sessionId,
-        slicesSinceLastSynthesis: emptyCounters(),
-        lifetimeSlices: emptyCounters(),
-        synthesisDue: false,
-        dueReason: null,
-        lastSynthesisAt: null,
-        lastSliceAt: now,
-        synthesisCount: 0,
-    };
-}
-export function loadSynthesisCheckpointState(projectRoot = process.cwd()) {
-    const statePath = synthesisCheckpointPath(projectRoot);
-    if (!fs.existsSync(statePath))
-        return null;
-    try {
-        const parsed = JSON.parse(fs.readFileSync(statePath, 'utf8'));
-        if (parsed.version !== STATE_VERSION)
-            return null;
-        return parsed;
-    }
-    catch {
-        return null;
-    }
-}
-export function saveSynthesisCheckpointState(state, projectRoot = process.cwd()) {
-    const statePath = synthesisCheckpointPath(projectRoot);
-    fs.mkdirSync(path.dirname(statePath), { recursive: true });
-    fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
-    return statePath;
-}
-export function evaluateSynthesisDue(counters, config) {
-    if (!config.enabled) {
-        return { due: false, reason: null };
-    }
-    if (config.every_n_gates > 0 && counters.gates >= config.every_n_gates) {
-        return {
-            due: true,
-            reason: `gate threshold (${counters.gates}/${config.every_n_gates})`,
-        };
-    }
-    if (config.every_n_turns > 0 && counters.turns >= config.every_n_turns) {
-        return {
-            due: true,
-            reason: `turn threshold (${counters.turns}/${config.every_n_turns})`,
-        };
-    }
-    if (config.every_n_todos_completed > 0 &&
-        counters.todosCompleted >= config.every_n_todos_completed) {
-        return {
-            due: true,
-            reason: `todo threshold (${counters.todosCompleted}/${config.every_n_todos_completed})`,
-        };
-    }
-    return { due: false, reason: null };
-}
-function incrementCounter(counters, kind) {
-    const next = { ...counters };
-    if (kind === 'gate')
-        next.gates += 1;
-    else if (kind === 'turn')
-        next.turns += 1;
-    else
-        next.todosCompleted += 1;
-    return next;
-}
-export function recordExecutionSlice(kind, ctx) {
-    if (!ctx.sessionId)
-        return null;
-    const projectRoot = ctx.projectRoot ?? process.cwd();
-    const config = loadSynthesisConfig(projectRoot);
-    if (!config.enabled)
-        return null;
-    const existing = loadSynthesisCheckpointState(projectRoot);
-    const base = existing && existing.sessionId === ctx.sessionId
-        ? existing
-        : createInitialSynthesisState(ctx.sessionId);
-    if (base.synthesisDue && kind !== 'todo_completed')
-        return null;
-    const now = new Date().toISOString();
-    const slicesSinceLastSynthesis = incrementCounter(base.slicesSinceLastSynthesis, kind);
-    const lifetimeSlices = incrementCounter(base.lifetimeSlices, kind);
-    let synthesisDue = base.synthesisDue;
-    let dueReason = base.dueReason;
-    let becameDue = false;
-    if (!synthesisDue) {
-        const evaluation = evaluateSynthesisDue(slicesSinceLastSynthesis, config);
-        if (evaluation.due) {
-            synthesisDue = true;
-            dueReason = evaluation.reason;
-            becameDue = true;
-        }
-    }
-    const state = {
-        ...base,
-        slicesSinceLastSynthesis,
-        lifetimeSlices,
-        synthesisDue,
-        dueReason,
-        lastSliceAt: now,
-    };
-    saveSynthesisCheckpointState(state, projectRoot);
-    return { state, becameDue, dueReason };
-}
-export function completeSynthesisCheckpoint(projectRoot = process.cwd(), sessionId) {
-    const state = loadSynthesisCheckpointState(projectRoot);
-    if (!state)
-        return null;
-    if (sessionId && state.sessionId !== sessionId)
-        return null;
-    const completed = {
-        ...state,
-        slicesSinceLastSynthesis: emptyCounters(),
-        synthesisDue: false,
-        dueReason: null,
-        lastSynthesisAt: new Date().toISOString(),
-        synthesisCount: state.synthesisCount + 1,
-    };
-    saveSynthesisCheckpointState(completed, projectRoot);
-    return completed;
-}
-export function isSynthesisCheckpointDue(projectRoot = process.cwd(), sessionId) {
-    const state = loadSynthesisCheckpointState(projectRoot);
-    if (!state?.synthesisDue)
-        return false;
-    if (sessionId && state.sessionId !== sessionId)
-        return false;
-    return loadSynthesisConfig(projectRoot).enabled;
-}
-export function getSynthesisDueReason(projectRoot = process.cwd(), sessionId) {
-    const state = loadSynthesisCheckpointState(projectRoot);
-    if (!state?.synthesisDue)
-        return null;
-    if (sessionId && state.sessionId !== sessionId)
-        return null;
-    return state.dueReason;
-}
-/** Session bound to an active synthesis checkpoint (for MCP when host omits sessionId). */
-export function getSynthesisCheckpointSessionId(projectRoot = process.cwd()) {
-    const state = loadSynthesisCheckpointState(projectRoot);
-    if (!state?.synthesisDue)
-        return null;
-    return state.sessionId;
-}

package/dist/nucleus/thin-dispatch.d.ts

@@ -1,33 +0,0 @@
-/**
- * xray Nucleus — thinDispatch (Phase 1E)
- *
- * Stable nucleus surface for complexity scoring and agent routing.
- * Wraps ComplexityAnalyzer; delegates routing to complexity-core utilities.
- *
- * Import from here or from delegation/index.ts (which re-exports these).
- */
-import { ComplexityMetrics, ComplexityScore, ComplexityLevel, ComplexityThresholds } from "../delegation/complexity-core.js";
-export type { ComplexityMetrics, ComplexityScore, ComplexityLevel, ComplexityThresholds };
-export declare const NUCLEUS_THIN_DISPATCH_VERSION = "0.1.0";
-/**
- * Score the complexity of an operation given its description and context.
- * Primary entry point for thinDispatch complexity scoring in the nucleus.
- */
-export declare function scoreComplexity(operation: string, context: unknown, thresholds?: ComplexityThresholds): ComplexityScore;
-/**
- * Route a complexity score / level to the appropriate agent type.
- * Uses core complexity-core mappings (tier → agent).
- */
-export declare function routeToAgent(scoreOrLevel: number | ComplexityScore, level?: ComplexityLevel): string;
-/**
- * Convenience: score first, then route — one call.
- */
-export declare function scoreAndRoute(operation: string, context: unknown, thresholds?: ComplexityThresholds): {
-    score: ComplexityScore;
-    agent: string;
-    memoryRouting?: {
-        providerId: string;
-        adjustedScore: number;
-        signals: string[];
-    };
-};

package/dist/nucleus/thin-dispatch.js

@@ -1,85 +0,0 @@
-/**
- * xray Nucleus — thinDispatch (Phase 1E)
- *
- * Stable nucleus surface for complexity scoring and agent routing.
- * Wraps ComplexityAnalyzer; delegates routing to complexity-core utilities.
- *
- * Import from here or from delegation/index.ts (which re-exports these).
- */
-import { frameworkLogger } from "../core/framework-logger.js";
-import { getLevelFromScore, getAgentForTier, levelToTier, } from "../delegation/complexity-core.js";
-import { ComplexityAnalyzer } from "../delegation/complexity-analyzer.js";
-import { getMemoryRoutingProviderSync, initializeMemoryRouting, } from "../memory-routing/index.js";
-initializeMemoryRouting();
-export const NUCLEUS_THIN_DISPATCH_VERSION = "0.1.0";
-/**
- * Score the complexity of an operation given its description and context.
- * Primary entry point for thinDispatch complexity scoring in the nucleus.
- */
-export function scoreComplexity(operation, context, thresholds) {
-    const analyzer = new ComplexityAnalyzer();
-    const metrics = analyzer.analyzeComplexity(operation, context);
-    const score = analyzer.calculateComplexityScore(metrics);
-    frameworkLogger.log("nucleus-thin-dispatch", "score-complexity", "info", {
-        operation: operation.substring(0, 100),
-        score: score.score,
-        level: score.level,
-        strategy: score.recommendedStrategy,
-    });
-    return score;
-}
-/**
- * Route a complexity score / level to the appropriate agent type.
- * Uses core complexity-core mappings (tier → agent).
- */
-export function routeToAgent(scoreOrLevel, level) {
-    let effectiveLevel;
-    if (level) {
-        effectiveLevel = level;
-    }
-    else if (typeof scoreOrLevel === "object" && scoreOrLevel !== null) {
-        effectiveLevel = scoreOrLevel.level;
-    }
-    else if (typeof scoreOrLevel === "number") {
-        effectiveLevel = getLevelFromScore(scoreOrLevel);
-    }
-    else {
-        effectiveLevel = "simple";
-    }
-    const tier = levelToTier(effectiveLevel);
-    return getAgentForTier(tier);
-}
-/**
- * Convenience: score first, then route — one call.
- */
-export function scoreAndRoute(operation, context, thresholds) {
-    const score = scoreComplexity(operation, context, thresholds);
-    let agent = routeToAgent(score);
-    const provider = getMemoryRoutingProviderSync();
-    let memoryRouting;
-    if (provider.id !== "null") {
-        const resolved = provider.resolveThinDispatch(agent, operation, score.score);
-        agent = resolved.agent;
-        memoryRouting = {
-            providerId: resolved.context.providerId,
-            adjustedScore: resolved.adjustedScore,
-            signals: resolved.context.matchedSignals,
-        };
-        const adjustedLevel = getLevelFromScore(resolved.adjustedScore, thresholds);
-        frameworkLogger.log("nucleus-thin-dispatch", "memory-routing", "info", {
-            providerId: resolved.context.providerId,
-            baseAgent: routeToAgent(score),
-            resolvedAgent: agent,
-            baseScore: score.score,
-            adjustedScore: resolved.adjustedScore,
-            level: adjustedLevel,
-            signals: resolved.context.matchedSignals,
-        });
-        return {
-            score: { ...score, score: resolved.adjustedScore, level: adjustedLevel },
-            agent,
-            memoryRouting,
-        };
-    }
-    return { score, agent };
-}

package/dist/nucleus/user-aside.d.ts

@@ -1,70 +0,0 @@
-/**
- * User aside — parallel work tracks (worktree-like) declared by the user.
- * SSOT: `.xray/state/asides/{id}.json` + `_active.json`.
- * Todo ids: `{asideId}.a.{phase}.{todo}` — globally unique per aside.
- */
-import { type LeadDevPlan, type LeadDevPlanTaskInput, type LeadDevTodo } from './autonomy-kernel.js';
-import { type PersistedLeadDevPlan } from './lead-dev-plan-persistence.js';
-export declare const USER_ASIDE_ID_PATTERN: RegExp;
-/** Namespaced aside todo: `suit-nft.a.1.1` */
-export declare const USER_ASIDE_TODO_PATTERN: RegExp;
-export declare const USER_ASIDE_STATE_VERSION: 1;
-export type UserAsideStatus = 'active' | 'paused' | 'completed' | 'archived';
-export interface UserAsideGovernance {
-    /** Session-boot hint to run confer before aside phase work (manual MCP — not auto confer). */
-    conferOnPhaseStart?: boolean;
-    /** Repertoire trap signal names surfaced in session-boot for aside work. */
-    trapSignals?: string[];
-}
-export interface UserAside {
-    version: typeof USER_ASIDE_STATE_VERSION;
-    id: string;
-    title: string;
-    status: UserAsideStatus;
-    owner?: string;
-    description: string;
-    definitionOfDone?: string;
-    worktree?: string;
-    branch?: string;
-    persistedAt?: string;
-    sessionId?: string;
-    governance?: UserAsideGovernance;
-    plan: LeadDevPlan;
-}
-export interface ActiveAsidePointer {
-    asideId: string;
-    activatedAt: string;
-    sessionId?: string;
-}
-export declare class UserAsideValidationError extends Error {
-    constructor(message: string);
-}
-export declare function assertSafeAsideId(asideId: string): string;
-export declare function asideTodoId(asideId: string, phaseIndex: number, todoIndex: number): string;
-export declare function isUserAsideTodoId(todoId: string): boolean;
-export declare function parseAsideIdFromTodoId(todoId: string): string | null;
-export declare function userAsidesDir(projectRoot?: string): string;
-export declare function userAsidePath(asideId: string, projectRoot?: string): string;
-export declare function activeAsidePointerPath(projectRoot?: string): string;
-export declare function isUserAsidesEnabled(projectRoot?: string): boolean;
-/** Build a phased aside plan from task intake (mirrors lead-dev plan, namespaced todo ids). */
-export declare function buildUserAsidePlan(asideId: string, title: string, description: string, taskInputs?: LeadDevPlanTaskInput[], mcpOverallComplexity?: number, projectRoot?: string): UserAside | null;
-/** Merge new task intake into an existing aside (re-intake). */
-export declare function mergeUserAsideIntake(existing: UserAside, description: string, taskInputs: LeadDevPlanTaskInput[], mcpOverallComplexity?: number, projectRoot?: string): UserAside;
-export declare function loadUserAside(asideId: string, projectRoot?: string): UserAside | null;
-export declare function saveUserAside(aside: UserAside, projectRoot?: string): string;
-export declare function listUserAsideIds(projectRoot?: string): string[];
-export declare function loadActiveAsidePointer(projectRoot?: string): ActiveAsidePointer | null;
-export declare function getActiveAsideId(projectRoot?: string, sessionId?: string | null): string | null;
-export declare function setActiveAsideId(asideId: string, projectRoot?: string, sessionId?: string | null): ActiveAsidePointer;
-export declare function clearActiveAside(projectRoot?: string): boolean;
-export declare function loadActiveUserAside(projectRoot?: string, sessionId?: string | null): UserAside | null;
-/** PersistedLeadDevPlan view of an aside for spawn-gate reuse. */
-export declare function asideToSpawnPlan(aside: UserAside): PersistedLeadDevPlan;
-/** Aside routable when active for session, or pointer is unscoped (accepted exception). */
-export declare function isAsideActiveForSession(asideId: string, projectRoot?: string, sessionId?: string | null): boolean;
-export declare function findAsideContainingTodo(todoId: string, projectRoot?: string, preferredAsideId?: string): UserAside | null;
-export declare function updateUserAsideTodoStatus(todoId: string, status: LeadDevTodo['status'], projectRoot?: string, sessionId?: string | null): boolean;
-export declare function getNextAsideTodo(aside: UserAside): LeadDevTodo | null;
-export declare function formatUserAsideSummary(aside: UserAside): string;
-export declare function getUserAsideBootHints(projectRoot?: string, sessionId?: string | null): Record<string, unknown> | null;