oxe-cc 1.0.0 → 1.3.0

package/packages/runtime/src/context/context-profiles.ts

@@ -0,0 +1,60 @@
+import type { ContextArtifact } from './context-pack-builder';
+
+export type ContextDecisionType = 'execute' | 'verify' | 'plan' | 'review' | 'debug' | 'migration';
+
+export interface ContextProfile {
+  decision_type: ContextDecisionType;
+  artifact_kind_weights: Record<ContextArtifact['kind'], number>;
+  quality_threshold: number;
+  max_artifacts: number;
+  max_tokens: number;
+}
+
+export const DEFAULT_PROFILES: Record<ContextDecisionType, ContextProfile> = {
+  execute: {
+    decision_type: 'execute',
+    artifact_kind_weights: { evidence: 0.8, lesson: 0.3, file: 0.6, summary: 0.4 },
+    quality_threshold: 0.6,
+    max_artifacts: 20,
+    max_tokens: 8000,
+  },
+  verify: {
+    decision_type: 'verify',
+    artifact_kind_weights: { evidence: 0.9, lesson: 0.2, file: 0.5, summary: 0.5 },
+    quality_threshold: 0.7,
+    max_artifacts: 15,
+    max_tokens: 6000,
+  },
+  plan: {
+    decision_type: 'plan',
+    artifact_kind_weights: { evidence: 0.4, lesson: 0.9, file: 0.7, summary: 0.6 },
+    quality_threshold: 0.5,
+    max_artifacts: 25,
+    max_tokens: 10000,
+  },
+  review: {
+    decision_type: 'review',
+    artifact_kind_weights: { evidence: 0.6, lesson: 0.5, file: 0.8, summary: 0.5 },
+    quality_threshold: 0.55,
+    max_artifacts: 20,
+    max_tokens: 8000,
+  },
+  debug: {
+    decision_type: 'debug',
+    artifact_kind_weights: { evidence: 0.9, lesson: 0.6, file: 0.7, summary: 0.4 },
+    quality_threshold: 0.6,
+    max_artifacts: 20,
+    max_tokens: 8000,
+  },
+  migration: {
+    decision_type: 'migration',
+    artifact_kind_weights: { evidence: 0.7, lesson: 0.7, file: 0.9, summary: 0.5 },
+    quality_threshold: 0.65,
+    max_artifacts: 30,
+    max_tokens: 12000,
+  },
+};
+
+export function getProfile(decisionType: ContextDecisionType): ContextProfile {
+  return DEFAULT_PROFILES[decisionType];
+}

package/packages/runtime/src/context/index.ts

@@ -1 +1,3 @@
-export * from './context-pack-builder';
+export * from './context-pack-builder';
+export * from './context-pack-store';
+export * from './context-profiles';

package/packages/runtime/src/decision/decision-engine.ts

@@ -0,0 +1,174 @@
+import crypto from 'crypto';
+import path from 'path';
+import fs from 'fs';
+import type { DecisionMemo } from './decision-memo';
+
+export type DecisionType =
+  | 'proceed'
+  | 'retry'
+  | 'escalate_gate'
+  | 'skip'
+  | 'abort'
+  | 'promote_lesson';
+
+export type DecisionSignal =
+  | 'policy_allowed'
+  | 'policy_denied'
+  | 'gate_pending'
+  | 'gate_approved'
+  | 'evidence_sufficient'
+  | 'evidence_missing'
+  | 'retry_budget_available'
+  | 'retry_budget_exhausted'
+  | 'lesson_match'
+  | 'risk_high';
+
+export type SeniorityLevel = 'junior' | 'standard' | 'senior' | 'expert';
+
+export interface DecisionRecord {
+  decision_id: string;
+  work_item_id: string | null;
+  run_id: string;
+  type: DecisionType;
+  seniority: SeniorityLevel;
+  confidence: number;
+  signals: DecisionSignal[];
+  rationale: string;
+  timestamp: string;
+  memo?: DecisionMemo;
+}
+
+export interface DecisionLog {
+  run_id: string;
+  decisions: DecisionRecord[];
+}
+
+export interface DecisionInput {
+  work_item_id?: string;
+  run_id: string;
+  policy_allowed: boolean;
+  gate_pending: boolean;
+  gate_approved: boolean;
+  retry_count: number;
+  max_retries: number;
+  evidence_count: number;
+  risk_level: 'none' | 'low' | 'medium' | 'high' | 'critical';
+  lesson_match: boolean;
+  memo?: DecisionMemo;
+}
+
+function computeSeniority(confidence: number): SeniorityLevel {
+  if (confidence >= 0.9) return 'expert';
+  if (confidence >= 0.75) return 'senior';
+  if (confidence >= 0.5) return 'standard';
+  return 'junior';
+}
+
+export class DecisionEngine {
+  evaluate(input: DecisionInput): DecisionRecord {
+    const signals: DecisionSignal[] = [];
+    let type: DecisionType = 'proceed';
+    let confidence = 0.8;
+    let rationale = '';
+
+    if (!input.policy_allowed) {
+      signals.push('policy_denied');
+      type = 'abort';
+      confidence = 1.0;
+      rationale = 'Policy denied execution — aborting without retry.';
+    } else {
+      signals.push('policy_allowed');
+
+      if (input.gate_pending && !input.gate_approved) {
+        signals.push('gate_pending');
+        type = 'escalate_gate';
+        confidence = 0.95;
+        rationale = 'Human gate pending — escalating for approval before proceeding.';
+      } else {
+        if (input.gate_approved) signals.push('gate_approved');
+
+        if (input.risk_level === 'high' || input.risk_level === 'critical') {
+          signals.push('risk_high');
+          confidence = Math.max(0.4, confidence - 0.3);
+          rationale += 'High residual risk detected. ';
+        }
+
+        if (input.retry_count >= input.max_retries) {
+          signals.push('retry_budget_exhausted');
+          type = 'abort';
+          confidence = 0.9;
+          rationale += `Retry budget exhausted (${input.retry_count}/${input.max_retries}).`;
+        } else if (input.retry_count > 0) {
+          signals.push('retry_budget_available');
+          type = 'retry';
+          confidence = 0.7;
+          rationale += `Retrying (attempt ${input.retry_count + 1}/${input.max_retries + 1}).`;
+        } else {
+          if (input.evidence_count > 0) {
+            signals.push('evidence_sufficient');
+            confidence = Math.min(1.0, confidence + 0.1);
+          } else {
+            signals.push('evidence_missing');
+            confidence = Math.max(0.3, confidence - 0.2);
+          }
+
+          if (input.lesson_match) {
+            signals.push('lesson_match');
+            type = 'promote_lesson';
+            confidence = Math.min(1.0, confidence + 0.05);
+          }
+
+          if (!rationale) rationale = 'All signals green — proceeding with execution.';
+        }
+      }
+    }
+
+    return {
+      decision_id: `dec-${crypto.randomBytes(4).toString('hex')}`,
+      work_item_id: input.work_item_id ?? null,
+      run_id: input.run_id,
+      type,
+      seniority: computeSeniority(confidence),
+      confidence: Math.round(confidence * 100) / 100,
+      signals,
+      rationale: rationale.trim(),
+      timestamp: new Date().toISOString(),
+      ...(input.memo !== undefined ? { memo: input.memo } : {}),
+    };
+  }
+}
+
+export function appendDecision(projectRoot: string, runId: string, record: DecisionRecord): void {
+  const p = logPath(projectRoot, runId);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+
+  const log = loadDecisionLog(projectRoot, runId) ?? { run_id: runId, decisions: [] };
+  log.decisions.push(record);
+  fs.writeFileSync(p, JSON.stringify(log, null, 2), 'utf8');
+}
+
+export function loadDecisionLog(projectRoot: string, runId: string): DecisionLog | null {
+  const p = logPath(projectRoot, runId);
+  if (!fs.existsSync(p)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8')) as DecisionLog;
+  } catch {
+    return null;
+  }
+}
+
+export function queryDecisions(
+  log: DecisionLog,
+  filter: { type?: DecisionType; workItemId?: string; minConfidence?: number }
+): DecisionRecord[] {
+  return log.decisions.filter((d) => {
+    if (filter.type && d.type !== filter.type) return false;
+    if (filter.workItemId && d.work_item_id !== filter.workItemId) return false;
+    if (filter.minConfidence !== undefined && d.confidence < filter.minConfidence) return false;
+    return true;
+  });
+}
+
+function logPath(projectRoot: string, runId: string): string {
+  return path.join(projectRoot, '.oxe', 'runs', runId, 'decisions.json');
+}

package/packages/runtime/src/decision/decision-memo.ts

@@ -0,0 +1,211 @@
+import crypto from 'crypto';
+import path from 'path';
+import fs from 'fs';
+
+export type ChangeStrategy =
+  | 'minimal_patch'
+  | 'isolated_refactor'
+  | 'expand_contract'
+  | 'feature_flag'
+  | 'no_op';
+
+export interface BlastRadiusEstimate {
+  estimated_files: number;
+  subsystems: string[];
+  risk_score: number;
+  reversible: boolean;
+}
+
+export interface RollbackPlan {
+  strategy: 'revert_commit' | 'restore_workspace' | 'undo_patch' | 'no_rollback';
+  steps: string[];
+  estimated_cost: 'low' | 'medium' | 'high';
+  preconditions: string[];
+}
+
+export interface DecisionMemo {
+  memo_id: string;
+  work_item_id: string;
+  run_id: string;
+  problem_summary: string;
+  chosen_strategy: ChangeStrategy;
+  alternatives_rejected: Array<{ strategy: ChangeStrategy; reason: string }>;
+  blast_radius: BlastRadiusEstimate;
+  rollback_plan: RollbackPlan;
+  min_evidence_required: string[];
+  confidence: number;
+  created_at: string;
+}
+
+// ─── BlastRadius estimation ───────────────────────────────────────────────────
+
+function deriveSubsystems(mutationScope: string[]): string[] {
+  const seen = new Set<string>();
+  for (const p of mutationScope) {
+    const parts = p.replace(/\\/g, '/').split('/');
+    if (parts.length >= 2) seen.add(parts[0]);
+    else seen.add(p);
+  }
+  return [...seen];
+}
+
+function estimateRiskScore(mutationScope: string[], retryCount: number, riskLevel: string): number {
+  let score = 0;
+  score += Math.min(0.4, mutationScope.length * 0.05);
+  score += retryCount > 0 ? Math.min(0.2, retryCount * 0.05) : 0;
+  switch (riskLevel) {
+    case 'critical': score += 0.4; break;
+    case 'high': score += 0.3; break;
+    case 'medium': score += 0.15; break;
+    case 'low': score += 0.05; break;
+    default: break;
+  }
+  return Math.min(1, score);
+}
+
+export function buildBlastRadius(
+  mutationScope: string[],
+  retryCount: number,
+  riskLevel: string
+): BlastRadiusEstimate {
+  const risk_score = estimateRiskScore(mutationScope, retryCount, riskLevel);
+  return {
+    estimated_files: mutationScope.length,
+    subsystems: deriveSubsystems(mutationScope),
+    risk_score: Math.round(risk_score * 100) / 100,
+    reversible: riskLevel !== 'critical' && mutationScope.length <= 10,
+  };
+}
+
+// ─── RollbackPlan ─────────────────────────────────────────────────────────────
+
+export function buildRollbackPlan(
+  blastRadius: BlastRadiusEstimate,
+  retryCount: number
+): RollbackPlan {
+  if (blastRadius.risk_score >= 0.7 || !blastRadius.reversible) {
+    return {
+      strategy: 'restore_workspace',
+      steps: ['snapshot workspace before mutation', 'restore snapshot on failure', 'verify clean state'],
+      estimated_cost: 'high',
+      preconditions: ['workspace snapshot available', 'no shared-state mutations'],
+    };
+  }
+  if (retryCount > 1 || blastRadius.estimated_files > 5) {
+    return {
+      strategy: 'revert_commit',
+      steps: ['record commit SHA before change', 'git revert on failure'],
+      estimated_cost: 'medium',
+      preconditions: ['git repo initialized', 'changes committed atomically'],
+    };
+  }
+  return {
+    strategy: 'undo_patch',
+    steps: ['apply inverse patch'],
+    estimated_cost: 'low',
+    preconditions: ['original file state recorded'],
+  };
+}
+
+// ─── StrategySelector ────────────────────────────────────────────────────────
+
+export class StrategySelector {
+  select(mutationScope: string[], retryCount: number, riskLevel: string): ChangeStrategy {
+    if (riskLevel === 'critical') return 'feature_flag';
+    if (retryCount > 1) return 'minimal_patch';
+    if (mutationScope.length > 8) return 'isolated_refactor';
+    if (riskLevel === 'high') return 'feature_flag';
+    if (mutationScope.length > 3) return 'expand_contract';
+    if (mutationScope.length === 0) return 'no_op';
+    return 'minimal_patch';
+  }
+
+  alternatives(chosen: ChangeStrategy, mutationScope: string[], riskLevel: string): Array<{ strategy: ChangeStrategy; reason: string }> {
+    const all: ChangeStrategy[] = ['minimal_patch', 'isolated_refactor', 'expand_contract', 'feature_flag', 'no_op'];
+    return all
+      .filter((s) => s !== chosen)
+      .map((s) => ({ strategy: s, reason: this.rejectionReason(s, chosen, mutationScope, riskLevel) }));
+  }
+
+  private rejectionReason(s: ChangeStrategy, chosen: ChangeStrategy, mutationScope: string[], riskLevel: string): string {
+    switch (s) {
+      case 'no_op': return 'mutation scope is non-empty; no-op would not satisfy requirements';
+      case 'feature_flag': return riskLevel !== 'critical' && riskLevel !== 'high' ? 'risk level does not warrant feature flag overhead' : `${chosen} preferred for scope size`;
+      case 'isolated_refactor': return mutationScope.length <= 8 ? 'scope is small enough for simpler strategy' : `${chosen} preferred`;
+      case 'expand_contract': return 'expand-contract requires coordinated deployment; overhead not justified here';
+      case 'minimal_patch': return `${chosen} preferred due to scope or risk level`;
+      default: return 'not applicable';
+    }
+  }
+}
+
+// ─── Memo builder & persistence ──────────────────────────────────────────────
+
+export interface BuildMemoInput {
+  work_item_id: string;
+  run_id: string;
+  problem_summary: string;
+  mutation_scope: string[];
+  retry_count: number;
+  risk_level: string;
+  min_evidence_required?: string[];
+  confidence?: number;
+}
+
+export function buildMemo(input: BuildMemoInput): DecisionMemo {
+  const selector = new StrategySelector();
+  const chosen = selector.select(input.mutation_scope, input.retry_count, input.risk_level);
+  const blast_radius = buildBlastRadius(input.mutation_scope, input.retry_count, input.risk_level);
+  const rollback_plan = buildRollbackPlan(blast_radius, input.retry_count);
+  const alternatives_rejected = selector.alternatives(chosen, input.mutation_scope, input.risk_level);
+
+  return {
+    memo_id: `memo-${crypto.randomBytes(4).toString('hex')}`,
+    work_item_id: input.work_item_id,
+    run_id: input.run_id,
+    problem_summary: input.problem_summary,
+    chosen_strategy: chosen,
+    alternatives_rejected,
+    blast_radius,
+    rollback_plan,
+    min_evidence_required: input.min_evidence_required ?? [],
+    confidence: input.confidence ?? (1 - blast_radius.risk_score),
+    created_at: new Date().toISOString(),
+  };
+}
+
+function memoDir(projectRoot: string, runId: string): string {
+  return path.join(projectRoot, '.oxe', 'runs', runId, 'memos');
+}
+
+export function saveMemo(projectRoot: string, memo: DecisionMemo): void {
+  const dir = memoDir(projectRoot, memo.run_id);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, `${memo.memo_id}.json`), JSON.stringify(memo, null, 2), 'utf8');
+}
+
+export function loadMemo(projectRoot: string, runId: string, memoId: string): DecisionMemo | null {
+  const p = path.join(memoDir(projectRoot, runId), `${memoId}.json`);
+  if (!fs.existsSync(p)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8')) as DecisionMemo;
+  } catch {
+    return null;
+  }
+}
+
+export function listMemos(projectRoot: string, runId: string): DecisionMemo[] {
+  const dir = memoDir(projectRoot, runId);
+  if (!fs.existsSync(dir)) return [];
+  return fs
+    .readdirSync(dir)
+    .filter((f) => f.endsWith('.json'))
+    .map((f) => {
+      try {
+        return JSON.parse(fs.readFileSync(path.join(dir, f), 'utf8')) as DecisionMemo;
+      } catch {
+        return null;
+      }
+    })
+    .filter((m): m is DecisionMemo => m !== null);
+}

package/packages/runtime/src/decision/index.ts

@@ -0,0 +1,2 @@
+export * from './decision-engine';
+export * from './decision-memo';

package/packages/runtime/src/delivery/branch-manager.ts

@@ -1,84 +1,91 @@
-import { execFileSync, spawnSync } from 'child_process';
-
-export interface BranchInfo {
-  name: string;
-  current: boolean;
-  commit: string;
-}
-
-export class BranchManager {
-  constructor(private readonly projectRoot: string) {}
-
-  currentBranch(): string {
-    return this.git(['rev-parse', '--abbrev-ref', 'HEAD']).trim();
-  }
-
-  currentCommit(): string {
-    return this.git(['rev-parse', 'HEAD']).trim();
-  }
-
-  createSessionBranch(sessionId: string): string {
-    const name = `oxe/${sessionId}`;
-    this.git(['checkout', '-b', name]);
-    return name;
-  }
-
-  createOxeBranch(name: string, base?: string): string {
-    const fullName = name.startsWith('oxe/') ? name : `oxe/${name}`;
-    if (base) {
-      this.git(['checkout', '-b', fullName, base]);
-    } else {
-      this.git(['checkout', '-b', fullName]);
-    }
-    return fullName;
-  }
-
-  switchTo(branchName: string): void {
-    this.git(['checkout', branchName]);
-  }
-
-  deleteBranch(name: string, force = false): void {
-    const flag = force ? '-D' : '-d';
-    this.git(['branch', flag, name]);
-  }
-
-  listOxeBranches(): BranchInfo[] {
-    const raw = this.git(['branch', '--list', 'oxe/*', '--format=%(refname:short) %(objectname:short) %(HEAD)']);
-    return raw
-      .split('\n')
-      .filter(Boolean)
-      .map((line) => {
-        const parts = line.trim().split(/\s+/);
-        return {
-          name: parts[0],
-          commit: parts[1] ?? '',
-          current: parts[2] === '*',
-        };
-      });
-  }
-
-  mergeWorktreeBranch(worktreeBranch: string, targetBranch: string): void {
-    const saved = this.currentBranch();
-    try {
-      this.git(['checkout', targetBranch]);
-      this.git(['merge', '--no-ff', worktreeBranch, '-m', `oxe: merge ${worktreeBranch}`]);
-    } finally {
-      try { this.git(['checkout', saved]); } catch { /* best effort */ }
-    }
-  }
-
-  branchExists(name: string): boolean {
-    const result = spawnSync('git', ['rev-parse', '--verify', name], {
-      cwd: this.projectRoot,
-      encoding: 'utf8',
-    });
-    return result.status === 0;
-  }
-
-  private git(args: string[]): string {
-    return execFileSync('git', args, {
-      cwd: this.projectRoot,
-      encoding: 'utf8',
-    });
-  }
-}
+import { execFileSync, spawnSync } from 'child_process';
+
+export interface BranchInfo {
+  name: string;
+  current: boolean;
+  commit: string;
+}
+
+export class BranchManager {
+  constructor(private readonly projectRoot: string) {}
+
+  currentBranch(): string {
+    return this.git(['rev-parse', '--abbrev-ref', 'HEAD']).trim();
+  }
+
+  currentCommit(): string {
+    return this.git(['rev-parse', 'HEAD']).trim();
+  }
+
+  createSessionBranch(sessionId: string): string {
+    const name = `oxe/${sessionId}`;
+    this.git(['checkout', '-b', name]);
+    return name;
+  }
+
+  createOxeBranch(name: string, base?: string): string {
+    const fullName = name.startsWith('oxe/') ? name : `oxe/${name}`;
+    if (base) {
+      this.git(['checkout', '-b', fullName, base]);
+    } else {
+      this.git(['checkout', '-b', fullName]);
+    }
+    return fullName;
+  }
+
+  switchTo(branchName: string): void {
+    this.git(['checkout', branchName]);
+  }
+
+  deleteBranch(name: string, force = false): void {
+    const flag = force ? '-D' : '-d';
+    this.git(['branch', flag, name]);
+  }
+
+  listOxeBranches(): BranchInfo[] {
+    const raw = this.git(['branch', '--list', 'oxe/*', '--format=%(refname:short) %(objectname:short) %(HEAD)']);
+    return raw
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => {
+        const parts = line.trim().split(/\s+/);
+        return {
+          name: parts[0],
+          commit: parts[1] ?? '',
+          current: parts[2] === '*',
+        };
+      });
+  }
+
+  mergeWorktreeBranch(worktreeBranch: string, targetBranch: string): void {
+    const saved = this.currentBranch();
+    try {
+      this.git(['checkout', targetBranch]);
+      this.git(['merge', '--no-ff', worktreeBranch, '-m', `oxe: merge ${worktreeBranch}`]);
+    } finally {
+      try { this.git(['checkout', saved]); } catch { /* best effort */ }
+    }
+  }
+
+  branchExists(name: string): boolean {
+    const result = spawnSync('git', ['rev-parse', '--verify', name], {
+      cwd: this.projectRoot,
+      encoding: 'utf8',
+    });
+    return result.status === 0;
+  }
+
+  push(remote: string, branchName: string, setUpstream = false): void {
+    const args = ['push'];
+    if (setUpstream) args.push('-u');
+    args.push(remote, branchName);
+    this.git(args);
+  }
+
+  private git(args: string[]): string {
+    return execFileSync('git', args, {
+      cwd: this.projectRoot,
+      encoding: 'utf8',
+    });
+  }
+}