agentic-orchestrator 0.1.6 → 0.1.8

package/apps/control-plane/src/core/kernel.ts

@@ -1,24 +1,47 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { ensureDir, pathExists, readJson, atomicWriteJson, atomicWriteFile, withFileLock, nowIso, stableHash } from './fs.js';
+import {
+  ensureDir,
+  pathExists,
+  readJson,
+  atomicWriteJson,
+  atomicWriteFile,
+  withFileLock,
+  nowIso,
+  stableHash,
+} from './fs.js';
 import { SchemaRegistry, loadAndValidateYaml } from './schemas.js';
 import { normalizeRepoPath } from './path-rules.js';
 import { parseFrontMatter, buildFrontMatter } from './frontmatter.js';
 import { runGit, runCommand } from './git.js';
 import { ERROR_CODES } from './error-codes.js';
 import { ok, fail, withSuggestedActions, type ToolResponse } from './response.js';
-import { ALLOWED_ACTORS, DEFAULT_CLUSTER, DEFAULT_ROLE_STATUS, GATE_RESULT, STATUS, TOOLS } from './constants.js';
+import {
+  ALLOWED_ACTORS,
+  DEFAULT_CLUSTER,
+  DEFAULT_ROLE_STATUS,
+  GATE_RESULT,
+  STATUS,
+  TOOLS,
+} from './constants.js';
 import { AopPathLayout, ensureAopRuntimeLayout } from './path-layout.js';
 import {
   applyWorktreeSymlinks,
   formatWorkspaceHookWarning,
   runWorktreePostCreate,
-  type WorkspaceHookWarning
+  type WorkspaceHookWarning,
 } from './workspace-hooks.js';
 import type { RuntimeSessionsSnapshot } from './runtime-sessions.js';
 import { ToolRegistryLoader } from '../mcp/tool-registry-loader.js';
-import { ToolHandlerRegistry, ToolRouter, type ToolHandlerContext } from '../application/tools/tool-router.js';
-import { RunLeaseService, type AcquireRunLeaseInput } from '../application/services/run-lease-service.js';
+import {
+  ToolHandlerRegistry,
+  ToolRouter,
+  type ToolHandlerContext,
+} from '../application/tools/tool-router.js';
+import {
+  RunLeaseService,
+  type AcquireRunLeaseInput,
+} from '../application/services/run-lease-service.js';
 import { LockService } from '../application/services/lock-service.js';
 import { ReportingService } from '../application/services/reporting-service.js';
 import { FeatureStateService } from '../application/services/feature-state-service.js';
@@ -29,15 +52,21 @@ import { GateService } from '../application/services/gate-service.js';
 import { QaIndexService } from '../application/services/qa-index-service.js';
 import { MergeService } from '../application/services/merge-service.js';
 import { CollisionQueueService } from '../application/services/collision-queue-service.js';
-import { FeatureDeletionService, type FeatureDeleteResult } from '../application/services/feature-deletion-service.js';
+import {
+  FeatureDeletionService,
+  type FeatureDeleteResult,
+} from '../application/services/feature-deletion-service.js';
 import { CostTrackingService } from '../application/services/cost-tracking-service.js';
-import { PerformanceAnalyticsService, type FeatureOutcome } from '../application/services/performance-analytics-service.js';
+import {
+  PerformanceAnalyticsService,
+  type FeatureOutcome,
+} from '../application/services/performance-analytics-service.js';
 import { loadComposedPolicy } from '../application/services/policy-loader-service.js';
 import {
   ACTIVITY_DETECTOR_SLOT,
   NOTIFICATION_CHANNEL_SLOT,
   SCM_PROVIDER_SLOT,
-  globalAdapterRegistry
+  globalAdapterRegistry,
 } from '../application/adapters/adapter-registry.js';
 import type { WorkerProvider } from '../providers/providers.js';
 
@@ -137,7 +166,11 @@ export class AopKernel {
   private provider: WorkerProvider | null = null;
   private readonly configOverrides: KernelConfigOverrides;
 
-  constructor(repoRoot: string, instanceId = 'default', configOverrides: KernelConfigOverrides = {}) {
+  constructor(
+    repoRoot: string,
+    instanceId = 'default',
+    configOverrides: KernelConfigOverrides = {},
+  ) {
     this.repoRoot = repoRoot;
     this.instanceId = instanceId;
     this.configOverrides = configOverrides;
@@ -169,9 +202,9 @@ export class AopKernel {
       Promise.resolve(
         fail(ERROR_CODES.INVALID_ARGUMENT, `Unknown tool ${toolName}`, {
           retryable: false,
-          requires_human: true
-        })
-      )
+          requires_human: true,
+        }),
+      ),
     );
   }
 
@@ -244,7 +277,7 @@ export class AopKernel {
       last_heartbeat_at: at,
       lease_expires_at: at,
       orchestrator_epoch: 0,
-      feature_sessions: {}
+      feature_sessions: {},
     };
   }
 
@@ -267,7 +300,7 @@ export class AopKernel {
           typeof typed.planner_session_id === 'string' ? typed.planner_session_id : 'unassigned',
         builder_session_id:
           typeof typed.builder_session_id === 'string' ? typed.builder_session_id : 'unassigned',
-        qa_session_id: typeof typed.qa_session_id === 'string' ? typed.qa_session_id : 'unassigned'
+        qa_session_id: typeof typed.qa_session_id === 'string' ? typed.qa_session_id : 'unassigned',
       };
     }
 
@@ -282,7 +315,10 @@ export class AopKernel {
         typeof source.orchestrator_session_id === 'string' && source.orchestrator_session_id
           ? source.orchestrator_session_id
           : fallback.orchestrator_session_id,
-      provider: typeof source.provider === 'string' && source.provider ? source.provider : fallback.provider,
+      provider:
+        typeof source.provider === 'string' && source.provider
+          ? source.provider
+          : fallback.provider,
       model: typeof source.model === 'string' && source.model ? source.model : fallback.model,
       provider_config_ref_hash:
         typeof source.provider_config_ref_hash === 'string' && source.provider_config_ref_hash
@@ -292,8 +328,14 @@ export class AopKernel {
         typeof source.owner_instance_id === 'string' && source.owner_instance_id
           ? source.owner_instance_id
           : fallback.owner_instance_id,
-      lease_id: typeof source.lease_id === 'string' && source.lease_id ? source.lease_id : fallback.lease_id,
-      started_at: typeof source.started_at === 'string' && source.started_at ? source.started_at : fallback.started_at,
+      lease_id:
+        typeof source.lease_id === 'string' && source.lease_id
+          ? source.lease_id
+          : fallback.lease_id,
+      started_at:
+        typeof source.started_at === 'string' && source.started_at
+          ? source.started_at
+          : fallback.started_at,
       last_heartbeat_at:
         typeof source.last_heartbeat_at === 'string' && source.last_heartbeat_at
           ? source.last_heartbeat_at
@@ -303,7 +345,7 @@ export class AopKernel {
           ? source.lease_expires_at
           : fallback.lease_expires_at,
       orchestrator_epoch: epoch,
-      feature_sessions: featureSessions
+      feature_sessions: featureSessions,
     };
   }
 
@@ -311,16 +353,29 @@ export class AopKernel {
     const now = nowIso();
     const source = value && typeof value === 'object' ? (value as Record<string, unknown>) : {};
     return {
-      version: typeof source.version === 'number' && Number.isFinite(source.version) ? Math.max(1, Math.floor(source.version)) : 1,
-      active: normalizeSet(asArray<string>(source.active).filter((item) => typeof item === 'string')),
-      blocked: normalizeSet(asArray<string>(source.blocked).filter((item) => typeof item === 'string')),
-      merged: normalizeSet(asArray<string>(source.merged).filter((item) => typeof item === 'string')),
+      version:
+        typeof source.version === 'number' && Number.isFinite(source.version)
+          ? Math.max(1, Math.floor(source.version))
+          : 1,
+      active: normalizeSet(
+        asArray<string>(source.active).filter((item) => typeof item === 'string'),
+      ),
+      blocked: normalizeSet(
+        asArray<string>(source.blocked).filter((item) => typeof item === 'string'),
+      ),
+      merged: normalizeSet(
+        asArray<string>(source.merged).filter((item) => typeof item === 'string'),
+      ),
       locks: source.locks && typeof source.locks === 'object' ? source.locks : {},
-      lock_leases: source.lock_leases && typeof source.lock_leases === 'object' ? source.lock_leases : {},
-      blocked_queue: asArray(source.blocked_queue).filter((item) => item && typeof item === 'object'),
+      lock_leases:
+        source.lock_leases && typeof source.lock_leases === 'object' ? source.lock_leases : {},
+      blocked_queue: asArray(source.blocked_queue).filter(
+        (item) => item && typeof item === 'object',
+      ),
       dep_blocked: asArray(source.dep_blocked).filter((item) => item && typeof item === 'object'),
-      updated_at: typeof source.updated_at === 'string' && source.updated_at ? source.updated_at : now,
-      runtime_sessions: this.normalizeRuntimeSessions(source.runtime_sessions, now)
+      updated_at:
+        typeof source.updated_at === 'string' && source.updated_at ? source.updated_at : now,
+      runtime_sessions: this.normalizeRuntimeSessions(source.runtime_sessions, now),
     };
   }
 
@@ -332,20 +387,40 @@ export class AopKernel {
     return expiry > Date.now();
   }
 
+  private async resolveDefaultConfigPath(fileName: string): Promise<string> {
+    const primary = path.join(this.pathLayout.orchestratorRoot, fileName);
+    if (await pathExists(primary)) {
+      return primary;
+    }
+    const legacy = path.join(this.pathLayout.legacyOrchestratorRoot, fileName);
+    if (await pathExists(legacy)) {
+      return legacy;
+    }
+    return primary;
+  }
+
   async load() {
     await ensureAopRuntimeLayout(this.pathLayout);
 
-    const gatesPath = this.configOverrides.gatesPath ?? path.join(this.orchestratorDir, 'gates.yaml');
-    const policyPath = this.configOverrides.policyPath ?? path.join(this.orchestratorDir, 'policy.yaml');
-    const agentsPath = this.configOverrides.agentsPath ?? path.join(this.orchestratorDir, 'agents.yaml');
-    const adaptersPath = this.configOverrides.adaptersPath ?? path.join(this.orchestratorDir, 'adapters.yaml');
+    const gatesPath =
+      this.configOverrides.gatesPath ?? (await this.resolveDefaultConfigPath('gates.yaml'));
+    const policyPath =
+      this.configOverrides.policyPath ?? (await this.resolveDefaultConfigPath('policy.yaml'));
+    const agentsPath =
+      this.configOverrides.agentsPath ?? (await this.resolveDefaultConfigPath('agents.yaml'));
+    const adaptersPath =
+      this.configOverrides.adaptersPath ?? (await this.resolveDefaultConfigPath('adapters.yaml'));
 
     const gates = await loadAndValidateYaml(this.schemaRegistry, 'gates.schema.json', gatesPath);
     if (!gates.validation.valid) {
       throw new Error(`invalid_gates_yaml:${JSON.stringify(gates.validation.errors)}`);
     }
 
-    const { mergedPolicy } = await loadComposedPolicy(this.repoRoot, policyPath, this.schemaRegistry);
+    const { mergedPolicy } = await loadComposedPolicy(
+      this.repoRoot,
+      policyPath,
+      this.schemaRegistry,
+    );
     const parsedPolicy = mergedPolicy as PolicyConfigSnapshot;
     const implementation = readObjectField(parsedPolicy, 'implementation');
     const testing = readObjectField(parsedPolicy, 'testing');
@@ -369,7 +444,11 @@ export class AopKernel {
     const adaptersExists = await pathExists(adaptersPath);
     let adapters = { parsed: {}, validation: { valid: true, errors: [] as unknown[] } };
     if (adaptersExists) {
-      adapters = await loadAndValidateYaml(this.schemaRegistry, 'adapters.schema.json', adaptersPath);
+      adapters = await loadAndValidateYaml(
+        this.schemaRegistry,
+        'adapters.schema.json',
+        adaptersPath,
+      );
       if (!adapters.validation.valid) {
         throw new Error(`invalid_adapters_yaml:${JSON.stringify(adapters.validation.errors)}`);
       }
@@ -379,7 +458,9 @@ export class AopKernel {
         try {
           globalAdapterRegistry.resolve(NOTIFICATION_CHANNEL_SLOT, notificationChannel, {});
         } catch {
-          throw new Error(`adapter_not_found:${NOTIFICATION_CHANNEL_SLOT.name}:${notificationChannel}`);
+          throw new Error(
+            `adapter_not_found:${NOTIFICATION_CHANNEL_SLOT.name}:${notificationChannel}`,
+          );
         }
       }
       const activityDetector = readStringField(parsedAdapters, ACTIVITY_DETECTOR_SLOT.name);
@@ -427,7 +508,11 @@ export class AopKernel {
     return allowedTools.includes(toolName);
   }
 
-  async invoke(toolName: string, args: AnyRecord = {}, context: KernelContext = {}): Promise<AnyRecord> {
+  async invoke(
+    toolName: string,
+    args: AnyRecord = {},
+    context: KernelContext = {},
+  ): Promise<AnyRecord> {
     await this.ensureLoaded();
     const actorType = context.actor_type ?? 'system';
     const actorId = context.actor_id ?? 'system';
@@ -436,7 +521,10 @@ export class AopKernel {
       return fail(
         ERROR_CODES.FORBIDDEN_TOOL_FOR_ROLE,
         `Tool ${toolName} is not allowed for role ${actorType}`,
-        withSuggestedActions({ actor_type: actorType, tool_name: toolName, retryable: false, requires_human: true }, ['Use orchestrator role for this operation'])
+        withSuggestedActions(
+          { actor_type: actorType, tool_name: toolName, retryable: false, requires_human: true },
+          ['Use orchestrator role for this operation'],
+        ),
       );
     }
 
@@ -466,14 +554,14 @@ export class AopKernel {
     if (text.startsWith('path_out_of_bounds')) {
       return fail(ERROR_CODES.PATH_OUT_OF_BOUNDS, 'Path escapes repository root', {
         retryable: false,
-        requires_human: true
+        requires_human: true,
       });
     }
 
     if (text.startsWith('lock_timeout:')) {
       return fail(ERROR_CODES.LOCK_CONFLICT, 'Timed out waiting for lock', {
         retryable: true,
-        requires_human: false
+        requires_human: false,
       });
     }
 
@@ -481,7 +569,7 @@ export class AopKernel {
       return fail(ERROR_CODES.UNKNOWN_GATE_PROFILE_OR_MODE, 'Unknown gate profile or mode', {
         value: text.split(':')[1],
         retryable: false,
-        requires_human: true
+        requires_human: true,
       });
     }
 
@@ -489,140 +577,234 @@ export class AopKernel {
       return fail(ERROR_CODES.UNSUPPORTED_PARSER, 'Gate parser type is not supported', {
         parser: text.split(':')[1],
         retryable: false,
-        requires_human: true
+        requires_human: true,
       });
     }
 
     if (text.includes('qa_index_version_conflict')) {
-      return fail(ERROR_CODES.QA_INDEX_VERSION_CONFLICT, 'QA index expected_version did not match current version', {
-        retryable: true,
-        requires_human: false
-      });
+      return fail(
+        ERROR_CODES.QA_INDEX_VERSION_CONFLICT,
+        'QA index expected_version did not match current version',
+        {
+          retryable: true,
+          requires_human: false,
+        },
+      );
     }
 
     return fail(ERROR_CODES.INTERNAL_ERROR, text, {
       retryable: false,
-      requires_human: true
+      requires_human: true,
     });
   }
 
-  async dispatchTool(toolName: string, args: AnyRecord, context: ToolHandlerContext): Promise<unknown> {
+  async dispatchTool(
+    toolName: string,
+    args: AnyRecord,
+    context: ToolHandlerContext,
+  ): Promise<unknown> {
     return await this.toolRouter.route(toolName, args, context);
   }
 
   private registerToolHandlers(): void {
-    this.toolHandlers.register(TOOLS.FEATURE_DISCOVER_SPECS, async () => await this.featureDiscoverSpecs());
-    this.toolHandlers.register(TOOLS.FEATURE_INIT, async (args) => await this.featureInit(readStringField(args, 'feature_id')));
-    this.toolHandlers.register(TOOLS.FEATURE_GET_CONTEXT, async (args) =>
-      await this.featureGetContext(readStringField(args, 'feature_id'))
+    this.toolHandlers.register(
+      TOOLS.FEATURE_DISCOVER_SPECS,
+      async () => await this.featureDiscoverSpecs(),
     );
-    this.toolHandlers.register(TOOLS.FEATURE_STATE_GET, async (args) =>
-      await this.featureStateGet(readStringField(args, 'feature_id'))
+    this.toolHandlers.register(
+      TOOLS.FEATURE_INIT,
+      async (args) => await this.featureInit(readStringField(args, 'feature_id')),
     );
-    this.toolHandlers.register(TOOLS.FEATURE_STATE_PATCH, async (args) =>
-      await this.featureStatePatch(
-        readStringField(args, 'feature_id'),
-        readNumberField(args, 'expected_version'),
-        args.patch
-      )
+    this.toolHandlers.register(
+      TOOLS.FEATURE_GET_CONTEXT,
+      async (args) => await this.featureGetContext(readStringField(args, 'feature_id')),
     );
-    this.toolHandlers.register(TOOLS.FEATURE_LOG_APPEND, async (args, context) =>
-      await this.featureLogAppend(readStringField(args, 'feature_id'), readStringField(args, 'note'), context)
+    this.toolHandlers.register(
+      TOOLS.FEATURE_STATE_GET,
+      async (args) => await this.featureStateGet(readStringField(args, 'feature_id')),
     );
-    this.toolHandlers.register(TOOLS.PLAN_SUBMIT, async (args) =>
-      await this.planSubmit(readStringField(args, 'feature_id'), args.plan_json, readNumberField(args, 'expected_version'))
+    this.toolHandlers.register(
+      TOOLS.FEATURE_STATE_PATCH,
+      async (args) =>
+        await this.featureStatePatch(
+          readStringField(args, 'feature_id'),
+          readNumberField(args, 'expected_version'),
+          args.patch,
+        ),
     );
-    this.toolHandlers.register(TOOLS.PLAN_GET, async (args) => await this.planGet(readStringField(args, 'feature_id')));
-    this.toolHandlers.register(TOOLS.PLAN_UPDATE, async (args) =>
-      await this.planUpdate(readStringField(args, 'feature_id'), readNumberField(args, 'expected_plan_version'), args.plan_json)
+    this.toolHandlers.register(
+      TOOLS.FEATURE_LOG_APPEND,
+      async (args, context) =>
+        await this.featureLogAppend(
+          readStringField(args, 'feature_id'),
+          readStringField(args, 'note'),
+          context,
+        ),
     );
-    this.toolHandlers.register(TOOLS.REPO_ENSURE_WORKTREE, async (args) =>
-      await this.repoEnsureWorktree(readStringField(args, 'feature_id'))
+    this.toolHandlers.register(
+      TOOLS.PLAN_SUBMIT,
+      async (args) =>
+        await this.planSubmit(
+          readStringField(args, 'feature_id'),
+          args.plan_json,
+          readNumberField(args, 'expected_version'),
+        ),
     );
-    this.toolHandlers.register(TOOLS.REPO_APPLY_PATCH, async (args) =>
-      await this.repoApplyPatch(readStringField(args, 'feature_id'), readStringField(args, 'unified_diff'))
+    this.toolHandlers.register(
+      TOOLS.PLAN_GET,
+      async (args) => await this.planGet(readStringField(args, 'feature_id')),
     );
-    this.toolHandlers.register(TOOLS.REPO_STATUS, async (args) => await this.repoStatus(readStringField(args, 'feature_id')));
-    this.toolHandlers.register(TOOLS.REPO_DIFF, async (args) =>
-      await this.repoDiff(readStringField(args, 'feature_id'), asArray<string>(args.options))
+    this.toolHandlers.register(
+      TOOLS.PLAN_UPDATE,
+      async (args) =>
+        await this.planUpdate(
+          readStringField(args, 'feature_id'),
+          readNumberField(args, 'expected_plan_version'),
+          args.plan_json,
+        ),
     );
-    this.toolHandlers.register(TOOLS.REPO_READ_FILE, async (args) =>
-      await this.repoReadFile(readStringField(args, 'feature_id'), readStringField(args, 'path'))
+    this.toolHandlers.register(
+      TOOLS.REPO_ENSURE_WORKTREE,
+      async (args) => await this.repoEnsureWorktree(readStringField(args, 'feature_id')),
     );
-    this.toolHandlers.register(TOOLS.REPO_SEARCH, async (args) =>
-      await this.repoSearch(readStringField(args, 'feature_id'), readStringField(args, 'query'))
+    this.toolHandlers.register(
+      TOOLS.REPO_APPLY_PATCH,
+      async (args) =>
+        await this.repoApplyPatch(
+          readStringField(args, 'feature_id'),
+          readStringField(args, 'unified_diff'),
+        ),
     );
-    this.toolHandlers.register(TOOLS.REPO_DIFF_BUNDLE, async (args) =>
-      await this.repoDiffBundle(readStringField(args, 'feature_id'))
+    this.toolHandlers.register(
+      TOOLS.REPO_STATUS,
+      async (args) => await this.repoStatus(readStringField(args, 'feature_id')),
     );
-    this.toolHandlers.register(TOOLS.FEATURE_READY_TO_MERGE, async (args) =>
-      await this.featureReadyToMerge(
-        readStringField(args, 'feature_id'),
-        readStringField(args, 'commit_message'),
-        readStringField(args, 'merge_strategy'),
-        readStringField(args, 'user_approval_token')
-      )
+    this.toolHandlers.register(
+      TOOLS.REPO_DIFF,
+      async (args) =>
+        await this.repoDiff(readStringField(args, 'feature_id'), asArray<string>(args.options)),
     );
-    this.toolHandlers.register(TOOLS.FEATURE_DELETE, async (args) =>
-      await this.featureDelete(
-        readStringField(args, 'feature_id'),
-        readBooleanField(args, 'dry_run'),
-        readBooleanField(args, 'confirm'),
-        readBooleanField(args, 'remove_worktree'),
-        readStringField(args, 'remove_branch')
-      )
+    this.toolHandlers.register(
+      TOOLS.REPO_READ_FILE,
+      async (args) =>
+        await this.repoReadFile(readStringField(args, 'feature_id'), readStringField(args, 'path')),
     );
-    this.toolHandlers.register(TOOLS.GATES_LIST, async (args) => await this.gatesList(readStringField(args, 'profile')));
-    this.toolHandlers.register(TOOLS.GATES_RUN, async (args) =>
-      await this.gatesRun(readStringField(args, 'feature_id'), readStringField(args, 'profile'), readStringField(args, 'mode'))
+    this.toolHandlers.register(
+      TOOLS.REPO_SEARCH,
+      async (args) =>
+        await this.repoSearch(readStringField(args, 'feature_id'), readStringField(args, 'query')),
     );
-    this.toolHandlers.register(TOOLS.EVIDENCE_LATEST, async (args) =>
-      await this.evidenceLatest(readStringField(args, 'feature_id'))
+    this.toolHandlers.register(
+      TOOLS.REPO_DIFF_BUNDLE,
+      async (args) => await this.repoDiffBundle(readStringField(args, 'feature_id')),
     );
-    this.toolHandlers.register(TOOLS.QA_TEST_INDEX_GET, async (args) =>
-      await this.qaTestIndexGet(readStringField(args, 'feature_id'))
+    this.toolHandlers.register(
+      TOOLS.FEATURE_READY_TO_MERGE,
+      async (args) =>
+        await this.featureReadyToMerge(
+          readStringField(args, 'feature_id'),
+          readStringField(args, 'commit_message'),
+          readStringField(args, 'merge_strategy'),
+          readStringField(args, 'user_approval_token'),
+        ),
     );
-    this.toolHandlers.register(TOOLS.QA_TEST_INDEX_UPDATE, async (args) =>
-      await this.qaTestIndexUpdate(
-        readStringField(args, 'feature_id'),
-        readNumberField(args, 'expected_version'),
-        args.updates,
-        asArray(args.evidence_refs)
-      )
+    this.toolHandlers.register(
+      TOOLS.FEATURE_DELETE,
+      async (args) =>
+        await this.featureDelete(
+          readStringField(args, 'feature_id'),
+          readBooleanField(args, 'dry_run'),
+          readBooleanField(args, 'confirm'),
+          readBooleanField(args, 'remove_worktree'),
+          readStringField(args, 'remove_branch'),
+        ),
     );
-    this.toolHandlers.register(TOOLS.LOCKS_ACQUIRE, async (args) =>
-      await this.locksAcquire(
-        readStringField(args, 'resource'),
-        readStringField(args, 'feature_id'),
-        readNumberField(args, 'wait_timeout_seconds')
-      )
+    this.toolHandlers.register(
+      TOOLS.GATES_LIST,
+      async (args) => await this.gatesList(readStringField(args, 'profile')),
     );
-    this.toolHandlers.register(TOOLS.LOCKS_RELEASE, async (args) =>
-      await this.locksRelease(readStringField(args, 'resource'), readStringField(args, 'feature_id'))
+    this.toolHandlers.register(
+      TOOLS.GATES_RUN,
+      async (args) =>
+        await this.gatesRun(
+          readStringField(args, 'feature_id'),
+          readStringField(args, 'profile'),
+          readStringField(args, 'mode'),
+        ),
+    );
+    this.toolHandlers.register(
+      TOOLS.EVIDENCE_LATEST,
+      async (args) => await this.evidenceLatest(readStringField(args, 'feature_id')),
+    );
+    this.toolHandlers.register(
+      TOOLS.QA_TEST_INDEX_GET,
+      async (args) => await this.qaTestIndexGet(readStringField(args, 'feature_id')),
+    );
+    this.toolHandlers.register(
+      TOOLS.QA_TEST_INDEX_UPDATE,
+      async (args) =>
+        await this.qaTestIndexUpdate(
+          readStringField(args, 'feature_id'),
+          readNumberField(args, 'expected_version'),
+          args.updates,
+          asArray(args.evidence_refs),
+        ),
+    );
+    this.toolHandlers.register(
+      TOOLS.LOCKS_ACQUIRE,
+      async (args) =>
+        await this.locksAcquire(
+          readStringField(args, 'resource'),
+          readStringField(args, 'feature_id'),
+          readNumberField(args, 'wait_timeout_seconds'),
+        ),
+    );
+    this.toolHandlers.register(
+      TOOLS.LOCKS_RELEASE,
+      async (args) =>
+        await this.locksRelease(
+          readStringField(args, 'resource'),
+          readStringField(args, 'feature_id'),
+        ),
     );
     this.toolHandlers.register(TOOLS.COLLISIONS_SCAN, async () => await this.collisionsScan());
     this.toolHandlers.register(TOOLS.REPORT_DASHBOARD, async () => await this.reportDashboard());
-    this.toolHandlers.register(TOOLS.REPORT_FEATURE_SUMMARY, async (args) =>
-      await this.reportFeatureSummary(readStringField(args, 'feature_id'))
+    this.toolHandlers.register(
+      TOOLS.REPORT_FEATURE_SUMMARY,
+      async (args) => await this.reportFeatureSummary(readStringField(args, 'feature_id')),
     );
-    this.toolHandlers.register(TOOLS.FEATURE_SEND_MESSAGE, async (args) =>
-      await this.featureSendMessage(readStringField(args, 'feature_id'), readStringField(args, 'message'))
+    this.toolHandlers.register(
+      TOOLS.FEATURE_SEND_MESSAGE,
+      async (args) =>
+        await this.featureSendMessage(
+          readStringField(args, 'feature_id'),
+          readStringField(args, 'message'),
+        ),
     );
-    this.toolHandlers.register(TOOLS.COST_RECORD, async (args) =>
-      await this.costRecord(
-        readStringField(args, 'feature_id'),
-        typeof args.tokens_used_delta === 'number' ? args.tokens_used_delta : 0,
-        typeof args.estimated_cost_usd_delta === 'number' ? args.estimated_cost_usd_delta : 0
-      )
+    this.toolHandlers.register(
+      TOOLS.COST_RECORD,
+      async (args) =>
+        await this.costRecord(
+          readStringField(args, 'feature_id'),
+          typeof args.tokens_used_delta === 'number' ? args.tokens_used_delta : 0,
+          typeof args.estimated_cost_usd_delta === 'number' ? args.estimated_cost_usd_delta : 0,
+        ),
     );
-    this.toolHandlers.register(TOOLS.COST_GET, async (args) =>
-      await this.costGet(readStringField(args, 'feature_id'))
+    this.toolHandlers.register(
+      TOOLS.COST_GET,
+      async (args) => await this.costGet(readStringField(args, 'feature_id')),
     );
-    this.toolHandlers.register(TOOLS.PERFORMANCE_RECORD_OUTCOME, async (args) =>
-      await this.performanceRecordOutcome(args)
+    this.toolHandlers.register(
+      TOOLS.PERFORMANCE_RECORD_OUTCOME,
+      async (args) => await this.performanceRecordOutcome(args),
     );
-    this.toolHandlers.register(TOOLS.PERFORMANCE_GET_ANALYTICS, async (args) =>
-      await this.performanceGetAnalytics(readStringField(args, 'provider'), readStringField(args, 'model'))
+    this.toolHandlers.register(
+      TOOLS.PERFORMANCE_GET_ANALYTICS,
+      async (args) =>
+        await this.performanceGetAnalytics(
+          readStringField(args, 'provider'),
+          readStringField(args, 'model'),
+        ),
     );
   }
 
@@ -697,30 +879,32 @@ export class AopKernel {
         plan: GATE_RESULT.NA,
         fast: GATE_RESULT.NA,
         full: GATE_RESULT.NA,
-        merge: GATE_RESULT.NA
+        merge: GATE_RESULT.NA,
       },
       locks: {
-        held: []
+        held: [],
       },
       collisions: {
         files: [],
         areas: [],
-        contracts: []
+        contracts: [],
       },
       cluster: { ...DEFAULT_CLUSTER },
       role_status: { ...DEFAULT_ROLE_STATUS },
-      last_updated: nowIso()
+      last_updated: nowIso(),
     };
   }
 
-  async readState(featureId: string): Promise<{ frontMatter: AnyRecord; body: string; raw: string }> {
+  async readState(
+    featureId: string,
+  ): Promise<{ frontMatter: AnyRecord; body: string; raw: string }> {
     const filePath = this.statePath(featureId);
     const raw = await fs.readFile(filePath, 'utf8');
     const parsed = parseFrontMatter(raw);
     return {
       frontMatter: parsed.frontMatter,
       body: parsed.body,
-      raw
+      raw,
     };
   }
 
@@ -728,11 +912,15 @@ export class AopKernel {
     const validation = await this.schemaRegistry.validate('state.schema.json', frontMatter);
     if (!validation.valid) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.STATE_VALIDATION_FAILED, 'state.md front matter failed schema validation', {
-          errors: validation.errors,
-          retryable: false,
-          requires_human: true
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.STATE_VALIDATION_FAILED,
+          'state.md front matter failed schema validation',
+          {
+            errors: validation.errors,
+            retryable: false,
+            requires_human: true,
+          },
+        ),
       };
     }
 
@@ -742,13 +930,13 @@ export class AopKernel {
 
   async withFeatureLock<T>(featureId: string, operation: () => Promise<T>): Promise<T> {
     return await withFileLock<T>(this.featureLockPath(featureId), operation, {
-      timeoutMs: 30_000
+      timeoutMs: 30_000,
     });
   }
 
   async withIndexLock<T>(operation: () => Promise<T>): Promise<T> {
     return await withFileLock<T>(this.indexLockPath, operation, {
-      timeoutMs: 30_000
+      timeoutMs: 30_000,
     });
   }
 
@@ -767,18 +955,25 @@ export class AopKernel {
     const validation = await this.schemaRegistry.validate('index.schema.json', normalized);
     if (!validation.valid) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.INDEX_VALIDATION_FAILED, 'index.json failed schema validation', {
-          errors: validation.errors,
-          retryable: false,
-          requires_human: true
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.INDEX_VALIDATION_FAILED,
+          'index.json failed schema validation',
+          {
+            errors: validation.errors,
+            retryable: false,
+            requires_human: true,
+          },
+        ),
       };
     }
 
     await atomicWriteJson(this.indexPath, normalized);
   }
 
-  async validateSchema(schemaName: string, value: unknown): Promise<{ valid: boolean; errors?: unknown }> {
+  async validateSchema(
+    schemaName: string,
+    value: unknown,
+  ): Promise<{ valid: boolean; errors?: unknown }> {
     return await this.schemaRegistry.validate(schemaName, value);
   }
 
@@ -806,15 +1001,27 @@ export class AopKernel {
     await atomicWriteJson(runLeasePath, data);
   }
 
-  async acquireRunLease(input: AcquireRunLeaseInput): Promise<{ data: { runtime_sessions: RuntimeSessionsSnapshot; took_over_stale: boolean; reused_existing_owner: boolean } }> {
+  async acquireRunLease(input: AcquireRunLeaseInput): Promise<{
+    data: {
+      runtime_sessions: RuntimeSessionsSnapshot;
+      took_over_stale: boolean;
+      reused_existing_owner: boolean;
+    };
+  }> {
     return await this.runLeaseService.acquireRunLease(input);
   }
 
-  async renewRunLease(runId: string, ownerInstanceId: string): Promise<{ data: { lease_expires_at: string } }> {
+  async renewRunLease(
+    runId: string,
+    ownerInstanceId: string,
+  ): Promise<{ data: { lease_expires_at: string } }> {
     return await this.runLeaseService.renewRunLease(runId, ownerInstanceId);
   }
 
-  async releaseRunLease(runId: string, ownerInstanceId: string): Promise<{ data: { released: boolean } }> {
+  async releaseRunLease(
+    runId: string,
+    ownerInstanceId: string,
+  ): Promise<{ data: { released: boolean } }> {
     return await this.runLeaseService.releaseRunLease(runId, ownerInstanceId);
   }
 
@@ -849,7 +1056,10 @@ export class AopKernel {
   async updateState(
     featureId: string,
     expectedVersion: number | null,
-    updater: (frontMatter: AnyRecord, body: string) => Promise<{ frontMatter?: AnyRecord; body?: string }>
+    updater: (
+      frontMatter: AnyRecord,
+      body: string,
+    ) => Promise<{ frontMatter?: AnyRecord; body?: string }>,
   ) {
     return await this.featureStateService.updateState(featureId, expectedVersion, updater);
   }
@@ -925,8 +1135,8 @@ export class AopKernel {
           feature_id: featureId,
           branch,
           worktree_path_abs: worktree,
-          existed: true
-        }
+          existed: true,
+        },
       };
     }
 
@@ -939,15 +1149,20 @@ export class AopKernel {
       const branchCreate = await runGit(this.repoRoot, ['branch', branch, baseRef]);
       if (branchCreate.code !== 0) {
         throw {
-          normalizedResponse: fail(ERROR_CODES.GIT_FAILURE, 'Unable to create feature branch', {
-            feature_id: featureId,
-            stderr: branchCreate.stderr,
-            retryable: false,
-            requires_human: true
-          }, {
-            command: ['git', 'branch', branch, baseRef],
-            exit_code: branchCreate.code
-          })
+          normalizedResponse: fail(
+            ERROR_CODES.GIT_FAILURE,
+            'Unable to create feature branch',
+            {
+              feature_id: featureId,
+              stderr: branchCreate.stderr,
+              retryable: false,
+              requires_human: true,
+            },
+            {
+              command: ['git', 'branch', branch, baseRef],
+              exit_code: branchCreate.code,
+            },
+          ),
         };
       }
     }
@@ -955,30 +1170,42 @@ export class AopKernel {
     const addWorktree = await runGit(this.repoRoot, ['worktree', 'add', worktree, branch]);
     if (addWorktree.code !== 0) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.GIT_FAILURE, 'Unable to create git worktree', {
-          feature_id: featureId,
-          stderr: addWorktree.stderr,
-          retryable: false,
-          requires_human: true
-        }, {
-          command: ['git', 'worktree', 'add', worktree, branch],
-          exit_code: addWorktree.code
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.GIT_FAILURE,
+          'Unable to create git worktree',
+          {
+            feature_id: featureId,
+            stderr: addWorktree.stderr,
+            retryable: false,
+            requires_human: true,
+          },
+          {
+            command: ['git', 'worktree', 'add', worktree, branch],
+            exit_code: addWorktree.code,
+          },
+        ),
       };
     }
 
-    const worktreeConfig = this.policy.worktree as {
-      base_branch: string;
-      symlinks?: string[];
-      post_create?: string[];
-    } | undefined;
+    const worktreeConfig = this.policy.worktree as
+      | {
+          base_branch: string;
+          symlinks?: string[];
+          post_create?: string[];
+        }
+      | undefined;
     const hookWarnings: WorkspaceHookWarning[] = [];
     const collectHookWarning = (warning: WorkspaceHookWarning) => {
       hookWarnings.push(warning);
     };
 
     if (worktreeConfig?.symlinks?.length) {
-      await applyWorktreeSymlinks(this.repoRoot, worktree, worktreeConfig.symlinks, collectHookWarning);
+      await applyWorktreeSymlinks(
+        this.repoRoot,
+        worktree,
+        worktreeConfig.symlinks,
+        collectHookWarning,
+      );
     }
 
     if (worktreeConfig?.post_create?.length) {
@@ -995,8 +1222,8 @@ export class AopKernel {
         feature_id: featureId,
         branch,
         worktree_path_abs: worktree,
-        existed: false
-      }
+        existed: false,
+      },
     };
   }
 
@@ -1015,33 +1242,42 @@ export class AopKernel {
   async repoStatus(featureId) {
     const worktree = this.worktreePath(featureId);
     const status = await runGit(this.repoRoot, ['status', '--porcelain'], { cwd: worktree });
-    const branch = await runGit(this.repoRoot, ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: worktree });
+    const branch = await runGit(this.repoRoot, ['rev-parse', '--abbrev-ref', 'HEAD'], {
+      cwd: worktree,
+    });
 
     return {
       data: {
         feature_id: featureId,
         branch: branch.stdout.trim(),
-        status_porcelain: status.stdout.trim().split('\n').filter(Boolean)
-      }
+        status_porcelain: status.stdout.trim().split('\n').filter(Boolean),
+      },
     };
   }
 
   async repoDiff(featureId, options = []) {
     const safeOptions = asArray<string>(options).filter(
-      (option) => typeof option === 'string' && option.startsWith('--')
+      (option) => typeof option === 'string' && option.startsWith('--'),
     );
-    const diff = await runGit(this.repoRoot, ['diff', ...safeOptions], { cwd: this.worktreePath(featureId) });
+    const diff = await runGit(this.repoRoot, ['diff', ...safeOptions], {
+      cwd: this.worktreePath(featureId),
+    });
     return {
       data: {
         feature_id: featureId,
-        diff: diff.stdout
-      }
+        diff: diff.stdout,
+      },
     };
   }
 
   async repoReadFile(featureId, filePath) {
-    const normalized = await normalizeRepoPath(this.repoRoot, path.join(this.worktreePath(featureId), filePath), this.policy.path_rules.allow_symlink_traversal)
-      .then((relative) => normalizeFromWorktree(this.worktreePath(featureId), this.repoRoot, relative));
+    const normalized = await normalizeRepoPath(
+      this.repoRoot,
+      path.join(this.worktreePath(featureId), filePath),
+      this.policy.path_rules.allow_symlink_traversal,
+    ).then((relative) =>
+      normalizeFromWorktree(this.worktreePath(featureId), this.repoRoot, relative),
+    );
     const absolute = path.join(this.repoRoot, normalized);
     const exists = await pathExists(absolute);
     if (!exists) {
@@ -1049,8 +1285,8 @@ export class AopKernel {
         normalizedResponse: fail(ERROR_CODES.FILE_NOT_FOUND, 'File not found', {
           path: normalized,
           retryable: false,
-          requires_human: false
-        })
+          requires_human: false,
+        }),
       };
     }
     const content = await fs.readFile(absolute, 'utf8');
@@ -1058,8 +1294,8 @@ export class AopKernel {
       data: {
         feature_id: featureId,
         path: normalized,
-        content
-      }
+        content,
+      },
     };
   }
 
@@ -1067,16 +1303,20 @@ export class AopKernel {
     const worktree = this.worktreePath(featureId);
     const rgResult = await runCommand('rg', ['-n', '--no-heading', query, '.'], {
       cwd: worktree,
-      timeoutMs: 30_000
+      timeoutMs: 30_000,
     });
 
     if (rgResult.code === 127) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.GIT_FAILURE, 'ripgrep (rg) not found - required for search functionality', {
-          stderr: rgResult.stderr,
-          retryable: false,
-          requires_human: true
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.GIT_FAILURE,
+          'ripgrep (rg) not found - required for search functionality',
+          {
+            stderr: rgResult.stderr,
+            retryable: false,
+            requires_human: true,
+          },
+        ),
       };
     }
 
@@ -1085,8 +1325,8 @@ export class AopKernel {
         normalizedResponse: fail(ERROR_CODES.GIT_FAILURE, 'Search failed', {
           stderr: rgResult.stderr,
           retryable: true,
-          requires_human: false
-        })
+          requires_human: false,
+        }),
       };
     }
 
@@ -1103,7 +1343,7 @@ export class AopKernel {
         return {
           path: line.slice(0, firstColon),
           line: Number(line.slice(firstColon + 1, secondColon)),
-          snippet: line.slice(secondColon + 1)
+          snippet: line.slice(secondColon + 1),
         };
       });
 
@@ -1111,15 +1351,19 @@ export class AopKernel {
       data: {
         feature_id: featureId,
         query,
-        matches
-      }
+        matches,
+      },
     };
   }
 
   async repoDiffBundle(featureId) {
-    const stat = await runGit(this.repoRoot, ['diff', '--stat'], { cwd: this.worktreePath(featureId) });
+    const stat = await runGit(this.repoRoot, ['diff', '--stat'], {
+      cwd: this.worktreePath(featureId),
+    });
     const full = await runGit(this.repoRoot, ['diff'], { cwd: this.worktreePath(featureId) });
-    const names = await runGit(this.repoRoot, ['diff', '--name-only'], { cwd: this.worktreePath(featureId) });
+    const names = await runGit(this.repoRoot, ['diff', '--name-only'], {
+      cwd: this.worktreePath(featureId),
+    });
     const latest = await this.evidenceLatest(featureId);
 
     return {
@@ -1127,9 +1371,12 @@ export class AopKernel {
         feature_id: featureId,
         diff_stat: stat.stdout,
         diff: full.stdout,
-        touched_files: names.stdout.split('\n').map((x) => x.trim()).filter(Boolean),
-        last_gate_summary: latest.data?.latest ?? null
-      }
+        touched_files: names.stdout
+          .split('\n')
+          .map((x) => x.trim())
+          .filter(Boolean),
+        last_gate_summary: latest.data?.latest ?? null,
+      },
     };
   }
 
@@ -1154,7 +1401,12 @@ export class AopKernel {
   }
 
   async qaTestIndexUpdate(featureId, expectedVersion, updates, evidenceRefs) {
-    return await this.qaIndexService.qaTestIndexUpdate(featureId, expectedVersion, updates, evidenceRefs);
+    return await this.qaIndexService.qaTestIndexUpdate(
+      featureId,
+      expectedVersion,
+      updates,
+      evidenceRefs,
+    );
   }
 
   async locksAcquire(resource, featureId, waitTimeoutSeconds = null) {
@@ -1178,7 +1430,12 @@ export class AopKernel {
   }
 
   async featureReadyToMerge(featureId, commitMessage, mergeStrategy, userApprovalToken) {
-    return await this.mergeService.featureReadyToMerge(featureId, commitMessage, mergeStrategy, userApprovalToken);
+    return await this.mergeService.featureReadyToMerge(
+      featureId,
+      commitMessage,
+      mergeStrategy,
+      userApprovalToken,
+    );
   }
 
   async featureDelete(
@@ -1186,13 +1443,13 @@ export class AopKernel {
     dryRun: boolean | null,
     confirm: boolean | null,
     removeWorktree: boolean | null,
-    removeBranch: string | null
+    removeBranch: string | null,
   ): Promise<FeatureDeleteResult> {
     return await this.featureDeletionService.featureDelete(featureId, {
       dryRun: dryRun ?? undefined,
       confirm: confirm ?? undefined,
       removeWorktree: removeWorktree ?? undefined,
-      removeBranch: removeBranch ?? undefined
+      removeBranch: removeBranch ?? undefined,
     });
   }
 
@@ -1224,21 +1481,34 @@ export class AopKernel {
     }
   }
 
-  async featureSendMessage(
-    featureId: string | null,
-    message: string | null
-  ): Promise<unknown> {
+  async featureSendMessage(featureId: string | null, message: string | null): Promise<unknown> {
     if (!featureId) {
-      throw { normalizedResponse: fail(ERROR_CODES.INVALID_ARGUMENT, 'feature_id is required', { retryable: false, requires_human: false }) };
+      throw {
+        normalizedResponse: fail(ERROR_CODES.INVALID_ARGUMENT, 'feature_id is required', {
+          retryable: false,
+          requires_human: false,
+        }),
+      };
     }
     if (!message) {
-      throw { normalizedResponse: fail(ERROR_CODES.INVALID_ARGUMENT, 'message is required and must not be empty', { retryable: false, requires_human: false }) };
+      throw {
+        normalizedResponse: fail(
+          ERROR_CODES.INVALID_ARGUMENT,
+          'message is required and must not be empty',
+          { retryable: false, requires_human: false },
+        ),
+      };
     }
 
     const runtimeSessions = await this.getRuntimeSessions();
     const featureSession = runtimeSessions.feature_sessions?.[featureId];
     if (!featureSession) {
-      throw { normalizedResponse: { ok: false, error: { code: 'session_not_found', message: 'No active session cluster for feature' } } };
+      throw {
+        normalizedResponse: {
+          ok: false,
+          error: { code: 'session_not_found', message: 'No active session cluster for feature' },
+        },
+      };
     }
 
     const state = await this.readState(featureId);
@@ -1275,7 +1545,12 @@ export class AopKernel {
     }
 
     if (!this.provider?.sendMessage) {
-      throw { normalizedResponse: { ok: false, error: { code: 'provider_unsupported', message: 'Provider does not support sendMessage' } } };
+      throw {
+        normalizedResponse: {
+          ok: false,
+          error: { code: 'provider_unsupported', message: 'Provider does not support sendMessage' },
+        },
+      };
     }
 
     await this.waitForSessionToBecomeActive(targetSessionId);
@@ -1285,7 +1560,7 @@ export class AopKernel {
       session_id: targetSessionId,
       target_role: targetRole,
       status,
-      delivered: true
+      delivered: true,
     };
   }
 
@@ -1313,7 +1588,7 @@ export class AopKernel {
       retry_count: typeof args.retry_count === 'number' ? args.retry_count : 0,
       duration_ms: typeof args.duration_ms === 'number' ? args.duration_ms : 0,
       cost_usd: typeof args.cost_usd === 'number' ? args.cost_usd : 0,
-      recorded_at: nowIso()
+      recorded_at: nowIso(),
     };
     const snapshot = await this.performanceAnalyticsService.recordOutcome(outcome);
     return { ok: true as const, data: { total_outcomes: snapshot.outcomes.length } };
@@ -1323,10 +1598,17 @@ export class AopKernel {
     if (provider || model) {
       const stats = await this.performanceAnalyticsService.getProviderStats(
         provider ?? undefined,
-        model ?? undefined
+        model ?? undefined,
       );
       const snapshot = await this.performanceAnalyticsService.getAnalytics();
-      return { ok: true as const, data: { outcomes: snapshot.outcomes, aggregates: stats, generated_at: snapshot.generated_at } };
+      return {
+        ok: true as const,
+        data: {
+          outcomes: snapshot.outcomes,
+          aggregates: stats,
+          generated_at: snapshot.generated_at,
+        },
+      };
     }
     const snapshot = await this.performanceAnalyticsService.getAnalytics();
     return { ok: true as const, data: snapshot };
@@ -1341,7 +1623,11 @@ function normalizeRepoPathForState(repoRoot: string, absolutePath: string) {
   return relative;
 }
 
-function normalizeFromWorktree(worktreePath: string, repoRoot: string, repoRelativeFromWorktree: string) {
+function normalizeFromWorktree(
+  worktreePath: string,
+  repoRoot: string,
+  repoRelativeFromWorktree: string,
+) {
   const absolute = path.resolve(repoRoot, repoRelativeFromWorktree);
   const maybeRelativeToWorktree = path.relative(worktreePath, absolute).replaceAll('\\\\', '/');
   if (!maybeRelativeToWorktree.startsWith('../')) {