aios-core 4.2.6 → 4.2.8

package/.aios-core/core/orchestration/context-manager.js

@@ -32,6 +32,8 @@ class ContextManager {
     // State file path
     this.stateDir = path.join(projectRoot, '.aios', 'workflow-state');
     this.statePath = path.join(this.stateDir, `${workflowId}.json`);
+    this.handoffDir = path.join(this.stateDir, 'handoffs');
+    this.confidenceDir = path.join(this.stateDir, 'confidence');
 
     // In-memory cache
     this._stateCache = null;
@@ -43,6 +45,8 @@ class ContextManager {
    */
   async ensureStateDir() {
     await fs.ensureDir(this.stateDir);
+    await fs.ensureDir(this.handoffDir);
+    await fs.ensureDir(this.confidenceDir);
   }
 
   /**
@@ -76,6 +80,7 @@ class ContextManager {
       phases: {},
       metadata: {
         projectRoot: this.projectRoot,
+        delivery_confidence: null,
       },
     };
   }
@@ -113,19 +118,25 @@ class ContextManager {
    * @param {number} phaseNum - Phase number
    * @param {Object} output - Phase output data
    */
-  async savePhaseOutput(phaseNum, output) {
+  async savePhaseOutput(phaseNum, output, options = {}) {
     const state = await this.loadState();
+    const completedAt = new Date().toISOString();
+    state.currentPhase = phaseNum;
+    state.status = 'in_progress';
+    const handoff = this._buildHandoffPackage(phaseNum, output, state, options, completedAt);
 
     state.phases[phaseNum] = {
       ...output,
-      completedAt: new Date().toISOString(),
+      completedAt,
+      handoff,
     };
-
-    state.currentPhase = phaseNum;
-    state.status = 'in_progress';
+    state.metadata = state.metadata || {};
+    state.metadata.delivery_confidence = this._calculateDeliveryConfidence(state);
 
     this._stateCache = state;
     await this._saveState();
+    await this._saveHandoffFile(handoff);
+    await this._saveConfidenceFile(state.metadata.delivery_confidence);
   }
 
   /**
@@ -145,10 +156,18 @@ class ContextManager {
       }
     }
 
+    const previousHandoffs = {};
+    for (const [phaseId, phaseData] of Object.entries(previousPhases)) {
+      if (phaseData && phaseData.handoff) {
+        previousHandoffs[phaseId] = phaseData.handoff;
+      }
+    }
+
     return {
       workflowId: this.workflowId,
       currentPhase: phaseNum,
       previousPhases,
+      previousHandoffs,
       metadata: state.metadata,
     };
   }
@@ -247,9 +266,318 @@ class ContextManager {
       currentPhase: state.currentPhase,
       completedPhases: phases,
       totalPhases: phases.length,
+      deliveryConfidence: state.metadata?.delivery_confidence || null,
     };
   }
 
+  /**
+   * Get latest delivery confidence score metadata.
+   * @returns {Object|null} Confidence payload
+   */
+  getDeliveryConfidence() {
+    return this._stateCache?.metadata?.delivery_confidence || null;
+  }
+
+  /**
+   * Build standardized handoff package for inter-agent transfer.
+   * @private
+   */
+  _buildHandoffPackage(phaseNum, output, state, options, completedAt) {
+    const handoffTarget = options.handoffTarget || {};
+    const decision = this._extractDecisionLog(output);
+    const evidence = this._extractEvidenceLinks(output);
+    const risks = this._extractOpenRisks(output);
+
+    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: decision,
+      evidence_links: evidence,
+      open_risks: risks,
+    };
+  }
+
+  /**
+   * Persist handoff package as a dedicated artifact.
+   * @private
+   */
+  async _saveHandoffFile(handoff) {
+    const phase = handoff?.from?.phase || 'unknown';
+    const filePath = path.join(this.handoffDir, `${this.workflowId}-phase-${phase}.handoff.json`);
+    await fs.ensureDir(this.handoffDir);
+    await fs.writeJson(filePath, handoff, { spaces: 2 });
+  }
+
+  /**
+   * Persist confidence score as a dedicated artifact.
+   * @private
+   */
+  async _saveConfidenceFile(confidence) {
+    if (!confidence) return;
+    const filePath = path.join(this.confidenceDir, `${this.workflowId}.delivery-confidence.json`);
+    await fs.ensureDir(this.confidenceDir);
+    await fs.writeJson(filePath, confidence, { spaces: 2 });
+  }
+
+  /**
+   * @private
+   */
+  _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,
+    };
+  }
+
+  /**
+   * @private
+   */
+  _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)];
+  }
+
+  /**
+   * @private
+   */
+  _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;
+  }
+
+  /**
+   * Compute delivery confidence score from workflow state.
+   * @private
+   */
+  _calculateDeliveryConfidence(state) {
+    const phases = Object.values(state.phases || {});
+    const weights = {
+      test_coverage: 0.25,
+      ac_completion: 0.30,
+      risk_score_inv: 0.20,
+      debt_score_inv: 0.15,
+      regression_clear: 0.10,
+    };
+    const components = {
+      test_coverage: this._calculateTestCoverage(phases),
+      ac_completion: this._calculateAcCompletion(phases),
+      risk_score_inv: this._calculateRiskInverseScore(phases),
+      debt_score_inv: this._calculateDebtInverseScore(phases),
+      regression_clear: this._calculateRegressionClear(phases),
+    };
+
+    const scoreBase = Object.keys(weights).reduce(
+      (acc, key) => acc + (components[key] || 0) * weights[key],
+      0,
+    );
+    const score = Number((scoreBase * 100).toFixed(2));
+    const threshold = this._resolveConfidenceThreshold();
+
+    return {
+      version: '1.0.0',
+      calculated_at: 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,
+    };
+  }
+
+  /**
+   * @private
+   */
+  _resolveConfidenceThreshold() {
+    const raw = process.env.AIOS_DELIVERY_CONFIDENCE_THRESHOLD;
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) ? parsed : 70;
+  }
+
+  /**
+   * @private
+   */
+  _calculateTestCoverage(phases) {
+    let totalChecks = 0;
+    let passedChecks = 0;
+
+    for (const phase of phases) {
+      const checks = phase?.validation?.checks;
+      if (!Array.isArray(checks)) continue;
+      for (const check of checks) {
+        totalChecks += 1;
+        if (check?.passed === true) passedChecks += 1;
+      }
+    }
+
+    if (totalChecks === 0) {
+      return phases.length > 0 ? 1 : 0;
+    }
+
+    return passedChecks / totalChecks;
+  }
+
+  /**
+   * @private
+   */
+  _calculateAcCompletion(phases) {
+    let total = 0;
+    let done = 0;
+    let hasExplicitData = false;
+
+    for (const phase of phases) {
+      const result = phase?.result || {};
+      if (Number.isFinite(result.ac_total) && Number.isFinite(result.ac_completed)) {
+        hasExplicitData = true;
+        total += Math.max(0, result.ac_total);
+        done += Math.min(Math.max(0, result.ac_completed), Math.max(0, result.ac_total));
+      } else if (Array.isArray(result.acceptance_criteria)) {
+        hasExplicitData = true;
+        total += result.acceptance_criteria.length;
+        done += result.acceptance_criteria.filter((item) => item?.done || item?.status === 'done').length;
+      }
+    }
+
+    if (hasExplicitData && total > 0) {
+      return done / total;
+    }
+
+    if (phases.length === 0) {
+      return 0;
+    }
+
+    const successful = phases.filter((phase) => phase?.result?.status !== 'failed').length;
+    return successful / phases.length;
+  }
+
+  /**
+   * @private
+   */
+  _calculateRiskInverseScore(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);
+  }
+
+  /**
+   * @private
+   */
+  _calculateDebtInverseScore(phases) {
+    const totalDebt = phases.reduce((sum, phase) => {
+      const result = phase?.result || {};
+      const explicitCount = Number.isFinite(result.technical_debt_count)
+        ? result.technical_debt_count
+        : Number.isFinite(result.debt_count)
+          ? result.debt_count
+          : 0;
+      const listCount = [
+        result.technical_debt,
+        result.debt_items,
+        result.todos,
+        result.hacks,
+      ].reduce((listSum, list) => listSum + (Array.isArray(list) ? list.length : 0), 0);
+      return sum + explicitCount + listCount;
+    }, 0);
+
+    return Math.max(0, 1 - totalDebt / 10);
+  }
+
+  /**
+   * @private
+   */
+  _calculateRegressionClear(phases) {
+    let totalRegressionChecks = 0;
+    let passedRegressionChecks = 0;
+
+    for (const phase of phases) {
+      const checks = phase?.validation?.checks;
+      if (!Array.isArray(checks)) continue;
+
+      for (const check of checks) {
+        const type = String(check?.type || '').toLowerCase();
+        const pathValue = String(check?.path || '').toLowerCase();
+        const checklist = String(check?.checklist || '').toLowerCase();
+        const isRegression = type.includes('regression')
+          || pathValue.includes('regression')
+          || checklist.includes('regression');
+
+        if (!isRegression) continue;
+        totalRegressionChecks += 1;
+        if (check?.passed === true) {
+          passedRegressionChecks += 1;
+        }
+      }
+    }
+
+    if (totalRegressionChecks === 0) {
+      return this._calculateTestCoverage(phases);
+    }
+
+    return passedRegressionChecks / totalRegressionChecks;
+  }
+
   /**
    * Reset workflow state (for re-execution)
    * @param {boolean} keepMetadata - Whether to preserve metadata

package/.aios-core/core/orchestration/dashboard-integration.js

@@ -252,12 +252,28 @@ class DashboardIntegration extends EventEmitter {
       await fs.writeJson(this.statusPath, status, { spaces: 2 });
       this.emit('statusUpdated', status);
     } catch (error) {
-      this.emit('error', { type: 'statusUpdate', error });
+      this._emitSafeError({ type: 'statusUpdate', error });
     }
 
     return status;
   }
 
+  /**
+   * Emit error event only when listeners are present, otherwise degrade to warning.
+   * Avoids unhandled EventEmitter 'error' exceptions in background update flows.
+   * @private
+   * @param {Object} payload
+   */
+  _emitSafeError(payload) {
+    if (this.listenerCount('error') > 0) {
+      this.emit('error', payload);
+      return;
+    }
+
+    const message = payload?.error?.message || 'unknown dashboard error';
+    console.warn(`[DashboardIntegration] ${payload?.type || 'error'}: ${message}`);
+  }
+
   /**
    * Build status object (AC2)
    * @returns {Object} Status object

package/.aios-core/core/orchestration/execution-profile-resolver.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const VALID_PROFILES = ['safe', 'balanced', 'aggressive'];
+const VALID_CONTEXTS = ['production', 'migration', 'security-sensitive', 'development'];
+
+const PROFILE_POLICIES = {
+  safe: {
+    require_confirmation: true,
+    require_tests_before_handoff: true,
+    max_parallel_changes: 1,
+    allow_destructive_operations: false,
+    allow_autonomous_refactors: false,
+  },
+  balanced: {
+    require_confirmation: 'high-risk-only',
+    require_tests_before_handoff: true,
+    max_parallel_changes: 3,
+    allow_destructive_operations: false,
+    allow_autonomous_refactors: true,
+  },
+  aggressive: {
+    require_confirmation: false,
+    require_tests_before_handoff: false,
+    max_parallel_changes: 8,
+    allow_destructive_operations: false,
+    allow_autonomous_refactors: true,
+  },
+};
+
+function normalizeProfile(profile) {
+  const value = String(profile || '').trim().toLowerCase();
+  return VALID_PROFILES.includes(value) ? value : null;
+}
+
+function normalizeContext(context) {
+  const value = String(context || '').trim().toLowerCase();
+  return VALID_CONTEXTS.includes(value) ? value : 'development';
+}
+
+function resolveExecutionProfile(input = {}) {
+  const context = normalizeContext(input.context);
+  const explicitProfile = normalizeProfile(input.explicitProfile);
+  const yolo = Boolean(input.yolo);
+  const reasons = [];
+
+  if (explicitProfile) {
+    reasons.push(`explicit profile selected: ${explicitProfile}`);
+    return {
+      profile: explicitProfile,
+      context,
+      policy: PROFILE_POLICIES[explicitProfile],
+      reasons,
+      source: 'explicit',
+    };
+  }
+
+  if (context === 'production' || context === 'security-sensitive') {
+    reasons.push(`context "${context}" enforces safe profile`);
+    return {
+      profile: 'safe',
+      context,
+      policy: PROFILE_POLICIES.safe,
+      reasons,
+      source: 'context',
+    };
+  }
+
+  if (context === 'migration') {
+    reasons.push('migration context enforces balanced profile');
+    return {
+      profile: 'balanced',
+      context,
+      policy: PROFILE_POLICIES.balanced,
+      reasons,
+      source: 'context',
+    };
+  }
+
+  if (yolo) {
+    reasons.push('yolo mode enabled for non-critical context');
+    return {
+      profile: 'aggressive',
+      context,
+      policy: PROFILE_POLICIES.aggressive,
+      reasons,
+      source: 'yolo',
+    };
+  }
+
+  reasons.push('default profile for standard development context');
+  return {
+    profile: 'balanced',
+    context,
+    policy: PROFILE_POLICIES.balanced,
+    reasons,
+    source: 'default',
+  };
+}
+
+module.exports = {
+  VALID_PROFILES,
+  VALID_CONTEXTS,
+  PROFILE_POLICIES,
+  normalizeProfile,
+  normalizeContext,
+  resolveExecutionProfile,
+};

package/.aios-core/core/orchestration/index.js

@@ -22,6 +22,7 @@ const ParallelExecutor = require('./parallel-executor');
 const TechStackDetector = require('./tech-stack-detector');
 const ConditionEvaluator = require('./condition-evaluator');
 const SkillDispatcher = require('./skill-dispatcher');
+const executionProfileResolver = require('./execution-profile-resolver');
 
 // Epic 0: Master Orchestrator (ADE)
 const MasterOrchestrator = require('./master-orchestrator');
@@ -159,6 +160,8 @@ module.exports = {
   TechStackDetector,
   ConditionEvaluator,
   SkillDispatcher,
+  ExecutionProfileResolver: executionProfileResolver,
+  resolveExecutionProfile: executionProfileResolver.resolveExecutionProfile,
 
   // Epic 0: Orchestrator constants
   OrchestratorState: MasterOrchestrator.OrchestratorState,

package/.aios-core/core/orchestration/skill-dispatcher.js

@@ -170,6 +170,8 @@ class SkillDispatcher {
         workflowId: context.workflowId,
         yoloMode: context.yoloMode || false,
         previousPhases: context.previousPhases || {},
+        executionProfile: context.executionProfile || null,
+        executionPolicy: context.executionPolicy || null,
       },
     };
   }

package/.aios-core/core/orchestration/subagent-prompt-builder.js

@@ -299,7 +299,9 @@ ${agentDef}
 **Task File:** ${taskFile}
 **Expected Output:** ${context.creates || 'See task definition'}
 **Execution Mode:** ${context.yoloMode ? 'YOLO (autonomous)' : 'Interactive'}
+**Execution Profile:** ${context.executionProfile || 'balanced'}
 **Elicitation Required:** ${context.elicit ? 'Yes' : 'No'}
+**Risk Policy:** ${JSON.stringify(context.executionPolicy || {}, null, 0)}
 
 ### Complete Task Definition: