ai-maestro 1.0.0

package/src/orchestration/orchestration-loop.mjs

@@ -0,0 +1,1971 @@
+const SCHEMA_VERSION = 1;
+
+const LOOP_STATES = new Set([
+  'loop.initialized',
+  'loop.input_validated',
+  'loop.classified',
+  'loop.manager_selected',
+  'loop.engine_candidate_selected',
+  'loop.preflight_evaluated',
+  'loop.budget_evaluated',
+  'loop.policy_evaluated',
+  'loop.runtime_gate_evaluated',
+  'loop.execution_planned',
+  'loop.delegation_planned',
+  'loop.subtasks_planned',
+  'loop.conflicts_evaluated',
+  'loop.execution_simulated',
+  'loop.results_consolidated',
+  'loop.result_verified',
+  'loop.completed',
+  'loop.failed',
+  'loop.blocked',
+  'loop.needs_human',
+  'loop.cancelled_limit',
+  'loop.cancelled_cycle',
+  'loop.cancelled_invalid_transition',
+  'loop.cancelled_invalid_input'
+]);
+
+const TERMINAL_STATES = new Set([
+  'loop.completed',
+  'loop.failed',
+  'loop.blocked',
+  'loop.needs_human',
+  'loop.cancelled_limit',
+  'loop.cancelled_cycle',
+  'loop.cancelled_invalid_transition',
+  'loop.cancelled_invalid_input'
+]);
+
+const EVENTS = new Set([
+  'START',
+  'INPUT_VALID',
+  'INPUT_INVALID',
+  'CLASSIFICATION_READY',
+  'CLASSIFICATION_INVALID',
+  'MANAGER_READY',
+  'MANAGER_INVALID',
+  'ENGINE_CANDIDATE_READY',
+  'ENGINE_CANDIDATE_INVALID',
+  'PREFLIGHT_READY',
+  'PREFLIGHT_INVALID',
+  'BUDGET_READY',
+  'BUDGET_INVALID',
+  'POLICY_READY',
+  'POLICY_INVALID',
+  'RUNTIME_GATE_READY',
+  'GATE_EXECUTE',
+  'GATE_BLOCK',
+  'GATE_NEEDS_HUMAN',
+  'GATE_DELEGATE',
+  'GATE_FALLBACK',
+  'GATE_UNKNOWN',
+  'PLAN_READY',
+  'DELEGATION_READY',
+  'DELEGATION_INVALID',
+  'SUBTASKS_READY',
+  'SUBTASKS_INVALID',
+  'CONFLICTS_CLEAR',
+  'CONFLICTS_FOUND',
+  'CONFLICTS_BLOCKING',
+  'CONFLICTS_INVALID',
+  'SIMULATION_READY',
+  'CONSOLIDATION_READY',
+  'CONSOLIDATION_SKIPPED',
+  'CONSOLIDATION_INVALID',
+  'VERIFICATION_READY',
+  'VERIFICATION_SKIPPED',
+  'VERIFICATION_INVALID',
+  'LIMIT_EXCEEDED',
+  'CYCLE_DETECTED',
+  'INVALID_TRANSITION',
+  'TERMINAL_STATE'
+]);
+
+const TRANSITIONS = {
+  'loop.initialized': {
+    INPUT_VALID: 'loop.input_validated',
+    INPUT_INVALID: 'loop.cancelled_invalid_input'
+  },
+  'loop.input_validated': {
+    CLASSIFICATION_READY: 'loop.classified',
+    CLASSIFICATION_INVALID: 'loop.failed'
+  },
+  'loop.classified': {
+    MANAGER_READY: 'loop.manager_selected',
+    MANAGER_INVALID: 'loop.failed'
+  },
+  'loop.manager_selected': {
+    ENGINE_CANDIDATE_READY: 'loop.engine_candidate_selected',
+    ENGINE_CANDIDATE_INVALID: 'loop.failed'
+  },
+  'loop.engine_candidate_selected': {
+    PREFLIGHT_READY: 'loop.preflight_evaluated',
+    PREFLIGHT_INVALID: 'loop.failed'
+  },
+  'loop.preflight_evaluated': {
+    BUDGET_READY: 'loop.budget_evaluated',
+    BUDGET_INVALID: 'loop.failed'
+  },
+  'loop.budget_evaluated': {
+    POLICY_READY: 'loop.policy_evaluated',
+    POLICY_INVALID: 'loop.failed'
+  },
+  'loop.policy_evaluated': {
+    RUNTIME_GATE_READY: 'loop.runtime_gate_evaluated',
+    GATE_UNKNOWN: 'loop.failed'
+  },
+  'loop.runtime_gate_evaluated': {
+    GATE_EXECUTE: 'loop.execution_planned',
+    GATE_DELEGATE: 'loop.execution_planned',
+    GATE_BLOCK: 'loop.blocked',
+    GATE_NEEDS_HUMAN: 'loop.needs_human',
+    GATE_FALLBACK: 'loop.blocked'
+  },
+  'loop.execution_planned': {
+    PLAN_READY: 'loop.conflicts_evaluated',
+    DELEGATION_READY: 'loop.delegation_planned',
+    DELEGATION_INVALID: 'loop.failed'
+  },
+  'loop.delegation_planned': {
+    SUBTASKS_READY: 'loop.subtasks_planned',
+    SUBTASKS_INVALID: 'loop.failed'
+  },
+  'loop.subtasks_planned': {
+    CONFLICTS_CLEAR: 'loop.conflicts_evaluated',
+    CONFLICTS_FOUND: 'loop.conflicts_evaluated',
+    CONFLICTS_BLOCKING: 'loop.blocked',
+    CONFLICTS_INVALID: 'loop.failed'
+  },
+  'loop.conflicts_evaluated': {
+    SIMULATION_READY: 'loop.execution_simulated'
+  },
+  'loop.execution_simulated': {
+    CONSOLIDATION_READY: 'loop.results_consolidated',
+    CONSOLIDATION_SKIPPED: 'loop.results_consolidated',
+    CONSOLIDATION_INVALID: 'loop.failed'
+  },
+  'loop.results_consolidated': {
+    VERIFICATION_READY: 'loop.result_verified',
+    VERIFICATION_SKIPPED: 'loop.result_verified',
+    VERIFICATION_INVALID: 'loop.failed'
+  },
+  'loop.result_verified': {
+    PLAN_READY: 'loop.completed'
+  }
+};
+
+const GATE_DECISIONS = new Set(['EXECUTE', 'BLOCK', 'NEEDS_HUMAN', 'DELEGATE', 'FALLBACK']);
+const ADAPTER_NAMES = new Set([
+  'classifyTask',
+  'selectManager',
+  'selectEngineCandidate',
+  'evaluatePreflight',
+  'evaluateBudget',
+  'evaluatePolicy',
+  'evaluateRuntimeGate',
+  'planDelegation',
+  'planSubtasks',
+  'detectConflicts',
+  'consolidate',
+  'verify'
+]);
+
+const GLOBAL_LIMITS = Object.freeze({
+  maxTransitions: 40,
+  maxAttempts: 3,
+  maxDepth: 2,
+  maxSubtasks: 8,
+  maxAgentsPerManager: 4
+});
+
+const DEFAULT_DECISIONS = Object.freeze({
+  classification: null,
+  manager: null,
+  engineCandidate: null,
+  preflight: null,
+  budget: null,
+  policy: null,
+  runtimeGate: null
+});
+
+const SENSITIVE_KEYS = ['token', 'secret', 'password', 'authorization', 'cookie', 'apikey', 'env'];
+
+export function planOrchestrationStep(input) {
+  assertPlainApiObject(input, 'input');
+  const {
+    state,
+    signal = null,
+    task,
+    context = {},
+    limits = {},
+    counters = {},
+    decisions = {},
+    moduleResults = {},
+    adapters = {},
+    previousTrace = [],
+    seenCycleSignatures = []
+  } = input;
+
+  if (typeof state !== 'string') {
+    throw new TypeError('state must be a string');
+  }
+  assertPlainApiObject(context, 'context');
+  assertPlainApiObject(limits, 'limits');
+  assertPlainApiObject(counters, 'counters');
+  assertPlainApiObject(decisions, 'decisions');
+  assertPlainApiObject(moduleResults, 'moduleResults');
+  assertPlainApiObject(adapters, 'adapters');
+  if (!Array.isArray(previousTrace)) {
+    throw new TypeError('previousTrace must be an array');
+  }
+  if (!Array.isArray(seenCycleSignatures)) {
+    throw new TypeError('seenCycleSignatures must be an array');
+  }
+  for (const [name, value] of Object.entries(adapters)) {
+    if (ADAPTER_NAMES.has(name) && typeof value !== 'function') {
+      throw new TypeError(`adapter ${name} must be a function`);
+    }
+  }
+  if (LOOP_STATES.has(state) && state !== 'loop.initialized' && !TERMINAL_STATES.has(state) && !isValidTask(task)) {
+    throw new TypeError('task must be an object with id for non-terminal states');
+  }
+
+  const normalizedLimits = normalizeLimits(limits);
+  const normalizedContext = cloneData(context);
+  const normalizedCounters = normalizeCounters(counters, normalizedContext);
+  const currentDecisions = normalizeDecisions(decisions);
+  const currentModules = isPlainObject(moduleResults) ? cloneData(moduleResults) : {};
+  const guards = [];
+  const warnings = [...normalizedLimits.warnings];
+  const errors = [];
+  const inconsistencies = [];
+  let nextContext = normalizedContext;
+  let nextDecisions = currentDecisions;
+  let nextModules = currentModules;
+  let nextCounters = normalizedCounters;
+  let event = signal;
+  let nextState = state;
+  let reason = '';
+  let terminalReason = null;
+  let provenance = [];
+  let conflicts = extractConflicts(nextModules, nextContext);
+
+  if (TERMINAL_STATES.has(state)) {
+    event = 'TERMINAL_STATE';
+    nextState = state;
+    reason = 'terminal state does not advance';
+    terminalReason = state;
+    guards.push('terminal-state');
+    return buildStepResult({
+      state,
+      event,
+      nextState,
+      reason,
+      terminalReason,
+      guards,
+      decisions: nextDecisions,
+      moduleResults: nextModules,
+      context: nextContext,
+      counters: incrementTransitions(normalizedCounters),
+      limits: normalizedLimits.limits,
+      previousTrace,
+      warnings,
+      errors,
+      inconsistencies,
+      conflicts,
+      provenance
+    });
+  }
+
+  if (normalizedCounters.transitions >= normalizedLimits.limits.maxTransitions ||
+      normalizedCounters.attempts > normalizedLimits.limits.maxAttempts ||
+      normalizedCounters.depth > normalizedLimits.limits.maxDepth) {
+    event = 'LIMIT_EXCEEDED';
+    nextState = 'loop.cancelled_limit';
+    reason = 'orchestration loop limit exceeded';
+    terminalReason = 'limit_exceeded';
+    guards.push('limit');
+    errors.push(loopError('LIMIT_EXCEEDED', reason, state, event, 'limits', 'blocking'));
+    return buildStepResult({
+      state,
+      event,
+      nextState,
+      reason,
+      terminalReason,
+      guards,
+      decisions: nextDecisions,
+      moduleResults: nextModules,
+      context: nextContext,
+      counters: incrementTransitions(normalizedCounters),
+      limits: normalizedLimits.limits,
+      previousTrace,
+      warnings,
+      errors,
+      inconsistencies,
+      conflicts,
+      provenance
+    });
+  }
+
+  if (!LOOP_STATES.has(state)) {
+    event = signal === null ? 'INVALID_TRANSITION' : String(signal);
+    nextState = 'loop.cancelled_invalid_transition';
+    reason = `unknown loop state: ${state}`;
+    terminalReason = 'invalid_transition';
+    guards.push('known-state');
+    errors.push(loopError('UNKNOWN_STATE', reason, state, event, 'state', 'error'));
+    return buildStepResult({
+      state,
+      event,
+      nextState,
+      reason,
+      terminalReason,
+      guards,
+      decisions: nextDecisions,
+      moduleResults: nextModules,
+      context: nextContext,
+      counters: incrementTransitions(normalizedCounters),
+      limits: normalizedLimits.limits,
+      previousTrace,
+      warnings,
+      errors,
+      inconsistencies,
+      conflicts,
+      provenance
+    });
+  }
+
+  if (signal !== null && !EVENTS.has(signal)) {
+    event = String(signal);
+    nextState = 'loop.cancelled_invalid_transition';
+    reason = `unknown event: ${String(signal)}`;
+    terminalReason = 'invalid_transition';
+    guards.push('known-event');
+    errors.push(loopError('UNKNOWN_EVENT', reason, state, event, 'signal', 'error'));
+    return buildStepResult({
+      state,
+      event,
+      nextState,
+      reason,
+      terminalReason,
+      guards,
+      decisions: nextDecisions,
+      moduleResults: nextModules,
+      context: nextContext,
+      counters: incrementTransitions(normalizedCounters),
+      limits: normalizedLimits.limits,
+      previousTrace,
+      warnings,
+      errors,
+      inconsistencies,
+      conflicts,
+      provenance
+    });
+  }
+
+  if (signal !== null && !isTransitionAllowed(state, signal)) {
+    event = signal;
+    nextState = 'loop.cancelled_invalid_transition';
+    reason = `invalid transition from ${state} using ${signal}`;
+    terminalReason = 'invalid_transition';
+    guards.push('valid-transition');
+    errors.push(loopError('INVALID_TRANSITION', reason, state, signal, 'signal', 'error'));
+    return buildStepResult({
+      state,
+      event,
+      nextState,
+      reason,
+      terminalReason,
+      guards,
+      decisions: nextDecisions,
+      moduleResults: nextModules,
+      context: nextContext,
+      counters: incrementTransitions(normalizedCounters),
+      limits: normalizedLimits.limits,
+      previousTrace,
+      warnings,
+      errors,
+      inconsistencies,
+      conflicts,
+      provenance
+    });
+  }
+
+  const derived = deriveTransition({
+    state,
+    task,
+    context: nextContext,
+    limits: normalizedLimits.limits,
+    counters: normalizedCounters,
+    decisions: nextDecisions,
+    moduleResults: nextModules,
+    adapters
+  });
+  if (derived.warnings.length > 0) warnings.push(...derived.warnings);
+  if (derived.errors.length > 0) errors.push(...derived.errors);
+  if (derived.inconsistencies.length > 0) inconsistencies.push(...derived.inconsistencies);
+  nextContext = derived.context;
+  nextDecisions = derived.decisions;
+  nextModules = derived.moduleResults;
+  nextCounters = derived.counters || normalizedCounters;
+  provenance = derived.provenance;
+  conflicts = derived.conflicts;
+
+  event = signal === null ? derived.event : signal;
+  if (!isTransitionAllowed(state, event)) {
+    const received = event;
+    event = received;
+    nextState = 'loop.cancelled_invalid_transition';
+    reason = `invalid transition from ${state} using ${received}`;
+    terminalReason = 'invalid_transition';
+    guards.push('valid-transition');
+    errors.push(loopError('INVALID_TRANSITION', reason, state, received, 'signal', 'error'));
+  } else {
+    nextState = TRANSITIONS[state][event];
+    reason = derived.reason;
+    terminalReason = TERMINAL_STATES.has(nextState) ? reasonToTerminal(nextState, derived) : null;
+    guards.push(...derived.guards);
+  }
+
+  const candidateSignature = createCycleSignature({
+    state,
+    event,
+    task,
+    context: nextContext,
+    counters: nextCounters,
+    decisions: nextDecisions,
+    moduleResults: nextModules,
+    conflicts
+  });
+  if (seenCycleSignatures.includes(candidateSignature) && nextState !== 'loop.cancelled_invalid_transition') {
+    event = 'CYCLE_DETECTED';
+    nextState = 'loop.cancelled_cycle';
+    reason = 'cycle signature was seen previously in this loop';
+    terminalReason = 'cycle_detected';
+    guards.push('cycle');
+    errors.push(loopError('CYCLE_DETECTED', reason, state, event, 'cycleSignature', 'blocking'));
+    nextContext = {
+      ...nextContext,
+      cycleInfo: {
+        signature: candidateSignature,
+        state,
+        event
+      }
+    };
+  }
+
+  return buildStepResult({
+    state,
+    event,
+    nextState,
+    reason,
+    terminalReason,
+    guards,
+    decisions: nextDecisions,
+    moduleResults: nextModules,
+    context: nextContext,
+    counters: incrementTransitions(nextCounters),
+    limits: normalizedLimits.limits,
+    previousTrace,
+    warnings: uniqueMessages(warnings),
+    errors,
+    inconsistencies,
+    conflicts,
+    provenance,
+    forcedCycleSignature: candidateSignature
+  });
+}
+
+export function runOrchestrationLoop(input) {
+  assertPlainApiObject(input, 'input');
+  const {
+    task,
+    context = {},
+    limits = {},
+    adapters = {},
+    moduleResults = {},
+    initialState = 'loop.initialized',
+    loopId = null
+  } = input;
+
+  if (typeof initialState !== 'string') {
+    throw new TypeError('initialState must be a string');
+  }
+  if (loopId !== null && (typeof loopId !== 'string' || loopId.trim().length === 0)) {
+    throw new TypeError('loopId must be a non-empty string when provided');
+  }
+  assertPlainApiObject(context, 'context');
+  assertPlainApiObject(limits, 'limits');
+  assertPlainApiObject(adapters, 'adapters');
+  assertPlainApiObject(moduleResults, 'moduleResults');
+
+  let state = initialState;
+  let trace = [];
+  let decisions = normalizeDecisions({});
+  let modules = cloneData(moduleResults);
+  let currentContext = cloneData(context);
+  let counters = normalizeCounters({}, currentContext);
+  let finalStep = null;
+  let seen = [];
+  const normalizedLimits = normalizeLimits(limits);
+
+  while (true) {
+    const step = planOrchestrationStep({
+      state,
+      task,
+      context: currentContext,
+      limits,
+      counters,
+      decisions,
+      moduleResults: modules,
+      adapters,
+      previousTrace: trace,
+      seenCycleSignatures: seen
+    });
+    finalStep = step;
+    trace = [...trace, cloneData(step.traceEntry)];
+    decisions = cloneData(step.decisions);
+    modules = cloneData(step.moduleResults);
+    currentContext = cloneData(step.context);
+    counters = cloneData(step.counters);
+    if (step.event !== 'CYCLE_DETECTED') {
+      seen = [...seen, step.cycleSignature];
+    }
+    state = step.nextState;
+    if (step.terminal) {
+      break;
+    }
+    if (counters.transitions > normalizedLimits.limits.maxTransitions + 1) {
+      break;
+    }
+  }
+
+  return buildLoopResult({
+    task,
+    context: currentContext,
+    initialState,
+    loopId,
+    trace,
+    finalStep,
+    decisions,
+    moduleResults: modules,
+    counters,
+    limits: normalizedLimits.limits
+  });
+}
+
+function deriveTransition(input) {
+  const base = {
+    event: 'INVALID_TRANSITION',
+    reason: 'no transition derived',
+    guards: [],
+    decisions: cloneData(input.decisions),
+    moduleResults: cloneData(input.moduleResults),
+    context: cloneData(input.context),
+    counters: cloneData(input.counters),
+    warnings: [],
+    errors: [],
+    inconsistencies: [],
+    conflicts: extractConflicts(input.moduleResults, input.context),
+    provenance: []
+  };
+
+  const fail = (event, code, message, field, severity = 'error') => ({
+    ...base,
+    event,
+    reason: message,
+    errors: [loopError(code, message, input.state, event, field, severity)]
+  });
+
+  try {
+    switch (input.state) {
+      case 'loop.initialized':
+        if (!isValidTask(input.task)) {
+          return fail('INPUT_INVALID', 'INVALID_INPUT', 'task must be an object with id', 'task');
+        }
+        return {
+          ...base,
+          event: 'INPUT_VALID',
+          reason: 'input task shape is valid',
+          guards: ['task-shape'],
+          context: {
+            ...base.context,
+            taskId: String(input.task.id),
+            parentTaskId: getParentTaskId(input.task, input.context)
+          },
+          provenance: [provenance('input', null, 'task', false)]
+        };
+      case 'loop.input_validated':
+        return deriveObjectDecision({
+          ...input,
+          base,
+          eventReady: 'CLASSIFICATION_READY',
+          eventInvalid: 'CLASSIFICATION_INVALID',
+          decisionKey: 'classification',
+          moduleKey: 'classification',
+          contextKey: 'classification',
+          adapterName: 'classifyTask',
+          reasonReady: 'classification is available',
+          validate: isPlainObject
+        });
+      case 'loop.classified':
+        return deriveObjectDecision({
+          ...input,
+          base,
+          eventReady: 'MANAGER_READY',
+          eventInvalid: 'MANAGER_INVALID',
+          decisionKey: 'manager',
+          moduleKey: 'manager',
+          contextKey: 'manager',
+          adapterName: 'selectManager',
+          reasonReady: 'manager plan is available',
+          validate: value => value === null || isPlainObject(value)
+        });
+      case 'loop.manager_selected':
+        return deriveObjectDecision({
+          ...input,
+          base,
+          eventReady: 'ENGINE_CANDIDATE_READY',
+          eventInvalid: 'ENGINE_CANDIDATE_INVALID',
+          decisionKey: 'engineCandidate',
+          moduleKey: 'engineCandidate',
+          contextKey: 'engineCandidate',
+          adapterName: 'selectEngineCandidate',
+          reasonReady: 'engine candidate is available',
+          validate: value => value === null || isPlainObject(value)
+        });
+      case 'loop.engine_candidate_selected':
+        return deriveObjectDecision({
+          ...input,
+          base,
+          eventReady: 'PREFLIGHT_READY',
+          eventInvalid: 'PREFLIGHT_INVALID',
+          decisionKey: 'preflight',
+          moduleKey: 'preflight',
+          contextKey: 'preflight',
+          adapterName: 'evaluatePreflight',
+          reasonReady: 'preflight result is available',
+          validate: isPlainObject
+        });
+      case 'loop.preflight_evaluated':
+        return deriveObjectDecision({
+          ...input,
+          base,
+          eventReady: 'BUDGET_READY',
+          eventInvalid: 'BUDGET_INVALID',
+          decisionKey: 'budget',
+          moduleKey: 'budget',
+          contextKey: 'budget',
+          adapterName: 'evaluateBudget',
+          reasonReady: 'budget result is available',
+          validate: isPlainObject
+        });
+      case 'loop.budget_evaluated':
+        return deriveObjectDecision({
+          ...input,
+          base,
+          eventReady: 'POLICY_READY',
+          eventInvalid: 'POLICY_INVALID',
+          decisionKey: 'policy',
+          moduleKey: 'policy',
+          contextKey: 'policy',
+          adapterName: 'evaluatePolicy',
+          reasonReady: 'policy result is available',
+          validate: isPlainObject
+        });
+      case 'loop.policy_evaluated':
+        return deriveRuntimeGate(input, base);
+      case 'loop.runtime_gate_evaluated':
+        return deriveGateBranch(input, base);
+      case 'loop.execution_planned':
+        return deriveExecutionPlan(input, base);
+      case 'loop.delegation_planned':
+        return deriveSubtasks(input, base);
+      case 'loop.subtasks_planned':
+        return deriveConflicts(input, base);
+      case 'loop.conflicts_evaluated':
+        return deriveSimulation(input, base);
+      case 'loop.execution_simulated':
+        return deriveConsolidation(input, base);
+      case 'loop.results_consolidated':
+        return deriveVerification(input, base);
+      case 'loop.result_verified':
+        return {
+          ...base,
+          event: 'PLAN_READY',
+          reason: 'planning pipeline reached terminal completion',
+          guards: ['planning-complete']
+        };
+      default:
+        return fail('INVALID_TRANSITION', 'UNKNOWN_STATE', `unknown loop state: ${input.state}`, 'state');
+    }
+  } catch (error) {
+    return fail('INVALID_TRANSITION', 'DERIVE_TRANSITION_FAILED', errorMessage(error), null);
+  }
+}
+
+function deriveObjectDecision(config) {
+  const source = resolveProvidedOrAdapter(config);
+  if (source.error) {
+    return {
+      ...config.base,
+      event: config.eventInvalid,
+      reason: source.error.message,
+      errors: [source.error]
+    };
+  }
+  if (!config.validate(source.value)) {
+    return {
+      ...config.base,
+      event: config.eventInvalid,
+      reason: `${config.decisionKey} result is malformed`,
+      errors: [loopError('MALFORMED_RESULT', `${config.decisionKey} result is malformed`, config.state, config.eventInvalid, config.decisionKey, 'error')]
+    };
+  }
+  return {
+    ...config.base,
+    event: config.eventReady,
+    reason: config.reasonReady,
+    guards: [`${config.decisionKey}-valid`],
+    decisions: {
+      ...config.base.decisions,
+      [config.decisionKey]: cloneData(source.value)
+    },
+    moduleResults: {
+      ...config.base.moduleResults,
+      [config.moduleKey]: cloneData(source.value)
+    },
+    provenance: [provenance(source.provenance, source.adapterName, config.decisionKey, false)]
+  };
+}
+
+function deriveRuntimeGate(input, base) {
+  const source = resolveProvidedOrAdapter({
+    ...input,
+    base,
+    decisionKey: 'runtimeGate',
+    moduleKey: 'runtimeGate',
+    contextKey: 'runtimeGateResult',
+    adapterName: 'evaluateRuntimeGate'
+  });
+  if (source.error) {
+    return {
+      ...base,
+      event: 'GATE_UNKNOWN',
+      reason: source.error.message,
+      errors: [source.error]
+    };
+  }
+  if (!isPlainObject(source.value) || !GATE_DECISIONS.has(source.value.decision)) {
+    return {
+      ...base,
+      event: 'GATE_UNKNOWN',
+      reason: 'runtime gate decision is unknown or malformed',
+      errors: [loopError('UNKNOWN_RUNTIME_GATE_DECISION', 'runtime gate decision is unknown or malformed', input.state, 'GATE_UNKNOWN', 'runtimeGate.decision', 'error')]
+    };
+  }
+  return {
+    ...base,
+    event: 'RUNTIME_GATE_READY',
+    reason: 'runtime gate decision is available',
+    guards: ['runtime-gate-valid'],
+    decisions: {
+      ...base.decisions,
+      runtimeGate: cloneData(source.value)
+    },
+    moduleResults: {
+      ...base.moduleResults,
+      runtimeGate: cloneData(source.value)
+    },
+    provenance: [provenance(source.provenance, source.adapterName, 'runtimeGate', false)]
+  };
+}
+
+function deriveGateBranch(input, base) {
+  const gate = input.decisions.runtimeGate || input.moduleResults.runtimeGate || input.context.runtimeGateResult;
+  const decision = isPlainObject(gate) ? gate.decision : null;
+  if (decision === 'EXECUTE') {
+    return {
+      ...base,
+      event: 'GATE_EXECUTE',
+      reason: 'runtime gate permits simulated execution planning',
+      guards: ['gate-execute'],
+      moduleResults: {
+        ...base.moduleResults,
+        executionPlan: directExecutionPlan(input.task)
+      }
+    };
+  }
+  if (decision === 'DELEGATE') {
+    return {
+      ...base,
+      event: 'GATE_DELEGATE',
+      reason: 'runtime gate requires delegation planning only',
+      guards: ['gate-delegate'],
+      moduleResults: {
+        ...base.moduleResults,
+        executionPlan: {
+          mode: 'delegate',
+          executionMode: 'serial',
+          order: [String(input.task.id)]
+        }
+      }
+    };
+  }
+  if (decision === 'BLOCK') {
+    return { ...base, event: 'GATE_BLOCK', reason: gateReason(gate, 'runtime gate blocked planning'), guards: ['gate-block'] };
+  }
+  if (decision === 'NEEDS_HUMAN') {
+    return { ...base, event: 'GATE_NEEDS_HUMAN', reason: gateReason(gate, 'runtime gate needs human decision'), guards: ['gate-needs-human'] };
+  }
+  if (decision === 'FALLBACK') {
+    return {
+      ...base,
+      event: 'GATE_FALLBACK',
+      reason: gateReason(gate, 'runtime gate requires fallback integration'),
+      guards: ['gate-fallback'],
+      moduleResults: {
+        ...base.moduleResults,
+        fallbackRequired: {
+          required: true,
+          applied: false,
+          decision: 'FALLBACK'
+        }
+      }
+    };
+  }
+  return {
+    ...base,
+    event: 'GATE_UNKNOWN',
+    reason: 'runtime gate decision is unknown',
+    errors: [loopError('UNKNOWN_RUNTIME_GATE_DECISION', 'runtime gate decision is unknown', input.state, 'GATE_UNKNOWN', 'runtimeGate.decision', 'error')]
+  };
+}
+
+function deriveExecutionPlan(input, base) {
+  const gate = input.decisions.runtimeGate || {};
+  const manager = input.decisions.manager || {};
+  if (gate.decision === 'DELEGATE' || manager.decision === 'decompose') {
+    const source = resolveProvidedOrAdapter({
+      ...input,
+      base,
+      decisionKey: 'plannedDelegation',
+      moduleKey: 'delegation',
+      contextKey: 'delegation',
+      adapterName: 'planDelegation'
+    });
+    if (source.error || !isPlainObject(source.value)) {
+      return {
+        ...base,
+        event: 'DELEGATION_INVALID',
+        reason: source.error ? source.error.message : 'delegation result is malformed',
+        errors: [source.error || loopError('MALFORMED_DELEGATION', 'delegation result is malformed', input.state, 'DELEGATION_INVALID', 'delegation', 'error')]
+      };
+    }
+    const validation = validateDelegation(source.value, input.limits);
+    if (validation.errors.length > 0) {
+      return {
+        ...base,
+        event: validation.blocking ? 'DELEGATION_INVALID' : 'DELEGATION_INVALID',
+        reason: validation.errors[0].message,
+        errors: validation.errors,
+        conflicts: validation.conflicts
+      };
+    }
+    return {
+      ...base,
+      event: 'DELEGATION_READY',
+      reason: 'delegation plan is available',
+      guards: ['delegation-valid', 'serial-only'],
+      moduleResults: {
+        ...base.moduleResults,
+        delegation: cloneData(source.value),
+        plannedSubtasks: cloneData(source.value.subtasks || []),
+        assignments: cloneData(source.value.assignments || [])
+      },
+      counters: {
+        ...base.counters,
+        subtasks: Array.isArray(source.value.subtasks) ? source.value.subtasks.length : 0,
+        agents: Array.isArray(source.value.assignments) ? source.value.assignments.length : 0
+      },
+      provenance: [provenance(source.provenance, source.adapterName, 'delegation', true)]
+    };
+  }
+  return {
+    ...base,
+    event: 'PLAN_READY',
+    reason: 'direct serial execution plan is ready',
+    guards: ['serial-plan'],
+    moduleResults: {
+      ...base.moduleResults,
+      executionPlan: directExecutionPlan(input.task)
+    }
+  };
+}
+
+function deriveSubtasks(input, base) {
+  const source = resolveProvidedOrAdapter({
+    ...input,
+    base,
+    decisionKey: 'plannedSubtasks',
+    moduleKey: 'plannedSubtasks',
+    contextKey: 'plannedSubtasks',
+    adapterName: 'planSubtasks',
+    fallbackValue: input.moduleResults.plannedSubtasks
+  });
+  const subtasks = Array.isArray(source.value)
+    ? source.value
+    : isPlainObject(source.value) && Array.isArray(source.value.subtasks)
+      ? source.value.subtasks
+      : source.value;
+  if (source.error || !Array.isArray(subtasks)) {
+    return {
+      ...base,
+      event: 'SUBTASKS_INVALID',
+      reason: source.error ? source.error.message : 'subtasks result is malformed',
+      errors: [source.error || loopError('MALFORMED_SUBTASKS', 'subtasks result is malformed', input.state, 'SUBTASKS_INVALID', 'subtasks', 'error')]
+    };
+  }
+  if (input.moduleResults.assignments !== undefined && !Array.isArray(input.moduleResults.assignments)) {
+    return {
+      ...base,
+      event: 'SUBTASKS_INVALID',
+      reason: 'assignments must be an array',
+      errors: [loopError('MALFORMED_ASSIGNMENTS', 'assignments must be an array', input.state, 'SUBTASKS_INVALID', 'assignments', 'error')]
+    };
+  }
+  const validation = validateSubtasks(subtasks, input.moduleResults.assignments || [], input.limits, input.context);
+  if (validation.errors.length > 0) {
+    return {
+      ...base,
+      event: validation.blocking ? 'SUBTASKS_INVALID' : 'SUBTASKS_INVALID',
+      reason: validation.errors[0].message,
+      errors: validation.errors,
+      conflicts: validation.conflicts
+    };
+  }
+  return {
+    ...base,
+    event: 'SUBTASKS_READY',
+    reason: 'subtask plan is valid and serial',
+    guards: ['subtasks-valid', 'subtask-limits'],
+    moduleResults: {
+      ...base.moduleResults,
+      plannedSubtasks: cloneData(subtasks),
+      serialOrder: subtasks.map(item => String(item.id))
+    },
+    counters: {
+      ...base.counters,
+      subtasks: subtasks.length
+    },
+    provenance: [provenance(source.provenance, source.adapterName, 'subtasks', true)]
+  };
+}
+
+function deriveConflicts(input, base) {
+  const source = resolveProvidedOrAdapter({
+    ...input,
+    base,
+    decisionKey: 'conflicts',
+    moduleKey: 'conflicts',
+    contextKey: 'conflicts',
+    adapterName: 'detectConflicts',
+    fallbackValue: []
+  });
+  if (source.error || !Array.isArray(source.value)) {
+    return {
+      ...base,
+      event: 'CONFLICTS_INVALID',
+      reason: source.error ? source.error.message : 'conflict result is malformed',
+      errors: [source.error || loopError('MALFORMED_CONFLICT', 'conflict result is malformed', input.state, 'CONFLICTS_INVALID', 'conflicts', 'error')]
+    };
+  }
+  const normalized = normalizeConflicts(source.value, input.moduleResults.plannedSubtasks || []);
+  if (normalized.errors.length > 0) {
+    return {
+      ...base,
+      event: 'CONFLICTS_INVALID',
+      reason: normalized.errors[0].message,
+      errors: normalized.errors,
+      conflicts: normalized.conflicts
+    };
+  }
+  if (normalized.blocking) {
+    return {
+      ...base,
+      event: 'CONFLICTS_BLOCKING',
+      reason: 'blocking file conflict prevents safe planning',
+      guards: ['conflicts-blocking'],
+      errors: [loopError('BLOCKING_CONFLICT', 'blocking file conflict prevents safe planning', input.state, 'CONFLICTS_BLOCKING', 'conflicts', 'blocking')],
+      conflicts: normalized.conflicts,
+      moduleResults: {
+        ...base.moduleResults,
+        conflicts: cloneData(normalized.conflicts)
+      }
+    };
+  }
+  return {
+    ...base,
+    event: normalized.conflicts.length > 0 ? 'CONFLICTS_FOUND' : 'CONFLICTS_CLEAR',
+    reason: normalized.conflicts.length > 0 ? 'serializable conflicts were recorded' : 'no file conflicts were found',
+    guards: ['conflicts-evaluated'],
+    conflicts: normalized.conflicts,
+    moduleResults: {
+      ...base.moduleResults,
+      conflicts: cloneData(normalized.conflicts)
+    },
+    provenance: [provenance(source.provenance, source.adapterName, 'conflicts', true)]
+  };
+}
+
+function deriveSimulation(input, base) {
+  const order = serialOrderFor(input.task, input.moduleResults);
+  const simulation = {
+    simulated: true,
+    executed: false,
+    executionMode: 'serial',
+    order,
+    engineCandidate: cloneData(input.decisions.engineCandidate),
+    workerCalled: false,
+    engineCalled: false,
+    commandsCalled: false,
+    hostValidationCalled: false,
+    fallbackApplied: false,
+    evidenceCreated: false,
+    workspaceDiffCreated: false
+  };
+  return {
+    ...base,
+    event: 'SIMULATION_READY',
+    reason: 'dry-run execution summary was simulated without effects',
+    guards: ['dry-run', 'no-effects'],
+    moduleResults: {
+      ...base.moduleResults,
+      simulation
+    },
+    provenance: [provenance('loop', null, 'simulation', true)]
+  };
+}
+
+function deriveConsolidation(input, base) {
+  const supplied = firstDefined(input.context.consolidatedResult, input.moduleResults.consolidation);
+  if (supplied !== undefined) {
+    if (!isValidConsolidation(supplied)) {
+      return {
+        ...base,
+        event: 'CONSOLIDATION_INVALID',
+        reason: 'consolidated result is malformed',
+        errors: [loopError('MALFORMED_CONSOLIDATION', 'consolidated result is malformed', input.state, 'CONSOLIDATION_INVALID', 'consolidation', 'error')]
+      };
+    }
+    return {
+      ...base,
+      event: 'CONSOLIDATION_READY',
+      reason: 'supplied consolidated result was preserved',
+      guards: ['consolidation-supplied'],
+      moduleResults: {
+        ...base.moduleResults,
+        consolidation: cloneData(supplied)
+      },
+      provenance: [provenance(Object.prototype.hasOwnProperty.call(input.context, 'consolidatedResult') ? 'input' : 'module-result', null, 'consolidation', false)]
+    };
+  }
+  const subtaskResults = firstDefined(input.context.simulatedSubtaskResults, input.moduleResults.simulatedSubtaskResults);
+  if (subtaskResults !== undefined) {
+    const source = callAdapter('consolidate', input.adapters.consolidate, {
+      task: cloneData(input.task),
+      subtasks: cloneData(input.moduleResults.plannedSubtasks || []),
+      subtaskResults: cloneData(subtaskResults),
+      simulated: true,
+      context: cloneData(input.context)
+    }, input.state, 'CONSOLIDATION_INVALID');
+    if (source.error || !isValidConsolidation(source.value)) {
+      return {
+        ...base,
+        event: 'CONSOLIDATION_INVALID',
+        reason: source.error ? source.error.message : 'consolidated result is malformed',
+        errors: [source.error || loopError('MALFORMED_CONSOLIDATION', 'consolidated result is malformed', input.state, 'CONSOLIDATION_INVALID', 'consolidation', 'error')]
+      };
+    }
+    return {
+      ...base,
+      event: 'CONSOLIDATION_READY',
+      reason: 'simulated subtask results were consolidated by adapter',
+      guards: ['simulated-results-supplied'],
+      moduleResults: {
+        ...base.moduleResults,
+        consolidation: cloneData(source.value)
+      },
+      provenance: [provenance('adapter', 'consolidate', 'consolidation', true)]
+    };
+  }
+  return {
+    ...base,
+    event: 'CONSOLIDATION_SKIPPED',
+    reason: 'no subtask results were supplied',
+    guards: ['no-consolidation-input'],
+    moduleResults: {
+      ...base.moduleResults,
+      consolidation: {
+        mode: 'not_run',
+        reason: 'no subtask results were supplied'
+      }
+    },
+    provenance: [provenance('loop', null, 'consolidation', true)]
+  };
+}
+
+function deriveVerification(input, base) {
+  const supplied = firstDefined(input.context.verificationResult, input.moduleResults.verification);
+  if (supplied !== undefined) {
+    if (!isValidVerification(supplied)) {
+      return {
+        ...base,
+        event: 'VERIFICATION_INVALID',
+        reason: 'verification result is malformed',
+        errors: [loopError('MALFORMED_VERIFICATION', 'verification result is malformed', input.state, 'VERIFICATION_INVALID', 'verification', 'error')]
+      };
+    }
+    return {
+      ...base,
+      event: 'VERIFICATION_READY',
+      reason: 'supplied verification result was preserved',
+      guards: ['verification-supplied'],
+      moduleResults: {
+        ...base.moduleResults,
+        verification: cloneData(supplied)
+      },
+      provenance: [provenance(Object.prototype.hasOwnProperty.call(input.context, 'verificationResult') ? 'input' : 'module-result', null, 'verification', false)]
+    };
+  }
+  const consolidation = input.moduleResults.consolidation;
+  if (isValidConsolidation(consolidation) && typeof input.adapters.verify === 'function') {
+    const source = callAdapter('verify', input.adapters.verify, {
+      task: cloneData(input.task),
+      consolidatedResult: cloneData(consolidation),
+      acceptanceCriteria: cloneData(input.context.acceptanceCriteria || [])
+    }, input.state, 'VERIFICATION_INVALID');
+    if (source.error || !isValidVerification(source.value)) {
+      return {
+        ...base,
+        event: 'VERIFICATION_INVALID',
+        reason: source.error ? source.error.message : 'verification result is malformed',
+        errors: [source.error || loopError('MALFORMED_VERIFICATION', 'verification result is malformed', input.state, 'VERIFICATION_INVALID', 'verification', 'error')]
+      };
+    }
+    return {
+      ...base,
+      event: 'VERIFICATION_READY',
+      reason: 'consolidated result was verified by adapter',
+      guards: ['consolidated-result-supplied'],
+      moduleResults: {
+        ...base.moduleResults,
+        verification: cloneData(source.value)
+      },
+      provenance: [provenance('adapter', 'verify', 'verification', true)]
+    };
+  }
+  return {
+    ...base,
+    event: 'VERIFICATION_SKIPPED',
+    reason: 'no consolidated result was supplied',
+    guards: ['no-verification-input'],
+    moduleResults: {
+      ...base.moduleResults,
+      verification: {
+        mode: 'not_run',
+        reason: 'no consolidated result was supplied'
+      }
+    },
+    provenance: [provenance('loop', null, 'verification', true)]
+  };
+}
+
+function resolveProvidedOrAdapter(config) {
+  const supplied = firstDefined(
+    config.context[config.contextKey],
+    config.moduleResults[config.moduleKey]
+  );
+  if (supplied !== undefined) {
+    return {
+      value: cloneData(supplied),
+      provenance: Object.prototype.hasOwnProperty.call(config.context, config.contextKey) ? 'input' : 'module-result',
+      adapterName: null
+    };
+  }
+  const adapter = config.adapters[config.adapterName];
+  if (typeof adapter !== 'function' && config.fallbackValue !== undefined) {
+    return {
+      value: cloneData(config.fallbackValue),
+      provenance: 'loop',
+      adapterName: null
+    };
+  }
+  const called = callAdapter(config.adapterName, adapter, {
+    task: cloneData(config.task),
+    context: cloneData(config.context),
+    decisions: cloneData(config.decisions),
+    moduleResults: cloneData(config.moduleResults),
+    limits: cloneData(config.limits),
+    counters: cloneData(config.counters)
+  }, config.state, config.eventInvalid || 'INVALID_TRANSITION');
+  if (called.error) {
+    return called;
+  }
+  return {
+    value: called.value,
+    provenance: 'adapter',
+    adapterName: config.adapterName
+  };
+}
+
+function callAdapter(name, adapter, payload, state, event) {
+  if (typeof adapter !== 'function') {
+    return {
+      error: loopError('ADAPTER_MISSING', `adapter ${name} is required for this state`, state, event, name, 'error')
+    };
+  }
+  let value;
+  try {
+    value = adapter(payload);
+  } catch (error) {
+    return {
+      error: loopError('ADAPTER_THROWN', `adapter ${name} failed: ${errorMessage(error)}`, state, event, name, 'error')
+    };
+  }
+  if (value === undefined) {
+    return {
+      error: loopError('ADAPTER_RETURNED_UNDEFINED', `adapter ${name} returned undefined`, state, event, name, 'error')
+    };
+  }
+  if (isThenable(value)) {
+    return {
+      error: loopError('ADAPTER_RETURNED_THENABLE', `adapter ${name} returned a Promise or thenable`, state, event, name, 'error')
+    };
+  }
+  return { value: cloneData(value) };
+}
+
+function validateDelegation(plan, limits) {
+  const errors = [];
+  const conflicts = [];
+  if (plan.executionMode !== 'serial') {
+    errors.push(loopError('NON_SERIAL_DELEGATION', 'delegation executionMode must be serial', 'loop.execution_planned', 'DELEGATION_INVALID', 'delegation.executionMode', 'blocking'));
+  }
+  if (!Array.isArray(plan.subtasks)) {
+    errors.push(loopError('MALFORMED_DELEGATION', 'delegation subtasks must be an array', 'loop.execution_planned', 'DELEGATION_INVALID', 'delegation.subtasks', 'error'));
+  }
+  if (!Array.isArray(plan.assignments)) {
+    errors.push(loopError('MALFORMED_DELEGATION', 'delegation assignments must be an array', 'loop.execution_planned', 'DELEGATION_INVALID', 'delegation.assignments', 'error'));
+  }
+  if (Array.isArray(plan.assignments)) {
+    const count = plan.assignments.length;
+    if (count > limits.maxAgentsPerManager) {
+      errors.push(loopError('AGENT_LIMIT_EXCEEDED', `assignments exceed maxAgentsPerManager ${limits.maxAgentsPerManager}`, 'loop.execution_planned', 'DELEGATION_INVALID', 'assignments', 'blocking'));
+    }
+  }
+  if (Array.isArray(plan.subtasks) && plan.subtasks.length > limits.maxSubtasks) {
+    errors.push(loopError('SUBTASK_LIMIT_EXCEEDED', `subtasks exceed maxSubtasks ${limits.maxSubtasks}`, 'loop.execution_planned', 'DELEGATION_INVALID', 'subtasks', 'blocking'));
+  }
+  return { errors, conflicts, blocking: errors.some(error => error.severity === 'blocking') };
+}
+
+function validateSubtasks(subtasks, assignments, limits, context) {
+  const errors = [];
+  const conflicts = [];
+  if (Number(context.orchestrationDepth || 0) > limits.maxDepth) {
+    errors.push(loopError('DEPTH_LIMIT_EXCEEDED', `orchestrationDepth exceeds maxDepth ${limits.maxDepth}`, 'loop.delegation_planned', 'SUBTASKS_INVALID', 'context.orchestrationDepth', 'blocking'));
+  }
+  if (subtasks.length > limits.maxSubtasks) {
+    errors.push(loopError('SUBTASK_LIMIT_EXCEEDED', `subtasks exceed maxSubtasks ${limits.maxSubtasks}`, 'loop.delegation_planned', 'SUBTASKS_INVALID', 'subtasks', 'blocking'));
+  }
+  const ids = subtasks.map(item => isPlainObject(item) ? item.id : null);
+  const idSet = new Set(ids.filter(value => typeof value === 'string' && value.length > 0));
+  if (idSet.size !== ids.length) {
+    errors.push(loopError('INVALID_SUBTASK_REFERENCE', 'subtask ids must be unique non-empty strings', 'loop.delegation_planned', 'SUBTASKS_INVALID', 'subtasks.id', 'error'));
+  }
+  for (const subtask of subtasks) {
+    if (!isPlainObject(subtask)) {
+      errors.push(loopError('MALFORMED_SUBTASK', 'subtask must be an object', 'loop.delegation_planned', 'SUBTASKS_INVALID', 'subtasks', 'error'));
+      continue;
+    }
+    if (subtask.parentTaskId !== undefined && subtask.parentTaskId !== context.taskId) {
+      errors.push(loopError('INVALID_SUBTASK_REFERENCE', 'subtask parentTaskId does not match parent context', 'loop.delegation_planned', 'SUBTASKS_INVALID', 'subtasks.parentTaskId', 'error'));
+    }
+    if (subtask.expectedFiles !== undefined && !Array.isArray(subtask.expectedFiles)) {
+      errors.push(loopError('MALFORMED_SUBTASK', 'expectedFiles must be an array when present', 'loop.delegation_planned', 'SUBTASKS_INVALID', 'subtasks.expectedFiles', 'error'));
+    }
+    if (Array.isArray(subtask.expectedFiles)) {
+      for (const file of subtask.expectedFiles) {
+        if (typeof file !== 'string' || file.length === 0) {
+          errors.push(loopError('MALFORMED_SUBTASK', 'expectedFiles entries must be non-empty strings', 'loop.delegation_planned', 'SUBTASKS_INVALID', 'subtasks.expectedFiles', 'error'));
+        }
+      }
+    }
+    if (Array.isArray(subtask.blockedBy)) {
+      for (const dependency of subtask.blockedBy) {
+        if (!idSet.has(dependency)) {
+          errors.push(loopError('INVALID_SUBTASK_REFERENCE', `blockedBy references missing subtask ${String(dependency)}`, 'loop.delegation_planned', 'SUBTASKS_INVALID', 'subtasks.blockedBy', 'error'));
+        }
+      }
+    } else if (subtask.blockedBy !== undefined) {
+      errors.push(loopError('MALFORMED_SUBTASK', 'blockedBy must be an array when present', 'loop.delegation_planned', 'SUBTASKS_INVALID', 'subtasks.blockedBy', 'error'));
+    }
+  }
+  if (hasDependencyCycle(subtasks)) {
+    errors.push(loopError('SUBTASK_DEPENDENCY_CYCLE', 'blockedBy references contain a cycle', 'loop.delegation_planned', 'SUBTASKS_INVALID', 'subtasks.blockedBy', 'blocking'));
+  }
+  for (const assignment of assignments) {
+    if (!isPlainObject(assignment) || typeof assignment.subtaskId !== 'string' || !idSet.has(assignment.subtaskId)) {
+      errors.push(loopError('INVALID_ASSIGNMENT_REFERENCE', 'assignment references a missing subtask', 'loop.delegation_planned', 'SUBTASKS_INVALID', 'assignments.subtaskId', 'error'));
+      continue;
+    }
+    if (!(typeof assignment.candidateEngine === 'string' || assignment.candidateEngine === null)) {
+      errors.push(loopError('INVALID_ASSIGNMENT_REFERENCE', 'assignment candidateEngine must be a string or null', 'loop.delegation_planned', 'SUBTASKS_INVALID', 'assignments.candidateEngine', 'error'));
+    }
+  }
+  return { errors, conflicts, blocking: errors.some(error => error.severity === 'blocking') };
+}
+
+function normalizeConflicts(conflicts, subtasks) {
+  const errors = [];
+  const normalized = [];
+  for (const conflict of conflicts) {
+    if (!isPlainObject(conflict) ||
+        typeof conflict.type !== 'string' ||
+        !['low', 'medium', 'high', 'critical'].includes(conflict.severity) ||
+        typeof conflict.reason !== 'string') {
+      errors.push(loopError('MALFORMED_CONFLICT', 'conflict entry is malformed', 'loop.subtasks_planned', 'CONFLICTS_INVALID', 'conflicts', 'error'));
+      continue;
+    }
+    normalized.push(cloneData(conflict));
+  }
+  for (const conflict of inferConflictRisks(subtasks)) {
+    normalized.push(conflict);
+  }
+  const blocking = normalized.some(conflict => {
+    const target = String(conflict.file || conflict.path || '').replace(/\\/g, '/').toLowerCase();
+    return conflict.severity === 'critical' ||
+      conflict.type === 'parallel-write' ||
+      isSensitivePath(target) ||
+      /^[a-z]:[\\/]/i.test(target);
+  });
+  return {
+    errors,
+    conflicts: sortConflicts(normalized),
+    blocking
+  };
+}
+
+function inferConflictRisks(subtasks) {
+  const conflicts = [];
+  const fileOwners = new Map();
+  for (const subtask of Array.isArray(subtasks) ? subtasks : []) {
+    if (!isPlainObject(subtask)) continue;
+    if (Array.isArray(subtask.expectedFiles) && subtask.expectedFiles.length === 0 && hasWriteFiles(subtask)) {
+      conflicts.push({
+        type: 'missing-expected-files',
+        severity: 'medium',
+        reason: 'write subtask does not declare expectedFiles',
+        subtaskId: subtask.id
+      });
+    }
+    const expectedFiles = Array.isArray(subtask.expectedFiles) ? subtask.expectedFiles : [];
+    for (const file of expectedFiles) {
+      const key = String(file);
+      const owners = fileOwners.get(key) || [];
+      owners.push(String(subtask.id));
+      fileOwners.set(key, owners);
+      if (isSensitivePath(key)) {
+        conflicts.push({
+          type: 'sensitive-path',
+          severity: 'critical',
+          reason: 'sensitive or outside path is not safe for planned delegation',
+          subtaskId: subtask.id,
+          file: key
+        });
+      }
+    }
+    if (subtask.parallelizable === true && hasWriteFiles(subtask)) {
+      conflicts.push({
+        type: 'parallel-write',
+        severity: 'critical',
+        reason: 'parallelizable file writes are not allowed',
+        subtaskId: subtask.id
+      });
+    }
+  }
+  for (const [file, owners] of fileOwners.entries()) {
+    if (owners.length > 1) {
+      conflicts.push({
+        type: 'file-write-conflict',
+        severity: 'high',
+        reason: 'multiple subtasks target the same file',
+        subtaskIds: owners,
+        file
+      });
+    }
+  }
+  const files = [...fileOwners.keys()].sort(compareStrings);
+  for (let index = 0; index < files.length; index += 1) {
+    for (let other = index + 1; other < files.length; other += 1) {
+      const left = normalizePathForCompare(files[index]);
+      const right = normalizePathForCompare(files[other]);
+      if (left && right && (right.startsWith(`${left}/`) || left.startsWith(`${right}/`))) {
+        conflicts.push({
+          type: 'path-overlap',
+          severity: 'critical',
+          reason: 'parent/child file paths require explicit precedence before delegation',
+          subtaskIds: uniqueSortedStrings([...(fileOwners.get(files[index]) || []), ...(fileOwners.get(files[other]) || [])]),
+          file: files[index],
+          path: files[other]
+        });
+      }
+    }
+  }
+  return conflicts;
+}
+
+function buildStepResult(input) {
+  const terminal = TERMINAL_STATES.has(input.nextState);
+  const counters = cloneData(input.counters);
+  const cycleSignature = input.forcedCycleSignature || createCycleSignature({
+    state: input.state,
+    event: input.event,
+    task: null,
+    context: input.context,
+    counters,
+    decisions: input.decisions,
+    moduleResults: input.moduleResults,
+    conflicts: input.conflicts
+  });
+  const traceEntry = {
+    schemaVersion: SCHEMA_VERSION,
+    sequence: input.previousTrace.length,
+    previousState: input.state,
+    event: input.event,
+    nextState: input.nextState,
+    terminal,
+    terminalReason: input.terminalReason,
+    reason: input.reason,
+    guards: cloneData(input.guards),
+    decisions: redactSensitive(input.decisions),
+    taskId: stringOrNull(input.context.taskId),
+    parentTaskId: stringOrNull(input.context.parentTaskId),
+    manager: managerIdFrom(input.decisions.manager),
+    engineCandidate: engineIdFrom(input.decisions.engineCandidate),
+    runtimeGateDecision: runtimeGateDecision(input.decisions.runtimeGate),
+    limits: cloneData(input.limits),
+    counters,
+    warnings: uniqueMessages(input.warnings),
+    errors: sortErrors(input.errors),
+    conflicts: redactSensitive(sortConflicts(input.conflicts)),
+    provenance: cloneData(input.provenance),
+    cycleSignature
+  };
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    previousState: input.state,
+    event: input.event,
+    nextState: input.nextState,
+    terminal,
+    terminalReason: input.terminalReason,
+    reason: input.reason,
+    guards: cloneData(input.guards),
+    decisions: cloneData(input.decisions),
+    moduleResults: cloneData(input.moduleResults),
+    context: cloneData(input.context),
+    counters,
+    cycleSignature,
+    traceEntry,
+    warnings: uniqueMessages(input.warnings),
+    errors: sortErrors(input.errors),
+    inconsistencies: sortErrors(input.inconsistencies)
+  };
+}
+
+function buildLoopResult(input) {
+  const finalState = input.finalStep ? input.finalStep.nextState : input.initialState;
+  const warnings = uniqueMessages(input.trace.flatMap(entry => entry.warnings));
+  const errors = sortErrors(input.trace.flatMap(entry => entry.errors));
+  const inconsistencies = sortErrors(input.finalStep ? input.finalStep.inconsistencies : []);
+  const consolidation = cloneData(input.moduleResults.consolidation || null);
+  const verification = cloneData(input.moduleResults.verification || null);
+  const verificationOutcome = isPlainObject(verification) && verification.mode !== 'not_run'
+    ? stringOrNull(verification.verificationOutcome || verification.outcome)
+    : null;
+  const conflicts = sortConflicts(input.moduleResults.conflicts || []);
+  const result = {
+    schemaVersion: SCHEMA_VERSION,
+    loopId: input.loopId || defaultLoopId(input.task, input.context),
+    dryRun: true,
+    executed: false,
+    taskId: isValidTask(input.task) ? String(input.task.id) : null,
+    parentTaskId: getParentTaskId(input.task, input.context),
+    initialState: input.initialState,
+    finalLoopState: finalState,
+    terminalReason: input.finalStep ? input.finalStep.terminalReason : null,
+    completedPlanning: finalState === 'loop.completed',
+    trace: cloneData(input.trace),
+    decisions: normalizeDecisions(input.decisions),
+    plannedSubtasks: cloneData(input.moduleResults.plannedSubtasks || []),
+    plannedDelegation: cloneData(input.moduleResults.delegation || null),
+    conflicts,
+    selectedManager: managerIdFrom(input.decisions.manager),
+    engineCandidate: engineIdFrom(input.decisions.engineCandidate),
+    runtimeGateDecision: runtimeGateDecision(input.decisions.runtimeGate),
+    simulation: cloneData(input.moduleResults.simulation || null),
+    consolidation,
+    verification,
+    verificationOutcome,
+    warnings,
+    errors,
+    inconsistencies,
+    limits: cloneData(input.limits),
+    limitsConsumed: cloneData(input.counters),
+    cycleInfo: cloneData(input.context.cycleInfo || null),
+    recommendedNextAction: recommendedNextAction(finalState, input.decisions.runtimeGate, consolidation, verification, conflicts),
+    summary: ''
+  };
+  result.summary = `Loop ${stateSummary(finalState)}: planning=${String(result.completedPlanning)}, executed=false, gate=${result.runtimeGateDecision || 'none'}, verification=${verificationOutcome || 'not_run'}.`;
+  return cloneData(result);
+}
+
+function isTransitionAllowed(state, event) {
+  return Object.prototype.hasOwnProperty.call(TRANSITIONS, state) &&
+    Object.prototype.hasOwnProperty.call(TRANSITIONS[state], event);
+}
+
+function normalizeLimits(limits) {
+  const resolved = {};
+  const warnings = [];
+  for (const [key, ceiling] of Object.entries(GLOBAL_LIMITS)) {
+    const value = limits[key];
+    if (value === undefined) {
+      resolved[key] = ceiling;
+    } else if (Number.isInteger(value) && value > 0) {
+      if (value > ceiling) {
+        resolved[key] = ceiling;
+        warnings.push(`${key} clamped to ${ceiling}`);
+      } else {
+        resolved[key] = value;
+      }
+    } else {
+      throw new TypeError(`limits.${key} must be a positive integer`);
+    }
+  }
+  return { limits: resolved, warnings };
+}
+
+function normalizeCounters(counters, context) {
+  const defaults = {
+    transitions: 0,
+    attempts: Number(context.attemptNumber || counters.attempts || 1),
+    depth: Number(context.orchestrationDepth || counters.depth || 0),
+    subtasks: Number(counters.subtasks || 0),
+    agents: Number(counters.agents || 0)
+  };
+  const normalized = {};
+  for (const [key, value] of Object.entries({ ...defaults, ...counters })) {
+    if (!Number.isInteger(Number(value)) || Number(value) < 0) {
+      throw new TypeError(`counters.${key} must be a non-negative integer`);
+    }
+    normalized[key] = Number(value);
+  }
+  if (normalized.attempts === 0) normalized.attempts = 1;
+  return normalized;
+}
+
+function incrementTransitions(counters) {
+  return {
+    ...cloneData(counters),
+    transitions: counters.transitions + 1
+  };
+}
+
+function normalizeDecisions(decisions) {
+  return {
+    ...cloneData(DEFAULT_DECISIONS),
+    ...cloneData(decisions)
+  };
+}
+
+function createCycleSignature(input) {
+  const stable = {
+    classification: summarizeObject(input.decisions.classification, ['taskKind', 'complexity', 'risk', 'canDelegate']),
+    manager: summarizeObject(input.decisions.manager, ['id', 'sector', 'decision']),
+    engineCandidate: engineIdFrom(input.decisions.engineCandidate),
+    preflight: summarizeObject(input.decisions.preflight, ['decision', 'reason']),
+    budget: summarizeObject(input.decisions.budget, ['allowed', 'ok', 'reason']),
+    policy: summarizeObject(input.decisions.policy, ['allowed', 'ok', 'reason']),
+    gate: runtimeGateDecision(input.decisions.runtimeGate),
+    subtasks: idsFrom(input.moduleResults.plannedSubtasks),
+    assignments: idsFrom(input.moduleResults.assignments, 'subtaskId'),
+    conflicts: sortConflicts(input.conflicts).map(conflict => ({
+      type: conflict.type,
+      file: redactCycleScalar(conflict.file || conflict.path || null),
+      ids: conflict.subtaskIds || [conflict.subtaskId].filter(Boolean)
+    })),
+    consolidationCompleteness: input.moduleResults.consolidation && input.moduleResults.consolidation.consolidationCompleteness || null,
+    verificationOutcome: input.moduleResults.verification && (input.moduleResults.verification.verificationOutcome || input.moduleResults.verification.outcome) || null
+  };
+  return [
+    'cycle',
+    input.state,
+    input.event,
+    taskIdFrom(input.task, input.context),
+    stringOrNull(input.context.parentTaskId) || 'root',
+    runtimeGateDecision(input.decisions.runtimeGate) || 'none',
+    canonicalStringify(input.counters),
+    canonicalStringify(stable)
+  ].join(':');
+}
+
+function directExecutionPlan(task) {
+  return {
+    mode: 'direct',
+    executionMode: 'serial',
+    order: [String(task.id)]
+  };
+}
+
+function serialOrderFor(task, modules) {
+  if (Array.isArray(modules.serialOrder) && modules.serialOrder.length > 0) {
+    return modules.serialOrder.map(String);
+  }
+  if (Array.isArray(modules.plannedSubtasks) && modules.plannedSubtasks.length > 0) {
+    return modules.plannedSubtasks.map(item => String(item.id));
+  }
+  return isValidTask(task) ? [String(task.id)] : [];
+}
+
+function isValidConsolidation(value) {
+  return isPlainObject(value) &&
+    value.schemaVersion === 1 &&
+    typeof value.taskId === 'string' &&
+    ['accepted', 'accepted_with_warnings', 'rejected', 'inconclusive', 'needs_human'].includes(value.status) &&
+    ['complete', 'partial', 'invalid'].includes(value.consolidationCompleteness) &&
+    arrayFieldsValid(value, ['perSubtask', 'evidence', 'missingEvidence', 'warnings', 'failures', 'codeFailures', 'infrastructureFailures', 'conflicts', 'inconsistencies', 'invalidReferences', 'remainingIssues', 'inputErrors']);
+}
+
+function isValidVerification(value) {
+  if (!isPlainObject(value)) return false;
+  if (value.mode === 'not_run') return typeof value.reason === 'string';
+  const outcome = value.verificationOutcome || value.outcome;
+  return value.schemaVersion === 1 &&
+    ['verified', 'verified_with_warnings', 'rejected', 'inconclusive', 'blocked', 'needs_human'].includes(outcome);
+}
+
+function arrayFieldsValid(value, fields) {
+  return fields.every(field => value[field] === undefined || Array.isArray(value[field]));
+}
+
+function recommendedNextAction(state, gate, consolidation, verification, conflicts) {
+  if (state === 'loop.cancelled_limit') return 'stop_limit';
+  if (state === 'loop.cancelled_cycle') return 'stop_cycle';
+  if (state === 'loop.cancelled_invalid_transition' || state === 'loop.cancelled_invalid_input' || state === 'loop.failed') return 'stop_invalid';
+  if (state === 'loop.needs_human') return 'request_human';
+  if (state === 'loop.blocked') {
+    if (runtimeGateDecision(gate) === 'FALLBACK') return 'integrate_runtime_later';
+    if (conflicts.some(conflict => conflict.severity === 'critical')) return 'review_conflicts';
+    return 'resolve_block';
+  }
+  if (state === 'loop.completed') {
+    const verificationRan = isPlainObject(verification) && verification.mode !== 'not_run' && isValidVerification(verification);
+    const verificationOutcomeValue = verificationRan ? verification.verificationOutcome || verification.outcome : null;
+    if (!isValidConsolidation(consolidation) ||
+        !verificationRan ||
+        !['verified', 'verified_with_warnings'].includes(verificationOutcomeValue)) {
+      return 'provide_simulated_results';
+    }
+    return 'execute_worker';
+  }
+  return 'stop_invalid';
+}
+
+function reasonToTerminal(nextState, derived) {
+  if (nextState === 'loop.completed') return 'completed';
+  if (nextState === 'loop.blocked') return derived.event === 'GATE_FALLBACK' ? 'fallback_required' : 'blocked';
+  if (nextState === 'loop.needs_human') return 'needs_human';
+  if (nextState === 'loop.cancelled_invalid_input') return 'invalid_input';
+  if (nextState === 'loop.failed') return 'failed';
+  return null;
+}
+
+function stateSummary(state) {
+  return state.replace(/^loop\./, '');
+}
+
+function defaultLoopId(task, context) {
+  return `loop:${isValidTask(task) ? String(task.id) : 'null'}:${stringOrNull(context.parentTaskId) || 'root'}`;
+}
+
+function taskIdFrom(task, context) {
+  return isValidTask(task) ? String(task.id) : stringOrNull(context.taskId) || 'null';
+}
+
+function getParentTaskId(task, context) {
+  return stringOrNull(context.parentTaskId) || (isPlainObject(task) ? stringOrNull(task.parentTaskId) : null);
+}
+
+function isValidTask(task) {
+  return isPlainObject(task) && task.id !== undefined && task.id !== null && String(task.id).length > 0;
+}
+
+function gateReason(gate, fallback) {
+  if (!isPlainObject(gate)) return fallback;
+  if (typeof gate.reason === 'string') return gate.reason;
+  if (Array.isArray(gate.reasons) && gate.reasons.length > 0) return gate.reasons.map(String).join('; ');
+  return fallback;
+}
+
+function runtimeGateDecision(gate) {
+  return isPlainObject(gate) && typeof gate.decision === 'string' ? gate.decision : null;
+}
+
+function managerIdFrom(manager) {
+  if (!isPlainObject(manager)) return null;
+  return stringOrNull(manager.id) || stringOrNull(manager.sector) || stringOrNull(manager.managerId);
+}
+
+function engineIdFrom(engine) {
+  if (engine === null) return null;
+  if (!isPlainObject(engine)) return null;
+  return stringOrNull(engine.id) || stringOrNull(engine.selectedEngine) || stringOrNull(engine.engine);
+}
+
+function idsFrom(values, key = 'id') {
+  return Array.isArray(values)
+    ? values.map(item => isPlainObject(item) ? stringOrNull(item[key]) : null).filter(Boolean).sort(compareStrings)
+    : [];
+}
+
+function summarizeObject(value, keys) {
+  if (!isPlainObject(value)) return null;
+  return Object.fromEntries(keys.map(key => [key, cloneData(value[key] ?? null)]));
+}
+
+function hasDependencyCycle(subtasks) {
+  const graph = new Map();
+  for (const subtask of subtasks) {
+    if (!isPlainObject(subtask) || typeof subtask.id !== 'string') continue;
+    graph.set(subtask.id, Array.isArray(subtask.blockedBy) ? subtask.blockedBy.filter(id => typeof id === 'string') : []);
+  }
+  const visiting = new Set();
+  const visited = new Set();
+  const visit = id => {
+    if (visiting.has(id)) return true;
+    if (visited.has(id)) return false;
+    visiting.add(id);
+    for (const next of graph.get(id) || []) {
+      if (visit(next)) return true;
+    }
+    visiting.delete(id);
+    visited.add(id);
+    return false;
+  };
+  return [...graph.keys()].some(visit);
+}
+
+function hasWriteFiles(subtask) {
+  if (!isPlainObject(subtask)) return false;
+  if (subtask.requires && subtask.requires.filesystemWrite === false) return false;
+  return true;
+}
+
+function isSensitivePath(value) {
+  const text = String(value).replace(/\\/g, '/').toLowerCase();
+  return text === '.env' ||
+    text.endsWith('/.env') ||
+    text.includes('/.env/') ||
+    text.includes('secret') ||
+    text.includes('token') ||
+    text.includes('credential') ||
+    text.includes('password') ||
+    text.includes('authorization') ||
+    text.includes('cookie') ||
+    text.includes('apikey') ||
+    text.includes('api-key') ||
+    text.startsWith('../') ||
+    text.includes('/../') ||
+    text.startsWith('/') ||
+    /^[a-z]:\//i.test(text);
+}
+
+function normalizePathForCompare(value) {
+  return String(value || '').replace(/\\/g, '/').replace(/\/+$/g, '').toLowerCase();
+}
+
+function extractConflicts(moduleResults, context) {
+  const conflicts = firstDefined(moduleResults && moduleResults.conflicts, context && context.conflicts);
+  return Array.isArray(conflicts) ? sortConflicts(conflicts) : [];
+}
+
+function sortConflicts(conflicts) {
+  return (Array.isArray(conflicts) ? conflicts : [])
+    .map(item => cloneData(item))
+    .sort((a, b) => compareStrings(severityRank(a.severity), severityRank(b.severity)) ||
+      compareStrings(a.type || '', b.type || '') ||
+      compareStrings(a.file || a.path || '', b.file || b.path || '') ||
+      compareStrings(canonicalStringify(a.subtaskIds || a.subtaskId || ''), canonicalStringify(b.subtaskIds || b.subtaskId || '')));
+}
+
+function severityRank(severity) {
+  return { critical: '0', high: '1', medium: '2', low: '3' }[severity] || '9';
+}
+
+function loopError(code, message, state, event, field, severity, provenanceValue = null) {
+  return {
+    code,
+    message,
+    state: state || null,
+    event: event || null,
+    field: field || null,
+    severity,
+    provenance: provenanceValue
+  };
+}
+
+function sortErrors(errors) {
+  return (Array.isArray(errors) ? errors : []).map(item => cloneData(item)).sort((a, b) =>
+    compareStrings(a.severity || '', b.severity || '') ||
+    compareStrings(a.code || '', b.code || '') ||
+    compareStrings(a.message || '', b.message || '')
+  );
+}
+
+function provenance(source, adapter, field, simulated) {
+  return {
+    source,
+    adapter,
+    field,
+    simulated
+  };
+}
+
+function firstDefined(...values) {
+  for (const value of values) {
+    if (value !== undefined) return value;
+  }
+  return undefined;
+}
+
+function uniqueMessages(values) {
+  return [...new Set((Array.isArray(values) ? values : []).filter(value => typeof value === 'string'))].sort(compareStrings);
+}
+
+function uniqueSortedStrings(values) {
+  return [...new Set((Array.isArray(values) ? values : []).map(value => String(value)).filter(Boolean))].sort(compareStrings);
+}
+
+function assertPlainApiObject(value, name) {
+  if (!isPlainObject(value)) {
+    throw new TypeError(`${name} must be an object`);
+  }
+}
+
+function isPlainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isThenable(value) {
+  return value !== null && (typeof value === 'object' || typeof value === 'function') && typeof value.then === 'function';
+}
+
+function stringOrNull(value) {
+  return typeof value === 'string' && value.length > 0 ? value : null;
+}
+
+function errorMessage(error) {
+  return error && typeof error.message === 'string' ? error.message : String(error);
+}
+
+function redactSensitive(value, seen = new WeakMap(), parentKey = '') {
+  if (Array.isArray(value)) {
+    if (seen.has(value)) return '[Circular]';
+    seen.set(value, true);
+    return value.map(item => redactSensitive(item, seen, parentKey));
+  }
+  if (isPlainObject(value)) {
+    if (seen.has(value)) return '[Circular]';
+    seen.set(value, true);
+    return Object.fromEntries(Object.keys(value).sort(compareStrings).map(key => {
+      const sensitive = SENSITIVE_KEYS.some(fragment => key.toLowerCase().includes(fragment));
+      return [key, sensitive ? '[REDACTED]' : redactSensitive(value[key], seen, key)];
+    }));
+  }
+  if (typeof value === 'string' && isSensitiveTraceString(value)) {
+    return '[REDACTED]';
+  }
+  return parentKey && SENSITIVE_KEYS.some(fragment => parentKey.toLowerCase().includes(fragment)) ? '[REDACTED]' : value;
+}
+
+function isSensitiveTraceString(value) {
+  const text = value.replace(/\\/g, '/').toLowerCase();
+  return text === '.env' ||
+    text.endsWith('/.env') ||
+    text.includes('/.env/') ||
+    text.includes('secret') ||
+    text.includes('token') ||
+    text.startsWith('../') ||
+    text.includes('/../') ||
+    text.startsWith('/') ||
+    /^[a-z]:\//i.test(text);
+}
+
+function redactCycleScalar(value) {
+  if (typeof value === 'string' && isSensitiveTraceString(value)) {
+    return '[REDACTED]';
+  }
+  return value;
+}
+
+function cloneData(value, seen = new WeakMap()) {
+  if (Array.isArray(value)) {
+    if (seen.has(value)) return '[Circular]';
+    seen.set(value, true);
+    return value.map(item => cloneData(item, seen));
+  }
+  if (isPlainObject(value)) {
+    if (seen.has(value)) return '[Circular]';
+    seen.set(value, true);
+    return Object.fromEntries(Object.keys(value).sort(compareStrings).map(key => [key, cloneData(value[key], seen)]));
+  }
+  if (typeof value === 'bigint') {
+    return `${value.toString()}n`;
+  }
+  if (typeof value === 'function' || typeof value === 'symbol') {
+    return String(value);
+  }
+  return value;
+}
+
+function canonicalStringify(value, seen = new WeakMap()) {
+  if (Array.isArray(value)) {
+    if (seen.has(value)) return '"[Circular]"';
+    seen.set(value, true);
+    return `[${value.map(item => canonicalStringify(item, seen)).join(',')}]`;
+  }
+  if (isPlainObject(value)) {
+    if (seen.has(value)) return '"[Circular]"';
+    seen.set(value, true);
+    return `{${Object.keys(value).sort(compareStrings).map(key => `${JSON.stringify(key)}:${canonicalStringify(value[key], seen)}`).join(',')}}`;
+  }
+  if (typeof value === 'bigint') {
+    return JSON.stringify(`${value.toString()}n`);
+  }
+  if (typeof value === 'function' || typeof value === 'symbol') {
+    return JSON.stringify(String(value));
+  }
+  return JSON.stringify(value);
+}
+
+function compareStrings(a, b) {
+  const left = String(a);
+  const right = String(b);
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}