agentic-orchestrator 0.1.2 → 0.1.4

package/apps/control-plane/src/application/services/pr-monitor-service.ts

@@ -0,0 +1,262 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { TOOLS } from '../../core/constants.js';
+import type { FeatureStatePayload, ToolCaller as SupervisorToolCaller } from '../../core/tool-caller.js';
+import type { NotifierService } from './notifier-service.js';
+
+const execFileAsync = promisify(execFile);
+
+export type CiStatus = 'passing' | 'failing' | 'pending' | 'none';
+export type ReviewDecision = 'approved' | 'changes_requested' | 'pending' | 'none';
+
+export interface PrInfo {
+  number: number;
+  url: string;
+  ci_status: CiStatus;
+  review_decision: ReviewDecision;
+  merge_ready: boolean;
+  pending_review_threads: number;
+  has_conflicts: boolean;
+  merge_score: number;
+}
+
+export interface ChangesRequestedPolicy {
+  enabled: boolean;
+  action: string;
+  escalate_after: number;
+}
+
+export type GhRunner = (args: string[]) => Promise<{ stdout: string; exitCode: number }>;
+
+export function createGhRunner(fn?: GhRunner): GhRunner {
+  if (fn !== undefined) {
+    return fn;
+  }
+  return async (args: string[]) => {
+    try {
+      const { stdout } = await execFileAsync('gh', args, { timeout: 15_000 });
+      return { stdout, exitCode: 0 };
+    } catch (err: unknown) {
+      const e = err as Record<string, unknown>;
+      if (e['code'] === 'ENOENT' || e['code'] === 127) {
+        return { stdout: '', exitCode: 127 };
+      }
+      const exitCode = typeof e['code'] === 'number' ? e['code'] : 1;
+      return { stdout: '', exitCode };
+    }
+  };
+}
+
+export interface PrMonitorServiceDependencies {
+  toolCaller: SupervisorToolCaller;
+  notifier?: NotifierService;
+  reactionsPolicy?: { changes_requested?: ChangesRequestedPolicy };
+  ghRunner?: GhRunner;
+}
+
+interface GhPrViewResult {
+  number: number;
+  url: string;
+  statusCheckRollup: Array<{ state: string }> | null;
+  reviewDecision: string | null;
+  mergeable: string;
+  reviewThreads: Array<{ isResolved: boolean }> | null;
+}
+
+interface GhReviewsResult {
+  reviews: Array<{ body: string; state: string }>;
+}
+
+function mapCiStatus(checks: Array<{ state: string }> | null | undefined): CiStatus {
+  if (!checks || checks.length === 0) {
+    return 'none';
+  }
+  const upper = checks.map((c) => c.state.toUpperCase());
+  if (upper.some((s) => s === 'FAILURE' || s === 'ERROR')) {
+    return 'failing';
+  }
+  if (upper.some((s) => s === 'PENDING' || s === 'IN_PROGRESS' || s === 'EXPECTED' || s === 'WAITING')) {
+    return 'pending';
+  }
+  return 'passing';
+}
+
+function mapReviewDecision(decision: string | null | undefined): ReviewDecision {
+  if (!decision) {
+    return 'none';
+  }
+  switch (decision.toUpperCase()) {
+    case 'APPROVED':
+      return 'approved';
+    case 'CHANGES_REQUESTED':
+      return 'changes_requested';
+    case 'REVIEW_REQUIRED':
+      return 'pending';
+    default:
+      return 'none';
+  }
+}
+
+export class PrMonitorService {
+  private readonly toolCaller: SupervisorToolCaller;
+  private readonly notifier: NotifierService | undefined;
+  private readonly reactionsPolicy: { changes_requested?: ChangesRequestedPolicy } | undefined;
+  private readonly ghRunner: GhRunner;
+
+  constructor(dependencies: PrMonitorServiceDependencies) {
+    this.toolCaller = dependencies.toolCaller;
+    this.notifier = dependencies.notifier;
+    this.reactionsPolicy = dependencies.reactionsPolicy;
+    this.ghRunner = dependencies.ghRunner ?? createGhRunner();
+  }
+
+  async detectPr(featureId: string, branch: string): Promise<PrInfo | null> {
+    const candidates = [...new Set([branch, featureId, `feature/${featureId}`].map((value) => value.trim()).filter(Boolean))];
+    let parsed: GhPrViewResult | null = null;
+    for (const candidate of candidates) {
+      const result = await this.ghRunner([
+        'pr', 'view', '--head', candidate,
+        '--json', 'number,url,statusCheckRollup,reviewDecision,mergeable,reviewThreads'
+      ]);
+
+      if (result.exitCode !== 0 || !result.stdout.trim()) {
+        continue;
+      }
+
+      try {
+        const maybeParsed = JSON.parse(result.stdout) as GhPrViewResult;
+        if (maybeParsed.number) {
+          parsed = maybeParsed;
+          break;
+        }
+      } catch {
+        // Try the next candidate branch.
+      }
+    }
+
+    if (!parsed?.number) {
+      return null;
+    }
+
+    const ci_status = mapCiStatus(parsed.statusCheckRollup);
+    const review_decision = mapReviewDecision(parsed.reviewDecision);
+    const has_conflicts = parsed.mergeable === 'CONFLICTING';
+    const merge_ready =
+      parsed.mergeable === 'MERGEABLE' && ci_status === 'passing' && review_decision === 'approved';
+    const pending_review_threads = parsed.reviewThreads?.filter((t) => !t.isResolved).length ?? 0;
+
+    const partial: Omit<PrInfo, 'merge_score'> = {
+      number: parsed.number,
+      url: parsed.url,
+      ci_status,
+      review_decision,
+      merge_ready,
+      pending_review_threads,
+      has_conflicts
+    };
+    const merge_score = this.computeMergeScore({ ...partial, merge_score: 0 });
+    return { ...partial, merge_score };
+  }
+
+  async storePrState(featureId: string, prInfo: PrInfo): Promise<void> {
+    const current = await this.toolCaller.callTool<FeatureStatePayload>(
+      'orchestrator',
+      TOOLS.FEATURE_STATE_GET,
+      { feature_id: featureId }
+    );
+
+    await this.toolCaller.callTool('orchestrator', TOOLS.FEATURE_STATE_PATCH, {
+      feature_id: featureId,
+      expected_version: current.data.front_matter.version,
+      patch: {
+        front_matter: {
+          pr: {
+            number: prInfo.number,
+            url: prInfo.url,
+            ci_status: prInfo.ci_status,
+            review_decision: prInfo.review_decision,
+            merge_ready: prInfo.merge_ready,
+            pending_review_threads: prInfo.pending_review_threads,
+            has_conflicts: prInfo.has_conflicts,
+            merge_score: prInfo.merge_score
+          }
+        }
+      }
+    });
+  }
+
+  computeMergeScore(prInfo: PrInfo): number {
+    let score = 0;
+    if (prInfo.ci_status === 'passing') {
+      score += 40;
+    }
+    if (prInfo.review_decision === 'approved') {
+      score += 40;
+    }
+    if (!prInfo.has_conflicts) {
+      score += 15;
+    }
+    if (prInfo.pending_review_threads === 0) {
+      score += 5;
+    }
+    return score;
+  }
+
+  async handleChangesRequested(featureId: string, prInfo: PrInfo): Promise<void> {
+    const reaction = this.reactionsPolicy?.changes_requested;
+    if (!reaction?.enabled) {
+      return;
+    }
+    if (reaction.action !== 'send_review_context_to_agent') {
+      return;
+    }
+
+    const reviewResult = await this.ghRunner(['pr', 'view', String(prInfo.number), '--json', 'reviews']);
+
+    let reviewBody = '';
+    if (reviewResult.exitCode === 0 && reviewResult.stdout.trim()) {
+      try {
+        const parsed = JSON.parse(reviewResult.stdout) as GhReviewsResult;
+        const lastReview = parsed.reviews?.[parsed.reviews.length - 1];
+        reviewBody = lastReview?.body ?? '';
+      } catch {
+        // ignore parse errors
+      }
+    }
+
+    await this.toolCaller.callTool('orchestrator', TOOLS.FEATURE_LOG_APPEND, {
+      feature_id: featureId,
+      note: `PR #${prInfo.number} changes requested. Review context:\n${reviewBody}`
+    });
+
+    await this.toolCaller
+      .callTool('orchestrator', TOOLS.FEATURE_SEND_MESSAGE, {
+        feature_id: featureId,
+        message: `PR review requested changes:\n${reviewBody || '(no review body provided)'}`,
+      })
+      .catch(() => undefined);
+
+    if (this.notifier) {
+      await this.notifier.notify('changes_requested', {
+        feature_id: featureId,
+        message: `PR #${prInfo.number} has changes requested for feature '${featureId}'.`,
+        details: { pr_number: prInfo.number, pr_url: prInfo.url }
+      });
+    }
+  }
+
+  async checkAndUpdate(featureId: string, branch: string): Promise<PrInfo | null> {
+    const prInfo = await this.detectPr(featureId, branch);
+    if (!prInfo) {
+      return null;
+    }
+
+    await this.storePrState(featureId, prInfo);
+
+    if (prInfo.review_decision === 'changes_requested') {
+      await this.handleChangesRequested(featureId, prInfo);
+    }
+
+    return prInfo;
+  }
+}

package/apps/control-plane/src/application/services/reactions-service.ts

@@ -0,0 +1,175 @@
+import { TOOLS } from '../../core/constants.js';
+import type { FeatureStatePayload, ToolCaller as SupervisorToolCaller } from '../../core/tool-caller.js';
+import type { NotifierService } from './notifier-service.js';
+
+export interface GateFailedReaction {
+  enabled: boolean;
+  max_retries: number;
+  action: 'retry_with_agent_repair' | 'notify_only';
+  escalate_after: number;
+  retry_delay_ms: number;
+}
+
+export interface ReactionsPolicy {
+  gate_failed?: GateFailedReaction;
+  agent_stuck?: { enabled: boolean; action: string; idle_threshold_ms: number; escalate_after: number };
+  collision_detected?: { enabled: boolean; action: string };
+  ready_to_merge?: { enabled: boolean; action: string };
+  changes_requested?: { enabled: boolean; action: string; escalate_after: number };
+}
+
+export interface GateRepairContext {
+  featureId: string;
+  gateName: string;
+  exitCode: number;
+  logs: string;
+  evidenceSummary: string;
+  retryCount: number;
+  failureHistory?: Array<{
+    attempt: number;
+    gate_name: string;
+    exit_code: number;
+    evidence_summary: string;
+    logs_excerpt: string;
+    failed_at: string;
+    retry_delay_ms?: number;
+  }>;
+}
+
+export interface ReactionsServiceDependencies {
+  toolCaller: SupervisorToolCaller;
+  notifier?: NotifierService;
+  policy?: ReactionsPolicy;
+}
+
+const DEFAULT_GATE_FAILED_REACTION: GateFailedReaction = {
+  enabled: false,
+  max_retries: 2,
+  action: 'notify_only',
+  escalate_after: 2,
+  retry_delay_ms: 30000
+};
+
+export class ReactionsService {
+  private readonly toolCaller: SupervisorToolCaller;
+  private readonly notifier: NotifierService | undefined;
+  private readonly policy: ReactionsPolicy;
+
+  constructor(dependencies: ReactionsServiceDependencies) {
+    this.toolCaller = dependencies.toolCaller;
+    this.notifier = dependencies.notifier;
+    this.policy = dependencies.policy ?? {};
+  }
+
+  shouldRetry(_featureId: string, retryCount: number): boolean {
+    const reaction = this.policy.gate_failed ?? DEFAULT_GATE_FAILED_REACTION;
+    if (!reaction.enabled) {
+      return false;
+    }
+    if (reaction.action !== 'retry_with_agent_repair') {
+      return false;
+    }
+    return retryCount < reaction.max_retries;
+  }
+
+  retryDelayMs(): number {
+    const reaction = this.policy.gate_failed ?? DEFAULT_GATE_FAILED_REACTION;
+    if (typeof reaction.retry_delay_ms === 'number' && Number.isFinite(reaction.retry_delay_ms) && reaction.retry_delay_ms >= 0) {
+      return Math.floor(reaction.retry_delay_ms);
+    }
+    return DEFAULT_GATE_FAILED_REACTION.retry_delay_ms;
+  }
+
+  maxRetries(): number {
+    const reaction = this.policy.gate_failed ?? DEFAULT_GATE_FAILED_REACTION;
+    if (typeof reaction.max_retries === 'number' && Number.isFinite(reaction.max_retries) && reaction.max_retries >= 0) {
+      return Math.floor(reaction.max_retries);
+    }
+    return DEFAULT_GATE_FAILED_REACTION.max_retries;
+  }
+
+  async waitBeforeRetry(): Promise<void> {
+    const delayMs = this.retryDelayMs();
+    if (delayMs <= 0) {
+      return;
+    }
+    await new Promise<void>((resolve) => setTimeout(resolve, delayMs));
+  }
+
+  buildRepairPrompt(ctx: GateRepairContext): string {
+    const maxRetries = this.maxRetries();
+    const delayMs = this.retryDelayMs();
+    const failureSummary =
+      Array.isArray(ctx.failureHistory) && ctx.failureHistory.length > 0
+        ? ctx.failureHistory
+            .slice(-3)
+            .map(
+              (item) =>
+                `- attempt=${item.attempt}; gate=${item.gate_name}; exit=${item.exit_code}; at=${item.failed_at}; evidence=${item.evidence_summary || 'n/a'}`
+            )
+            .join('\n')
+        : '(none)';
+    return [
+      'Gate execution failed. Review the error logs below and apply fixes.',
+      '',
+      `Gate: ${ctx.gateName}`,
+      `Exit Code: ${ctx.exitCode}`,
+      '',
+      'Logs:',
+      ctx.logs,
+      '',
+      'Evidence:',
+      ctx.evidenceSummary,
+      '',
+      `Retry: ${ctx.retryCount + 1} of ${maxRetries}`
+      ,
+      `Retry delay (ms): ${delayMs}`,
+      '',
+      'Failure history (most recent first):',
+      failureSummary
+    ].join('\n');
+  }
+
+  async recordRetry(featureId: string, retryCount: number): Promise<void> {
+    const current = await this.toolCaller.callTool<FeatureStatePayload>(
+      'orchestrator',
+      TOOLS.FEATURE_STATE_GET,
+      { feature_id: featureId }
+    );
+    await this.toolCaller.callTool('orchestrator', TOOLS.FEATURE_STATE_PATCH, {
+      feature_id: featureId,
+      expected_version: current.data.front_matter.version,
+      patch: {
+        front_matter: {
+          gate_retry_count: retryCount,
+          last_retry_at: new Date().toISOString()
+        }
+      }
+    });
+  }
+
+  shouldEscalate(retryCount: number): boolean {
+    const reaction = this.policy.gate_failed ?? DEFAULT_GATE_FAILED_REACTION;
+    return retryCount >= reaction.escalate_after;
+  }
+
+  async notifyEscalation(featureId: string, ctx: GateRepairContext): Promise<void> {
+    if (!this.notifier) {
+      return;
+    }
+    await this.notifier.notify('gate_failed', {
+      feature_id: featureId,
+      message: `Gate '${ctx.gateName}' failed after ${ctx.retryCount} retries on feature '${featureId}'.`,
+      details: {
+        gate_name: ctx.gateName,
+        exit_code: ctx.exitCode,
+        retry_count: ctx.retryCount,
+        retry_delay_ms: this.retryDelayMs(),
+        max_retries: this.maxRetries(),
+        escalate_after: (this.policy.gate_failed ?? DEFAULT_GATE_FAILED_REACTION).escalate_after,
+        last_failure: ctx.failureHistory?.at(-1) ?? null,
+        failure_history: ctx.failureHistory ?? []
+      }
+    });
+  }
+}

package/apps/control-plane/src/application/services/reporting-service.ts

@@ -1,5 +1,5 @@
 import { detectPlanCollisions } from '../../core/collisions.js';
-import { pathExists, stableHash } from '../../core/fs.js';
+import { pathExists, readJson, stableHash } from '../../core/fs.js';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type AnyRecord = Record<string, any>;
@@ -23,6 +23,7 @@ export interface ReportingServicePort {
   getPolicySnapshot(): AnyRecord;
   readIndex(): Promise<AnyRecord>;
   statePath(featureId: string): string;
+  featureCostPath(featureId: string): string;
   readState(featureId: string): Promise<{ frontMatter: AnyRecord }>;
   featureStateGet(featureId: string): Promise<{ data: { front_matter: AnyRecord } }>;
   repoDiffBundle(featureId: string): Promise<{ data: AnyRecord }>;
@@ -83,13 +84,27 @@ export class ReportingService {
         continue;
       }
       const state = await this.port.readState(featureId);
+      const costData = await readJson<{ estimated_cost_usd: number; tokens_used: number }>(
+        this.port.featureCostPath(featureId), null
+      );
       features.push({
         feature_id: featureId,
         status: state.frontMatter.status,
+        branch:
+          typeof state.frontMatter.worktree_branch === 'string'
+            ? state.frontMatter.worktree_branch
+            : typeof state.frontMatter.branch === 'string'
+              ? state.frontMatter.branch
+              : null,
         locks: readHeldLocks(state.frontMatter),
         gate_profile: state.frontMatter.gate_profile,
         gates: state.frontMatter.gates,
-        last_updated: state.frontMatter.last_updated
+        pr: state.frontMatter.pr ?? null,
+        last_updated: state.frontMatter.last_updated,
+        activity_state: state.frontMatter.activity_state,
+        activity_last_event_at: state.frontMatter.activity_last_event_at,
+        activity_detected_via: state.frontMatter.activity_detected_via,
+        cost: costData ? { estimated_cost_usd: costData.estimated_cost_usd, tokens_used: costData.tokens_used } : null
       });
     }
 

package/apps/control-plane/src/application/services/run-lease-service.ts

@@ -36,6 +36,8 @@ export interface RunLeaseServicePort {
   withIndexLock<T>(operation: () => Promise<T>): Promise<T>;
   readIndex(): Promise<IndexSnapshot>;
   writeIndex(index: IndexSnapshot): Promise<void>;
+  readRunLease(): Promise<RuntimeSessionsSnapshot>;
+  writeRunLease(data: RuntimeSessionsSnapshot): Promise<void>;
   normalizeRuntimeSessions(value: unknown, at?: string): RuntimeSessionsSnapshot;
   isRunLeaseFresh(runtimeSessions: RuntimeSessionsSnapshot): boolean;
   emptyRuntimeSessions(at?: string): RuntimeSessionsSnapshot;
@@ -71,8 +73,7 @@ export class RunLeaseService {
         : stableHash('none');
 
     return await this.port.withIndexLock(async () => {
-      const index = await this.port.readIndex();
-      const current = this.port.normalizeRuntimeSessions(index.runtime_sessions);
+      const current = this.port.normalizeRuntimeSessions(await this.port.readRunLease());
       const hasLease = current.run_id !== 'none' && current.owner_instance_id !== 'none';
       const fresh = hasLease && this.port.isRunLeaseFresh(current);
       const sameOwner = current.run_id === input.run_id && current.owner_instance_id === input.owner_instance_id;
@@ -126,10 +127,7 @@ export class RunLeaseService {
         claimed.feature_sessions = {};
       }
 
-      index.runtime_sessions = claimed;
-      index.version += 1;
-      index.updated_at = nowIso();
-      await this.port.writeIndex(index);
+      await this.port.writeRunLease(claimed);
 
       return {
         data: {
@@ -153,8 +151,7 @@ export class RunLeaseService {
 
     const ttlMs = this.port.runLeaseTtlSeconds() * 1000;
     return await this.port.withIndexLock(async () => {
-      const index = await this.port.readIndex();
-      const current = this.port.normalizeRuntimeSessions(index.runtime_sessions);
+      const current = this.port.normalizeRuntimeSessions(await this.port.readRunLease());
       if (current.run_id !== runId || current.owner_instance_id !== ownerInstanceId) {
         throw {
           normalizedResponse: fail(ERROR_CODES.RUN_LEASE_NOT_OWNED, 'Cannot renew a run lease not owned by this instance', {
@@ -173,10 +170,7 @@ export class RunLeaseService {
         last_heartbeat_at: nowIso(),
         lease_expires_at: new Date(Date.now() + ttlMs).toISOString()
       };
-      index.runtime_sessions = updated;
-      index.version += 1;
-      index.updated_at = nowIso();
-      await this.port.writeIndex(index);
+      await this.port.writeRunLease(updated);
 
       return {
         data: {
@@ -188,16 +182,12 @@ export class RunLeaseService {
 
   async releaseRunLease(runId: string, ownerInstanceId: string): Promise<{ data: { released: boolean } }> {
     return await this.port.withIndexLock(async () => {
-      const index = await this.port.readIndex();
-      const current = this.port.normalizeRuntimeSessions(index.runtime_sessions);
+      const current = this.port.normalizeRuntimeSessions(await this.port.readRunLease());
       if (current.run_id !== runId || current.owner_instance_id !== ownerInstanceId) {
         return { data: { released: false } };
       }
 
-      index.runtime_sessions = this.port.emptyRuntimeSessions(nowIso());
-      index.version += 1;
-      index.updated_at = nowIso();
-      await this.port.writeIndex(index);
+      await this.port.writeRunLease(this.port.emptyRuntimeSessions(nowIso()));
       return { data: { released: true } };
     });
   }
@@ -219,8 +209,7 @@ export class RunLeaseService {
     }
 
     return await this.port.withIndexLock(async () => {
-      const index = await this.port.readIndex();
-      const current = this.port.normalizeRuntimeSessions(index.runtime_sessions);
+      const current = this.port.normalizeRuntimeSessions(await this.port.readRunLease());
       if (current.run_id !== run_id || current.owner_instance_id !== owner_instance_id) {
         throw {
           normalizedResponse: fail(ERROR_CODES.RUN_LEASE_NOT_OWNED, 'Cannot update orchestrator session without run ownership', {
@@ -242,10 +231,7 @@ export class RunLeaseService {
         orchestrator_session_id,
         orchestrator_epoch: nextEpoch
       };
-      index.runtime_sessions = updated;
-      index.version += 1;
-      index.updated_at = nowIso();
-      await this.port.writeIndex(index);
+      await this.port.writeRunLease(updated);
 
       return {
         data: {
@@ -259,8 +245,7 @@ export class RunLeaseService {
     const { run_id, owner_instance_id, feature_id, planner_session_id, builder_session_id, qa_session_id } = params;
 
     return await this.port.withIndexLock(async () => {
-      const index = await this.port.readIndex();
-      const current = this.port.normalizeRuntimeSessions(index.runtime_sessions);
+      const current = this.port.normalizeRuntimeSessions(await this.port.readRunLease());
       if (current.run_id !== run_id || current.owner_instance_id !== owner_instance_id) {
         throw {
           normalizedResponse: fail(ERROR_CODES.RUN_LEASE_NOT_OWNED, 'Cannot update feature sessions without run ownership', {
@@ -283,13 +268,10 @@ export class RunLeaseService {
         }
       };
 
-      index.runtime_sessions = {
+      await this.port.writeRunLease({
         ...current,
         feature_sessions: nextFeatureSessions
-      };
-      index.version += 1;
-      index.updated_at = nowIso();
-      await this.port.writeIndex(index);
+      });
       return { data: { updated: true } };
     });
   }
@@ -297,8 +279,7 @@ export class RunLeaseService {
   async pruneFeatureSessionAssignments(params: PruneFeatureSessionParams): Promise<{ data: { removed: string[] } }> {
     const active = new Set(params.active_feature_ids);
     return await this.port.withIndexLock(async () => {
-      const index = await this.port.readIndex();
-      const current = this.port.normalizeRuntimeSessions(index.runtime_sessions);
+      const current = this.port.normalizeRuntimeSessions(await this.port.readRunLease());
       if (current.run_id !== params.run_id || current.owner_instance_id !== params.owner_instance_id) {
         throw {
           normalizedResponse: fail(ERROR_CODES.RUN_LEASE_NOT_OWNED, 'Cannot prune feature sessions without run ownership', {
@@ -324,13 +305,10 @@ export class RunLeaseService {
       }
 
       if (removed.length > 0) {
-        index.runtime_sessions = {
+        await this.port.writeRunLease({
           ...current,
           feature_sessions: kept
-        };
-        index.version += 1;
-        index.updated_at = nowIso();
-        await this.port.writeIndex(index);
+        });
       }
 
       removed.sort((a, b) => a.localeCompare(b));

package/apps/control-plane/src/application/tools/tool-metadata.ts

@@ -18,7 +18,10 @@ const MUTATING_TOOLS = [
   TOOLS.LOCKS_ACQUIRE,
   TOOLS.LOCKS_RELEASE,
   TOOLS.FEATURE_READY_TO_MERGE,
-  TOOLS.FEATURE_DELETE
+  TOOLS.FEATURE_DELETE,
+  TOOLS.FEATURE_SEND_MESSAGE,
+  TOOLS.COST_RECORD,
+  TOOLS.PERFORMANCE_RECORD_OUTCOME
 ] as const;
 
 export const TOOL_BEHAVIOR_METADATA: Readonly<Record<string, ToolBehaviorMetadata>> = Object.freeze(

package/apps/control-plane/src/cli/aop.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env -S tsx
+#!/usr/bin/env node
 import { runCli } from '../interfaces/cli/bootstrap.js';
 import type { RuntimeContext } from './types.js';