agentic-qe 3.14.2 → 3.14.4

package/dist/coordination/workflow-orchestrator.js

@@ -13,6 +13,7 @@ import { createEvent } from '../shared/events/domain-events.js';
 import { toError, toErrorMessage } from '../shared/error-utils.js';
 export { WorkflowEvents, DEFAULT_WORKFLOW_CONFIG, } from './workflow-types.js';
 import { WorkflowEvents, DEFAULT_WORKFLOW_CONFIG } from './workflow-types.js';
+import { hashWorkflowValue, parallelOutputConflicts, parallelUndeclaredReads, parallelWritePaths, } from './workflow-composition.js';
 // Import deterministic actions
 import { findDeterministicAction } from './deterministic-actions.js';
 // Import built-in workflows
@@ -105,13 +106,13 @@ export class WorkflowOrchestrator {
             executionId, workflowId, workflowName: workflow.name,
             status: 'running', startedAt, progress: 0,
             currentSteps: [], completedSteps: [], failedSteps: [], skippedSteps: [],
-            context, stepResults: new Map(),
+            context, stepResults: new Map(), parallelCompositionReceipts: [],
         };
         this.executions.set(executionId, execution);
         await this.publishWorkflowStarted(execution, workflow);
         this.runWorkflow(workflow, execution).catch(async (error) => {
             execution.status = 'failed';
-            execution.error = String(error);
+            execution.error = toErrorMessage(error);
             execution.completedAt = new Date();
             execution.duration = execution.completedAt.getTime() - startedAt.getTime();
             await this.publishWorkflowFailed(execution, 'unknown', String(error));
@@ -131,13 +132,7 @@ export class WorkflowOrchestrator {
         execution.status = 'cancelled';
         execution.completedAt = new Date();
         execution.duration = execution.completedAt.getTime() - execution.startedAt.getTime();
-        // Clean up any pending approval gates for this execution to prevent timer leaks
-        for (const [key, gate] of this.approvalGates.entries()) {
-            if (key.startsWith(`${executionId}:`)) {
-                gate.resolve({ approved: false, reason: 'Workflow cancelled' });
-                this.approvalGates.delete(key);
-            }
-        }
+        this.closeApprovalGates(executionId, 'Workflow cancelled');
         await this.publishEvent(WorkflowEvents.WorkflowCancelled, {
             executionId, workflowId: execution.workflowId, workflowName: execution.workflowName,
         }, execution.context.metadata.correlationId);
@@ -164,7 +159,7 @@ export class WorkflowOrchestrator {
         execution.status = 'running';
         this.runWorkflow(workflow, execution).catch(async (error) => {
             execution.status = 'failed';
-            execution.error = String(error);
+            execution.error = toErrorMessage(error);
         });
         return ok(undefined);
     }
@@ -296,8 +291,9 @@ export class WorkflowOrchestrator {
     // ============================================================================
     async runWorkflow(workflow, execution) {
         const timeout = workflow.timeout || this.config.defaultWorkflowTimeout;
+        let workflowTimer;
         const timeoutPromise = new Promise((_, reject) => {
-            setTimeout(() => reject(new Error(`Workflow timeout after ${timeout}ms`)), timeout);
+            workflowTimer = setTimeout(() => reject(new Error(`Workflow timeout after ${timeout}ms`)), timeout);
         });
         try {
             await Promise.race([this.executeSteps(workflow, execution), timeoutPromise]);
@@ -312,13 +308,19 @@ export class WorkflowOrchestrator {
         catch (error) {
             if (execution.status === 'running') {
                 execution.status = 'failed';
-                execution.error = String(error);
+                execution.error = toErrorMessage(error);
+                this.closeApprovalGates(execution.executionId, 'Workflow failed');
                 execution.completedAt = new Date();
                 execution.duration = execution.completedAt.getTime() - execution.startedAt.getTime();
                 const failedStep = execution.currentSteps[0] || 'unknown';
-                await this.publishWorkflowFailed(execution, failedStep, String(error));
+                execution.currentSteps = [];
+                await this.publishWorkflowFailed(execution, failedStep, toErrorMessage(error));
             }
         }
+        finally {
+            if (workflowTimer)
+                clearTimeout(workflowTimer);
+        }
         if (this.config.persistExecutions)
             await this.persistExecution(execution);
     }
@@ -337,45 +339,131 @@ export class WorkflowOrchestrator {
                 break;
             const parallelSteps = readySteps.filter((s) => !s.dependsOn?.length);
             const sequentialSteps = readySteps.filter((s) => s.dependsOn?.length);
-            if (parallelSteps.length > 0) {
+            // A lone root has no concurrent siblings and needs no clone/barrier.
+            if (parallelSteps.length === 1)
+                sequentialSteps.unshift(parallelSteps[0]);
+            if (parallelSteps.length > 1) {
                 execution.currentSteps = parallelSteps.map((s) => s.id);
-                const results = await Promise.allSettled(parallelSteps.map((step) => this.executeStep(step, execution, workflow)));
+                const receipt = {
+                    version: 1, workflowId: workflow.id,
+                    workflowRevision: `${workflow.version}:${hashWorkflowValue(workflow)}`,
+                    executionId: execution.executionId,
+                    groupId: parallelSteps.map(step => step.id).join('|'),
+                    steps: [], conflicts: [], strategy: 'rejected', disposition: 'invalid',
+                };
+                execution.parallelCompositionReceipts ??= [];
+                execution.parallelCompositionReceipts.push(receipt);
+                try {
+                    receipt.steps = parallelSteps.map(step => ({
+                        stepId: step.id, disposition: 'not_started',
+                        writes: parallelWritePaths(step).map(write => write.path),
+                    }));
+                    receipt.conflicts = parallelOutputConflicts(parallelSteps);
+                }
+                catch (error) {
+                    throw new Error(`parallel_output_invalid_path: ${toErrorMessage(error)}`);
+                }
+                if (receipt.conflicts.length > 0) {
+                    receipt.disposition = 'conflict';
+                    throw new Error(`parallel_output_conflict: ${receipt.conflicts.map(c => `${c.stepA}.${c.pathA} ↔ ${c.stepB}.${c.pathB}`).join(', ')}`);
+                }
+                const undeclaredReads = parallelUndeclaredReads(parallelSteps);
+                if (undeclaredReads.length > 0) {
+                    throw new Error(`parallel_dependency_error: ${undeclaredReads.map(read => `${read.stepId} reads ${read.sourcePath} from concurrent step ${read.otherStepId}`).join(', ')}`);
+                }
+                // Every action observes the same pre-group state. Its own mutations to
+                // the supplied context cannot leak into a sibling's input or the
+                // shared workflow context.
+                let groupContext;
+                let contexts;
+                let baseResultsHash;
+                try {
+                    groupContext = structuredClone(execution.context);
+                    baseResultsHash = hashWorkflowValue(groupContext.results);
+                    contexts = parallelSteps.map(() => structuredClone(groupContext));
+                }
+                catch (error) {
+                    throw new Error(`parallel_context_uncloneable: ${toErrorMessage(error)}`);
+                }
+                const results = await Promise.allSettled(parallelSteps.map((step, index) => this.executeStep(step, execution, workflow, contexts[index], true)));
+                let hardFailure;
                 for (let i = 0; i < parallelSteps.length; i++) {
                     const step = parallelSteps[i];
                     const result = results[i];
                     if (result.status === 'fulfilled') {
                         const stepResult = result.value;
+                        execution.stepResults.set(step.id, stepResult);
                         if (stepResult.status === 'completed') {
                             completedSteps.add(step.id);
                             execution.completedSteps.push(step.id);
+                            receipt.steps[i].disposition = 'succeeded';
+                            try {
+                                receipt.steps[i].outputHash = hashWorkflowValue(stepResult.output);
+                            }
+                            catch (error) {
+                                throw new Error(`parallel_output_unhashable: ${toErrorMessage(error)}`);
+                            }
                         }
                         else if (stepResult.status === 'skipped') {
                             skippedSteps.add(step.id);
                             execution.skippedSteps.push(step.id);
+                            receipt.steps[i].disposition = 'skipped';
                         }
                         else if (stepResult.status === 'failed') {
                             failedSteps.add(step.id);
                             execution.failedSteps.push(step.id);
-                            if (!step.continueOnFailure) {
-                                execution.status = 'failed';
-                                execution.error = stepResult.error;
-                                return;
-                            }
+                            receipt.steps[i].disposition = 'failed';
+                            if (!step.continueOnFailure)
+                                hardFailure ??= stepResult.error ?? 'Unknown error';
                         }
                     }
                     else {
                         failedSteps.add(step.id);
                         execution.failedSteps.push(step.id);
-                        if (!step.continueOnFailure) {
-                            execution.status = 'failed';
-                            execution.error = result.reason?.message || 'Unknown error';
-                            return;
-                        }
+                        receipt.steps[i].disposition = 'failed';
+                        if (!step.continueOnFailure)
+                            hardFailure ??= toErrorMessage(result.reason);
                     }
                     const pendingIndex = pendingSteps.indexOf(step);
                     if (pendingIndex !== -1)
                         pendingSteps.splice(pendingIndex, 1);
                 }
+                if (execution.status !== 'running' || hardFailure !== undefined) {
+                    receipt.disposition = 'partial';
+                    if (hardFailure !== undefined)
+                        throw new Error(hardFailure);
+                    if (execution.status !== 'running')
+                        return;
+                }
+                else {
+                    try {
+                        const stagedContext = {
+                            ...groupContext, results: structuredClone(groupContext.results),
+                        };
+                        for (let i = 0; i < parallelSteps.length; i++) {
+                            const result = results[i];
+                            if (result.status === 'fulfilled' && result.value.status === 'completed') {
+                                this.mapStepOutput(parallelSteps[i], result.value.output, stagedContext);
+                            }
+                        }
+                        const combinedStateHash = hashWorkflowValue(stagedContext.results);
+                        if (execution.status !== 'running') {
+                            receipt.disposition = 'partial';
+                            return;
+                        }
+                        if (hashWorkflowValue(execution.context.results) !== baseResultsHash) {
+                            throw new Error('parallel_context_changed: shared results changed before composition');
+                        }
+                        execution.context.results = stagedContext.results;
+                        receipt.combinedStateHash = combinedStateHash;
+                        receipt.strategy = 'disjoint';
+                        receipt.disposition = 'composed';
+                    }
+                    catch (error) {
+                        receipt.disposition = 'invalid';
+                        throw new Error(`parallel_output_invalid: ${toErrorMessage(error)}`);
+                    }
+                }
             }
             for (const step of sequentialSteps) {
                 if (execution.status !== 'running')
@@ -409,29 +497,47 @@ export class WorkflowOrchestrator {
         }
         execution.currentSteps = [];
     }
-    async executeStep(step, execution, _workflow) {
+    async executeStep(step, execution, _workflow, context = execution.context, deferOutput = false) {
         const startedAt = new Date();
         const result = { stepId: step.id, status: 'pending', startedAt };
         try {
-            if (step.skipCondition && this.evaluateCondition(step.skipCondition, execution.context)) {
+            if (step.skipCondition && this.evaluateCondition(step.skipCondition, context)) {
                 result.status = 'skipped';
                 result.completedAt = new Date();
                 result.duration = result.completedAt.getTime() - startedAt.getTime();
-                execution.stepResults.set(step.id, result);
+                if (!deferOutput)
+                    execution.stepResults.set(step.id, result);
                 await this.publishStepSkipped(execution, step);
                 return result;
             }
-            if (step.condition && !this.evaluateCondition(step.condition, execution.context)) {
+            if (step.condition && !this.evaluateCondition(step.condition, context)) {
                 result.status = 'skipped';
                 result.completedAt = new Date();
                 result.duration = result.completedAt.getTime() - startedAt.getTime();
-                execution.stepResults.set(step.id, result);
+                if (!deferOutput)
+                    execution.stepResults.set(step.id, result);
                 await this.publishStepSkipped(execution, step);
                 return result;
             }
             result.status = 'running';
             await this.publishStepStarted(execution, step);
-            const input = this.buildStepInput(step, execution.context);
+            const input = this.buildStepInput(step, context);
+            // Approval must precede the action and any output mapping. Otherwise a
+            // rejected or expired gate cannot prevent the side effect it protects.
+            if (step.approval) {
+                result.status = 'awaiting_approval';
+                execution.stepResults.set(step.id, result);
+                const approvalResult = await this.waitForApproval(step, execution);
+                if (!approvalResult.approved || execution.status !== 'running') {
+                    result.status = 'failed';
+                    result.error = approvalResult.reason || 'Step rejected at approval gate';
+                    result.completedAt = new Date();
+                    result.duration = result.completedAt.getTime() - startedAt.getTime();
+                    await this.publishStepFailed(execution, step, result.error);
+                    return result;
+                }
+                result.status = 'running';
+            }
             let lastError;
             const maxAttempts = step.retry?.maxAttempts || 1;
             let backoffMs = step.retry?.backoffMs || 1000;
@@ -440,32 +546,31 @@ export class WorkflowOrchestrator {
                 result.retryCount = attempt - 1;
                 try {
                     const stepTimeout = step.timeout || this.config.defaultStepTimeout;
-                    const output = await this.executeStepAction(step, input, execution.context, stepTimeout);
-                    this.mapStepOutput(step, output, execution.context);
-                    // Handle approval gate if configured
-                    if (step.approval) {
-                        const approvalResult = await this.waitForApproval(step, execution);
-                        if (!approvalResult.approved) {
-                            result.status = 'failed';
-                            result.error = approvalResult.reason || 'Step rejected at approval gate';
-                            result.output = output;
-                            result.completedAt = new Date();
-                            result.duration = result.completedAt.getTime() - startedAt.getTime();
-                            execution.stepResults.set(step.id, result);
-                            await this.publishStepFailed(execution, step, result.error);
-                            return result;
-                        }
+                    const output = await this.executeStepAction(step, input, context, stepTimeout);
+                    if (!deferOutput)
+                        this.mapStepOutput(step, output, context);
+                    let capturedOutput;
+                    try {
+                        capturedOutput = deferOutput ? structuredClone(output) : output;
+                    }
+                    catch (error) {
+                        throw new Error(`parallel_output_uncloneable: ${toErrorMessage(error)}`);
                     }
                     result.status = 'completed';
-                    result.output = output;
+                    result.output = capturedOutput;
                     result.completedAt = new Date();
                     result.duration = result.completedAt.getTime() - startedAt.getTime();
-                    execution.stepResults.set(step.id, result);
+                    if (!deferOutput)
+                        execution.stepResults.set(step.id, result);
                     await this.publishStepCompleted(execution, step, result);
                     return result;
                 }
                 catch (error) {
                     lastError = toError(error);
+                    // Retrying an already-successful external action because its output
+                    // could not be snapshotted could duplicate effects.
+                    if (lastError.message.startsWith('parallel_output_uncloneable:'))
+                        break;
                     if (attempt < maxAttempts) {
                         await this.delay(backoffMs);
                         backoffMs *= backoffMultiplier;
@@ -476,9 +581,10 @@ export class WorkflowOrchestrator {
             result.error = lastError?.message || 'Unknown error';
             result.completedAt = new Date();
             result.duration = result.completedAt.getTime() - startedAt.getTime();
-            execution.stepResults.set(step.id, result);
+            if (!deferOutput)
+                execution.stepResults.set(step.id, result);
             if (step.rollback)
-                await this.executeRollback(step.rollback, execution.context);
+                await this.executeRollback(step.rollback, context);
             await this.publishStepFailed(execution, step, result.error);
             return result;
         }
@@ -487,7 +593,8 @@ export class WorkflowOrchestrator {
             result.error = toErrorMessage(error);
             result.completedAt = new Date();
             result.duration = result.completedAt.getTime() - startedAt.getTime();
-            execution.stepResults.set(step.id, result);
+            if (!deferOutput)
+                execution.stepResults.set(step.id, result);
             await this.publishStepFailed(execution, step, result.error);
             return result;
         }
@@ -545,7 +652,9 @@ export class WorkflowOrchestrator {
         return input;
     }
     mapStepOutput(step, output, context) {
-        context.results[step.id] = output;
+        Object.defineProperty(context.results, step.id, {
+            value: output, writable: true, enumerable: true, configurable: true,
+        });
         if (step.outputMapping && typeof output === 'object' && output !== null) {
             for (const [sourcePath, targetPath] of Object.entries(step.outputMapping)) {
                 const value = this.getValueByPath(output, sourcePath);
@@ -681,6 +790,16 @@ export class WorkflowOrchestrator {
                 return err(new Error(`Invalid domain for step ${step.id}: ${step.domain}`));
             if (!step.action)
                 return err(new Error(`Step ${step.id} must have an action`));
+            if (step.approval && typeof step.approval === 'object') {
+                const { expiresAfter, autoApproveAfter } = step.approval;
+                if (expiresAfter !== undefined && autoApproveAfter !== undefined) {
+                    return err(new Error(`Step ${step.id} sets both approval expiry fields`));
+                }
+                const expiry = expiresAfter ?? autoApproveAfter;
+                if (expiry !== undefined && (!Number.isSafeInteger(expiry) || expiry < 0 || expiry > 2_147_483_647)) {
+                    return err(new Error(`Step ${step.id} has an invalid approval expiry`));
+                }
+            }
             if (step.dependsOn) {
                 for (const dep of step.dependsOn) {
                     if (!definition.steps.some((s) => s.id === dep)) {
@@ -816,49 +935,64 @@ export class WorkflowOrchestrator {
     // ============================================================================
     // Private Methods - Approval Gates
     // ============================================================================
+    closeApprovalGates(executionId, reason) {
+        for (const [key, gate] of this.approvalGates.entries()) {
+            if (key.startsWith(`${executionId}:`)) {
+                gate.resolve({ approved: false, reason });
+            }
+        }
+    }
     /**
-     * Wait for external approval (or auto-approve after timeout).
+     * Wait for external approval. An unanswered gate expires without approval.
      * Returns an object with approved status and optional rejection reason.
      */
     async waitForApproval(step, execution) {
+        // Cancellation may arrive while publishing StepStarted, before this gate
+        // exists. Do not register an indefinite approval for a terminal workflow.
+        if (execution.status !== 'running') {
+            return { approved: false, reason: `Workflow is ${execution.status}` };
+        }
         const approvalConfig = typeof step.approval === 'object' ? step.approval : {};
-        const autoApproveAfter = approvalConfig.autoApproveAfter ?? 300000; // 5 min default
+        const expiresAfter = approvalConfig.expiresAfter ?? approvalConfig.autoApproveAfter ?? 300000;
         const message = approvalConfig.message ?? `Awaiting approval for step: ${step.name}`;
-        // Update step result status
-        const stepResult = execution.stepResults.get(step.id);
-        if (stepResult)
-            stepResult.status = 'awaiting_approval';
-        // Emit StepAwaitingApproval event
-        await this.publishEvent(WorkflowEvents.StepAwaitingApproval, {
-            executionId: execution.executionId,
-            workflowId: execution.workflowId,
-            stepId: step.id,
-            stepName: step.name,
-            domain: step.domain,
-            message,
-            autoApproveAfter: autoApproveAfter > 0 ? autoApproveAfter : undefined,
-        }, execution.context.metadata.correlationId);
+        if (!Number.isSafeInteger(expiresAfter) || expiresAfter < 0 || expiresAfter > 2_147_483_647) {
+            return { approved: false, reason: 'Invalid approval expiry' };
+        }
         const key = `${execution.executionId}:${step.id}`;
-        return new Promise((resolve) => {
-            // Store the gate so approveStep/rejectStep can resolve it
-            const gate = { resolve };
+        let timer;
+        const approval = new Promise((resolve) => {
+            // Register before publishing: a synchronous event consumer can approve.
+            const gate = { resolve: (result) => {
+                    if (this.approvalGates.get(key) !== gate)
+                        return;
+                    this.approvalGates.delete(key);
+                    if (timer)
+                        clearTimeout(timer);
+                    resolve(result);
+                } };
             this.approvalGates.set(key, gate);
-            // Auto-approve timer (0 = never auto-approve)
-            if (autoApproveAfter > 0) {
-                const timer = setTimeout(() => {
-                    if (this.approvalGates.has(key)) {
-                        this.approvalGates.delete(key);
-                        resolve({ approved: true }); // auto-approve on timeout
-                    }
-                }, autoApproveAfter);
-                // Wrap resolve to also clear the timer
-                const originalResolve = gate.resolve;
-                gate.resolve = (result) => {
-                    clearTimeout(timer);
-                    originalResolve(result);
-                };
+            if (expiresAfter > 0) {
+                timer = setTimeout(() => {
+                    gate.resolve({ approved: false, reason: 'Approval expired' });
+                }, expiresAfter);
             }
         });
+        try {
+            await this.publishEvent(WorkflowEvents.StepAwaitingApproval, {
+                executionId: execution.executionId,
+                workflowId: execution.workflowId,
+                stepId: step.id,
+                stepName: step.name,
+                domain: step.domain,
+                message,
+                expiresAfter: expiresAfter > 0 ? expiresAfter : undefined,
+            }, execution.context.metadata.correlationId);
+        }
+        catch (error) {
+            this.approvalGates.get(key)?.resolve({ approved: false, reason: 'Approval event failed' });
+            throw error;
+        }
+        return approval;
     }
     // ============================================================================
     // Private Methods - Utilities

package/dist/coordination/workflow-types.d.ts

@@ -72,7 +72,9 @@ export interface WorkflowStepDefinition {
     continueOnFailure?: boolean;
     /** Approval gate configuration */
     approval?: boolean | {
-        /** Auto-approve after this many ms (0 = never auto-approve) */
+        /** Expire an unanswered approval after this many ms (0 = wait indefinitely; default 5 min) */
+        expiresAfter?: number;
+        /** @deprecated Legacy alias for expiresAfter; never grants approval on timeout */
         autoApproveAfter?: number;
         /** Approval prompt message */
         message?: string;
@@ -144,6 +146,30 @@ export interface WorkflowContext {
         triggeredBy?: string;
     };
 }
+/** Evidence for one parallel group, without retaining raw step output. */
+export interface ParallelCompositionReceipt {
+    version: 1;
+    workflowId: string;
+    workflowRevision: string;
+    executionId: string;
+    groupId: string;
+    steps: Array<{
+        stepId: string;
+        disposition: 'succeeded' | 'failed' | 'skipped' | 'cancelled' | 'not_started';
+        outputHash?: string;
+        writes: string[];
+    }>;
+    conflicts: Array<{
+        pathA: string;
+        stepA: string;
+        pathB: string;
+        stepB: string;
+        kind: 'exact' | 'ancestor-descendant';
+    }>;
+    strategy: 'disjoint' | 'rejected';
+    combinedStateHash?: string;
+    disposition: 'composed' | 'conflict' | 'partial' | 'invalid';
+}
 /**
  * Workflow execution status
  */
@@ -162,6 +188,7 @@ export interface WorkflowExecutionStatus {
     skippedSteps: string[];
     context: WorkflowContext;
     stepResults: Map<string, StepExecutionResult>;
+    parallelCompositionReceipts?: ParallelCompositionReceipt[];
     error?: string;
 }
 /**
@@ -219,6 +246,8 @@ export interface StepEventPayload {
 }
 export interface StepAwaitingApprovalPayload extends StepEventPayload {
     message?: string;
+    expiresAfter?: number;
+    /** @deprecated No longer emitted; read expiresAfter instead */
     autoApproveAfter?: number;
 }
 export interface IWorkflowOrchestrator {

package/dist/coordination/yaml-pipeline-loader.js

@@ -339,17 +339,21 @@ export class YamlPipelineLoader {
         if (typeof raw === 'boolean') {
             return ok(raw);
         }
-        // Object form: approval: { autoApproveAfter, message }
+        // Object form: approval: { expiresAfter, message }
         if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
             return err(new Error(`Step '${stepId}': 'approval' must be a boolean or object`));
         }
         const a = raw;
         const result = {};
-        if (a.autoApproveAfter !== undefined) {
-            if (typeof a.autoApproveAfter !== 'number' || a.autoApproveAfter < 0) {
-                return err(new Error(`Step '${stepId}': approval.autoApproveAfter must be a non-negative number`));
+        if (a.expiresAfter !== undefined && a.autoApproveAfter !== undefined) {
+            return err(new Error(`Step '${stepId}': set only one approval expiry field`));
+        }
+        const expiry = a.expiresAfter ?? a.autoApproveAfter;
+        if (expiry !== undefined) {
+            if (typeof expiry !== 'number' || !Number.isSafeInteger(expiry) || expiry < 0 || expiry > 2_147_483_647) {
+                return err(new Error(`Step '${stepId}': approval expiry must be an integer from 0 to 2147483647 milliseconds`));
             }
-            result.autoApproveAfter = a.autoApproveAfter;
+            result.expiresAfter = expiry;
         }
         if (a.message !== undefined) {
             if (typeof a.message !== 'string') {

package/dist/domains/chaos-resilience/services/chaos-engineer.js

@@ -12,6 +12,7 @@ import { validateCommand } from '../../../shared/security/command-validator.js';
 import { toErrorMessage, toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
 import { secureRandom } from '../../../shared/utils/crypto-random.js';
+import { getClaudeModelForTier } from '../../../shared/llm/model-registry.js';
 const DEFAULT_CONFIG = {
     defaultTimeout: 60000, // 60 seconds
     maxConcurrentFaults: 3,
@@ -289,13 +290,7 @@ export class ChaosEngineerService {
      * ADR-051: Get model name for tier
      */
     getModelForTier(tier) {
-        const models = {
-            1: 'claude-haiku-4-5',
-            2: 'claude-sonnet-4-6',
-            3: 'claude-sonnet-4-6',
-            4: 'claude-opus-4-7',
-        };
-        return models[tier] || models[2];
+        return getClaudeModelForTier(tier);
     }
     /**
      * ADR-051: LLM-powered experiment hypothesis analysis

package/dist/domains/code-intelligence/services/knowledge-graph.js

@@ -12,6 +12,7 @@ import { safeJsonParse } from '../../../shared/safe-json.js';
 import { existsSync, statSync } from 'fs';
 import { dirname, resolve as resolvePath, join as joinPath } from 'path';
 import { extractTsJs } from '../../../shared/parsers/treesitter-ts-extractor.js';
+import { getClaudeModelForTier } from '../../../shared/llm/model-registry.js';
 const DEFAULT_CONFIG = {
     maxNodes: 100000,
     maxEdgesPerNode: 500,
@@ -333,13 +334,7 @@ export class KnowledgeGraphService {
      * @param tier - Model tier (1=Haiku, 2=Sonnet, 3=Sonnet, 4=Opus)
      */
     getModelForTier(tier) {
-        switch (tier) {
-            case 1: return 'claude-haiku-4-5-20251001';
-            case 2: return 'claude-sonnet-4-6';
-            case 3: return 'claude-sonnet-4-6';
-            case 4: return 'claude-opus-4-7';
-            default: return 'claude-sonnet-4-6';
-        }
+        return getClaudeModelForTier(tier);
     }
     /**
      * Extract semantic relationships from code using LLM