agentic-orchestrator 0.1.2 → 0.1.4

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

@@ -27,6 +27,8 @@ export interface GateStep {
   cwd?: string;
   env?: Record<string, string>;
   timeout_seconds?: number;
+  parallel_group?: string;
+  depends_on?: string[];
 }
 
 export interface GateProfile {
@@ -172,6 +174,37 @@ export async function parseCoverage(parserConfig: ParserConfig | undefined, work
   return defaultCoverageParserRegistry.parse(parserConfig, content);
 }
 
+export function buildExecutionWaves(steps: GateStep[]): GateStep[][] {
+  const stepMap = new Map(steps.map((s) => [s.name, s]));
+  const placed = new Set<string>();
+  const waves: GateStep[][] = [];
+
+  let remaining = [...steps];
+  while (remaining.length > 0) {
+    const wave: GateStep[] = [];
+    for (const step of remaining) {
+      const deps = step.depends_on ?? [];
+      if (deps.every((dep) => placed.has(dep) || !stepMap.has(dep))) {
+        wave.push(step);
+      }
+    }
+
+    if (wave.length === 0) {
+      // Circular dependency — force remaining into final wave
+      waves.push(remaining);
+      break;
+    }
+
+    waves.push(wave);
+    for (const step of wave) {
+      placed.add(step.name);
+    }
+    remaining = remaining.filter((s) => !placed.has(s.name));
+  }
+
+  return waves;
+}
+
 export class GateExecutionService {
   private readonly thresholdPolicy: CoverageThresholdPolicy;
 
@@ -179,6 +212,70 @@ export class GateExecutionService {
     this.thresholdPolicy = thresholdPolicy;
   }
 
+  private async executeStep(
+    step: GateStep,
+    ctx: {
+      featureId: string;
+      mode: string;
+      policy: PolicyShape;
+      env: NodeJS.ProcessEnv;
+      worktreePath: string;
+      logDirectory: string;
+    }
+  ): Promise<Record<string, unknown>> {
+    const timeoutSeconds = Number(step.timeout_seconds ?? ctx.policy.execution.default_step_timeout_seconds);
+    const stepLogPath = path.join(
+      ctx.logDirectory,
+      `${Date.now()}-${ctx.mode}-${step.name.replaceAll(/[^a-zA-Z0-9_-]/g, '_')}.log`
+    );
+
+    const retryPolicy = ctx.policy.execution.retry_policy;
+    let attempts = 0;
+    let lastResult: CommandResult = { code: 1, signal: null, stdout: '', stderr: '', timeout: false };
+    const maxAttempts = retryPolicy.transient_max_retries + 1;
+
+    while (attempts < maxAttempts) {
+      attempts += 1;
+      const result = await runCommand(step.cmd[0], step.cmd.slice(1), {
+        cwd: step.cwd ? path.join(ctx.worktreePath, step.cwd) : ctx.worktreePath,
+        env: { ...ctx.env, ...step.env },
+        timeoutMs: timeoutSeconds * 1000
+      });
+
+      lastResult = result;
+      const logText = [
+        `# feature=${ctx.featureId} mode=${ctx.mode} step=${step.name} attempt=${attempts}`,
+        `# cmd=${JSON.stringify(step.cmd)}`,
+        `# exit=${result.code} timeout=${result.timeout}`,
+        '',
+        '## stdout',
+        result.stdout,
+        '',
+        '## stderr',
+        result.stderr
+      ].join('\n');
+      await fs.writeFile(stepLogPath, `${logText}\n`, 'utf8');
+
+      if (result.timeout || result.code === 0) {
+        break;
+      }
+
+      const isTransient = retryPolicy.transient_error_codes.includes(result.code);
+      if (!isTransient) {
+        break;
+      }
+    }
+
+    return {
+      name: step.name,
+      cmd: step.cmd,
+      attempts,
+      exit_code: lastResult.code,
+      timeout: lastResult.timeout,
+      log_path: stepLogPath
+    };
+  }
+
   async runMode({
     featureId,
     mode,
@@ -206,68 +303,91 @@ export class GateExecutionService {
     await ensureDir(logDirectory);
     await ensureDir(evidenceDirectory);
 
-    const retryPolicy = policy.execution.retry_policy;
     const env = pickAllowedEnv(policy.execution.env_allowlist);
     const stepResults: Array<Record<string, unknown>> = [];
     let overall = 'pass';
 
-    for (const step of modeSteps) {
-      const timeoutSeconds = Number(step.timeout_seconds ?? policy.execution.default_step_timeout_seconds);
-      const stepLogPath = path.join(
-        logDirectory,
-        `${Date.now()}-${mode}-${step.name.replaceAll(/[^a-zA-Z0-9_-]/g, '_')}.log`
-      );
-
-      let attempts = 0;
-      let lastResult: CommandResult = { code: 1, signal: null, stdout: '', stderr: '', timeout: false };
-      const maxAttempts = retryPolicy.transient_max_retries + 1;
-
-      while (attempts < maxAttempts) {
-        attempts += 1;
-        const result = await runCommand(step.cmd[0], step.cmd.slice(1), {
-          cwd: step.cwd ? path.join(worktreePath, step.cwd) : worktreePath,
-          env: { ...env, ...step.env },
-          timeoutMs: timeoutSeconds * 1000
+    const hasParallelConfig = modeSteps.some((s) => s.parallel_group || s.depends_on?.length);
+
+    if (hasParallelConfig) {
+      const waves = buildExecutionWaves(modeSteps);
+      const completedSteps = new Set<string>();
+      const failedSteps = new Set<string>();
+
+      for (const wave of waves) {
+        const runnableSteps = wave.filter((step) => {
+          if (!step.depends_on?.length) {
+            return true;
+          }
+          return step.depends_on.every((dep) => completedSteps.has(dep) && !failedSteps.has(dep));
         });
 
-        lastResult = result;
-        const logText = [
-          `# feature=${featureId} mode=${mode} step=${step.name} attempt=${attempts}`,
-          `# cmd=${JSON.stringify(step.cmd)}`,
-          `# exit=${result.code} timeout=${result.timeout}`,
-          '',
-          '## stdout',
-          result.stdout,
-          '',
-          '## stderr',
-          result.stderr
-        ].join('\n');
-        await fs.writeFile(stepLogPath, `${logText}\n`, 'utf8');
-
-        if (result.timeout || result.code === 0) {
-          break;
+        const skippedSteps = wave.filter((step) => !runnableSteps.includes(step));
+        for (const step of skippedSteps) {
+          failedSteps.add(step.name);
+          stepResults.push({
+            name: step.name,
+            cmd: step.cmd,
+            attempts: 0,
+            exit_code: -1,
+            timeout: false,
+            skipped: true,
+            skip_reason: 'dependency_failed',
+            parallel_group: step.parallel_group,
+            started_at: nowIso(),
+            finished_at: nowIso()
+          });
         }
 
-        const isTransient = retryPolicy.transient_error_codes.includes(result.code);
-        if (!isTransient) {
-          break;
+        const results = await Promise.allSettled(
+          runnableSteps.map(async (step) => {
+            const startedAt = nowIso();
+            const stepResult = await this.executeStep(step, {
+              featureId,
+              mode,
+              policy,
+              env,
+              worktreePath,
+              logDirectory
+            });
+            stepResult['parallel_group'] = step.parallel_group;
+            stepResult['started_at'] = startedAt;
+            stepResult['finished_at'] = nowIso();
+            return stepResult;
+          })
+        );
+
+        for (const result of results) {
+          if (result.status === 'fulfilled') {
+            const val = result.value;
+            stepResults.push(val);
+            if (val['exit_code'] === 0 && !val['timeout']) {
+              completedSteps.add(val['name'] as string);
+            } else {
+              overall = 'fail';
+              failedSteps.add(val['name'] as string);
+            }
+          }
         }
       }
+    } else {
+      for (const step of modeSteps) {
+        const startedAt = nowIso();
+        const result = await this.executeStep(step, {
+          featureId,
+          mode,
+          policy,
+          env,
+          worktreePath,
+          logDirectory
+        });
 
-      const stepState = {
-        name: step.name,
-        cmd: step.cmd,
-        attempts,
-        exit_code: lastResult.code,
-        timeout: lastResult.timeout,
-        log_path: stepLogPath
-      };
-
-      stepResults.push(stepState);
+        stepResults.push({ ...result, started_at: startedAt, finished_at: nowIso() });
 
-      if (lastResult.timeout || lastResult.code !== 0) {
-        overall = 'fail';
-        break;
+        if (result.timeout || result.exit_code !== 0) {
+          overall = 'fail';
+          break;
+        }
       }
     }
 

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

@@ -9,6 +9,12 @@ 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 { AopPathLayout, ensureAopRuntimeLayout } from './path-layout.js';
+import {
+  applyWorktreeSymlinks,
+  formatWorkspaceHookWarning,
+  runWorktreePostCreate,
+  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';
@@ -24,6 +30,15 @@ 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 { CostTrackingService } from '../application/services/cost-tracking-service.js';
+import { PerformanceAnalyticsService, type FeatureOutcome } from '../application/services/performance-analytics-service.js';
+import {
+  ACTIVITY_DETECTOR_SLOT,
+  NOTIFICATION_CHANNEL_SLOT,
+  SCM_PROVIDER_SLOT,
+  globalAdapterRegistry
+} from '../application/adapters/adapter-registry.js';
+import type { WorkerProvider } from '../providers/providers.js';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type AnyRecord = Record<string, any>;
@@ -33,6 +48,13 @@ interface KernelContext {
   actor_id?: string;
 }
 
+interface KernelConfigOverrides {
+  policyPath?: string;
+  gatesPath?: string;
+  agentsPath?: string;
+  adaptersPath?: string;
+}
+
 export interface AgentsRoleConfig {
   system_prompt_path?: string;
 }
@@ -91,6 +113,7 @@ export class AopKernel {
   gatesConfig: AnyRecord;
   policy: PolicyConfigSnapshot;
   agentsConfig: AgentsConfigSnapshot;
+  adaptersConfig: Record<string, unknown>;
   toolRegistry: AnyRecord | null;
   toolHandlers: ToolHandlerRegistry;
   toolRouter: ToolRouter;
@@ -106,16 +129,24 @@ export class AopKernel {
   private readonly qaIndexService: QaIndexService;
   private readonly mergeService: MergeService;
   private readonly featureDeletionService: FeatureDeletionService;
+  private readonly costTrackingService: CostTrackingService;
+  private readonly performanceAnalyticsService: PerformanceAnalyticsService;
   private readonly pathLayout: AopPathLayout;
+  readonly instanceId: string;
+  private provider: WorkerProvider | null = null;
+  private readonly configOverrides: KernelConfigOverrides;
 
-  constructor(repoRoot: string) {
+  constructor(repoRoot: string, instanceId = 'default', configOverrides: KernelConfigOverrides = {}) {
     this.repoRoot = repoRoot;
+    this.instanceId = instanceId;
+    this.configOverrides = configOverrides;
     this.pathLayout = new AopPathLayout(repoRoot);
     this.schemaRegistry = new SchemaRegistry(repoRoot);
     this.loaded = false;
     this.gatesConfig = {};
     this.policy = {};
     this.agentsConfig = {};
+    this.adaptersConfig = {};
     this.toolRegistry = null;
     this.toolHandlers = new ToolHandlerRegistry();
     this.registerToolHandlers();
@@ -131,6 +162,8 @@ export class AopKernel {
     this.qaIndexService = new QaIndexService(this);
     this.mergeService = new MergeService(this);
     this.featureDeletionService = new FeatureDeletionService(this);
+    this.costTrackingService = new CostTrackingService(this);
+    this.performanceAnalyticsService = new PerformanceAnalyticsService(this);
     this.toolRouter = new ToolRouter(this.toolHandlers, (toolName) =>
       Promise.resolve(
         fail(ERROR_CODES.INVALID_ARGUMENT, `Unknown tool ${toolName}`, {
@@ -145,6 +178,10 @@ export class AopKernel {
     return this.repoRoot;
   }
 
+  setProvider(provider: WorkerProvider): void {
+    this.provider = provider;
+  }
+
   getAgentsConfig(): AgentsConfigSnapshot {
     return this.agentsConfig;
   }
@@ -153,6 +190,10 @@ export class AopKernel {
     return this.policy.rbac ?? {};
   }
 
+  getAdaptersConfig(): Record<string, unknown> {
+    return this.adaptersConfig;
+  }
+
   getPolicySnapshot(): AnyRecord {
     return this.policy;
   }
@@ -276,6 +317,7 @@ export class AopKernel {
       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'),
+      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)
     };
@@ -292,9 +334,10 @@ export class AopKernel {
   async load() {
     await ensureAopRuntimeLayout(this.pathLayout);
 
-    const gatesPath = path.join(this.orchestratorDir, 'gates.yaml');
-    const policyPath = path.join(this.orchestratorDir, 'policy.yaml');
-    const agentsPath = path.join(this.orchestratorDir, 'agents.yaml');
+    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 gates = await loadAndValidateYaml(this.schemaRegistry, 'gates.schema.json', gatesPath);
     if (!gates.validation.valid) {
@@ -326,9 +369,44 @@ 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);
+      if (!adapters.validation.valid) {
+        throw new Error(`invalid_adapters_yaml:${JSON.stringify(adapters.validation.errors)}`);
+      }
+      const parsedAdapters = readObjectField(adapters, 'parsed');
+      const notificationChannel = readStringField(parsedAdapters, NOTIFICATION_CHANNEL_SLOT.name);
+      if (notificationChannel) {
+        try {
+          globalAdapterRegistry.resolve(NOTIFICATION_CHANNEL_SLOT, notificationChannel, {});
+        } catch {
+          throw new Error(`adapter_not_found:${NOTIFICATION_CHANNEL_SLOT.name}:${notificationChannel}`);
+        }
+      }
+      const activityDetector = readStringField(parsedAdapters, ACTIVITY_DETECTOR_SLOT.name);
+      if (activityDetector) {
+        try {
+          globalAdapterRegistry.resolve(ACTIVITY_DETECTOR_SLOT, activityDetector, {});
+        } catch {
+          throw new Error(`adapter_not_found:${ACTIVITY_DETECTOR_SLOT.name}:${activityDetector}`);
+        }
+      }
+      const scmProvider = readStringField(parsedAdapters, SCM_PROVIDER_SLOT.name);
+      if (scmProvider) {
+        try {
+          globalAdapterRegistry.resolve(SCM_PROVIDER_SLOT, scmProvider, {});
+        } catch {
+          throw new Error(`adapter_not_found:${SCM_PROVIDER_SLOT.name}:${scmProvider}`);
+        }
+      }
+    }
+
     this.gatesConfig = gates.parsed;
     this.policy = parsedPolicy;
     this.agentsConfig = agents.parsed as AgentsConfigSnapshot;
+    this.adaptersConfig = readObjectField(adapters, 'parsed');
     const registryLoader = new ToolRegistryLoader(this.repoRoot);
     this.toolRegistry = await registryLoader.load();
     this.loaded = true;
@@ -530,6 +608,25 @@ export class AopKernel {
     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.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.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'))
+    );
   }
 
   featurePath(featureId) {
@@ -548,6 +645,14 @@ export class AopKernel {
     return this.pathLayout.planPath(featureId);
   }
 
+  featureCostPath(featureId: string): string {
+    return this.pathLayout.featureCostPath(featureId);
+  }
+
+  analyticsPath(): string {
+    return path.join(this.pathLayout.runtimeRoot, 'analytics', 'performance.json');
+  }
+
   qaIndexPath(featureId) {
     return this.pathLayout.qaIndexPath(featureId);
   }
@@ -681,8 +786,27 @@ export class AopKernel {
   }
 
   async getRuntimeSessions(): Promise<RuntimeSessionsSnapshot> {
+    return this.normalizeRuntimeSessions(await this.readRunLease());
+  }
+
+  async readRunLease(): Promise<RuntimeSessionsSnapshot> {
+    const runLeasePath = this.pathLayout.runLeaseFilePath(this.instanceId);
+    const existing = await readJson(runLeasePath, null);
+    if (existing !== null) {
+      return this.normalizeRuntimeSessions(existing);
+    }
+    // Migration: fall back to index.json runtime_sessions for existing repos
     const index = await this.readIndex();
-    return this.normalizeRuntimeSessions(index.runtime_sessions);
+    if (index.runtime_sessions && index.runtime_sessions.run_id !== 'none') {
+      return this.normalizeRuntimeSessions(index.runtime_sessions);
+    }
+    return this.emptyRuntimeSessions();
+  }
+
+  async writeRunLease(data: RuntimeSessionsSnapshot): Promise<void> {
+    const runLeasePath = this.pathLayout.runLeaseFilePath(this.instanceId);
+    await ensureDir(path.dirname(runLeasePath));
+    await atomicWriteJson(runLeasePath, data);
   }
 
   async acquireRunLease(input: AcquireRunLeaseInput): Promise<{ data: { runtime_sessions: RuntimeSessionsSnapshot; took_over_stale: boolean; reused_existing_owner: boolean } }> {
@@ -846,6 +970,29 @@ export class AopKernel {
       };
     }
 
+    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);
+    }
+
+    if (worktreeConfig?.post_create?.length) {
+      await runWorktreePostCreate(worktree, worktreeConfig.post_create, collectHookWarning);
+    }
+
+    for (const warning of hookWarnings) {
+      // Preserve non-fatal behavior while making hook failures observable.
+      console.warn(`[aop] workspace hook warning: ${formatWorkspaceHookWarning(warning)}`);
+    }
+
     return {
       data: {
         feature_id: featureId,
@@ -1059,6 +1206,134 @@ export class AopKernel {
   async recoverFromState() {
     return await this.lockService.recoverFromState();
   }
+
+  private async waitForSessionToBecomeActive(sessionId: string): Promise<void> {
+    if (!this.provider?.getSessionInfo) {
+      return;
+    }
+
+    const timeoutMs = 5000;
+    const pollIntervalMs = 250;
+    const deadline = Date.now() + timeoutMs;
+
+    while (Date.now() <= deadline) {
+      const sessionInfo = await this.provider.getSessionInfo(sessionId).catch(() => null);
+      if (sessionInfo?.active) {
+        return;
+      }
+      await new Promise<void>((resolve) => {
+        setTimeout(resolve, pollIntervalMs);
+      });
+    }
+  }
+
+  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 }) };
+    }
+    if (!message) {
+      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' } } };
+    }
+
+    const state = await this.readState(featureId);
+    const status = typeof state.frontMatter.status === 'string' ? state.frontMatter.status : '';
+    const gates = readObjectField(state.frontMatter, 'gates');
+
+    let targetRole = 'orchestrator';
+    let targetSessionId = runtimeSessions.orchestrator_session_id;
+
+    if (status === STATUS.PLANNING) {
+      targetRole = 'planner';
+      targetSessionId = featureSession.planner_session_id;
+    } else if (status === STATUS.BUILDING) {
+      targetRole = 'builder';
+      targetSessionId = featureSession.builder_session_id;
+    } else if (status === STATUS.QA || status === STATUS.READY_TO_MERGE) {
+      targetRole = 'qa';
+      targetSessionId = featureSession.qa_session_id;
+    } else if (status === STATUS.BLOCKED) {
+      const fastGate = readStringField(gates, 'fast');
+      const fullGate = readStringField(gates, 'full');
+      if (fastGate === GATE_RESULT.FAIL && fullGate !== GATE_RESULT.FAIL) {
+        targetRole = 'builder';
+        targetSessionId = featureSession.builder_session_id;
+      } else {
+        targetRole = 'qa';
+        targetSessionId = featureSession.qa_session_id;
+      }
+    }
+
+    if (!targetSessionId || targetSessionId === 'unassigned' || targetSessionId === 'unknown') {
+      targetRole = 'orchestrator';
+      targetSessionId = runtimeSessions.orchestrator_session_id;
+    }
+
+    if (!this.provider?.sendMessage) {
+      throw { normalizedResponse: { ok: false, error: { code: 'provider_unsupported', message: 'Provider does not support sendMessage' } } };
+    }
+
+    await this.waitForSessionToBecomeActive(targetSessionId);
+    await this.provider.sendMessage(targetSessionId, message);
+    return {
+      feature_id: featureId,
+      session_id: targetSessionId,
+      target_role: targetRole,
+      status,
+      delivered: true
+    };
+  }
+
+  async costRecord(featureId: string, tokensDelta: number, costUsdDelta: number) {
+    const updated = await this.costTrackingService.recordCost(featureId, tokensDelta, costUsdDelta);
+    return { ok: true as const, data: updated };
+  }
+
+  async costGet(featureId: string) {
+    const cost = await this.costTrackingService.getFeatureCost(featureId);
+    return { ok: true as const, data: cost };
+  }
+
+  async checkBudget(featureId: string) {
+    return await this.costTrackingService.checkBudget(featureId);
+  }
+
+  async performanceRecordOutcome(args: AnyRecord) {
+    const outcome: FeatureOutcome = {
+      feature_id: typeof args.feature_id === 'string' ? args.feature_id : '',
+      provider: typeof args.provider === 'string' ? args.provider : '',
+      model: typeof args.model === 'string' ? args.model : '',
+      status: typeof args.status === 'string' ? args.status : '',
+      gate_pass: typeof args.gate_pass === 'boolean' ? args.gate_pass : false,
+      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()
+    };
+    const snapshot = await this.performanceAnalyticsService.recordOutcome(outcome);
+    return { ok: true as const, data: { total_outcomes: snapshot.outcomes.length } };
+  }
+
+  async performanceGetAnalytics(provider: string | null, model: string | null) {
+    if (provider || model) {
+      const stats = await this.performanceAnalyticsService.getProviderStats(
+        provider ?? 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 } };
+    }
+    const snapshot = await this.performanceAnalyticsService.getAnalytics();
+    return { ok: true as const, data: snapshot };
+  }
 }
 
 function normalizeRepoPathForState(repoRoot: string, absolutePath: string) {

package/apps/control-plane/src/core/path-layout.ts

@@ -29,6 +29,14 @@ export class AopPathLayout {
     return path.join(this.runtimeDataRoot, 'operation-ledger');
   }
 
+  runLeaseFilePath(instanceId: string): string {
+    return path.join(this.runtimeDataRoot, instanceId, 'run-lease.json');
+  }
+
+  runLeaseLockPath(instanceId: string): string {
+    return path.join(this.runtimeDataRoot, instanceId, '.run-lease.lock');
+  }
+
   get legacyFeaturesRoot(): string {
     return path.join(this.repoRoot, 'agentic', 'features');
   }
@@ -61,6 +69,10 @@ export class AopPathLayout {
     return path.join(this.featureRoot(featureId), 'plan.json');
   }
 
+  featureCostPath(featureId: string): string {
+    return path.join(this.featureRoot(featureId), 'cost.json');
+  }
+
   qaIndexPath(featureId: string): string {
     return path.join(this.featureRoot(featureId), 'qa_test_index.json');
   }