@lucapimenta/copy-chief-black 1.0.0

package/framework/.aios-core/copy-chief/context/aios-session-state.ts

@@ -0,0 +1,381 @@
+/**
+ * Session State Persistence Module
+ * Port of: aios-core/.aios-core/core/orchestration/session-state.js
+ *
+ * Provides session state persistence to disk for:
+ * - Resume work days later without losing context
+ * - Crash recovery with state restoration
+ * - Progress tracking across offer/deliverable development
+ *
+ * Adapted for Copy Chief: epic→offer, story→deliverable, phase→HELIX phase
+ *
+ * @module aios/session-state
+ * @version 1.2.0
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync, readdirSync } from 'fs';
+import { join, dirname } from 'path';
+
+let yaml: any;
+try { yaml = require('yaml'); } catch { yaml = require('js-yaml'); }
+
+const SESSION_STATE_VERSION = '1.2';
+const SESSION_STATE_FILENAME = '.session-state.yaml';
+const CRASH_THRESHOLD_MINUTES = 30;
+
+export const ActionType = {
+  GO: 'GO',
+  PAUSE: 'PAUSE',
+  REVIEW: 'REVIEW',
+  ABORT: 'ABORT',
+  PHASE_CHANGE: 'PHASE_CHANGE',
+  OFFER_STARTED: 'OFFER_STARTED',
+  DELIVERABLE_STARTED: 'DELIVERABLE_STARTED',
+  DELIVERABLE_COMPLETED: 'DELIVERABLE_COMPLETED',
+  CHECKPOINT_REACHED: 'CHECKPOINT_REACHED',
+  ERROR_OCCURRED: 'ERROR_OCCURRED',
+} as const;
+
+export const HelixPhase = {
+  RESEARCH: 'research',
+  BRIEFING: 'briefing',
+  PRODUCTION: 'production',
+  REVIEW: 'review',
+  DELIVERY: 'delivery',
+} as const;
+
+export const ResumeOption = {
+  CONTINUE: 'continue',
+  REVIEW: 'review',
+  RESTART: 'restart',
+  DISCARD: 'discard',
+} as const;
+
+// ============ Types ============
+
+export interface OfferContext {
+  id: string;
+  title: string;
+  total_deliverables: number;
+}
+
+export interface SessionProgress {
+  current_deliverable: string | null;
+  deliverables_done: string[];
+  deliverables_pending: string[];
+}
+
+export interface WorkflowContext {
+  current_phase: string | null;
+  attempt_count: number;
+  phase_results: Record<string, any>;
+  started_at: string;
+}
+
+export interface LastAction {
+  type: string;
+  timestamp: string;
+  deliverable: string | null;
+  phase: string | null;
+}
+
+export interface ContextSnapshot {
+  files_modified: number;
+  persona_distribution: Record<string, number>;
+  last_persona: string | null;
+  branch: string;
+}
+
+export interface SessionStateData {
+  session_state: {
+    version: string;
+    last_updated: string;
+    offer: OfferContext;
+    progress: SessionProgress;
+    workflow: WorkflowContext;
+    last_action: LastAction;
+    context_snapshot: ContextSnapshot;
+    resume_instructions: string;
+    overrides: Record<string, any>;
+  };
+}
+
+export interface CrashDetectionResult {
+  isCrash: boolean;
+  minutesSinceUpdate: number;
+  lastActionType: string;
+  lastPhase: string | null;
+  lastDeliverable: string | null;
+  reason: string;
+}
+
+// ============ Class ============
+
+export class AiosSessionState {
+  projectRoot: string;
+  options: { debug: boolean; autoMigrate: boolean };
+  stateFilePath: string;
+  state: SessionStateData | null;
+
+  constructor(projectRoot: string, options: { debug?: boolean; autoMigrate?: boolean } = {}) {
+    this.projectRoot = projectRoot;
+    this.options = { debug: false, autoMigrate: true, ...options };
+    this.stateFilePath = join(projectRoot, '.aios', SESSION_STATE_FILENAME);
+    this.state = null;
+  }
+
+  getStateFilePath(): string { return this.stateFilePath; }
+
+  exists(): boolean {
+    return existsSync(this.stateFilePath);
+  }
+
+  createSessionState(offerInfo: { id: string; title: string; totalDeliverables: number; deliverableIds: string[] }, branch = 'main'): SessionStateData {
+    const now = new Date().toISOString();
+    this.state = {
+      session_state: {
+        version: SESSION_STATE_VERSION,
+        last_updated: now,
+        offer: {
+          id: offerInfo.id,
+          title: offerInfo.title,
+          total_deliverables: offerInfo.totalDeliverables,
+        },
+        progress: {
+          current_deliverable: offerInfo.deliverableIds[0] || null,
+          deliverables_done: [],
+          deliverables_pending: [...offerInfo.deliverableIds],
+        },
+        workflow: {
+          current_phase: null,
+          attempt_count: 0,
+          phase_results: {},
+          started_at: now,
+        },
+        last_action: {
+          type: ActionType.OFFER_STARTED,
+          timestamp: now,
+          deliverable: offerInfo.deliverableIds[0] || null,
+          phase: null,
+        },
+        context_snapshot: {
+          files_modified: 0,
+          persona_distribution: {},
+          last_persona: null,
+          branch,
+        },
+        resume_instructions: this._generateResumeInstructions({
+          offerTitle: offerInfo.title,
+          currentDeliverable: offerInfo.deliverableIds[0],
+          deliverablesDone: 0,
+          totalDeliverables: offerInfo.totalDeliverables,
+          lastPhase: null,
+          lastPersona: null,
+        }),
+        overrides: {},
+      },
+    };
+    this.save();
+    if (this.options.debug) console.log(`[AiosSessionState] Created: ${this.stateFilePath}`);
+    return this.state;
+  }
+
+  loadSessionState(): SessionStateData | null {
+    if (this.exists()) {
+      const content = readFileSync(this.stateFilePath, 'utf8');
+      this.state = (yaml.parse || yaml.load)(content) as SessionStateData;
+      if (this.options.debug) console.log(`[AiosSessionState] Loaded from: ${this.stateFilePath}`);
+      return this.state;
+    }
+    return null;
+  }
+
+  updateSessionState(updates: Partial<{
+    progress: Partial<SessionProgress>;
+    workflow: Partial<WorkflowContext>;
+    last_action: Partial<LastAction>;
+    context_snapshot: Partial<ContextSnapshot>;
+    overrides: Record<string, any>;
+  }>): SessionStateData {
+    if (!this.state) throw new Error('Session state not initialized.');
+    const now = new Date().toISOString();
+    const ss = this.state.session_state;
+    ss.last_updated = now;
+
+    if (updates.progress) ss.progress = { ...ss.progress, ...updates.progress };
+    if (updates.workflow) ss.workflow = { ...ss.workflow, ...updates.workflow };
+    if (updates.last_action) ss.last_action = { ...updates.last_action, timestamp: now } as LastAction;
+    if (updates.context_snapshot) ss.context_snapshot = { ...ss.context_snapshot, ...updates.context_snapshot };
+    if (updates.overrides) ss.overrides = { ...(ss.overrides || {}), ...updates.overrides };
+
+    ss.resume_instructions = this._generateResumeInstructions({
+      offerTitle: ss.offer.title,
+      currentDeliverable: ss.progress.current_deliverable,
+      deliverablesDone: ss.progress.deliverables_done.length,
+      totalDeliverables: ss.offer.total_deliverables,
+      lastPhase: ss.last_action.phase,
+      lastPersona: ss.context_snapshot.last_persona,
+    });
+
+    this.save();
+    return this.state;
+  }
+
+  recordPhaseChange(phase: string, deliverableId: string, persona: string): SessionStateData {
+    const updates: any = {
+      workflow: { current_phase: phase },
+      last_action: { type: ActionType.PHASE_CHANGE, deliverable: deliverableId, phase },
+      context_snapshot: { last_persona: persona },
+    };
+    if (this.state && persona) {
+      const dist = this.state.session_state.context_snapshot.persona_distribution || {};
+      dist[persona] = (dist[persona] || 0) + 1;
+      updates.context_snapshot.persona_distribution = dist;
+    }
+    return this.updateSessionState(updates);
+  }
+
+  recordDeliverableCompleted(deliverableId: string, nextDeliverableId: string | null = null): SessionStateData {
+    const done = [...this.state!.session_state.progress.deliverables_done, deliverableId];
+    const pending = this.state!.session_state.progress.deliverables_pending.filter(id => id !== deliverableId);
+    return this.updateSessionState({
+      progress: {
+        current_deliverable: nextDeliverableId || pending[0] || null,
+        deliverables_done: done,
+        deliverables_pending: pending,
+      },
+      workflow: { current_phase: null, attempt_count: 0, phase_results: {} },
+      last_action: { type: ActionType.DELIVERABLE_COMPLETED, deliverable: deliverableId, phase: null },
+    });
+  }
+
+  recordPause(deliverableId: string, phase: string): SessionStateData {
+    return this.updateSessionState({
+      last_action: { type: ActionType.PAUSE, deliverable: deliverableId, phase },
+    });
+  }
+
+  // ============ Crash Detection ============
+
+  detectCrash(): CrashDetectionResult {
+    if (!this.state) this.loadSessionState();
+    if (!this.state) return { isCrash: false, minutesSinceUpdate: 0, lastActionType: '', lastPhase: null, lastDeliverable: null, reason: 'No session state found' };
+
+    const lastUpdated = new Date(this.state.session_state.last_updated);
+    const lastActionType = this.state.session_state.last_action.type;
+    const now = new Date();
+    const minutesSinceUpdate = (now.getTime() - lastUpdated.getTime()) / (1000 * 60);
+    const normalEndStates = [ActionType.PAUSE, ActionType.DELIVERABLE_COMPLETED, ActionType.ABORT];
+    const isCrash = minutesSinceUpdate > CRASH_THRESHOLD_MINUTES && !normalEndStates.includes(lastActionType as any);
+
+    return {
+      isCrash,
+      minutesSinceUpdate: Math.round(minutesSinceUpdate),
+      lastActionType,
+      lastPhase: this.state.session_state.last_action.phase,
+      lastDeliverable: this.state.session_state.last_action.deliverable,
+      reason: isCrash
+        ? `Session appears to have crashed ${Math.round(minutesSinceUpdate)} minutes ago during ${lastActionType}`
+        : 'Session ended normally',
+    };
+  }
+
+  // ============ Resume ============
+
+  getResumeOptions(): Record<string, { label: string; description: string }> {
+    const current = this.state?.session_state.progress.current_deliverable || '?';
+    return {
+      [ResumeOption.CONTINUE]: { label: 'Continuar de onde parou', description: 'Resume from last saved state' },
+      [ResumeOption.REVIEW]: { label: 'Revisar o que foi feito', description: 'Show progress summary before continuing' },
+      [ResumeOption.RESTART]: { label: `Recomecar ${current} do zero`, description: 'Restart current deliverable' },
+      [ResumeOption.DISCARD]: { label: 'Iniciar nova oferta (descarta sessao)', description: 'Discard session' },
+    };
+  }
+
+  getResumeSummary(): string {
+    if (!this.state) return 'No session state loaded.';
+    const { offer, progress, last_action } = this.state.session_state;
+    return `Session anterior detectada!\n\nOferta: ${offer.title}\nProgresso: ${progress.deliverables_done.length} de ${offer.total_deliverables} deliverables\nUltimo: ${progress.current_deliverable}\nFase: ${last_action.phase || 'N/A'}`;
+  }
+
+  handleResumeOption(option: string): { action: string; deliverable?: string | null; phase?: string | null; summary?: any; message?: string } {
+    switch (option) {
+      case ResumeOption.CONTINUE:
+        return { action: 'continue', deliverable: this.state!.session_state.progress.current_deliverable, phase: this.state!.session_state.workflow.current_phase };
+      case ResumeOption.REVIEW:
+        return { action: 'review', summary: this.getProgressSummary() };
+      case ResumeOption.RESTART:
+        this.updateSessionState({
+          workflow: { current_phase: null, attempt_count: 0, phase_results: {}, started_at: new Date().toISOString() },
+          last_action: { type: ActionType.DELIVERABLE_STARTED, deliverable: this.state!.session_state.progress.current_deliverable, phase: null },
+        });
+        return { action: 'restart', deliverable: this.state!.session_state.progress.current_deliverable };
+      case ResumeOption.DISCARD:
+        this.discard();
+        return { action: 'discard', message: 'Session discarded. Ready for new offer.' };
+      default:
+        throw new Error(`Unknown resume option: ${option}`);
+    }
+  }
+
+  getProgressSummary(): any {
+    if (!this.state) return null;
+    const { offer, progress, workflow, context_snapshot } = this.state.session_state;
+    return {
+      offer: { id: offer.id, title: offer.title, totalDeliverables: offer.total_deliverables },
+      progress: {
+        completed: progress.deliverables_done.length,
+        total: offer.total_deliverables,
+        percentage: Math.round((progress.deliverables_done.length / offer.total_deliverables) * 100),
+        deliverablesDone: progress.deliverables_done,
+        deliverablesPending: progress.deliverables_pending,
+        currentDeliverable: progress.current_deliverable,
+      },
+      workflow: { currentPhase: workflow.current_phase, attemptCount: workflow.attempt_count, phaseResults: workflow.phase_results },
+      context: { filesModified: context_snapshot.files_modified, personaDistribution: context_snapshot.persona_distribution, branch: context_snapshot.branch },
+    };
+  }
+
+  // ============ Persistence ============
+
+  save(): void {
+    if (!this.state) throw new Error('No state to save');
+    const dir = dirname(this.stateFilePath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const content = (yaml.stringify || yaml.dump)(this.state, { lineWidth: 120, noRefs: true });
+    writeFileSync(this.stateFilePath, content, 'utf8');
+  }
+
+  discard(): void {
+    if (this.exists()) {
+      const archivePath = `${this.stateFilePath}.discarded.${Date.now()}`;
+      renameSync(this.stateFilePath, archivePath);
+      if (this.options.debug) console.log(`[AiosSessionState] Archived to: ${archivePath}`);
+    }
+    this.state = null;
+  }
+
+  // ============ Helpers ============
+
+  private _generateResumeInstructions(context: { offerTitle: string; currentDeliverable: string | null; deliverablesDone: number; totalDeliverables: number; lastPhase: string | null; lastPersona: string | null }): string {
+    let instructions = '';
+    if (context.currentDeliverable) instructions += `Deliverable ${context.currentDeliverable} em fase de ${context.lastPhase || 'inicio'}.\n`;
+    if (context.lastPersona) instructions += `${context.lastPersona} estava trabalhando.\n`;
+    instructions += `Progresso: ${context.deliverablesDone} de ${context.totalDeliverables} deliverables completos.\n`;
+    instructions += 'Proximo passo: continuar producao ou revisar o que foi feito.';
+    return instructions;
+  }
+
+  static validateSchema(state: SessionStateData): { isValid: boolean; errors: string[] } {
+    const errors: string[] = [];
+    if (!state?.session_state) { errors.push('Missing session_state root'); return { isValid: false, errors }; }
+    const ss = state.session_state;
+    if (!ss.version) errors.push('Missing version');
+    if (!ss.offer?.id || !ss.offer?.title || ss.offer?.total_deliverables === undefined) errors.push('Invalid offer field');
+    if (!ss.progress || !Array.isArray(ss.progress.deliverables_done) || !Array.isArray(ss.progress.deliverables_pending)) errors.push('Invalid progress field');
+    if (!ss.last_action?.type || !ss.last_action?.timestamp) errors.push('Invalid last_action field');
+    return { isValid: errors.length === 0, errors };
+  }
+}
+
+export { SESSION_STATE_VERSION, SESSION_STATE_FILENAME, CRASH_THRESHOLD_MINUTES };

package/framework/.aios-core/copy-chief/context/context-manager.js

@@ -0,0 +1,316 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var context_manager_exports = {};
+__export(context_manager_exports, {
+  ContextManager: () => ContextManager
+});
+module.exports = __toCommonJS(context_manager_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+class ContextManager {
+  workflowId;
+  projectRoot;
+  stateDir;
+  statePath;
+  handoffDir;
+  confidenceDir;
+  _stateCache;
+  constructor(workflowId, projectRoot) {
+    this.workflowId = workflowId;
+    this.projectRoot = projectRoot;
+    this.stateDir = (0, import_path.join)(projectRoot, ".aios", "workflow-state");
+    this.statePath = (0, import_path.join)(this.stateDir, `${workflowId}.json`);
+    this.handoffDir = (0, import_path.join)(this.stateDir, "handoffs");
+    this.confidenceDir = (0, import_path.join)(this.stateDir, "confidence");
+    this._stateCache = null;
+  }
+  ensureStateDir() {
+    for (const dir of [this.stateDir, this.handoffDir, this.confidenceDir]) {
+      if (!(0, import_fs.existsSync)(dir)) (0, import_fs.mkdirSync)(dir, { recursive: true });
+    }
+  }
+  initialize() {
+    this.ensureStateDir();
+    if ((0, import_fs.existsSync)(this.statePath)) {
+      this._stateCache = JSON.parse((0, import_fs.readFileSync)(this.statePath, "utf-8"));
+    } else {
+      this._stateCache = this._createInitialState();
+      this._saveState();
+    }
+    return this._stateCache;
+  }
+  _createInitialState() {
+    return {
+      workflowId: this.workflowId,
+      status: "initialized",
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      currentPhase: 0,
+      phases: {},
+      metadata: { projectRoot: this.projectRoot, delivery_confidence: null }
+    };
+  }
+  loadState() {
+    if (this._stateCache) return this._stateCache;
+    if ((0, import_fs.existsSync)(this.statePath)) {
+      this._stateCache = JSON.parse((0, import_fs.readFileSync)(this.statePath, "utf-8"));
+      return this._stateCache;
+    }
+    return this._createInitialState();
+  }
+  _saveState() {
+    this.ensureStateDir();
+    this._stateCache.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    (0, import_fs.writeFileSync)(this.statePath, JSON.stringify(this._stateCache, null, 2));
+  }
+  savePhaseOutput(phaseNum, output, options = {}) {
+    const state = this.loadState();
+    const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    state.currentPhase = phaseNum;
+    state.status = "in_progress";
+    const handoff = this._buildHandoffPackage(phaseNum, output, state, options, completedAt);
+    state.phases[phaseNum] = { ...output, completedAt, handoff };
+    state.metadata = state.metadata || {};
+    state.metadata.delivery_confidence = this._calculateDeliveryConfidence(state);
+    this._stateCache = state;
+    this._saveState();
+    this._saveHandoffFile(handoff);
+    this._saveConfidenceFile(state.metadata.delivery_confidence);
+  }
+  getContextForPhase(phaseNum) {
+    const state = this.loadState();
+    const previousPhases = {};
+    for (let i = 1; i < phaseNum; i++) {
+      if (state.phases[i]) previousPhases[i] = state.phases[i];
+    }
+    const previousHandoffs = {};
+    for (const [phaseId, phaseData] of Object.entries(previousPhases)) {
+      if (phaseData?.handoff) previousHandoffs[phaseId] = phaseData.handoff;
+    }
+    return { workflowId: this.workflowId, currentPhase: phaseNum, previousPhases, previousHandoffs, metadata: state.metadata };
+  }
+  getPreviousPhaseOutputs() {
+    return this._stateCache?.phases || {};
+  }
+  getPhaseOutput(phaseNum) {
+    return this.getPreviousPhaseOutputs()[phaseNum] || null;
+  }
+  markCompleted() {
+    const state = this.loadState();
+    state.status = "completed";
+    state.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this._stateCache = state;
+    this._saveState();
+  }
+  markFailed(error, failedPhase) {
+    const state = this.loadState();
+    state.status = "failed";
+    state.error = error;
+    state.failedPhase = failedPhase;
+    state.failedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this._stateCache = state;
+    this._saveState();
+  }
+  updateMetadata(metadata) {
+    const state = this.loadState();
+    state.metadata = { ...state.metadata, ...metadata };
+    this._stateCache = state;
+    this._saveState();
+  }
+  getLastCompletedPhase() {
+    const phases = this.getPreviousPhaseOutputs();
+    const phaseNums = Object.keys(phases).map(Number);
+    return phaseNums.length > 0 ? Math.max(...phaseNums) : 0;
+  }
+  isPhaseCompleted(phaseNum) {
+    const output = this.getPhaseOutput(phaseNum);
+    return output !== null && output.completedAt !== void 0;
+  }
+  getDeliveryConfidence() {
+    return this._stateCache?.metadata?.delivery_confidence || null;
+  }
+  getSummary() {
+    const state = this._stateCache || this._createInitialState();
+    const phases = Object.keys(state.phases).map(Number);
+    return {
+      workflowId: state.workflowId,
+      status: state.status,
+      startedAt: state.startedAt,
+      completedAt: state.completedAt,
+      currentPhase: state.currentPhase,
+      completedPhases: phases,
+      totalPhases: phases.length,
+      deliveryConfidence: state.metadata?.delivery_confidence || null
+    };
+  }
+  reset(keepMetadata = true) {
+    const savedMetadata = keepMetadata ? this._stateCache?.metadata ?? {} : {};
+    this._stateCache = this._createInitialState();
+    this._stateCache.metadata = { ...this._stateCache.metadata, ...savedMetadata };
+    this._saveState();
+  }
+  exportState() {
+    return { ...this._stateCache };
+  }
+  importState(state) {
+    this._stateCache = state;
+    this._saveState();
+  }
+  // ============ Private Helpers ============
+  _buildHandoffPackage(phaseNum, output, state, options, completedAt) {
+    const handoffTarget = options.handoffTarget || {};
+    return {
+      version: "1.0.0",
+      workflow_id: this.workflowId,
+      generated_at: completedAt,
+      from: { phase: phaseNum, agent: output.agent || null, action: output.action || null, task: output.task || null },
+      to: { phase: handoffTarget.phase || null, agent: handoffTarget.agent || null },
+      context_snapshot: { workflow_status: state.status, current_phase: state.currentPhase, metadata: state.metadata || {} },
+      decision_log: this._extractDecisionLog(output),
+      evidence_links: this._extractEvidenceLinks(output),
+      open_risks: this._extractOpenRisks(output)
+    };
+  }
+  _saveHandoffFile(handoff) {
+    const phase = handoff?.from?.phase || "unknown";
+    const filePath = (0, import_path.join)(this.handoffDir, `${this.workflowId}-phase-${phase}.handoff.json`);
+    if (!(0, import_fs.existsSync)(this.handoffDir)) (0, import_fs.mkdirSync)(this.handoffDir, { recursive: true });
+    (0, import_fs.writeFileSync)(filePath, JSON.stringify(handoff, null, 2));
+  }
+  _saveConfidenceFile(confidence) {
+    if (!confidence) return;
+    const filePath = (0, import_path.join)(this.confidenceDir, `${this.workflowId}.delivery-confidence.json`);
+    if (!(0, import_fs.existsSync)(this.confidenceDir)) (0, import_fs.mkdirSync)(this.confidenceDir, { recursive: true });
+    (0, import_fs.writeFileSync)(filePath, JSON.stringify(confidence, null, 2));
+  }
+  _extractDecisionLog(output) {
+    const result = output.result || {};
+    const entries = Array.isArray(result.decisions) ? result.decisions : Array.isArray(result.decision_log) ? result.decision_log : [];
+    const sourcePaths = [];
+    if (result.decisionLogPath) sourcePaths.push(result.decisionLogPath);
+    if (result.decision_log_path) sourcePaths.push(result.decision_log_path);
+    return { entries, source_paths: sourcePaths, count: entries.length };
+  }
+  _extractEvidenceLinks(output) {
+    const evidence = [];
+    const result = output.result || {};
+    const validation = output.validation || {};
+    if (Array.isArray(result.evidence_links)) evidence.push(...result.evidence_links);
+    if (Array.isArray(validation.checks)) {
+      for (const check of validation.checks) {
+        if (check.path) evidence.push(check.path);
+        if (check.checklist) evidence.push(check.checklist);
+      }
+    }
+    return [...new Set(evidence)];
+  }
+  _extractOpenRisks(output) {
+    const result = output.result || {};
+    const risks = [];
+    if (Array.isArray(result.open_risks)) risks.push(...result.open_risks);
+    if (Array.isArray(result.risks)) risks.push(...result.risks);
+    if (Array.isArray(result.risk_register)) risks.push(...result.risk_register);
+    return risks;
+  }
+  _calculateDeliveryConfidence(state) {
+    const phases = Object.values(state.phases || {});
+    const weights = { test_coverage: 0.25, ac_completion: 0.3, risk_score_inv: 0.2, debt_score_inv: 0.15, regression_clear: 0.1 };
+    const testCoverage = this._calcTestCoverage(phases);
+    const acCompletion = this._calcAcCompletion(phases);
+    const riskInv = this._calcRiskInverse(phases);
+    const debtInv = this._calcDebtInverse(phases);
+    const regressionClear = this._calcRegressionClear(phases, testCoverage);
+    const components = { test_coverage: testCoverage, ac_completion: acCompletion, risk_score_inv: riskInv, debt_score_inv: debtInv, regression_clear: regressionClear };
+    const scoreBase = Object.entries(weights).reduce((acc, [key, w]) => acc + (components[key] || 0) * w, 0);
+    const score = Number((scoreBase * 100).toFixed(2));
+    const threshold = Number(process.env.AIOS_DELIVERY_CONFIDENCE_THRESHOLD) || 70;
+    return {
+      version: "1.0.0",
+      calculated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      score,
+      threshold,
+      gate_passed: score >= threshold,
+      formula: { expression: "confidence = (test_coverage*0.25 + ac_completion*0.30 + risk_score_inv*0.20 + debt_score_inv*0.15 + regression_clear*0.10) * 100", weights },
+      components,
+      phase_count: phases.length
+    };
+  }
+  _calcTestCoverage(phases) {
+    let total = 0, passed = 0;
+    for (const phase of phases) {
+      if (!Array.isArray(phase?.validation?.checks)) continue;
+      for (const check of phase.validation.checks) {
+        total++;
+        if (check?.passed) passed++;
+      }
+    }
+    return total === 0 ? phases.length > 0 ? 1 : 0 : passed / total;
+  }
+  _calcAcCompletion(phases) {
+    let total = 0, done = 0, hasExplicit = false;
+    for (const phase of phases) {
+      const r = phase?.result || {};
+      if (Number.isFinite(r.ac_total) && Number.isFinite(r.ac_completed)) {
+        hasExplicit = true;
+        total += Math.max(0, r.ac_total);
+        done += Math.min(Math.max(0, r.ac_completed), Math.max(0, r.ac_total));
+      } else if (Array.isArray(r.acceptance_criteria)) {
+        hasExplicit = true;
+        total += r.acceptance_criteria.length;
+        done += r.acceptance_criteria.filter((i) => i?.done || i?.status === "done").length;
+      }
+    }
+    if (hasExplicit && total > 0) return done / total;
+    if (phases.length === 0) return 0;
+    return phases.filter((p) => p?.result?.status !== "failed").length / phases.length;
+  }
+  _calcRiskInverse(phases) {
+    const totalRisks = phases.reduce((sum, phase) => {
+      const handoffRisks = Array.isArray(phase?.handoff?.open_risks) ? phase.handoff.open_risks.length : 0;
+      const resultRisks = this._extractOpenRisks(phase).length;
+      return sum + Math.max(handoffRisks, resultRisks);
+    }, 0);
+    return Math.max(0, 1 - totalRisks / 10);
+  }
+  _calcDebtInverse(phases) {
+    const totalDebt = phases.reduce((sum, phase) => {
+      const r = phase?.result || {};
+      const explicit = Number.isFinite(r.technical_debt_count) ? r.technical_debt_count : Number.isFinite(r.debt_count) ? r.debt_count : 0;
+      const listCount = [r.technical_debt, r.debt_items, r.todos, r.hacks].reduce((s, list) => s + (Array.isArray(list) ? list.length : 0), 0);
+      return sum + explicit + listCount;
+    }, 0);
+    return Math.max(0, 1 - totalDebt / 10);
+  }
+  _calcRegressionClear(phases, fallbackTestCoverage) {
+    let total = 0, passed = 0;
+    for (const phase of phases) {
+      if (!Array.isArray(phase?.validation?.checks)) continue;
+      for (const check of phase.validation.checks) {
+        const isRegression = [String(check?.type || ""), String(check?.path || ""), String(check?.checklist || "")].some((s) => s.toLowerCase().includes("regression"));
+        if (!isRegression) continue;
+        total++;
+        if (check?.passed) passed++;
+      }
+    }
+    return total === 0 ? fallbackTestCoverage : passed / total;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContextManager
+});