oxe-cc 0.9.3 → 1.0.0

package/bin/oxe-cc.js

@@ -2125,7 +2125,7 @@ ${green}Uso:${reset}
   npx oxe-cc init-oxe [opções] [pasta-do-projeto]
   npx oxe-cc context <build|inspect> [opções] [pasta-do-projeto]
   npx oxe-cc dashboard [opções] [pasta-do-projeto]
-  npx oxe-cc runtime <status|start|pause|resume|replay> [opções] [pasta-do-projeto]
+  npx oxe-cc runtime <status|start|pause|resume|replay|compile|project|ci> [opções] [pasta-do-projeto]
   npx oxe-cc azure <status|doctor|auth|sync|find|servicebus|eventgrid|sql|operations> [opções] [pasta-do-projeto]
   npx oxe-cc capabilities <list|install|remove|update> [opções] [id]
   npx oxe-cc uninstall [opções] [pasta-do-projeto]
@@ -2167,18 +2167,24 @@ ${green}context${reset} (Context Engine V2: seleção, compressão e inspeção
   --json                                 saída estruturada em JSON
   --dir <pasta>                          raiz do projeto (padrão: diretório atual)
 
-${green}runtime${reset} (controle operacional explícito do ACTIVE-RUN)
-  status                                 mostra o run ativo resolvido para a sessão atual
-  start                                  cria um novo run com tracing inicial
-  pause                                  pausa o run ativo e preserva o cursor
-  resume                                 retoma o run ativo
-  replay                                 marca replay parcial por onda ou tarefa
-  --session <sessions/sNNN-slug>         força sessão específica
-  --wave <número>                        fixa onda atual/cursor
-  --task <Tn>                            fixa tarefa atual/cursor
-  --mode <complete|wave|task>            modo operacional do cursor
-  --reason <texto>                       motivo explícito da transição
-  --dir <pasta>                          raiz do projeto (padrão: diretório atual)
+${green}runtime${reset} (controle operacional explícito do ACTIVE-RUN)
+  status                                 mostra o run ativo resolvido para a sessão atual
+  start                                  cria um novo run com tracing inicial
+  pause                                  pausa o run ativo e preserva o cursor
+  resume                                 retoma o run ativo
+  replay                                 marca replay parcial por onda ou tarefa
+  compile                                compila PLAN/SPEC em ExecutionGraph formal + verification suite
+  project                                projeta markdowns derivados do estado canônico
+  ci                                     executa checks do runtime e persiste o resultado na run
+  --session <sessions/sNNN-slug>         força sessão específica
+  --wave <número>                        fixa onda atual/cursor
+  --task <Tn>                            fixa tarefa atual/cursor
+  --mode <complete|wave|task>            modo operacional do cursor
+  --reason <texto>                       motivo explícito da transição
+  --run <run_id>                         (replay|ci) filtra um run específico
+  --from <event_id>                      (replay) começa em um event_id específico
+  --write                                (replay) gera REPLAY-SESSION.md
+  --dir <pasta>                          raiz do projeto (padrão: diretório atual)
 
 ${green}azure${reset} (provider Azure nativo via Azure CLI no Windows)
   status                                 estado compacto: CLI, login, subscription, inventário, pendências
@@ -3707,11 +3713,11 @@ async function runDashboard(opts) {
 /**
  * @param {RuntimeOpts} opts
  */
-function runRuntime(opts) {
-  const c = useAnsiColors();
-  printSection('OXE ▸ runtime');
-  if (!fs.existsSync(opts.dir)) {
-    console.error(`${yellow}Diretório não encontrado: ${opts.dir}${reset}`);
+async function runRuntime(opts) {
+  const c = useAnsiColors();
+  printSection('OXE ▸ runtime');
+  if (!fs.existsSync(opts.dir)) {
+    console.error(`${yellow}Diretório não encontrado: ${opts.dir}${reset}`);
     process.exit(1);
   }
   bootstrapOxe(opts.dir, { dryRun: false, force: false });
@@ -3722,20 +3728,32 @@ function runRuntime(opts) {
   console.log(`  ${c ? green : ''}Projeto:${c ? reset : ''} ${c ? cyan : ''}${opts.dir}${c ? reset : ''}`);
   console.log(`  ${c ? green : ''}Sessão:${c ? reset : ''} ${c ? cyan : ''}${activeSession || 'modo legado'}${c ? reset : ''}`);
 
-  if (opts.action === 'status') {
-    const current = oxeOperational.readRunState(opts.dir, activeSession);
-    if (!current) {
-      console.log(`  ${yellow}Nenhum ACTIVE-RUN encontrado.${reset}`);
-      return;
-    }
-    console.log(`  ${c ? green : ''}Run:${c ? reset : ''} ${current.run_id}`);
-    console.log(`  ${c ? green : ''}Estado:${c ? reset : ''} ${current.status}`);
-    console.log(`  ${c ? green : ''}Cursor:${c ? reset : ''} onda=${current.cursor && current.cursor.wave != null ? current.cursor.wave : '—'} tarefa=${current.cursor && current.cursor.task ? current.cursor.task : '—'} modo=${current.cursor && current.cursor.mode ? current.cursor.mode : '—'}`);
-    console.log(`  ${c ? green : ''}Arquivo:${c ? reset : ''} ${path.join(p.runsDir, `${current.run_id}.json`)}`);
-    return;
-  }
-
-  if (opts.action === 'replay' && !opts.task) {
+  if (opts.action === 'status') {
+    const current = oxeOperational.readRunState(opts.dir, activeSession);
+    if (!current) {
+      console.log(`  ${yellow}Nenhum ACTIVE-RUN encontrado.${reset}`);
+      return;
+    }
+    console.log(`  ${c ? green : ''}Run:${c ? reset : ''} ${current.run_id}`);
+    console.log(`  ${c ? green : ''}Estado:${c ? reset : ''} ${current.status}`);
+    console.log(`  ${c ? green : ''}Cursor:${c ? reset : ''} onda=${current.cursor && current.cursor.wave != null ? current.cursor.wave : '—'} tarefa=${current.cursor && current.cursor.task ? current.cursor.task : '—'} modo=${current.cursor && current.cursor.mode ? current.cursor.mode : '—'}`);
+    console.log(`  ${c ? green : ''}Arquivo:${c ? reset : ''} ${path.join(p.runsDir, `${current.run_id}.json`)}`);
+    if (current.compiled_graph && current.compiled_graph.metadata) {
+      console.log(`  ${c ? green : ''}Graph:${c ? reset : ''} ${current.compiled_graph.metadata.node_count || 0} nós · ${current.compiled_graph.metadata.wave_count || 0} ondas`);
+    }
+    if (current.canonical_state && current.canonical_state.summary) {
+      console.log(`  ${c ? green : ''}Canonical:${c ? reset : ''} work_items=${current.canonical_state.summary.work_item_count || 0} · attempts=${current.canonical_state.summary.attempt_count || 0}`);
+    }
+    if (current.ci_checks && current.ci_checks.summary) {
+      console.log(`  ${c ? green : ''}CI:${c ? reset : ''} pass=${current.ci_checks.summary.pass || 0} fail=${current.ci_checks.summary.fail || 0} skip=${current.ci_checks.summary.skip || 0} error=${current.ci_checks.summary.error || 0}`);
+    }
+    if (current.projections && current.projections.generated_at) {
+      console.log(`  ${c ? green : ''}Projection:${c ? reset : ''} ${current.projections.generated_at}`);
+    }
+    return;
+  }
+
+  if (opts.action === 'replay' && !opts.task) {
     const report = oxeOperational.replayEvents(opts.dir, activeSession, {
       runId: opts.runId || undefined,
       fromEventId: opts.fromEventId || undefined,
@@ -3747,34 +3765,97 @@ function runRuntime(opts) {
     console.log(`  ${c ? green : ''}Ondas:${c ? reset : ''} ${report.waveIds.join(', ') || '—'}`);
     console.log(`  ${c ? green : ''}Tarefas:${c ? reset : ''} ${report.taskSequence.join(', ') || '—'}`);
     console.log(`  ${c ? green : ''}Falhas:${c ? reset : ''} ${report.failureEvents.length}`);
-    if (report.totalEvents > 0) {
-      console.log('');
-      const dim = c ? '\x1b[2m' : '';
-      console.log(`  ${dim}#   Tipo                    Wave    Task    Delta      Timestamp${c ? reset : ''}`);
-      for (let i = 0; i < Math.min(report.events.length, 50); i++) {
-        const e = report.events[i];
-        const delta = i > 0 ? `+${(e._delta_ms / 1000).toFixed(1)}s` : '—';
-        const num = String(i + 1).padStart(3);
-        const type = String(e.type).padEnd(22).slice(0, 22);
-        const wave = String(e.wave_id || '—').padEnd(7).slice(0, 7);
-        const task = String(e.task_id || '—').padEnd(7).slice(0, 7);
-        const deltaStr = delta.padStart(10);
-        console.log(`  ${num} ${type} ${wave} ${task} ${deltaStr}  ${e.timestamp}`);
-      }
+    if (report.totalEvents > 0) {
+      console.log('');
+      const dim = c ? '\x1b[2m' : '';
+      console.log(`  ${dim}#   Tipo                    Wave    Task    Delta      Timestamp${c ? reset : ''}`);
+      for (let i = 0; i < Math.min(report.events.length, 50); i++) {
+        const e = report.events[i];
+        const delta = i > 0 ? `+${(e._delta_ms / 1000).toFixed(1)}s` : '—';
+        const num = String(i + 1).padStart(3);
+        const type = String(e.type).padEnd(22).slice(0, 22);
+        const wave = String(e.wave_id || '—').padEnd(7).slice(0, 7);
+        const task = String(e.task_id || e.work_item_id || '—').padEnd(7).slice(0, 7);
+        const deltaStr = delta.padStart(10);
+        console.log(`  ${num} ${type} ${wave} ${task} ${deltaStr}  ${e.timestamp}`);
+      }
       if (report.events.length > 50) {
         console.log(`  … (${report.events.length - 50} mais)`);
       }
     }
     if (report._reportPath) {
       console.log(`\n  ${c ? green : ''}Relatório:${c ? reset : ''} ${report._reportPath}`);
-    }
-    return;
-  }
-
-  try {
-    const next = oxeOperational.applyRuntimeAction(opts.dir, activeSession, {
-      action: opts.action,
-      wave: opts.wave,
+    }
+    return;
+  }
+
+  if (opts.action === 'compile') {
+    try {
+      const compiled = oxeOperational.compileExecutionGraphFromArtifacts(opts.dir, activeSession);
+      const suite = oxeOperational.compileVerificationSuiteFromArtifacts(opts.dir, activeSession, {
+        runState: compiled.run,
+      });
+      console.log(`  ${c ? green : ''}✓${c ? reset : ''} Runtime compilado.`);
+      console.log(`  ${c ? green : ''}Run:${c ? reset : ''} ${compiled.run.run_id}`);
+      console.log(`  ${c ? green : ''}Graph:${c ? reset : ''} ${compiled.graph.metadata.node_count} nó(s) · ${compiled.graph.metadata.wave_count} onda(s)`);
+      console.log(`  ${c ? green : ''}Checks:${c ? reset : ''} ${Array.isArray(suite.suite.checks) ? suite.suite.checks.length : 0}`);
+      if (compiled.validationErrors.length) {
+        console.log(`  ${yellow}Validation:${reset} ${compiled.validationErrors.join(' | ')}`);
+      }
+      console.log(`  ${c ? green : ''}Arquivo:${c ? reset : ''} ${path.join(p.runsDir, `${compiled.run.run_id}.json`)}`);
+      return;
+    } catch (err) {
+      console.error(`${red}${err && err.message ? err.message : 'Falha ao compilar o runtime.'}${reset}`);
+      process.exit(1);
+    }
+  }
+
+  if (opts.action === 'project') {
+    try {
+      const projected = oxeOperational.projectRuntimeArtifacts(opts.dir, activeSession, { write: true });
+      console.log(`  ${c ? green : ''}✓${c ? reset : ''} Projeções geradas a partir do estado canônico.`);
+      console.log(`  ${c ? green : ''}Run:${c ? reset : ''} ${projected.run.run_id}`);
+      console.log(`  ${c ? green : ''}STATE:${c ? reset : ''} ${projected.paths.state}`);
+      console.log(`  ${c ? green : ''}PLAN:${c ? reset : ''} ${projected.paths.plan}`);
+      console.log(`  ${c ? green : ''}VERIFY:${c ? reset : ''} ${projected.paths.verify}`);
+      console.log(`  ${c ? green : ''}RUN-SUMMARY:${c ? reset : ''} ${projected.paths.runSummary}`);
+      console.log(`  ${c ? green : ''}PR-SUMMARY:${c ? reset : ''} ${projected.paths.prSummary}`);
+      return;
+    } catch (err) {
+      console.error(`${red}${err && err.message ? err.message : 'Falha ao projetar artefatos do runtime.'}${reset}`);
+      process.exit(1);
+    }
+  }
+
+  if (opts.action === 'ci') {
+    try {
+      const report = await oxeOperational.runRuntimeCiChecks(opts.dir, activeSession, {
+        runId: opts.runId || undefined,
+      });
+      console.log(`  ${c ? green : ''}Run:${c ? reset : ''} ${report.runId || '—'}`);
+      for (const result of report.results) {
+        const color = result.status === 'pass'
+          ? green
+          : result.status === 'skip'
+            ? dim
+            : red;
+        console.log(`  ${c ? color : ''}${result.status.toUpperCase()}${c ? reset : ''} ${result.check} · ${result.message}`);
+      }
+      console.log(`  ${c ? green : ''}Resumo:${c ? reset : ''} pass=${report.summary.pass} fail=${report.summary.fail} skip=${report.summary.skip} error=${report.summary.error}`);
+      if (!report.summary.allPassed) {
+        process.exitCode = 1;
+      }
+      return;
+    } catch (err) {
+      console.error(`${red}${err && err.message ? err.message : 'Falha ao executar checks do runtime.'}${reset}`);
+      process.exit(1);
+    }
+  }
+
+  try {
+    const next = oxeOperational.applyRuntimeAction(opts.dir, activeSession, {
+      action: opts.action,
+      wave: opts.wave,
       task: opts.task || null,
       mode: opts.mode || null,
       reason: opts.reason || '',
@@ -4427,9 +4508,12 @@ async function main() {
       console.error(`${yellow}Diretório não encontrado: ${runtime.dir}${reset}`);
       process.exit(1);
     }
-    runRuntime(runtime);
-    return;
-  }
+    runRuntime(runtime).catch((err) => {
+      console.error(`${red}${err && err.message ? err.message : 'Falha ao executar runtime.'}${reset}`);
+      process.exit(1);
+    });
+    return;
+  }
 
   if (command === 'plugins') {
     printBanner();

package/lib/runtime/compiler/graph-compiler.d.ts

@@ -0,0 +1,83 @@
+import type { WorkspaceStrategy } from '../models/workspace';
+export interface ParsedTask {
+    id: string;
+    title: string;
+    wave: number | null;
+    dependsOn: string[];
+    files: string[];
+    verifyCommand: string | null;
+    aceite: string[];
+    done: boolean;
+    meta?: Record<string, unknown> | null;
+}
+export interface ParsedSpecCriterion {
+    id: string;
+    criterion: string;
+    howToVerify: string;
+}
+export interface ParsedSpec {
+    objective: string | null;
+    criteria: ParsedSpecCriterion[];
+}
+export interface ParsedPlan {
+    tasks: ParsedTask[];
+    waves: Record<number, string[]>;
+    totalTasks: number;
+}
+export interface Action {
+    type: 'read_code' | 'generate_patch' | 'run_tests' | 'run_lint' | 'collect_evidence' | 'custom';
+    command?: string;
+    targets?: string[];
+}
+export interface VerifyContract {
+    must_pass: string[];
+    acceptance_refs: string[];
+    command: string | null;
+}
+export interface NodePolicy {
+    requires_human_approval: boolean;
+    max_retries: number;
+}
+export interface GraphNode {
+    id: string;
+    title: string;
+    wave: number;
+    depends_on: string[];
+    workspace_strategy: WorkspaceStrategy;
+    mutation_scope: string[];
+    actions: Action[];
+    verify: VerifyContract;
+    policy: NodePolicy;
+}
+export interface GraphEdge {
+    from: string;
+    to: string;
+    type: 'dependency' | 'wave_sequence';
+}
+export interface Wave {
+    wave_number: number;
+    node_ids: string[];
+}
+export interface ExecutionGraphMetadata {
+    compiled_at: string;
+    plan_hash: string;
+    spec_hash: string;
+    node_count: number;
+    wave_count: number;
+}
+export interface ExecutionGraph {
+    nodes: Map<string, GraphNode>;
+    edges: GraphEdge[];
+    waves: Wave[];
+    metadata: ExecutionGraphMetadata;
+}
+export interface CompilerOptions {
+    default_workspace_strategy?: WorkspaceStrategy;
+    default_max_retries?: number;
+    require_approval_for_all?: boolean;
+    skip_done_tasks?: boolean;
+}
+export declare function compile(plan: ParsedPlan, spec: ParsedSpec, options?: CompilerOptions): ExecutionGraph;
+export declare function validateGraph(graph: ExecutionGraph): string[];
+export declare function toSerializable(graph: ExecutionGraph): Record<string, unknown>;
+export declare function fromSerializable(raw: Record<string, unknown>): ExecutionGraph;

package/lib/runtime/compiler/graph-compiler.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = compile;
+exports.validateGraph = validateGraph;
+exports.toSerializable = toSerializable;
+exports.fromSerializable = fromSerializable;
+const crypto_1 = __importDefault(require("crypto"));
+function compile(plan, spec, options = {}) {
+    const { default_workspace_strategy = 'git_worktree', default_max_retries = 2, require_approval_for_all = false, skip_done_tasks = false, } = options;
+    const nodes = new Map();
+    const edges = [];
+    const waveMap = new Map();
+    for (const task of plan.tasks) {
+        if (skip_done_tasks && task.done)
+            continue;
+        const waveNumber = task.wave ?? 1;
+        const node = {
+            id: task.id,
+            title: task.title,
+            wave: waveNumber,
+            depends_on: task.dependsOn,
+            workspace_strategy: default_workspace_strategy,
+            mutation_scope: task.files,
+            actions: buildActions(task),
+            verify: {
+                must_pass: task.verifyCommand ? ['tests'] : [],
+                acceptance_refs: task.aceite,
+                command: task.verifyCommand,
+            },
+            policy: {
+                requires_human_approval: require_approval_for_all,
+                max_retries: default_max_retries,
+            },
+        };
+        nodes.set(task.id, node);
+        for (const dep of task.dependsOn) {
+            edges.push({ from: dep, to: task.id, type: 'dependency' });
+        }
+        if (!waveMap.has(waveNumber))
+            waveMap.set(waveNumber, []);
+        waveMap.get(waveNumber).push(task.id);
+    }
+    const waves = Array.from(waveMap.entries())
+        .sort(([a], [b]) => a - b)
+        .map(([wave_number, node_ids]) => ({ wave_number, node_ids }));
+    return {
+        nodes,
+        edges,
+        waves,
+        metadata: {
+            compiled_at: new Date().toISOString(),
+            plan_hash: hashObject(plan),
+            spec_hash: hashObject(spec),
+            node_count: nodes.size,
+            wave_count: waves.length,
+        },
+    };
+}
+function validateGraph(graph) {
+    const errors = [];
+    const nodeIds = new Set(graph.nodes.keys());
+    for (const [id, node] of graph.nodes) {
+        for (const dep of node.depends_on) {
+            if (!nodeIds.has(dep)) {
+                errors.push(`Node ${id} depends on unknown node ${dep}`);
+            }
+        }
+    }
+    // Detect cycles using DFS
+    const visited = new Set();
+    const inStack = new Set();
+    function hasCycle(nodeId) {
+        if (inStack.has(nodeId))
+            return true;
+        if (visited.has(nodeId))
+            return false;
+        visited.add(nodeId);
+        inStack.add(nodeId);
+        const node = graph.nodes.get(nodeId);
+        if (node) {
+            for (const dep of node.depends_on) {
+                if (hasCycle(dep))
+                    return true;
+            }
+        }
+        inStack.delete(nodeId);
+        return false;
+    }
+    for (const id of nodeIds) {
+        if (hasCycle(id)) {
+            errors.push(`Cycle detected involving node ${id}`);
+            break;
+        }
+    }
+    return errors;
+}
+function toSerializable(graph) {
+    return {
+        nodes: Object.fromEntries(graph.nodes),
+        edges: graph.edges,
+        waves: graph.waves,
+        metadata: graph.metadata,
+    };
+}
+function fromSerializable(raw) {
+    const nodes = new Map(Object.entries(raw.nodes));
+    return {
+        nodes,
+        edges: raw.edges,
+        waves: raw.waves,
+        metadata: raw.metadata,
+    };
+}
+function buildActions(task) {
+    const actions = [];
+    if (task.files.length > 0) {
+        actions.push({ type: 'read_code', targets: task.files });
+    }
+    actions.push({ type: 'generate_patch' });
+    if (task.verifyCommand) {
+        actions.push({ type: 'run_tests', command: task.verifyCommand });
+    }
+    actions.push({ type: 'collect_evidence' });
+    return actions;
+}
+function hashObject(obj) {
+    return crypto_1.default
+        .createHash('sha256')
+        .update(JSON.stringify(obj))
+        .digest('hex')
+        .slice(0, 12);
+}

package/lib/runtime/compiler/index.d.ts

@@ -0,0 +1 @@
+export * from './graph-compiler';

package/lib/runtime/compiler/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./graph-compiler"), exports);

package/lib/runtime/context/context-pack-builder.d.ts

@@ -0,0 +1,36 @@
+import type { WorkItem } from '../models/work-item';
+import type { Evidence } from '../models/evidence';
+import type { RunState } from '../reducers/run-state-reducer';
+export interface ContextArtifact {
+    id: string;
+    kind: 'evidence' | 'lesson' | 'file' | 'summary';
+    content: string;
+    relevanceScore: number;
+    tags: string[];
+}
+export interface LessonMetric {
+    lesson_id: string;
+    title: string;
+    tags: string[];
+    embedding?: number[];
+    content: string;
+}
+export interface ContextPackOptions {
+    maxArtifacts?: number;
+    maxTokensEstimate?: number;
+    deduplicateThreshold?: number;
+}
+export interface ContextPack {
+    work_item_id: string;
+    artifacts: ContextArtifact[];
+    total_artifacts_considered: number;
+    redundancy_removed: number;
+    built_at: string;
+}
+export declare class ContextPackBuilder {
+    private readonly opts;
+    constructor(opts?: ContextPackOptions);
+    build(workItem: WorkItem, state: RunState, evidenceItems: Evidence[], evidenceContents: Map<string, string>, lessons: LessonMetric[]): ContextPack;
+    /** Convenience: build with no evidence, just lessons and state summary */
+    buildLightweight(workItem: WorkItem, state: RunState, lessons: LessonMetric[]): ContextPack;
+}

package/lib/runtime/context/context-pack-builder.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextPackBuilder = void 0;
+// ─── Relevance scoring ────────────────────────────────────────────────────────
+function scoreEvidenceRelevance(evidence, workItem) {
+    let score = 0.5;
+    const eid = evidence.evidence_id.toLowerCase();
+    const title = workItem.title.toLowerCase();
+    const scope = workItem.mutation_scope ?? [];
+    if (scope.some((s) => eid.includes(s.toLowerCase())))
+        score += 0.3;
+    if (title.split(/\s+/).some((w) => w.length > 3 && eid.includes(w)))
+        score += 0.1;
+    if (evidence.type === 'junit_xml')
+        score += 0.05;
+    if (evidence.type === 'diff')
+        score += 0.05;
+    return Math.min(score, 1.0);
+}
+function scoreLessonRelevance(lesson, workItem) {
+    const itemTags = new Set([
+        ...workItem.mutation_scope.map((s) => s.toLowerCase()),
+        ...workItem.title.toLowerCase().split(/\s+/).filter((w) => w.length > 3),
+    ]);
+    const lessonTags = lesson.tags.map((t) => t.toLowerCase());
+    const overlap = lessonTags.filter((t) => itemTags.has(t)).length;
+    const jaccard = overlap / (itemTags.size + lessonTags.length - overlap || 1);
+    return Math.min(0.3 + jaccard * 0.7, 1.0);
+}
+// ─── Redundancy elimination ───────────────────────────────────────────────────
+function cosineSimilarity(a, b) {
+    const wordsA = new Set(a.content.toLowerCase().split(/\W+/).filter((w) => w.length > 3));
+    const wordsB = new Set(b.content.toLowerCase().split(/\W+/).filter((w) => w.length > 3));
+    if (wordsA.size === 0 || wordsB.size === 0)
+        return 0;
+    let intersection = 0;
+    for (const w of wordsA)
+        if (wordsB.has(w))
+            intersection++;
+    return intersection / Math.sqrt(wordsA.size * wordsB.size);
+}
+function deduplicateArtifacts(artifacts, threshold) {
+    const kept = [];
+    let removed = 0;
+    for (const candidate of artifacts) {
+        const isDuplicate = kept.some((existing) => cosineSimilarity(candidate, existing) >= threshold);
+        if (isDuplicate) {
+            removed++;
+        }
+        else {
+            kept.push(candidate);
+        }
+    }
+    return { kept, removed };
+}
+// ─── Token budget estimation ──────────────────────────────────────────────────
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+function applyTokenBudget(artifacts, maxTokens) {
+    let used = 0;
+    const result = [];
+    for (const a of artifacts) {
+        const t = estimateTokens(a.content);
+        if (used + t > maxTokens)
+            break;
+        result.push(a);
+        used += t;
+    }
+    return result;
+}
+// ─── Context Pack Builder ─────────────────────────────────────────────────────
+class ContextPackBuilder {
+    constructor(opts = {}) {
+        this.opts = opts;
+    }
+    build(workItem, state, evidenceItems, evidenceContents, lessons) {
+        const { maxArtifacts = 20, maxTokensEstimate = 8000, deduplicateThreshold = 0.85, } = this.opts;
+        const raw = [];
+        // Score and collect evidence
+        for (const ev of evidenceItems) {
+            const content = evidenceContents.get(ev.evidence_id) ?? '';
+            if (!content)
+                continue;
+            raw.push({
+                id: ev.evidence_id,
+                kind: 'evidence',
+                content,
+                relevanceScore: scoreEvidenceRelevance(ev, workItem),
+                tags: [ev.type, workItem.work_item_id],
+            });
+        }
+        // Score and collect lessons
+        for (const lesson of lessons) {
+            raw.push({
+                id: lesson.lesson_id,
+                kind: 'lesson',
+                content: lesson.content,
+                relevanceScore: scoreLessonRelevance(lesson, workItem),
+                tags: lesson.tags,
+            });
+        }
+        // Add run-level summary if available
+        const completedCount = state.completedWorkItems.size;
+        if (completedCount > 0) {
+            raw.push({
+                id: `run-summary-${workItem.run_id}`,
+                kind: 'summary',
+                content: `Run progress: ${completedCount} completed, ${state.failedWorkItems.size} failed, ${state.blockedWorkItems.size} blocked.`,
+                relevanceScore: 0.4,
+                tags: ['run-context'],
+            });
+        }
+        const totalConsidered = raw.length;
+        // Sort by relevance descending
+        raw.sort((a, b) => b.relevanceScore - a.relevanceScore);
+        // Deduplicate
+        const { kept, removed } = deduplicateArtifacts(raw, deduplicateThreshold);
+        // Apply max artifacts cap
+        const capped = kept.slice(0, maxArtifacts);
+        // Apply token budget
+        const final = applyTokenBudget(capped, maxTokensEstimate);
+        return {
+            work_item_id: workItem.work_item_id,
+            artifacts: final,
+            total_artifacts_considered: totalConsidered,
+            redundancy_removed: removed,
+            built_at: new Date().toISOString(),
+        };
+    }
+    /** Convenience: build with no evidence, just lessons and state summary */
+    buildLightweight(workItem, state, lessons) {
+        return this.build(workItem, state, [], new Map(), lessons);
+    }
+}
+exports.ContextPackBuilder = ContextPackBuilder;

package/lib/runtime/context/index.d.ts

@@ -0,0 +1 @@
+export * from './context-pack-builder';