agentic-orchestrator 0.1.28 → 0.2.1

package/apps/control-plane/test/supervisor.spec.ts

@@ -5,7 +5,7 @@ import { AopKernel } from '../src/index.js';
 import { createToolingRuntime } from '../src/index.js';
 import { NullWorkerProvider } from '../src/index.js';
 import { SupervisorRuntime } from '../src/index.js';
-import { makeTempRepo, writeFeatureSpec } from './helpers.js';
+import { makeTempRepo, verifyFeatureIntake, writeFeatureSpec } from './helpers.js';
 
 let repoRoot: string;
 
@@ -76,6 +76,7 @@ async function initFeature(kernel: AopKernel, featureId: string) {
     { actor_type: 'orchestrator', actor_id: 'test' },
   );
   expect(init.ok).toBe(true);
+  await verifyFeatureIntake(kernel, featureId);
 }
 async function readRunLease() {
   const leaseFile = path.join(repoRoot, '.aop', 'runtime', 'default', 'run-lease.json');
@@ -88,6 +89,18 @@ async function writeRunLease(data: Record<string, unknown>) {
   await fs.writeFile(leaseFile, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
 }
 
+async function readExecutionControl() {
+  const controlFile = path.join(repoRoot, '.aop', 'runtime', 'default', 'execution-control.json');
+  const raw = await fs.readFile(controlFile, 'utf8');
+  return JSON.parse(raw);
+}
+
+async function writeExecutionControl(data: Record<string, unknown>) {
+  const controlFile = path.join(repoRoot, '.aop', 'runtime', 'default', 'execution-control.json');
+  await fs.mkdir(path.dirname(controlFile), { recursive: true });
+  await fs.writeFile(controlFile, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+}
+
 function expectConcreteWorkerSessions(assignment: Record<string, string>) {
   expect(assignment.planner_session_id).not.toBe('unassigned');
   expect(assignment.builder_session_id).not.toBe('unassigned');
@@ -115,6 +128,12 @@ async function expectQueuedClusterSentinel(kernel: AopKernel, featureId: string)
 function countAllocatedSessionIds(sessions: any): number {
   const usedSessionIds = new Set<string>();
   usedSessionIds.add(sessions.orchestrator_session_id);
+  if (
+    typeof sessions.reconciler_session_id === 'string' &&
+    sessions.reconciler_session_id !== 'unknown'
+  ) {
+    usedSessionIds.add(sessions.reconciler_session_id);
+  }
   for (const assignment of Object.values<any>(sessions.feature_sessions)) {
     for (const sessionId of [
       assignment.planner_session_id,
@@ -130,7 +149,7 @@ function countAllocatedSessionIds(sessions: any): number {
 }
 
 describe('SupervisorRuntime topology', () => {
-  it('enforces 1 + 3N topology and queued sentinel sessions', async () => {
+  it('enforces 2 + 3N topology and queued sentinel sessions', async () => {
     const { kernel, tooling, provider } = await boot();
 
     await writeFeatureSpec(repoRoot, 'feature_a');
@@ -152,8 +171,8 @@ describe('SupervisorRuntime topology', () => {
     expectConcreteWorkerSessions(sessions.feature_sessions.feature_a);
     expectUnassignedWorkerSessions(sessions.feature_sessions.feature_b);
 
-    // N=1 active feature => exactly 1 orchestrator + 3 worker sessions.
-    expect(countAllocatedSessionIds(sessions)).toBe(4);
+    // N=1 active feature => exactly 1 orchestrator + 1 shared reconciler + 3 worker sessions.
+    expect(countAllocatedSessionIds(sessions)).toBe(5);
 
     const activeState = await kernel.invoke(
       'feature.state_get',
@@ -166,9 +185,70 @@ describe('SupervisorRuntime topology', () => {
     );
 
     await expectQueuedClusterSentinel(kernel, 'feature_b');
-  });
+  }, 15000);
+
+  it('applies pending execution-control requests during startup without restarting the supervisor', async () => {
+    const { kernel, tooling, provider } = await boot();
+    await writeFeatureSpec(repoRoot, 'feature_added');
+    await writeExecutionControl({
+      version: 1,
+      run_id: 'run:add-startup',
+      owner_instance_id: 'owner:add-startup',
+      updated_at: new Date().toISOString(),
+      items: [
+        {
+          request_id: 'exec_req_001',
+          request_type: 'add_features',
+          status: 'pending',
+          requested_at: new Date().toISOString(),
+          processed_at: null,
+          requested_by: 'cli:add',
+          operation_id: 'runtime_execution_request_submit__feature_added__123',
+          features: [
+            {
+              feature_id: 'feature_added',
+              spec_path: '.aop/features/feature_added/spec.md',
+            },
+          ],
+          progress: null,
+          outcome: null,
+        },
+      ],
+    });
+
+    const runtime = new SupervisorRuntime(kernel, provider, tooling.inProcessClient, {
+      run_id: 'run:add-startup',
+      owner_instance_id: 'owner:add-startup',
+      max_active_features: 1,
+      max_iterations_per_phase: 0,
+    });
+
+    const result = await runtime.start([]);
+    expect(result.queue_depth).toBe(0);
 
-  it('enforces exact 1 + 3N topology for N=3 active features', async () => {
+    const state = await kernel.invoke(
+      'feature.state_get',
+      { feature_id: 'feature_added' },
+      { actor_type: 'orchestrator', actor_id: 'test' },
+    );
+    expect(state.ok).toBe(true);
+    expect(state.data.front_matter.cluster.planner_session_id).not.toBe('unknown');
+
+    const executionControl = await readExecutionControl();
+    expect(executionControl.items[0]).toMatchObject({
+      status: 'applied',
+    });
+    const outcome = executionControl.items[0].outcome ?? {};
+    const handledFeatureIds = new Set<string>([
+      ...((Array.isArray(outcome.queued) ? outcome.queued : []) as string[]),
+      ...((Array.isArray(outcome.skipped)
+        ? outcome.skipped.map((item: { feature_id: string }) => item.feature_id)
+        : []) as string[]),
+    ]);
+    expect(handledFeatureIds.has('feature_added')).toBe(true);
+  }, 20_000);
+
+  it('enforces exact 2 + 3N topology for N=3 active features', async () => {
     const { kernel, tooling, provider } = await boot();
 
     for (const featureId of ['feature_a', 'feature_b', 'feature_c']) {
@@ -193,7 +273,7 @@ describe('SupervisorRuntime topology', () => {
     expectConcreteWorkerSessions(sessions.feature_sessions.feature_a);
     expectConcreteWorkerSessions(sessions.feature_sessions.feature_b);
     expectConcreteWorkerSessions(sessions.feature_sessions.feature_c);
-    expect(countAllocatedSessionIds(sessions)).toBe(10);
+    expect(countAllocatedSessionIds(sessions)).toBe(11);
 
     for (const featureId of ['feature_a', 'feature_b', 'feature_c']) {
       const state = await kernel.invoke(
@@ -206,7 +286,7 @@ describe('SupervisorRuntime topology', () => {
         sessions.orchestrator_session_id,
       );
     }
-  });
+  }, 20_000);
 
   it('enforces queued sentinel sessions when feature count exceeds max_active_features', async () => {
     const { kernel, tooling, provider } = await boot();
@@ -238,9 +318,9 @@ describe('SupervisorRuntime topology', () => {
       await expectQueuedClusterSentinel(kernel, featureId);
     }
 
-    // N=3 active features => exactly 1 orchestrator + 9 worker sessions.
-    expect(countAllocatedSessionIds(sessions)).toBe(10);
-  });
+    // N=3 active features => exactly 1 orchestrator + 1 shared reconciler + 9 worker sessions.
+    expect(countAllocatedSessionIds(sessions)).toBe(11);
+  }, 20_000);
 
   it('promotes queued feature when an admitted feature is already terminal at admission time', async () => {
     const { kernel, tooling, provider } = await boot();
@@ -300,7 +380,7 @@ describe('SupervisorRuntime topology', () => {
     const sessions = await readRunLease();
     expectConcreteWorkerSessions(sessions.feature_sessions.feature_b);
     expect(sessions.feature_sessions.feature_a).toBeUndefined();
-    expect(countAllocatedSessionIds(sessions)).toBe(4);
+    expect(countAllocatedSessionIds(sessions)).toBe(5);
   });
 
   it('prunes stale feature session assignments outside active+queue scope across start cycles', async () => {
@@ -326,8 +406,8 @@ describe('SupervisorRuntime topology', () => {
     const secondSessions = await readRunLease();
 
     expect(Object.keys(secondSessions.feature_sessions).sort()).toEqual(['feature_a', 'feature_b']);
-    expect(countAllocatedSessionIds(secondSessions)).toBe(7);
-  });
+    expect(countAllocatedSessionIds(secondSessions)).toBe(8);
+  }, 10_000);
 
   it('blocks concurrent run ownership with run_already_active', async () => {
     const { kernel, tooling, provider } = await boot();
@@ -406,7 +486,6 @@ describe('SupervisorRuntime topology', () => {
 
     const kernel = new AopKernel(repoRoot);
     await kernel.ensureLoaded();
-    await kernel.ensureFeatureLayout('global');
     const tooling = await createToolingRuntime(repoRoot, kernel);
 
     await writeFeatureSpec(repoRoot, 'feature_recovery');
@@ -434,7 +513,7 @@ describe('SupervisorRuntime topology', () => {
     expect(provider.orchestratorSessionIds).toHaveLength(2);
     expect(provider.orchestratorSessionIds[0]).toBe(firstOrchestratorSession);
     expect(provider.orchestratorSessionIds[1]).toBe(sessions.orchestrator_session_id);
-    expect(countAllocatedSessionIds(sessions)).toBe(4);
+    expect(countAllocatedSessionIds(sessions)).toBe(5);
 
     const orphanAuditPath = path.join(repoRoot, '.aop', 'features', 'global', 'decisions.md');
     const orphanAudit = await fs.readFile(orphanAuditPath, 'utf8');