agentic-orchestrator 0.1.28 → 0.2.0

package/apps/control-plane/test/feature-lifecycle.spec.ts

@@ -38,6 +38,20 @@ function makePort(
     planGet: vi.fn(async () => ({ data: { plan: { files: {} } } })),
     qaTestIndexGet: vi.fn(async () => ({ data: { items: [] } })),
     evidenceLatest: vi.fn(async () => ({ data: { latest: null } })),
+    featureQuestionContext: vi.fn(async () => ({ open_questions: [], latest_answer: null })),
+    featureIntakeContext: vi.fn(async () => ({
+      bootstrap_manifest: null,
+      verified_manifest: null,
+      review: null,
+      summary: {
+        status: 'in_progress',
+        bootstrap_manifest_version: null,
+        verified_manifest_version: null,
+        open_ambiguity_count: 0,
+        last_verified_at: null,
+        promotion_basis: null,
+      },
+    })),
     ...overrides,
   };
 }
@@ -65,9 +79,12 @@ describe('FeatureLifecycleService', () => {
         const featuresDir = path.join(tmpDir, '.aop', 'features');
         const f1 = path.join(featuresDir, 'feature_a');
         const f2 = path.join(featuresDir, 'not_a_feature'); // no spec.md
+        const strayFile = path.join(featuresDir, 'README.txt');
         await fs.mkdir(f1, { recursive: true });
         await fs.mkdir(f2, { recursive: true });
+        await fs.mkdir(featuresDir, { recursive: true });
         await fs.writeFile(path.join(f1, 'spec.md'), '# Feature A', 'utf8');
+        await fs.writeFile(strayFile, 'not a feature', 'utf8');
 
         const port = makePort({
           getRepoRoot: vi.fn(() => tmpDir),
@@ -127,6 +144,71 @@ describe('FeatureLifecycleService', () => {
         await fs.rm(tmpDir, { recursive: true, force: true });
       }
     });
+
+    it('GIVEN_index_run_id_WHEN_featureInit_called_THEN_seeds_run_history_with_active_entry', async () => {
+      const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-lc-run-'));
+      try {
+        const runId = 'run:00000000-0000-0000-0000-000000000999';
+        let capturedState: Record<string, unknown> | null = null;
+        const port = makePort({
+          getRepoRoot: vi.fn(() => tmpDir),
+          statePath: vi.fn(() => path.join(tmpDir, 'state.md')),
+          qaIndexPath: vi.fn(() => path.join(tmpDir, 'qa.json')),
+          readIndex: vi.fn(async () => ({
+            active: [],
+            blocked: [],
+            version: 0,
+            updated_at: '',
+            runtime_sessions: { run_id: runId },
+          })),
+          makeDefaultState: vi.fn(() => ({
+            feature_id: 'f1',
+            status: 'planning',
+            version: 0,
+            run_history: [
+              {
+                run_id: runId,
+                started_at: '2026-03-05T00:00:00.000Z',
+                status: 'completed',
+              },
+              {
+                run_id: 'run:00000000-0000-0000-0000-000000000998',
+                started_at: '2026-03-04T00:00:00.000Z',
+                status: 'failed',
+              },
+            ],
+          })),
+          writeState: vi.fn(async (_id, frontMatter) => {
+            capturedState = frontMatter;
+          }),
+        });
+        const service = new FeatureLifecycleService(port);
+        await service.featureInit('f1');
+
+        const runHistory = (capturedState?.['run_history'] as Array<{ run_id: string }>) ?? [];
+        expect(runHistory[0].run_id).toBe(runId);
+        expect(runHistory).toHaveLength(2);
+      } finally {
+        await fs.rm(tmpDir, { recursive: true, force: true });
+      }
+    });
+
+    it('GIVEN_worktree_path_equals_repo_root_WHEN_featureInit_called_THEN_returns_dot_path', async () => {
+      const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-lc-root-'));
+      try {
+        const port = makePort({
+          getRepoRoot: vi.fn(() => tmpDir),
+          statePath: vi.fn(() => path.join(tmpDir, 'state.md')),
+          qaIndexPath: vi.fn(() => path.join(tmpDir, 'qa.json')),
+          repoEnsureWorktree: vi.fn(async () => ({ data: { worktree_path_abs: tmpDir } })),
+        });
+        const service = new FeatureLifecycleService(port);
+        const result = await service.featureInit('feature_root');
+        expect(result.data.worktree_path).toBe('.');
+      } finally {
+        await fs.rm(tmpDir, { recursive: true, force: true });
+      }
+    });
   });
 
   describe('featureGetContext', () => {
@@ -138,6 +220,7 @@ describe('FeatureLifecycleService', () => {
       const result = await service.featureGetContext('f1');
       expect(result.data.spec).toBe('');
       expect(result.data.feature_id).toBe('f1');
+      expect(result.data.decision_log).toBe('');
     });
 
     it('GIVEN_featureId_with_evidence_WHEN_featureGetContext_called_THEN_latest_evidence_included', async () => {
@@ -149,6 +232,49 @@ describe('FeatureLifecycleService', () => {
       const service = new FeatureLifecycleService(port);
       const result = await service.featureGetContext('f1');
       expect(result.data.latest_evidence).toEqual(evidence);
+      expect(result.data.decision_log).toBe('');
+    });
+
+    it('GIVEN_decision_log_present_WHEN_featureGetContext_called_THEN_decision_log_returned', async () => {
+      const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-decctx-'));
+      try {
+        const logPath = path.join(tmpDir, 'decisions.md');
+        await fs.writeFile(
+          logPath,
+          '- 2026-03-04T12:00:00Z [orchestrator:o1] resumed work\n',
+          'utf8',
+        );
+        const port = makePort({
+          specPath: vi.fn(() => '/nonexistent/spec.md'),
+          decisionsPath: vi.fn(() => logPath),
+        });
+        const service = new FeatureLifecycleService(port);
+        const result = await service.featureGetContext('f1');
+        expect(result.data.decision_log).toContain('resumed work');
+      } finally {
+        await fs.rm(tmpDir, { recursive: true, force: true });
+      }
+    });
+
+    it('GIVEN_large_decision_log_WHEN_featureGetContext_called_THEN_trims_to_tail', async () => {
+      const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-dec-tail-'));
+      try {
+        const logPath = path.join(tmpDir, 'decisions.md');
+        const head = 'A'.repeat(2000);
+        const tail = `TAIL-${'B'.repeat(31_000)}`;
+        const fullLog = `${head}${tail}`;
+        await fs.writeFile(logPath, fullLog, 'utf8');
+        const port = makePort({
+          specPath: vi.fn(() => '/nonexistent/spec.md'),
+          decisionsPath: vi.fn(() => logPath),
+        });
+        const service = new FeatureLifecycleService(port);
+        const result = await service.featureGetContext('f1');
+        expect(result.data.decision_log.length).toBe(32_000);
+        expect(result.data.decision_log).toBe(fullLog.slice(-32_000));
+      } finally {
+        await fs.rm(tmpDir, { recursive: true, force: true });
+      }
     });
   });
 

package/apps/control-plane/test/feature-resume-phase.spec.ts

@@ -0,0 +1,164 @@
+import { describe, expect, it } from 'vitest';
+import { STATUS } from '../src/core/constants.js';
+import { deriveFeatureResumePhase } from '../src/core/feature-resume-phase.js';
+
+describe('deriveFeatureResumePhase', () => {
+  it('prefers the explicit awaiting-input resume status when present', () => {
+    expect(
+      deriveFeatureResumePhase({
+        status: STATUS.AWAITING_INPUT,
+        human_input: {
+          resume_status: STATUS.QA,
+        },
+      }),
+    ).toBe(STATUS.QA);
+  });
+
+  it('uses the newest pending mainline-divergence conflict resume status for blocked features', () => {
+    expect(
+      deriveFeatureResumePhase({
+        status: STATUS.BLOCKED,
+        conflicts: [
+          {
+            type: 'mainline_divergence',
+            resolution_status: 'resolved',
+            resume_status: STATUS.BUILDING,
+          },
+          {
+            type: 'mainline_divergence',
+            resolution_status: 'pending',
+            resume_status: STATUS.QA,
+          },
+        ],
+      }),
+    ).toBe(STATUS.QA);
+  });
+
+  it('skips unrelated and resolved conflicts before using an in-progress mainline resume status', () => {
+    expect(
+      deriveFeatureResumePhase({
+        status: STATUS.BLOCKED,
+        conflicts: [
+          {
+            type: 'mainline_divergence',
+            resolution_status: 'in_progress',
+            resume_status: STATUS.BUILDING,
+          },
+          {
+            type: 'other_conflict',
+            resolution_status: 'pending',
+            resume_status: STATUS.QA,
+          },
+          {
+            type: 'mainline_divergence',
+            resolution_status: 'resolved',
+            resume_status: STATUS.READY_TO_MERGE,
+          },
+        ],
+      }),
+    ).toBe(STATUS.BUILDING);
+  });
+
+  it('keeps blocked intake work in intake until the intake contract is verified', () => {
+    expect(
+      deriveFeatureResumePhase({
+        status: STATUS.BLOCKED,
+        intake: {
+          status: 'in_progress',
+        },
+      }),
+    ).toBe(STATUS.INTAKE);
+  });
+
+  it('keeps awaiting-input features in intake when no explicit resume status is present', () => {
+    expect(
+      deriveFeatureResumePhase({
+        status: STATUS.AWAITING_INPUT,
+        intake: {
+          status: 'awaiting_input',
+        },
+      }),
+    ).toBe(STATUS.INTAKE);
+  });
+
+  it('routes blocked merge-repair states back to ready_to_merge', () => {
+    expect(
+      deriveFeatureResumePhase({
+        status: STATUS.BLOCKED,
+        status_reason: 'merge_gate_repair:2',
+        evidence: {
+          last_gate_mode: 'merge',
+        },
+      }),
+    ).toBe(STATUS.READY_TO_MERGE);
+  });
+
+  it('routes active merge-repair bookkeeping back to ready_to_merge even without a merge status reason', () => {
+    expect(
+      deriveFeatureResumePhase({
+        status: STATUS.BLOCKED,
+        merge_repair: {
+          active: true,
+          attempts: 1,
+          max_attempts: 5,
+        },
+      }),
+    ).toBe(STATUS.READY_TO_MERGE);
+  });
+
+  it('routes blocked full-gate failures back to qa', () => {
+    expect(
+      deriveFeatureResumePhase({
+        status: STATUS.BLOCKED,
+        evidence: {
+          last_gate_mode: 'full',
+        },
+      }),
+    ).toBe(STATUS.QA);
+  });
+
+  it('routes blocked fast-gate and planned work back to building', () => {
+    expect(
+      deriveFeatureResumePhase({
+        status: STATUS.BLOCKED,
+        gates: {
+          plan: 'pass',
+        },
+      }),
+    ).toBe(STATUS.BUILDING);
+  });
+
+  it('ignores pending mainline conflicts with non-resumable statuses and falls through to later recovery rules', () => {
+    expect(
+      deriveFeatureResumePhase({
+        status: STATUS.BLOCKED,
+        conflicts: [
+          {
+            type: 'mainline_divergence',
+            resolution_status: 'pending',
+            resume_status: 'not_a_real_phase',
+          },
+        ],
+        gates: {
+          fast: 'pass',
+        },
+      }),
+    ).toBe(STATUS.BUILDING);
+  });
+
+  it('treats blank string statuses as absent and falls back to planning', () => {
+    expect(
+      deriveFeatureResumePhase({
+        status: '   ',
+      }),
+    ).toBe(STATUS.PLANNING);
+  });
+
+  it('falls back to planning when status is unknown', () => {
+    expect(
+      deriveFeatureResumePhase({
+        status: 'mystery',
+      }),
+    ).toBe(STATUS.PLANNING);
+  });
+});

package/apps/control-plane/test/feature-send-message-service.spec.ts

@@ -17,6 +17,7 @@ function makeRuntimeSessions(
   return {
     run_id: 'run1',
     orchestrator_session_id: 'orch-session',
+    reconciler_session_id: 'unknown',
     provider: 'codex',
     model: 'gpt-4',
     provider_config_ref_hash: 'hash',
@@ -266,6 +267,95 @@ describe('FeatureSendMessageService', () => {
     expect(result.target_role).toBe('orchestrator');
   });
 
+  it('GIVEN_blocked_feature_with_pending_mainline_conflict_WHEN_featureSendMessage_THEN_routes_to_shared_reconciler', async () => {
+    const port = makePort({
+      readState: vi.fn(async () => ({
+        frontMatter: {
+          status: STATUS.BLOCKED,
+          conflicts: [{ type: 'mainline_divergence', resolution_status: 'pending' }],
+        },
+        body: '',
+        raw: '',
+      })),
+      getRuntimeSessions: vi.fn(async () =>
+        makeRuntimeSessions({
+          reconciler_session_id: 'reconciler-shared',
+        }),
+      ),
+      getProvider: vi.fn(() => ({ sendMessage: sendMessageMock })),
+    });
+    const service = new FeatureSendMessageService(port);
+    const result = (await service.featureSendMessage('feat1', 'hello')) as Record<string, unknown>;
+    expect(result.target_role).toBe('reconciler');
+    expect(result.session_id).toBe('reconciler-shared');
+    expect(sendMessageMock).toHaveBeenCalledWith('reconciler-shared', 'hello');
+  });
+
+  it('GIVEN_blocked_feature_with_in_progress_mainline_conflict_WHEN_featureSendMessage_THEN_routes_to_shared_reconciler', async () => {
+    const port = makePort({
+      readState: vi.fn(async () => ({
+        frontMatter: {
+          status: STATUS.BLOCKED,
+          conflicts: [{ type: 'mainline_divergence', resolution_status: 'in_progress' }],
+        },
+        body: '',
+        raw: '',
+      })),
+      getRuntimeSessions: vi.fn(async () =>
+        makeRuntimeSessions({
+          reconciler_session_id: 'reconciler-shared',
+        }),
+      ),
+      getProvider: vi.fn(() => ({ sendMessage: sendMessageMock })),
+    });
+    const service = new FeatureSendMessageService(port);
+    const result = (await service.featureSendMessage('feat1', 'hello')) as Record<string, unknown>;
+    expect(result.target_role).toBe('reconciler');
+    expect(result.session_id).toBe('reconciler-shared');
+  });
+
+  it('GIVEN_blocked_feature_with_invalid_conflict_entries_WHEN_featureSendMessage_THEN_uses_gate_routing', async () => {
+    const port = makePort({
+      readState: vi.fn(async () => ({
+        frontMatter: {
+          status: STATUS.BLOCKED,
+          conflicts: [null, 'bad-entry', { type: 'qa_blocker', resolution_status: 'pending' }],
+          gates: { fast: GATE_RESULT.FAIL, full: GATE_RESULT.PASS },
+        },
+        body: '',
+        raw: '',
+      })),
+      getProvider: vi.fn(() => ({ sendMessage: sendMessageMock })),
+    });
+    const service = new FeatureSendMessageService(port);
+    const result = (await service.featureSendMessage('feat1', 'hello')) as Record<string, unknown>;
+    expect(result.target_role).toBe('builder');
+    expect(result.session_id).toBe('builder-sess');
+  });
+
+  it('GIVEN_reconciler_session_is_unknown_WHEN_blocked_mainline_conflict_routed_THEN_falls_back_to_orchestrator', async () => {
+    const port = makePort({
+      readState: vi.fn(async () => ({
+        frontMatter: {
+          status: STATUS.BLOCKED,
+          conflicts: [{ type: 'mainline_divergence', resolution_status: 'pending' }],
+        },
+        body: '',
+        raw: '',
+      })),
+      getRuntimeSessions: vi.fn(async () =>
+        makeRuntimeSessions({
+          reconciler_session_id: 'unknown',
+        }),
+      ),
+      getProvider: vi.fn(() => ({ sendMessage: sendMessageMock })),
+    });
+    const service = new FeatureSendMessageService(port);
+    const result = (await service.featureSendMessage('feat1', 'hello')) as Record<string, unknown>;
+    expect(result.target_role).toBe('orchestrator');
+    expect(result.session_id).toBe('orch-session');
+  });
+
   it('GIVEN_successful_send_WHEN_featureSendMessage_THEN_returns_delivery_receipt', async () => {
     const port = makePort({
       readState: vi.fn(async () => ({
@@ -311,4 +401,75 @@ describe('FeatureSendMessageService', () => {
     const result = (await service.featureSendMessage('feat1', 'hello')) as Record<string, unknown>;
     expect(result.delivered).toBe(true);
   });
+
+  it('GIVEN_provider_getSessionInfo_errors_then_recovers_WHEN_featureSendMessage_THEN_delivery_still_succeeds', async () => {
+    const getSessionInfoMock = vi
+      .fn<(_: string) => Promise<{ active: boolean; provider: string }>>()
+      .mockRejectedValueOnce(new Error('transient'))
+      .mockResolvedValueOnce({ active: true, provider: 'codex' });
+    const port = makePort({
+      readState: vi.fn(async () => ({
+        frontMatter: { status: STATUS.BUILDING },
+        body: '',
+        raw: '',
+      })),
+      getProvider: vi.fn(() => ({
+        sendMessage: sendMessageMock,
+        getSessionInfo: getSessionInfoMock,
+      })),
+    });
+    const service = new FeatureSendMessageService(port);
+    const result = (await service.featureSendMessage('feat1', 'hello')) as Record<string, unknown>;
+    expect(result.delivered).toBe(true);
+    expect(getSessionInfoMock).toHaveBeenCalledTimes(2);
+  });
+
+  it('GIVEN_provider_getSessionInfo_never_activates_WHEN_featureSendMessage_THEN_times_out_and_still_sends', async () => {
+    vi.useFakeTimers();
+    const getSessionInfoMock = vi.fn(async () => ({ active: false, provider: 'codex' }));
+    const port = makePort({
+      readState: vi.fn(async () => ({
+        frontMatter: { status: STATUS.BUILDING },
+        body: '',
+        raw: '',
+      })),
+      getProvider: vi.fn(() => ({
+        sendMessage: sendMessageMock,
+        getSessionInfo: getSessionInfoMock,
+      })),
+    });
+    const service = new FeatureSendMessageService(port);
+    const resultPromise = service.featureSendMessage('feat1', 'hello');
+    await vi.advanceTimersByTimeAsync(6000);
+    const result = (await resultPromise) as Record<string, unknown>;
+    expect(result.delivered).toBe(true);
+    expect(sendMessageMock).toHaveBeenCalledWith('builder-sess', 'hello');
+    vi.useRealTimers();
+  });
+
+  it('GIVEN_ready_to_merge_with_unknown_qa_session_WHEN_featureSendMessage_THEN_falls_back_to_orchestrator', async () => {
+    const port = makePort({
+      readState: vi.fn(async () => ({
+        frontMatter: { status: STATUS.READY_TO_MERGE },
+        body: '',
+        raw: '',
+      })),
+      getRuntimeSessions: vi.fn(async () =>
+        makeRuntimeSessions({
+          feature_sessions: {
+            feat1: {
+              planner_session_id: 'planner-sess',
+              builder_session_id: 'builder-sess',
+              qa_session_id: 'unknown',
+            },
+          },
+        }),
+      ),
+      getProvider: vi.fn(() => ({ sendMessage: sendMessageMock })),
+    });
+    const service = new FeatureSendMessageService(port);
+    const result = (await service.featureSendMessage('feat1', 'hello')) as Record<string, unknown>;
+    expect(result.target_role).toBe('orchestrator');
+    expect(result.session_id).toBe('orch-session');
+  });
 });