agentic-orchestrator 0.1.6 → 0.1.8

package/apps/control-plane/scripts/validate-docker-mcp-contract.mjs

@@ -44,12 +44,16 @@ if (nodeMajor < MIN_NODE_MAJOR) {
   fail(`Dockerfile Node version ${nodeMajor} is below minimum required ${MIN_NODE_MAJOR}`);
 }
 
-assertContains(dockerfile, /apt-get install[^]*\bgit\b/m, 'docker image must include git toolchain');
+assertContains(
+  dockerfile,
+  /apt-get install[^]*\bgit\b/m,
+  'docker image must include git toolchain',
+);
 assertContains(dockerfile, /ENV\s+AOP_REPO_ROOT=\/repo/m, 'docker image must declare /repo root');
 assertContains(
   dockerfile,
   /ENTRYPOINT\s+\["\/bin\/sh",\s*"\/app\/docker\/mcp\.entrypoint\.sh"]/m,
-  'docker entrypoint must enforce runtime preflight checks'
+  'docker entrypoint must enforce runtime preflight checks',
 );
 
 assertContains(compose, /aop-mcp:/m, 'compose must declare aop-mcp service');
@@ -57,7 +61,11 @@ assertContains(compose, /- \.\.\/:\/repo/m, 'compose must bind-mount repository
 assertContains(compose, /working_dir:\s*\/repo/m, 'compose service must execute from /repo');
 
 assertContains(entrypoint, /if \[ ! -d "\/repo" ]/m, 'entrypoint must enforce /repo mount check');
-assertContains(entrypoint, /for tool in node npm npx git;/m, 'entrypoint must verify required toolchains');
+assertContains(
+  entrypoint,
+  /for tool in node npm npx git;/m,
+  'entrypoint must verify required toolchains',
+);
 assertContains(entrypoint, /\bexec\s+"\$@"/, 'entrypoint must contain exec "$@" passthrough');
 
 if (!runSmoke) {
@@ -66,7 +74,7 @@ if (!runSmoke) {
 
 const config = spawnSync('docker', ['compose', '-f', composePath, 'config'], {
   cwd: repoRoot,
-  stdio: 'inherit'
+  stdio: 'inherit',
 });
 if (config.status !== 0) {
   fail('docker compose config validation failed');
@@ -74,7 +82,7 @@ if (config.status !== 0) {
 
 const build = spawnSync('docker', ['compose', '-f', composePath, 'build', 'aop-mcp'], {
   cwd: repoRoot,
-  stdio: 'inherit'
+  stdio: 'inherit',
 });
 if (build.status !== 0) {
   fail('docker compose build smoke check failed');
@@ -82,11 +90,25 @@ if (build.status !== 0) {
 
 const smoke = spawnSync(
   'docker',
-  ['compose', '-f', composePath, 'run', '--rm', 'aop-mcp', 'npm', 'run', 'run', '--', 'status', '--transport', 'mcp'],
+  [
+    'compose',
+    '-f',
+    composePath,
+    'run',
+    '--rm',
+    'aop-mcp',
+    'npm',
+    'run',
+    'run',
+    '--',
+    'status',
+    '--transport',
+    'mcp',
+  ],
   {
     cwd: repoRoot,
-    stdio: 'inherit'
-  }
+    stdio: 'inherit',
+  },
 );
 if (smoke.status !== 0) {
   fail('docker compose run smoke check failed');

package/apps/control-plane/scripts/validate-mcp-contracts.ts

@@ -13,7 +13,7 @@ const KNOWN_ROLES = new Set(['orchestrator', 'planner', 'builder', 'qa', 'system
 const KNOWN_SHARED_SCHEMAS = new Set([
   'schemas/input/mutating.schema.json',
   'schemas/input/read.schema.json',
-  'schemas/output/standard_success.schema.json'
+  'schemas/output/standard_success.schema.json',
 ]);
 
 function fail(message: string): never {
@@ -40,14 +40,18 @@ async function main(): Promise<void> {
 
   if (protocol.mcp_protocol_version !== MCP_PROTOCOL_PIN.mcp_protocol_version) {
     fail(
-      `protocol_version_pin_mismatch expected=${MCP_PROTOCOL_PIN.mcp_protocol_version} actual=${protocol.mcp_protocol_version}`
+      `protocol_version_pin_mismatch expected=${MCP_PROTOCOL_PIN.mcp_protocol_version} actual=${protocol.mcp_protocol_version}`,
     );
   }
   if (protocol.sdk.package !== MCP_PROTOCOL_PIN.sdk.package) {
-    fail(`protocol_sdk_package_pin_mismatch expected=${MCP_PROTOCOL_PIN.sdk.package} actual=${protocol.sdk.package}`);
+    fail(
+      `protocol_sdk_package_pin_mismatch expected=${MCP_PROTOCOL_PIN.sdk.package} actual=${protocol.sdk.package}`,
+    );
   }
   if (protocol.sdk.version !== MCP_PROTOCOL_PIN.sdk.version) {
-    fail(`protocol_sdk_version_pin_mismatch expected=${MCP_PROTOCOL_PIN.sdk.version} actual=${protocol.sdk.version}`);
+    fail(
+      `protocol_sdk_version_pin_mismatch expected=${MCP_PROTOCOL_PIN.sdk.version} actual=${protocol.sdk.version}`,
+    );
   }
 
   for (const transport of REQUIRED_MCP_TRANSPORTS) {
@@ -90,7 +94,7 @@ async function main(): Promise<void> {
     const mutatingInCode = TOOL_BEHAVIOR_METADATA[tool.handler_id]?.mutating === true;
     if (mutatingInCatalog !== mutatingInCode) {
       errors.push(
-        `Tool "${tool.handler_id}" mutating flag mismatch: catalog=${String(mutatingInCatalog)}, code=${String(mutatingInCode)}`
+        `Tool "${tool.handler_id}" mutating flag mismatch: catalog=${String(mutatingInCatalog)}, code=${String(mutatingInCode)}`,
       );
     }
 
@@ -103,7 +107,9 @@ async function main(): Promise<void> {
 
     // V1.2: AJV schema compilation + V1.3: orphan tracking
     for (const schemaRef of [tool.input_schema_ref, tool.output_schema_ref]) {
-      if (!schemaRef) { continue; }
+      if (!schemaRef) {
+        continue;
+      }
       referencedSchemas.add(schemaRef);
       const schemaPath = path.resolve(toolsDir, schemaRef);
       try {
@@ -122,7 +128,7 @@ async function main(): Promise<void> {
   // V1.3: orphan schema detection
   const allSchemaFiles = [
     ...globSchemaFiles(path.join(toolsDir, 'schemas', 'input'), 'schemas/input'),
-    ...globSchemaFiles(path.join(toolsDir, 'schemas', 'output'), 'schemas/output')
+    ...globSchemaFiles(path.join(toolsDir, 'schemas', 'output'), 'schemas/output'),
   ];
   for (const file of allSchemaFiles) {
     if (!referencedSchemas.has(file) && !KNOWN_SHARED_SCHEMAS.has(file)) {

package/apps/control-plane/src/application/adapters/adapter-registry.ts

@@ -12,7 +12,11 @@ export interface AdapterManifest {
 }
 
 export interface AdapterRegistry {
-  register<T>(slot: AdapterSlot<T>, manifest: AdapterManifest, factory: (config: unknown) => T): void;
+  register<T>(
+    slot: AdapterSlot<T>,
+    manifest: AdapterManifest,
+    factory: (config: unknown) => T,
+  ): void;
   resolve<T>(slot: AdapterSlot<T>, name: string, config: unknown): T;
   list(slot: string): ReadonlyArray<AdapterManifest>;
   has(slot: string, name: string): boolean;
@@ -28,7 +32,11 @@ export interface AdapterRegistryError extends Error {
   details?: Record<string, unknown>;
 }
 
-function makeRegistryError(message: string, code: string, details?: Record<string, unknown>): AdapterRegistryError {
+function makeRegistryError(
+  message: string,
+  code: string,
+  details?: Record<string, unknown>,
+): AdapterRegistryError {
   const error = new Error(message) as AdapterRegistryError;
   error.code = code;
   if (details !== undefined) {
@@ -41,12 +49,17 @@ export class DefaultAdapterRegistry implements AdapterRegistry {
   // slot name → adapter name → entry
   private readonly _entries = new Map<string, Map<string, AdapterEntry<unknown>>>();
 
-  register<T>(slot: AdapterSlot<T>, manifest: AdapterManifest, factory: (config: unknown) => T): void {
+  register<T>(
+    slot: AdapterSlot<T>,
+    manifest: AdapterManifest,
+    factory: (config: unknown) => T,
+  ): void {
     let byName = this._entries.get(slot.name);
     if (!byName) {
       byName = new Map();
       this._entries.set(slot.name, byName);
-    }    byName.set(manifest.name, { manifest, factory: factory as (config: unknown) => unknown });
+    }
+    byName.set(manifest.name, { manifest, factory: factory as (config: unknown) => unknown });
   }
 
   resolve<T>(slot: AdapterSlot<T>, name: string, config: unknown): T {
@@ -57,7 +70,7 @@ export class DefaultAdapterRegistry implements AdapterRegistry {
       throw makeRegistryError(
         ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER,
         ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER,
-        { slot: slot.name, name }
+        { slot: slot.name, name },
       );
     }
 
@@ -84,7 +97,7 @@ export interface AgentProviderContract {
 }
 
 export const AGENT_PROVIDER_SLOT: AdapterSlot<AgentProviderContract> = {
-  name: 'agent-provider'
+  name: 'agent-provider',
 };
 
 // ---- Activity detector slot ----
@@ -94,7 +107,7 @@ export interface ActivityDetectorContract {
 }
 
 export const ACTIVITY_DETECTOR_SLOT: AdapterSlot<ActivityDetectorContract> = {
-  name: 'activity-detector'
+  name: 'activity-detector',
 };
 
 // ---- Notification channel slot ----
@@ -104,7 +117,7 @@ export interface NotificationChannelContract {
 }
 
 export const NOTIFICATION_CHANNEL_SLOT: AdapterSlot<NotificationChannelContract> = {
-  name: 'notification-channel'
+  name: 'notification-channel',
 };
 
 // ---- SCM provider slot ----
@@ -114,10 +127,17 @@ export interface ScmProviderContract {
 }
 
 export const SCM_PROVIDER_SLOT: AdapterSlot<ScmProviderContract> = {
-  name: 'scm-provider'
+  name: 'scm-provider',
 };
 
-const BUILT_IN_PROVIDER_NAMES = ['codex', 'claude', 'gemini', 'kiro-cli', 'copilot', 'custom'] as const;
+const BUILT_IN_PROVIDER_NAMES = [
+  'codex',
+  'claude',
+  'gemini',
+  'kiro-cli',
+  'copilot',
+  'custom',
+] as const;
 const BUILT_IN_ACTIVITY_DETECTORS = ['claude-jsonl', 'codex-rpc', 'process-heuristic'] as const;
 const BUILT_IN_NOTIFICATION_CHANNELS = ['desktop', 'slack', 'webhook'] as const;
 const BUILT_IN_SCM_PROVIDERS = ['github'] as const;
@@ -136,7 +156,7 @@ for (const providerName of BUILT_IN_PROVIDER_NAMES) {
   globalAdapterRegistry.register(
     AGENT_PROVIDER_SLOT,
     makeProviderManifest(providerName),
-    makeProviderFactory(providerName)
+    makeProviderFactory(providerName),
   );
 }
 
@@ -144,7 +164,7 @@ for (const detectorName of BUILT_IN_ACTIVITY_DETECTORS) {
   globalAdapterRegistry.register(
     ACTIVITY_DETECTOR_SLOT,
     { slot: ACTIVITY_DETECTOR_SLOT.name, name: detectorName },
-    () => ({ name: detectorName })
+    () => ({ name: detectorName }),
   );
 }
 
@@ -152,7 +172,7 @@ for (const channelName of BUILT_IN_NOTIFICATION_CHANNELS) {
   globalAdapterRegistry.register(
     NOTIFICATION_CHANNEL_SLOT,
     { slot: NOTIFICATION_CHANNEL_SLOT.name, name: channelName },
-    () => ({ name: channelName })
+    () => ({ name: channelName }),
   );
 }
 
@@ -160,10 +180,10 @@ for (const scmProviderName of BUILT_IN_SCM_PROVIDERS) {
   globalAdapterRegistry.register(
     SCM_PROVIDER_SLOT,
     { slot: SCM_PROVIDER_SLOT.name, name: scmProviderName },
-    () => ({ name: scmProviderName })
+    () => ({ name: scmProviderName }),
   );
 }
 
 export const REGISTERED_PROVIDER_NAMES: ReadonlySet<string> = new Set(
-  globalAdapterRegistry.list(AGENT_PROVIDER_SLOT.name).map((m) => m.name)
+  globalAdapterRegistry.list(AGENT_PROVIDER_SLOT.name).map((m) => m.name),
 );

package/apps/control-plane/src/application/multi-project-loader.ts

@@ -32,6 +32,8 @@ export interface MultiProjectConfig {
 
 const MULTI_PROJECT_YAML = 'multi-project.yaml';
 const SCHEMA_NAME = 'multi-project.schema.json';
+const PRIMARY_MULTI_PROJECT_DIR = ['config', 'agentic', 'orchestrator'] as const;
+const LEGACY_MULTI_PROJECT_DIR = ['agentic', 'orchestrator'] as const;
 
 function resolveHomePath(rawPath: string): string {
   if (rawPath.startsWith('~/') || rawPath === '~') {
@@ -50,13 +52,18 @@ function resolveConfiguredPath(rawPath: string, baseDir: string): string {
 
 export class MultiProjectLoader {
   async load(baseDir: string): Promise<MultiProjectConfig | null> {
-    const yamlPath = path.join(baseDir, 'agentic', 'orchestrator', MULTI_PROJECT_YAML);
+    const primaryYamlPath = path.join(baseDir, ...PRIMARY_MULTI_PROJECT_DIR, MULTI_PROJECT_YAML);
+    const legacyYamlPath = path.join(baseDir, ...LEGACY_MULTI_PROJECT_DIR, MULTI_PROJECT_YAML);
 
     let raw: string;
     try {
-      raw = await fs.readFile(yamlPath, 'utf8');
+      raw = await fs.readFile(primaryYamlPath, 'utf8');
     } catch {
-      return null;
+      try {
+        raw = await fs.readFile(legacyYamlPath, 'utf8');
+      } catch {
+        return null;
+      }
     }
 
     const parsed = YAML.parse(raw) as MultiProjectConfig;
@@ -65,13 +72,13 @@ export class MultiProjectLoader {
     const result = await schemaRegistry.validate(SCHEMA_NAME, parsed);
     if (!result.valid) {
       const error = new Error(
-        `multi-project.yaml validation failed: ${result.errors.map((e) => e.message).join(', ')}`
+        `multi-project.yaml validation failed: ${result.errors.map((e) => e.message).join(', ')}`,
       ) as AppError;
       error.code = ERROR_CODES.INVALID_ARGUMENT;
       error.details = {
         retryable: false,
         requires_human: true,
-        validation_errors: result.errors
+        validation_errors: result.errors,
       };
       throw error;
     }
@@ -80,8 +87,14 @@ export class MultiProjectLoader {
     const projects: ProjectConfig[] = parsed.projects.map((p) => ({
       ...p,
       path: resolveConfiguredPath(p.path, baseDir),
-      policy: typeof p.policy === 'string' ? resolveConfiguredPath(p.policy, resolveConfiguredPath(p.path, baseDir)) : undefined,
-      gates: typeof p.gates === 'string' ? resolveConfiguredPath(p.gates, resolveConfiguredPath(p.path, baseDir)) : undefined
+      policy:
+        typeof p.policy === 'string'
+          ? resolveConfiguredPath(p.policy, resolveConfiguredPath(p.path, baseDir))
+          : undefined,
+      gates:
+        typeof p.gates === 'string'
+          ? resolveConfiguredPath(p.gates, resolveConfiguredPath(p.path, baseDir))
+          : undefined,
     }));
 
     return { ...parsed, projects };
@@ -108,12 +121,16 @@ export class MultiProjectLoader {
   }
 
   async exists(baseDir: string): Promise<boolean> {
-    const yamlPath = path.join(baseDir, 'agentic', 'orchestrator', MULTI_PROJECT_YAML);
     try {
-      await fs.access(yamlPath);
+      await fs.access(path.join(baseDir, ...PRIMARY_MULTI_PROJECT_DIR, MULTI_PROJECT_YAML));
       return true;
     } catch {
-      return false;
+      try {
+        await fs.access(path.join(baseDir, ...LEGACY_MULTI_PROJECT_DIR, MULTI_PROJECT_YAML));
+        return true;
+      } catch {
+        return false;
+      }
     }
   }
 }

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

@@ -1,5 +1,9 @@
 import { TOOLS } from '../../core/constants.js';
-import type { FeatureStateFrontMatter, FeatureStatePayload, ToolCaller as SupervisorToolCaller } from '../../core/tool-caller.js';
+import type {
+  FeatureStateFrontMatter,
+  FeatureStatePayload,
+  ToolCaller as SupervisorToolCaller,
+} from '../../core/tool-caller.js';
 import type { NotifierService } from './notifier-service.js';
 
 export type ActivityState = 'active' | 'idle' | 'waiting_input' | 'blocked' | 'exited' | 'unknown';
@@ -40,7 +44,9 @@ const DEFAULT_IDLE_THRESHOLD_MS = 300_000;
 
 export class ActivityMonitorService {
   private readonly toolCaller: SupervisorToolCaller;
-  private readonly operationLedger: { getLastOperationAt(featureId: string): string | null } | undefined;
+  private readonly operationLedger:
+    | { getLastOperationAt(featureId: string): string | null }
+    | undefined;
   private readonly idleThresholdMs: number;
   private readonly notifier: NotifierService | undefined;
   private readonly reactionsPolicy: { agent_stuck?: AgentStuckReaction } | undefined;
@@ -66,7 +72,8 @@ export class ActivityMonitorService {
   }
 
   private resolveLastEvent(featureId: string, frontMatter: ActivityFrontMatter): string | null {
-    const statusReason = typeof frontMatter.status_reason === 'string' ? frontMatter.status_reason.toLowerCase() : '';
+    const statusReason =
+      typeof frontMatter.status_reason === 'string' ? frontMatter.status_reason.toLowerCase() : '';
     if (statusReason.includes('waiting_input') || statusReason.includes('awaiting_input')) {
       return frontMatter.last_heartbeat_at ?? frontMatter.last_run_at ?? null;
     }
@@ -85,7 +92,8 @@ export class ActivityMonitorService {
 
   private deriveState(frontMatter: ActivityFrontMatter, lastEventAt: string | null): ActivityState {
     const status = frontMatter.status;
-    const statusReason = typeof frontMatter.status_reason === 'string' ? frontMatter.status_reason.toLowerCase() : '';
+    const statusReason =
+      typeof frontMatter.status_reason === 'string' ? frontMatter.status_reason.toLowerCase() : '';
 
     if (status === 'failed' || status === 'merged') {
       return 'exited';
@@ -106,9 +114,13 @@ export class ActivityMonitorService {
 
   private async persistSnapshot(featureId: string, snapshot: ActivitySnapshot): Promise<void> {
     try {
-      const current = await this.toolCaller.callTool<FeatureStatePayload>('orchestrator', TOOLS.FEATURE_STATE_GET, {
-        feature_id: featureId
-      });
+      const current = await this.toolCaller.callTool<FeatureStatePayload>(
+        'orchestrator',
+        TOOLS.FEATURE_STATE_GET,
+        {
+          feature_id: featureId,
+        },
+      );
       const frontMatter = current.data.front_matter as ActivityFrontMatter & {
         version: number;
         activity_state?: string;
@@ -131,9 +143,9 @@ export class ActivityMonitorService {
             activity_state: snapshot.state,
             activity_last_event_at: snapshot.lastEventAt,
             activity_detected_via: snapshot.detectedVia,
-            activity_detector: this.detectorName
-          }
-        }
+            activity_detector: this.detectorName,
+          },
+        },
       });
     } catch {
       // Activity persistence is best-effort and should not block orchestration.
@@ -144,7 +156,7 @@ export class ActivityMonitorService {
     const response = await this.toolCaller.callTool<FeatureStatePayload>(
       'orchestrator',
       TOOLS.FEATURE_STATE_GET,
-      { feature_id: featureId }
+      { feature_id: featureId },
     );
 
     const frontMatter = response.data.front_matter as ActivityFrontMatter;
@@ -153,7 +165,7 @@ export class ActivityMonitorService {
       featureId,
       state: this.deriveState(frontMatter, lastEventAt),
       lastEventAt,
-      detectedVia: this.detectedVia(featureId)
+      detectedVia: this.detectedVia(featureId),
     };
   }
 
@@ -177,8 +189,8 @@ export class ActivityMonitorService {
         details: {
           state: snapshot.state,
           last_event_at: snapshot.lastEventAt,
-          idle_threshold_ms: this.idleThresholdMs
-        }
+          idle_threshold_ms: this.idleThresholdMs,
+        },
       });
     }
 

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

@@ -11,7 +11,7 @@ type StateReadResult = {
 
 type StateUpdater = (
   frontMatter: AnyRecord,
-  body: string
+  body: string,
 ) => Promise<{ frontMatter?: AnyRecord; body?: string }>;
 
 function asArray<T = unknown>(value: unknown): T[] {
@@ -47,8 +47,16 @@ export interface CollisionQueueServicePort {
   withIndexLock<T>(operation: () => Promise<T>): Promise<T>;
   readIndex(): Promise<AnyRecord>;
   writeIndex(index: AnyRecord): Promise<void>;
-  updateState(featureId: string, expectedVersion: number | null, updater: StateUpdater): Promise<AnyRecord>;
-  planSubmit(featureId: string, plan: AnyRecord, expectedVersion: number | null): Promise<{ data: { feature_id: string; accepted: boolean; plan_version: number } }>;
+  updateState(
+    featureId: string,
+    expectedVersion: number | null,
+    updater: StateUpdater,
+  ): Promise<AnyRecord>;
+  planSubmit(
+    featureId: string,
+    plan: AnyRecord,
+    expectedVersion: number | null,
+  ): Promise<{ data: { feature_id: string; accepted: boolean; plan_version: number } }>;
 }
 
 export class CollisionQueueService {
@@ -96,18 +104,21 @@ export class CollisionQueueService {
     return missing.length === 0;
   }
 
-  async checkPlanCollision(featureId: string, plan: AnyRecord): Promise<{ hasCollisions: boolean; fingerprint?: string }> {
+  async checkPlanCollision(
+    featureId: string,
+    plan: AnyRecord,
+  ): Promise<{ hasCollisions: boolean; fingerprint?: string }> {
     const policy = this.port.getPolicySnapshot();
     const acceptedPlans = await this.collectAcceptedPlans(featureId);
     const collisionResult = detectPlanCollisions(
       plan as Parameters<typeof detectPlanCollisions>[0],
       acceptedPlans as Parameters<typeof detectPlanCollisions>[1],
-      policy as Parameters<typeof detectPlanCollisions>[2]
+      policy as Parameters<typeof detectPlanCollisions>[2],
     );
 
     return {
       hasCollisions: collisionResult.hasCollisions,
-      fingerprint: collisionResult.fingerprint
+      fingerprint: collisionResult.fingerprint,
     };
   }
 
@@ -146,35 +157,38 @@ export class CollisionQueueService {
     }
   }
 
-  async reDriveBlockedQueue(): Promise<{ data: { processed: number; retried: number; still_blocked: number } }> {
+  async reDriveBlockedQueue(): Promise<{
+    data: { processed: number; retried: number; still_blocked: number };
+  }> {
     const policy = this.port.getPolicySnapshot();
-    
+
     if (policy.collision_policy !== 'block') {
       return {
         data: {
           processed: 0,
           retried: 0,
-          still_blocked: 0
-        }
+          still_blocked: 0,
+        },
       };
     }
 
     return await this.port.withIndexLock(async () => {
       const index = await this.port.readIndex();
       const queue: QueueEntry[] = asArray<QueueEntry>(index.blocked_queue);
-      
+
       if (queue.length === 0) {
         return {
           data: {
             processed: 0,
             retried: 0,
-            still_blocked: 0
-          }
+            still_blocked: 0,
+          },
         };
       }
 
       const sortedQueue = [...queue].sort(
-        (a, b) => a.detected_at.localeCompare(b.detected_at) || a.feature_id.localeCompare(b.feature_id)
+        (a, b) =>
+          a.detected_at.localeCompare(b.detected_at) || a.feature_id.localeCompare(b.feature_id),
       );
 
       const stillBlocked: QueueEntry[] = [];
@@ -199,8 +213,8 @@ export class CollisionQueueService {
         data: {
           processed: sortedQueue.length,
           retried: retriedCount,
-          still_blocked: stillBlocked.length
-        }
+          still_blocked: stillBlocked.length,
+        },
       };
     });
   }
@@ -211,7 +225,7 @@ export class CollisionQueueService {
       const queue: QueueEntry[] = asArray<QueueEntry>(index.blocked_queue);
       const before = queue.length;
       const filtered = queue.filter((entry) => entry.feature_id !== featureId);
-      
+
       if (filtered.length === before) {
         return { data: { removed: false } };
       }

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

@@ -34,21 +34,27 @@ export class CostTrackingService {
 
   async getFeatureCost(featureId: string): Promise<FeatureCost> {
     const existing = await readJson<FeatureCost>(this.port.featureCostPath(featureId), null);
-    return existing ?? {
-      feature_id: featureId,
-      tokens_used: 0,
-      estimated_cost_usd: 0.0,
-      last_updated: nowIso()
-    };
+    return (
+      existing ?? {
+        feature_id: featureId,
+        tokens_used: 0,
+        estimated_cost_usd: 0.0,
+        last_updated: nowIso(),
+      }
+    );
   }
 
-  async recordCost(featureId: string, tokensDelta: number, costUsdDelta: number): Promise<FeatureCost> {
+  async recordCost(
+    featureId: string,
+    tokensDelta: number,
+    costUsdDelta: number,
+  ): Promise<FeatureCost> {
     const current = await this.getFeatureCost(featureId);
     const updated: FeatureCost = {
       feature_id: featureId,
       tokens_used: current.tokens_used + tokensDelta,
       estimated_cost_usd: current.estimated_cost_usd + costUsdDelta,
-      last_updated: nowIso()
+      last_updated: nowIso(),
     };
     await atomicWriteJson(this.port.featureCostPath(featureId), updated);
     return updated;
@@ -60,23 +66,24 @@ export class CostTrackingService {
       policy.budget && typeof policy.budget === 'object' ? policy.budget : {}
     ) as BudgetPolicy;
 
-    const limitUsd = typeof budgetPolicy.per_feature_limit_usd === 'number'
-      ? budgetPolicy.per_feature_limit_usd
-      : Infinity;
-    const alertThreshold = typeof budgetPolicy.alert_threshold === 'number'
-      ? budgetPolicy.alert_threshold
-      : 0.8;
+    const limitUsd =
+      typeof budgetPolicy.per_feature_limit_usd === 'number'
+        ? budgetPolicy.per_feature_limit_usd
+        : Infinity;
+    const alertThreshold =
+      typeof budgetPolicy.alert_threshold === 'number' ? budgetPolicy.alert_threshold : 0.8;
 
     const cost = await this.getFeatureCost(featureId);
     const overBudget = Number.isFinite(limitUsd) && cost.estimated_cost_usd >= limitUsd;
-    const alertThresholdReached = Number.isFinite(limitUsd) && cost.estimated_cost_usd >= limitUsd * alertThreshold;
+    const alertThresholdReached =
+      Number.isFinite(limitUsd) && cost.estimated_cost_usd >= limitUsd * alertThreshold;
 
     return {
       over_budget: overBudget,
       alert_threshold_reached: alertThresholdReached,
       current_cost_usd: cost.estimated_cost_usd,
       limit_usd: Number.isFinite(limitUsd) ? limitUsd : -1,
-      alert_threshold: alertThreshold
+      alert_threshold: alertThreshold,
     };
   }
 }