agentic-orchestrator 0.1.2 → 0.1.4

package/apps/control-plane/test/run-coordinator.spec.ts

@@ -1,5 +1,5 @@
-import { describe, expect, it, vi } from 'vitest';
-import { TOOLS } from '../src/core/constants.js';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { STATUS, TOOLS } from '../src/core/constants.js';
 import { RunCoordinator } from '../src/supervisor/run-coordinator.js';
 
 describe('RunCoordinator iteration behavior', () => {
@@ -15,6 +15,9 @@ describe('RunCoordinator iteration behavior', () => {
         orchestrator_session_id: 'orch:test',
         feature_sessions: {}
       }))
+    ,
+      updateState: vi.fn(async () => ({})),
+      checkBudget: vi.fn(async () => ({ over_budget: false, alert_threshold_reached: false, current_cost_usd: 0, limit_usd: -1, alert_threshold: 0.8 }))
     };
 
     const provider = {
@@ -110,6 +113,9 @@ describe('RunCoordinator iteration behavior', () => {
         orchestrator_session_id: 'orch:test',
         feature_sessions: {}
       }))
+    ,
+      updateState: vi.fn(async () => ({})),
+      checkBudget: vi.fn(async () => ({ over_budget: false, alert_threshold_reached: false, current_cost_usd: 0, limit_usd: -1, alert_threshold: 0.8 }))
     };
 
     const provider = {
@@ -229,6 +235,9 @@ describe('RunCoordinator iteration behavior', () => {
         orchestrator_session_id: 'orch:test',
         feature_sessions: {}
       }))
+    ,
+      updateState: vi.fn(async () => ({})),
+      checkBudget: vi.fn(async () => ({ over_budget: false, alert_threshold_reached: false, current_cost_usd: 0, limit_usd: -1, alert_threshold: 0.8 }))
     };
 
     const provider = {
@@ -332,3 +341,473 @@ describe('RunCoordinator iteration behavior', () => {
     expect(planningWaveExecutor.run).toHaveBeenNthCalledWith(1, ['feature_b', 'feature_a']);
   });
 });
+
+describe('RunCoordinator notification and budget branches', () => {
+  beforeEach(() => { vi.clearAllMocks(); });
+
+  function makeCoordinatorDeps(opts: {
+    checkBudgetImpl?: () => Promise<{
+      over_budget: boolean;
+      alert_threshold_reached: boolean;
+      current_cost_usd: number;
+      limit_usd: number;
+      alert_threshold: number;
+    }>;
+    toolCallerImpl?: (role: string, toolName: string) => Promise<{ ok: boolean; data: unknown }>;
+    notifier?: { notify: ReturnType<typeof vi.fn> };
+    prMonitor?: { checkAndUpdate: ReturnType<typeof vi.fn> };
+    issueTracker?: {
+      getIssue: ReturnType<typeof vi.fn>;
+      addComment: ReturnType<typeof vi.fn>;
+      updateIssueStatus: ReturnType<typeof vi.fn>;
+    };
+    maxIterationsPerPhase?: number;
+    maxActiveFeatures?: number;
+  } = {}) {
+    const kernel = {
+      ensureLoaded: vi.fn(async () => undefined),
+      recoverFromState: vi.fn(async () => ({ data: { recovered: true } })),
+      acquireRunLease: vi.fn(async () => ({ data: { took_over_stale: false } })),
+      pruneFeatureSessionAssignments: vi.fn(async () => ({ data: { removed: [] as string[] } })),
+      getRuntimeSessions: vi.fn(async () => ({
+        run_id: 'run:test',
+        owner_instance_id: 'owner:test',
+        orchestrator_session_id: 'orch:test',
+        feature_sessions: {}
+      })),
+      updateState: vi.fn(async () => ({})),
+      checkBudget: opts.checkBudgetImpl
+        ? vi.fn(opts.checkBudgetImpl)
+        : vi.fn(async () => ({
+            over_budget: false,
+            alert_threshold_reached: false,
+            current_cost_usd: 0,
+            limit_usd: -1,
+            alert_threshold: 0.8
+          }))
+    };
+
+    const state = {
+      runId: 'run:test',
+      ownerInstanceId: 'owner:test',
+      orchestratorSessionId: 'orch:test',
+      sessionsByFeature: new Map<string, { planner: string; builder: string; qa: string }>(),
+      queue: [] as Array<{ feature_id: string }>,
+      runMetadata: {}
+    };
+
+    const defaultToolCallerImpl = async (_role: string, toolName: string) => {
+      if (toolName === TOOLS.REPORT_DASHBOARD) {
+        return { ok: true, data: { features: [] } };
+      }
+      return { ok: true, data: { front_matter: { status: STATUS.PLANNING } } };
+    };
+
+    const toolCaller = {
+      callTool: opts.toolCallerImpl
+        ? vi.fn(opts.toolCallerImpl)
+        : vi.fn(defaultToolCallerImpl)
+    };
+
+    const sessionOrchestrator = {
+      ensureGlobalOrchestratorSession: vi.fn(async () => undefined),
+      cleanupOrphanWorkerSessions: vi.fn(async () => undefined),
+      initializeFeatureCluster: vi.fn(async () => undefined),
+      closeFeatureCluster: vi.fn(async () => undefined),
+      reconcileQueuedFeatures: vi.fn(async () => undefined),
+      enforceActiveFeatureInvariant: vi.fn(async () => undefined)
+    };
+
+    const planningWaveExecutor = {
+      run: vi.fn(async () => undefined),
+      runPostQaReconciliation: vi.fn(async () => undefined)
+    };
+    const buildWaveExecutor = { run: vi.fn(async () => undefined) };
+    const qaWaveExecutor = { run: vi.fn(async () => undefined) };
+    const leaseHeartbeatService = { renew: vi.fn(async () => undefined) };
+    const provider = { selection: { provider: 'test', model: 'test-model' } };
+
+    const coordinator = new RunCoordinator({
+      kernel: kernel as never,
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+      state: state as never,
+      sessionOrchestrator: sessionOrchestrator as never,
+      planningWaveExecutor: planningWaveExecutor as never,
+      buildWaveExecutor: buildWaveExecutor as never,
+      qaWaveExecutor: qaWaveExecutor as never,
+      leaseHeartbeatService: leaseHeartbeatService as never,
+      maxActiveFeatures: opts.maxActiveFeatures ?? 5,
+      maxParallelGateRuns: 2,
+      maxIterationsPerPhase: opts.maxIterationsPerPhase ?? 1,
+      takeoverStaleRun: false,
+      providerConfigRefHash: () => 'hash',
+      notifier: opts.notifier as never,
+      prMonitor: opts.prMonitor as never,
+      issueTracker: opts.issueTracker as never
+    });
+
+    return { coordinator, kernel, toolCaller, sessionOrchestrator };
+  }
+
+  it('GIVEN_over_budget_feature_WHEN_pauseOverBudgetFeatures_runs_THEN_feature_removed_and_state_updated', async () => {
+    const { coordinator, kernel, sessionOrchestrator } = makeCoordinatorDeps({
+      checkBudgetImpl: async () => ({
+        over_budget: true,
+        alert_threshold_reached: false,
+        current_cost_usd: 5.5,
+        limit_usd: 5.0,
+        alert_threshold: 0.8
+      })
+    });
+
+    await coordinator.start([{ feature_id: 'feature_x' }]);
+
+    expect(kernel.updateState).toHaveBeenCalledWith('feature_x', null, expect.any(Function));
+    const updateStateCall = kernel.updateState.mock.calls[0] as unknown[] | undefined;
+    expect(updateStateCall).toBeDefined();
+    const callbackArg = updateStateCall?.[2] as ((fm: object) => Promise<{ frontMatter: { status: string } }>) | undefined;
+    expect(callbackArg).toBeDefined();
+    if (callbackArg == null) {
+      throw new Error('missing updateState callback');
+    }
+    const result = await callbackArg({});
+    expect(result.frontMatter.status).toBe(STATUS.PAUSED_BUDGET);
+    expect(sessionOrchestrator.closeFeatureCluster).toHaveBeenCalledWith('feature_x');
+  });
+
+  it('GIVEN_over_budget_feature_with_notifier_WHEN_pauseOverBudgetFeatures_runs_THEN_notifies_budget_exceeded', async () => {
+    const notifier = { notify: vi.fn(async () => undefined) };
+    const { coordinator } = makeCoordinatorDeps({
+      checkBudgetImpl: async () => ({
+        over_budget: true,
+        alert_threshold_reached: false,
+        current_cost_usd: 5.5,
+        limit_usd: 5.0,
+        alert_threshold: 0.8
+      }),
+      notifier
+    });
+
+    await coordinator.start([{ feature_id: 'feature_x' }]);
+
+    expect(notifier.notify).toHaveBeenCalledWith('budget_exceeded', expect.objectContaining({ feature_id: 'feature_x' }));
+  });
+
+  it('GIVEN_alert_threshold_reached_WHEN_pauseOverBudgetFeatures_runs_THEN_notifies_budget_alert', async () => {
+    const notifier = { notify: vi.fn(async () => undefined) };
+    const { coordinator } = makeCoordinatorDeps({
+      checkBudgetImpl: async () => ({
+        over_budget: false,
+        alert_threshold_reached: true,
+        current_cost_usd: 4.5,
+        limit_usd: 5.0,
+        alert_threshold: 0.9
+      }),
+      notifier
+    });
+
+    await coordinator.start([{ feature_id: 'feature_x' }]);
+
+    expect(notifier.notify).toHaveBeenCalledWith('budget_alert', expect.objectContaining({ feature_id: 'feature_x' }));
+  });
+
+  it('GIVEN_feature_transitions_to_BLOCKED_from_PLANNING_WHEN_notifyStatusTransitions_THEN_notifies_collision_detected', async () => {
+    const notifier = { notify: vi.fn(async () => undefined) };
+    let callCount = 0;
+    const { coordinator } = makeCoordinatorDeps({
+      // calls: 1=init_rebalance, 2=iter1_notify, 3=iter1_rebalance, 4=iter2_notify, 5=iter2_rebalance
+      toolCallerImpl: async (_role, toolName) => {
+        if (toolName === TOOLS.FEATURE_STATE_GET) {
+          callCount += 1;
+          const status = callCount <= 3 ? STATUS.PLANNING : STATUS.BLOCKED;
+          return { ok: true, data: { front_matter: { status } } };
+        }
+        if (toolName === TOOLS.REPORT_DASHBOARD) {
+          return { ok: true, data: { features: [] } };
+        }
+        return { ok: true, data: {} };
+      },
+      notifier,
+      maxIterationsPerPhase: 2
+    });
+
+    await coordinator.start([{ feature_id: 'feature_x' }]);
+
+    expect(notifier.notify).toHaveBeenCalledWith('collision_detected', expect.objectContaining({ feature_id: 'feature_x' }));
+  });
+
+  it('GIVEN_feature_transitions_to_BLOCKED_from_non_PLANNING_WHEN_notifyStatusTransitions_THEN_notifies_gate_failed', async () => {
+    const notifier = { notify: vi.fn(async () => undefined) };
+    let callCount = 0;
+    const { coordinator } = makeCoordinatorDeps({
+      toolCallerImpl: async (_role, toolName) => {
+        if (toolName === TOOLS.FEATURE_STATE_GET) {
+          callCount += 1;
+          const status = callCount === 1 ? STATUS.BUILDING : STATUS.BLOCKED;
+          return { ok: true, data: { front_matter: { status } } };
+        }
+        if (toolName === TOOLS.REPORT_DASHBOARD) {
+          return { ok: true, data: { features: [] } };
+        }
+        return { ok: true, data: {} };
+      },
+      notifier
+    });
+
+    await coordinator.start([{ feature_id: 'feature_x' }]);
+
+    expect(notifier.notify).toHaveBeenCalledWith('gate_failed', expect.objectContaining({ feature_id: 'feature_x' }));
+  });
+
+  it('GIVEN_feature_transitions_to_READY_TO_MERGE_WHEN_notifyStatusTransitions_THEN_notifies_and_calls_prMonitor', async () => {
+    const notifier = { notify: vi.fn(async () => undefined) };
+    const prMonitor = { checkAndUpdate: vi.fn(async () => null) };
+    let callCount = 0;
+    const { coordinator } = makeCoordinatorDeps({
+      toolCallerImpl: async (_role, toolName) => {
+        if (toolName === TOOLS.FEATURE_STATE_GET) {
+          callCount += 1;
+          const status = callCount === 1 ? STATUS.PLANNING : STATUS.READY_TO_MERGE;
+          return { ok: true, data: { front_matter: { status } } };
+        }
+        if (toolName === TOOLS.REPORT_DASHBOARD) {
+          return { ok: true, data: { features: [] } };
+        }
+        return { ok: true, data: {} };
+      },
+      notifier,
+      prMonitor
+    });
+
+    await coordinator.start([{ feature_id: 'feature_x' }]);
+
+    expect(notifier.notify).toHaveBeenCalledWith('ready_to_merge', expect.objectContaining({ feature_id: 'feature_x' }));
+    expect(prMonitor.checkAndUpdate).toHaveBeenCalledWith('feature_x', 'feature_x');
+  });
+
+  it('GIVEN_feature_has_existing_pr_WHEN_status_is_unchanged_THEN_pr_monitor_polls_continuously', async () => {
+    const prMonitor = { checkAndUpdate: vi.fn(async () => null) };
+    const { coordinator } = makeCoordinatorDeps({
+      toolCallerImpl: async (_role, toolName) => {
+        if (toolName === TOOLS.FEATURE_STATE_GET) {
+          return {
+            ok: true,
+            data: {
+              front_matter: {
+                status: STATUS.QA,
+                pr: { number: 77, url: 'https://example.com/pr/77' }
+              }
+            }
+          };
+        }
+        if (toolName === TOOLS.REPORT_DASHBOARD) {
+          return { ok: true, data: { features: [] } };
+        }
+        return { ok: true, data: {} };
+      },
+      prMonitor,
+      maxIterationsPerPhase: 2
+    });
+
+    await coordinator.start([{ feature_id: 'feature_x' }]);
+
+    expect(prMonitor.checkAndUpdate).toHaveBeenCalledWith('feature_x', 'feature_x');
+  });
+
+  it('GIVEN_feature_transitions_to_MERGED_WHEN_notifyStatusTransitions_THEN_notifies_feature_merged', async () => {
+    const notifier = { notify: vi.fn(async () => undefined) };
+    let callCount = 0;
+    const { coordinator } = makeCoordinatorDeps({
+      toolCallerImpl: async (_role, toolName) => {
+        if (toolName === TOOLS.FEATURE_STATE_GET) {
+          callCount += 1;
+          const status = callCount === 1 ? STATUS.PLANNING : STATUS.MERGED;
+          return { ok: true, data: { front_matter: { status } } };
+        }
+        if (toolName === TOOLS.REPORT_DASHBOARD) {
+          return { ok: true, data: { features: [] } };
+        }
+        return { ok: true, data: {} };
+      },
+      notifier
+    });
+
+    await coordinator.start([{ feature_id: 'feature_x' }]);
+
+    expect(notifier.notify).toHaveBeenCalledWith('feature_merged', expect.objectContaining({ feature_id: 'feature_x' }));
+  });
+
+  it('GIVEN_issue_tracker_WHEN_feature_first_enters_PLANNING_THEN_fetches_issue_and_stores_in_frontmatter', async () => {
+    const issueTracker = {
+      getIssue: vi.fn(async () => ({ id: '123', title: 'Test Issue', url: 'http://test' })),
+      addComment: vi.fn(async () => undefined),
+      updateIssueStatus: vi.fn(async () => undefined)
+    };
+    const { coordinator, kernel } = makeCoordinatorDeps({ issueTracker });
+
+    await coordinator.start([{ feature_id: 'feature_x' }]);
+
+    expect(issueTracker.getIssue).toHaveBeenCalledWith('x');
+    expect(kernel.updateState).toHaveBeenCalledWith(
+      'feature_x',
+      null,
+      expect.any(Function)
+    );
+  });
+
+  it('GIVEN_issue_tracker_WHEN_status_transitions_THEN_adds_comment', async () => {
+    const issueTracker = {
+      getIssue: vi.fn(async () => ({ id: '123', title: 'Test Issue', url: 'http://test' })),
+      addComment: vi.fn(async () => undefined),
+      updateIssueStatus: vi.fn(async () => undefined)
+    };
+    const { coordinator } = makeCoordinatorDeps({ issueTracker });
+
+    await coordinator.start([{ feature_id: 'feature_x' }]);
+
+    expect(issueTracker.addComment).toHaveBeenCalledWith('x', expect.stringContaining('planning'));
+  });
+
+  it('GIVEN_issue_tracker_WHEN_status_transitions_THEN_syncs_tracker_status_for_non_terminal_states', async () => {
+    const issueTracker = {
+      getIssue: vi.fn(async () => ({ id: '123', title: 'Test Issue', url: 'http://test' })),
+      addComment: vi.fn(async () => undefined),
+      updateIssueStatus: vi.fn(async () => undefined)
+    };
+    const { coordinator } = makeCoordinatorDeps({ issueTracker });
+
+    await coordinator.start([{ feature_id: 'feature_x' }]);
+
+    expect(issueTracker.updateIssueStatus).toHaveBeenCalledWith('x', STATUS.PLANNING);
+  });
+
+  it('GIVEN_issue_tracker_WHEN_status_is_MERGED_THEN_updates_issue_status_to_closed', async () => {
+    const issueTracker = {
+      getIssue: vi.fn(async () => ({ id: '123', title: 'Test Issue', url: 'http://test' })),
+      addComment: vi.fn(async () => undefined),
+      updateIssueStatus: vi.fn(async () => undefined)
+    };
+    let callCount = 0;
+    const { coordinator } = makeCoordinatorDeps({
+      toolCallerImpl: async (_role, toolName) => {
+        if (toolName === TOOLS.FEATURE_STATE_GET) {
+          callCount += 1;
+          const status = callCount === 1 ? STATUS.PLANNING : STATUS.MERGED;
+          return { ok: true, data: { front_matter: { status } } };
+        }
+        if (toolName === TOOLS.REPORT_DASHBOARD) {
+          return { ok: true, data: { features: [] } };
+        }
+        return { ok: true, data: {} };
+      },
+      issueTracker
+    });
+
+    await coordinator.start([{ feature_id: 'feature_x' }]);
+
+    expect(issueTracker.updateIssueStatus).toHaveBeenCalledWith('x', STATUS.MERGED);
+  });
+
+  it('GIVEN_same_status_seen_twice_WHEN_notifyStatusTransitions_THEN_skips_duplicate_notification', async () => {
+    const notifier = { notify: vi.fn(async () => undefined) };
+    const { coordinator } = makeCoordinatorDeps({
+      // always returns PLANNING — second iteration sees same status, should not re-notify
+      notifier,
+      maxIterationsPerPhase: 2
+    });
+
+    await coordinator.start([{ feature_id: 'feature_x' }]);
+
+    // notify called once only — second iteration sees same status, skipped
+    const planningNotifies = notifier.notify.mock.calls.filter(
+      (c: unknown[]) => c[0] !== 'budget_alert' && c[0] !== 'budget_exceeded'
+    );
+    expect(planningNotifies.length).toBe(0); // PLANNING has no notifier branch, just confirm no error
+  });
+
+  it('GIVEN_issue_tracker_returns_issue_without_title_WHEN_first_planning_transition_THEN_skips_updateState', async () => {
+    const issueTracker = {
+      getIssue: vi.fn(async () => ({ id: '123', title: '', url: 'http://test' })),
+      addComment: vi.fn(async () => undefined),
+      updateIssueStatus: vi.fn(async () => undefined)
+    };
+    const { coordinator, kernel } = makeCoordinatorDeps({ issueTracker });
+
+    await coordinator.start([{ feature_id: 'feature_x' }]);
+
+    expect(issueTracker.getIssue).toHaveBeenCalledWith('x');
+    // updateState should NOT be called since issue has no title
+    const stateUpdateForIssue = kernel.updateState.mock.calls.filter(
+      (c: unknown[]) => c[0] === 'feature_x'
+    );
+    expect(stateUpdateForIssue.length).toBe(0);
+  });
+
+  it('GIVEN_priority_order_with_unknown_feature_WHEN_applyOrchestratorPrioritization_runs_THEN_skips_unknown_and_appends_rest', async () => {
+    const workerDecisionRunner = {
+      execute: vi.fn(async () => ({
+        planSubmission: false,
+        patchApplied: false,
+        noteLogged: false,
+        requestHandled: true,
+        priorityOrder: ['unknown_feature', 'feature_b'],
+        toolResults: []
+      }))
+    };
+
+    const { ...rest } = makeCoordinatorDeps({ maxActiveFeatures: 2, maxIterationsPerPhase: 1 });
+    // Rebuild coordinator with workerDecisionRunner
+    const kernel2 = {
+      ensureLoaded: vi.fn(async () => undefined),
+      recoverFromState: vi.fn(async () => ({ data: { recovered: true } })),
+      acquireRunLease: vi.fn(async () => ({ data: { took_over_stale: false } })),
+      pruneFeatureSessionAssignments: vi.fn(async () => ({ data: { removed: [] as string[] } })),
+      getRuntimeSessions: vi.fn(async () => ({
+        run_id: 'run:test', owner_instance_id: 'owner:test', orchestrator_session_id: 'orch:test', feature_sessions: {}
+      })),
+      updateState: vi.fn(async () => ({})),
+      checkBudget: vi.fn(async () => ({ over_budget: false, alert_threshold_reached: false, current_cost_usd: 0, limit_usd: -1, alert_threshold: 0.8 }))
+    };
+    const state2 = {
+      runId: 'run:test', ownerInstanceId: 'owner:test', orchestratorSessionId: 'orch:test',
+      sessionsByFeature: new Map<string, { planner: string; builder: string; qa: string }>(),
+      queue: [] as Array<{ feature_id: string }>, runMetadata: {}
+    };
+    const toolCaller2 = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === 'report.dashboard') {
+          return { ok: true, data: { features: [] } };
+        }
+        return { ok: true, data: { front_matter: { status: STATUS.PLANNING } } };
+      })
+    };
+    const sessionOrchestrator2 = {
+      ensureGlobalOrchestratorSession: vi.fn(async () => undefined),
+      cleanupOrphanWorkerSessions: vi.fn(async () => undefined),
+      initializeFeatureCluster: vi.fn(async () => undefined),
+      closeFeatureCluster: vi.fn(async () => undefined),
+      reconcileQueuedFeatures: vi.fn(async () => undefined),
+      enforceActiveFeatureInvariant: vi.fn(async () => undefined)
+    };
+    const coord2 = new RunCoordinator({
+      kernel: kernel2 as never,
+      provider: { selection: { provider: 'test', model: 'test' } } as never,
+      toolCaller: toolCaller2 as never,
+      state: state2 as never,
+      sessionOrchestrator: sessionOrchestrator2 as never,
+      planningWaveExecutor: { run: vi.fn(async () => undefined), runPostQaReconciliation: vi.fn(async () => undefined) } as never,
+      buildWaveExecutor: { run: vi.fn(async () => undefined) } as never,
+      qaWaveExecutor: { run: vi.fn(async () => undefined) } as never,
+      leaseHeartbeatService: { renew: vi.fn(async () => undefined) } as never,
+      maxActiveFeatures: 2, maxParallelGateRuns: 2, maxIterationsPerPhase: 1,
+      takeoverStaleRun: false, providerConfigRefHash: () => 'hash',
+      workerDecisionRunner: workerDecisionRunner as never
+    });
+
+    void rest; // suppress unused warning
+    await coord2.start([{ feature_id: 'feature_a' }, { feature_id: 'feature_b' }]);
+    // Should complete without error; unknown_feature was skipped in prioritization
+    expect(workerDecisionRunner.execute).toHaveBeenCalled();
+  });
+});

package/apps/control-plane/test/schema-date-time.spec.ts

@@ -168,3 +168,49 @@ describe('Schema date-time enforcement', () => {
     );
   });
 });
+
+describe('isStrictRfc3339DateTime additional branches', () => {
+  it('GIVEN_date_with_day_out_of_range_WHEN_validated_THEN_invalid', async () => {
+    const kernel = new AopKernel(repoRoot);
+    await kernel.ensureLoaded();
+    const index = await kernel.readIndex();
+    const result = await kernel.validateSchema('index.schema.json', {
+      ...index,
+      runtime_sessions: { ...index.runtime_sessions, started_at: '2026-02-30T12:00:00Z' }
+    });
+    expect(result.valid).toBe(false);
+  });
+
+  it('GIVEN_date_with_hour_24_WHEN_validated_THEN_invalid', async () => {
+    const kernel = new AopKernel(repoRoot);
+    await kernel.ensureLoaded();
+    const index = await kernel.readIndex();
+    const result = await kernel.validateSchema('index.schema.json', {
+      ...index,
+      runtime_sessions: { ...index.runtime_sessions, started_at: '2026-01-15T24:00:00Z' }
+    });
+    expect(result.valid).toBe(false);
+  });
+
+  it('GIVEN_date_with_offset_hour_24_WHEN_validated_THEN_invalid', async () => {
+    const kernel = new AopKernel(repoRoot);
+    await kernel.ensureLoaded();
+    const index = await kernel.readIndex();
+    const result = await kernel.validateSchema('index.schema.json', {
+      ...index,
+      runtime_sessions: { ...index.runtime_sessions, started_at: '2026-01-15T12:00:00+24:00' }
+    });
+    expect(result.valid).toBe(false);
+  });
+
+  it('GIVEN_date_with_day_zero_WHEN_validated_THEN_invalid', async () => {
+    const kernel = new AopKernel(repoRoot);
+    await kernel.ensureLoaded();
+    const index = await kernel.readIndex();
+    const result = await kernel.validateSchema('index.schema.json', {
+      ...index,
+      runtime_sessions: { ...index.runtime_sessions, started_at: '2026-01-00T12:00:00Z' }
+    });
+    expect(result.valid).toBe(false);
+  });
+});

package/apps/control-plane/test/service-retry-paths.spec.ts

@@ -303,3 +303,33 @@ describe('Decomposition retry paths', () => {
     expect(index.merged).toEqual(['feature_merge_retry']);
   });
 });
+
+describe('FeatureStateService branch coverage', () => {
+  it('GIVEN_frontMatter_with_non_numeric_version_WHEN_updateState_called_THEN_version_starts_from_1', async () => {
+    const state = { frontMatter: { feature_id: 'f1', status: STATUS.PLANNING, version: 'not-a-number' as unknown as number }, body: '' };
+    const service = new FeatureStateService({
+      withFeatureLock: async <T>(_id: string, op: () => Promise<T>) => await op(),
+      readState: async () => ({ ...state }),
+      writeState: async (_id: string, fm: Record<string, unknown>) => { state.frontMatter = fm as typeof state.frontMatter; }
+    });
+
+    const result = await service.featureStatePatch('f1', null, { front_matter: { status: STATUS.PLANNING } });
+    // version should be 0 (non-numeric read) + 1 = 1
+    expect(result.data.version).toBe(1);
+  });
+
+  it('GIVEN_illegal_status_transition_WHEN_updateState_called_THEN_throws_INVALID_STATUS_TRANSITION', async () => {
+    const state = { frontMatter: { feature_id: 'f1', status: STATUS.MERGED, version: 1 }, body: '' };
+    const service = new FeatureStateService({
+      withFeatureLock: async <T>(_id: string, op: () => Promise<T>) => await op(),
+      readState: async () => ({ ...state }),
+      writeState: vi.fn()
+    });
+
+    await expect(
+      service.featureStatePatch('f1', null, { front_matter: { status: STATUS.PLANNING } })
+    ).rejects.toMatchObject({
+      normalizedResponse: { error: { code: ERROR_CODES.INVALID_STATUS_TRANSITION } }
+    });
+  });
+});