agentic-orchestrator 0.1.28 → 0.2.0

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

@@ -1,5 +1,11 @@
 import { nowIso, readJson } from '../../core/fs.js';
-import { detectPlanCollisions } from '../../core/collisions.js';
+import {
+  detectPlanCollisions,
+  hasContractCollisions,
+  splitPlanCollisionsByFeature,
+  type PlanCollisionsShape,
+} from '../../core/collisions.js';
+import { asPlanRecord, recoverStalePlanSubmitConflict } from '../../core/plan-submit-recovery.js';
 import { sortResourcesDeterministically } from '../../core/path-rules.js';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -37,6 +43,15 @@ interface QueueEntry {
   plan_snapshot?: AnyRecord;
 }
 
+function queueEntryKey(entry: QueueEntry): string {
+  return [
+    entry.feature_id,
+    String(entry.plan_version),
+    entry.detected_at,
+    entry.collision_fingerprint,
+  ].join('::');
+}
+
 export interface CollisionQueueServicePort {
   getPolicySnapshot(): AnyRecord;
   planPath(featureId: string): string;
@@ -57,6 +72,12 @@ export interface CollisionQueueServicePort {
     plan: AnyRecord,
     expectedVersion: number | null,
   ): Promise<{ data: { feature_id: string; accepted: boolean; plan_version: number } }>;
+  planGet(featureId: string): Promise<{ data: { feature_id: string; plan: unknown } }>;
+  planUpdate(
+    featureId: string,
+    expectedPlanVersion: number | null,
+    plan: AnyRecord,
+  ): Promise<{ data: { feature_id: string | null; accepted: boolean; plan_version: number } }>;
 }
 
 /**
@@ -99,9 +120,11 @@ export class CollisionQueueService {
 
   async collectAcceptedPlans(excludeFeatureId: string | null = null): Promise<AnyRecord[]> {
     const specs = await this.port.featureDiscoverSpecs();
+    const index = await this.port.readIndex();
+    const merged = new Set(asArray<string>(index.merged));
     const plans: AnyRecord[] = [];
     for (const item of specs.data.specs) {
-      if (item.feature_id === excludeFeatureId) {
+      if (item.feature_id === excludeFeatureId || merged.has(item.feature_id)) {
         continue;
       }
       const plan = await readJson(this.port.planPath(item.feature_id), null);
@@ -138,7 +161,7 @@ export class CollisionQueueService {
   async checkPlanCollision(
     featureId: string,
     plan: AnyRecord,
-  ): Promise<{ hasCollisions: boolean; fingerprint?: string }> {
+  ): Promise<{ hasCollisions: boolean; fingerprint?: string; approved: boolean }> {
     const policy = this.port.getPolicySnapshot();
     const acceptedPlans = await this.collectAcceptedPlans(featureId);
     const collisionResult = detectPlanCollisions(
@@ -150,9 +173,49 @@ export class CollisionQueueService {
     return {
       hasCollisions: collisionResult.hasCollisions,
       fingerprint: collisionResult.fingerprint,
+      approved: collisionResult.hasCollisions
+        ? await this.hasApprovedOverrides(featureId, collisionResult.collisions)
+        : false,
     };
   }
 
+  private async hasApprovedOverrides(
+    featureId: string,
+    collisions: PlanCollisionsShape,
+  ): Promise<boolean> {
+    if (hasContractCollisions(collisions)) {
+      return false;
+    }
+
+    const index = await this.port.readIndex();
+    const overrides = asArray<AnyRecord>(index.collision_overrides);
+    const pairs = splitPlanCollisionsByFeature(featureId, collisions);
+
+    return pairs.every((pair) => {
+      const featureIds = [featureId, pair.with_feature_id].sort((left, right) =>
+        left.localeCompare(right),
+      );
+      return overrides.some((entry) => {
+        const overrideFeatureIds = asArray<string>(entry.feature_ids).filter(
+          (item): item is string => typeof item === 'string',
+        );
+        const status = typeof entry.status === 'string' ? entry.status : 'unknown';
+        const fingerprint =
+          typeof entry.approved_collision_fingerprint === 'string'
+            ? entry.approved_collision_fingerprint
+            : null;
+
+        return (
+          overrideFeatureIds.length === 2 &&
+          overrideFeatureIds[0] === featureIds[0] &&
+          overrideFeatureIds[1] === featureIds[1] &&
+          (status === 'active' || status === 'applied') &&
+          fingerprint === pair.fingerprint
+        );
+      });
+    });
+  }
+
   async processSingleQueueEntry(entry: QueueEntry): Promise<{ retried: boolean; reason?: string }> {
     const persistedPlan = await readJson(this.port.planPath(entry.feature_id), null);
     const snapshotPlan =
@@ -175,7 +238,7 @@ export class CollisionQueueService {
     }
 
     const collision = await this.checkPlanCollision(entry.feature_id, plan);
-    if (collision.hasCollisions) {
+    if (collision.hasCollisions && !collision.approved) {
       return { retried: false, reason: 'collision_still_present' };
     }
 
@@ -183,7 +246,25 @@ export class CollisionQueueService {
       const expectedVersion = Number.isInteger(plan.revision_of) ? Number(plan.revision_of) : null;
       await this.port.planSubmit(entry.feature_id, plan, expectedVersion);
       return { retried: true };
-    } catch (_error) {
+    } catch (error) {
+      const recovered = await recoverStalePlanSubmitConflict({
+        error,
+        featureId: entry.feature_id,
+        submittedPlan: asPlanRecord(plan),
+        readAcceptedPlan: async (featureId) => (await this.port.planGet(featureId)).data.plan,
+        submitPlanUpdate: async (featureId, expectedPlanVersion, nextPlan) =>
+          await this.port.planUpdate(featureId, expectedPlanVersion, nextPlan as AnyRecord),
+        buildEquivalentSuccess: (featureId, currentPlanVersion) => ({
+          data: {
+            feature_id: featureId,
+            accepted: true,
+            plan_version: currentPlanVersion,
+          },
+        }),
+      });
+      if (recovered) {
+        return { retried: true };
+      }
       return { retried: false, reason: 'plan_submit_failed' };
     }
   }
@@ -214,51 +295,61 @@ export class CollisionQueueService {
       };
     }
 
-    return await this.port.withIndexLock(async () => {
+    const queue = await this.port.withIndexLock(async () => {
       const index = await this.port.readIndex();
-      const queue: QueueEntry[] = asArray<QueueEntry>(index.blocked_queue);
+      return asArray<QueueEntry>(index.blocked_queue);
+    });
 
-      if (queue.length === 0) {
-        return {
-          data: {
-            processed: 0,
-            retried: 0,
-            still_blocked: 0,
-          },
-        };
-      }
+    if (queue.length === 0) {
+      return {
+        data: {
+          processed: 0,
+          retried: 0,
+          still_blocked: 0,
+        },
+      };
+    }
 
-      const sortedQueue = [...queue].sort(
-        (a, b) =>
-          a.detected_at.localeCompare(b.detected_at) || a.feature_id.localeCompare(b.feature_id),
-      );
+    const sortedQueue = [...queue].sort(
+      (a, b) =>
+        a.detected_at.localeCompare(b.detected_at) || a.feature_id.localeCompare(b.feature_id),
+    );
 
-      const stillBlocked: QueueEntry[] = [];
-      let retriedCount = 0;
+    const stillBlocked: QueueEntry[] = [];
+    let retriedCount = 0;
 
-      for (const entry of sortedQueue) {
-        const result = await this.processSingleQueueEntry(entry);
-        if (result.retried) {
-          retriedCount += 1;
-        } else {
-          stillBlocked.push(entry);
-        }
+    for (const entry of sortedQueue) {
+      const result = await this.processSingleQueueEntry(entry);
+      if (result.retried) {
+        retriedCount += 1;
+      } else {
+        stillBlocked.push(entry);
       }
+    }
 
+    await this.port.withIndexLock(async () => {
       const currentIndex = await this.port.readIndex();
-      currentIndex.blocked_queue = stillBlocked;
+      const currentQueue = asArray<QueueEntry>(currentIndex.blocked_queue);
+      const processedKeys = new Set(sortedQueue.map((entry) => queueEntryKey(entry)));
+      const untouchedEntries = currentQueue.filter(
+        (entry) => !processedKeys.has(queueEntryKey(entry)),
+      );
+      currentIndex.blocked_queue = [...untouchedEntries, ...stillBlocked].sort(
+        (a, b) =>
+          a.detected_at.localeCompare(b.detected_at) || a.feature_id.localeCompare(b.feature_id),
+      );
       currentIndex.version += 1;
       currentIndex.updated_at = nowIso();
       await this.port.writeIndex(currentIndex);
-
-      return {
-        data: {
-          processed: sortedQueue.length,
-          retried: retriedCount,
-          still_blocked: stillBlocked.length,
-        },
-      };
     });
+
+    return {
+      data: {
+        processed: sortedQueue.length,
+        retried: retriedCount,
+        still_blocked: stillBlocked.length,
+      },
+    };
   }
 
   /**

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

@@ -1,4 +1,10 @@
 import { atomicWriteJson, nowIso, readJson } from '../../core/fs.js';
+import type {
+  NormalizedUsageRecord,
+  RoleUsageBreakdown,
+  UsageAvailability,
+} from '../usage-types.js';
+import { aggregateAvailability } from '../usage-types.js';
 
 /**
  * @fileoverview Cost tracking and budget enforcement service.
@@ -9,6 +15,8 @@ export interface FeatureCost {
   tokens_used: number;
   estimated_cost_usd: number;
   last_updated: string;
+  by_role?: RoleUsageBreakdown[];
+  aggregate_status?: UsageAvailability;
 }
 
 export interface BudgetPolicy {
@@ -126,6 +134,92 @@ export class CostTrackingService {
     return updated;
   }
 
+  /**
+   * Records per-role usage with availability status.
+   *
+   * Appends to the by_role breakdown and updates the aggregate totals.
+   * Only tokens with reported or estimated status contribute to totals;
+   * unavailable usage is never recorded as zero.
+   */
+  async recordRoleUsage(
+    featureId: string,
+    usageRecord: NormalizedUsageRecord,
+  ): Promise<FeatureCost> {
+    const current = await this.getFeatureCost(featureId);
+    const existingByRole = current.by_role ?? [];
+
+    const existingRoleEntry = existingByRole.find(
+      (entry) =>
+        entry.role === usageRecord.role &&
+        entry.provider === usageRecord.provider &&
+        entry.model === usageRecord.model,
+    );
+
+    if (existingRoleEntry) {
+      if (usageRecord.status !== 'unavailable') {
+        existingRoleEntry.input_tokens =
+          (existingRoleEntry.input_tokens ?? 0) + (usageRecord.input_tokens ?? 0);
+        existingRoleEntry.output_tokens =
+          (existingRoleEntry.output_tokens ?? 0) + (usageRecord.output_tokens ?? 0);
+        existingRoleEntry.total_tokens =
+          (existingRoleEntry.total_tokens ?? 0) + (usageRecord.total_tokens ?? 0);
+        existingRoleEntry.estimated_cost_usd =
+          (existingRoleEntry.estimated_cost_usd ?? 0) + (usageRecord.estimated_cost_usd ?? 0);
+      }
+      existingRoleEntry.invocation_count += 1;
+      if (usageRecord.status === 'unavailable' && existingRoleEntry.status === 'reported') {
+        // Degrade to unavailable if any invocation is unavailable
+        existingRoleEntry.status = 'unavailable';
+      }
+    } else {
+      existingByRole.push({
+        role: usageRecord.role,
+        provider: usageRecord.provider,
+        model: usageRecord.model,
+        status: usageRecord.status,
+        input_tokens: usageRecord.input_tokens,
+        output_tokens: usageRecord.output_tokens,
+        total_tokens: usageRecord.total_tokens,
+        estimated_cost_usd: usageRecord.estimated_cost_usd,
+        invocation_count: 1,
+      });
+    }
+
+    // Recalculate aggregates from by_role
+    let totalTokens = 0;
+    let totalCostUsd = 0;
+    for (const entry of existingByRole) {
+      if (entry.total_tokens !== null) {
+        totalTokens += entry.total_tokens;
+      }
+      if (entry.estimated_cost_usd !== null) {
+        totalCostUsd += entry.estimated_cost_usd;
+      }
+    }
+
+    const updated: FeatureCost = {
+      feature_id: featureId,
+      tokens_used: totalTokens,
+      estimated_cost_usd: totalCostUsd,
+      last_updated: nowIso(),
+      by_role: existingByRole,
+      aggregate_status: aggregateAvailability(
+        existingByRole.map((entry) => ({
+          status: entry.status,
+          input_tokens: entry.input_tokens,
+          output_tokens: entry.output_tokens,
+          total_tokens: entry.total_tokens,
+          provider: entry.provider,
+          model: entry.model,
+          role: entry.role,
+          estimated_cost_usd: entry.estimated_cost_usd,
+        })),
+      ),
+    };
+    await atomicWriteJson(this.port.featureCostPath(featureId), updated);
+    return updated;
+  }
+
   /**
    * Checks if feature is within budget limits.
    *