agentic-orchestrator 0.1.26 → 0.1.28

package/apps/control-plane/test/dashboard-client.spec.ts

@@ -3,9 +3,14 @@ import os from 'node:os';
 import path from 'node:path';
 import { afterEach, describe, expect, it } from 'vitest';
 import {
+  compareFeatureCheckpoints,
   readDashboardStatus,
+  readFeatureCheckpointDiff,
+  readFeatureCheckpoints,
   readFeatureCost,
+  readFeatureDetail,
   readFeatureLog,
+  readInteractivePerformanceMetrics,
   readFeatureQaTestIndex,
   readFeatureReviewBrief,
 } from '@/lib/aop-client.js';
@@ -359,4 +364,232 @@ describe('dashboard aop client mapping', () => {
       contract_risk_summary: 'Risk',
     });
   });
+
+  it('GIVEN_state_with_execution_mode_and_checkpoints_WHEN_readFeatureDetail_THEN_returns_timeline_with_validation_status', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-dash-client-'));
+    tempRoots.push(repoRoot);
+    const featureId = 'feature_checkpoints';
+    const featureRoot = path.join(repoRoot, '.aop', 'features', featureId);
+    await fs.mkdir(path.join(featureRoot, 'evidence'), { recursive: true });
+    await fs.writeFile(
+      path.join(featureRoot, 'state.md'),
+      [
+        '---',
+        `feature_id: ${featureId}`,
+        'version: 1',
+        'status: qa',
+        'branch: feature/feature_checkpoints',
+        'worktree_path: /tmp/worktrees/feature_checkpoints',
+        'execution_mode: interactive',
+        'checkpoints:',
+        '  - checkpoint_id: checkpoint-002',
+        '    timestamp: 2026-03-06T10:02:00.000Z',
+        '    files_changed: [src/a.ts]',
+        '    validation_status: invalid',
+        '    violations: [src/a.ts: forbidden_area]',
+        '    severity: error',
+        '    diff_snapshot: .aop/features/feature_checkpoints/checkpoints/checkpoint-002.diff',
+        '  - checkpoint_id: checkpoint-001',
+        '    timestamp: 2026-03-06T10:01:00.000Z',
+        '    files_changed: [src/b.ts]',
+        '    validation_status: valid',
+        '    violations: []',
+        '    diff_snapshot: .aop/features/feature_checkpoints/checkpoints/checkpoint-001.diff',
+        '---',
+        '',
+      ].join('\n'),
+      'utf8',
+    );
+    await fs.writeFile(
+      path.join(featureRoot, 'plan.json'),
+      JSON.stringify({ plan_version: 1 }),
+      'utf8',
+    );
+    await fs.writeFile(path.join(featureRoot, 'evidence', 'diff.patch'), '', 'utf8');
+
+    const detail = await readFeatureDetail(featureId, repoRoot);
+    expect(detail).not.toBeNull();
+    expect(detail?.execution_mode).toBe('interactive');
+    expect(detail?.checkpoints).toHaveLength(2);
+    expect(detail?.checkpoints?.[0]).toMatchObject({
+      checkpoint_id: 'checkpoint-002',
+      validation_status: 'invalid',
+      severity: 'error',
+    });
+    expect(detail?.checkpoints?.[1]).toMatchObject({
+      checkpoint_id: 'checkpoint-001',
+      validation_status: 'valid',
+    });
+  });
+
+  it('GIVEN_checkpoint_state_and_diff_artifacts_WHEN_read_checkpoint_helpers_THEN_returns_snapshot_and_comparison', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-dash-client-'));
+    tempRoots.push(repoRoot);
+    const featureId = 'feature_checkpoint_compare';
+    const featureRoot = path.join(repoRoot, '.aop', 'features', featureId);
+    const checkpointDir = path.join(featureRoot, 'checkpoints');
+    await fs.mkdir(checkpointDir, { recursive: true });
+    await fs.writeFile(
+      path.join(featureRoot, 'state.md'),
+      [
+        '---',
+        `feature_id: ${featureId}`,
+        'version: 1',
+        'status: qa',
+        'execution_mode: interactive',
+        'checkpoints:',
+        '  - checkpoint_id: checkpoint-002',
+        '    timestamp: 2026-03-06T10:02:00.000Z',
+        '    files_changed: [src/a.ts, src/b.ts]',
+        '    validation_status: valid',
+        '    violations: []',
+        '    diff_snapshot: .aop/features/feature_checkpoint_compare/checkpoints/checkpoint-002.diff',
+        '  - checkpoint_id: checkpoint-001',
+        '    timestamp: 2026-03-06T10:01:00.000Z',
+        '    files_changed: [src/a.ts]',
+        '    validation_status: valid',
+        '    violations: []',
+        '    diff_snapshot: .aop/features/feature_checkpoint_compare/checkpoints/checkpoint-001.diff',
+        '---',
+        '',
+      ].join('\n'),
+      'utf8',
+    );
+    await fs.writeFile(
+      path.join(checkpointDir, 'checkpoint-001.diff'),
+      [
+        'diff --git a/src/a.ts b/src/a.ts',
+        'index 1111111..2222222 100644',
+        '--- a/src/a.ts',
+        '+++ b/src/a.ts',
+        '@@ -1 +1 @@',
+        '-const value = 1;',
+        '+const value = 2;',
+      ].join('\n'),
+      'utf8',
+    );
+    await fs.writeFile(
+      path.join(checkpointDir, 'checkpoint-002.diff'),
+      [
+        'diff --git a/src/a.ts b/src/a.ts',
+        'index 1111111..3333333 100644',
+        '--- a/src/a.ts',
+        '+++ b/src/a.ts',
+        '@@ -1 +1 @@',
+        '-const value = 1;',
+        '+const value = 3;',
+        'diff --git a/src/b.ts b/src/b.ts',
+        'new file mode 100644',
+        '--- /dev/null',
+        '+++ b/src/b.ts',
+        '@@ -0,0 +1 @@',
+        '+export const b = true;',
+      ].join('\n'),
+      'utf8',
+    );
+
+    const checkpoints = await readFeatureCheckpoints(featureId, repoRoot);
+    expect(checkpoints?.execution_mode).toBe('interactive');
+    expect(checkpoints?.checkpoints).toHaveLength(2);
+
+    const snapshot = await readFeatureCheckpointDiff(featureId, 'checkpoint-001', repoRoot);
+    expect(snapshot?.checkpoint.checkpoint_id).toBe('checkpoint-001');
+    expect(snapshot?.diff).toContain('diff --git');
+
+    const comparison = await compareFeatureCheckpoints(
+      featureId,
+      'checkpoint-001',
+      'checkpoint-002',
+      repoRoot,
+    );
+    expect(comparison).not.toBeNull();
+    expect(comparison?.summary.changed).toBeGreaterThanOrEqual(1);
+    expect(comparison?.summary.added).toBeGreaterThanOrEqual(1);
+  });
+
+  it('GIVEN_interactive_metrics_and_worker_events_WHEN_readInteractivePerformanceMetrics_THEN_returns_aggregated_snapshot', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-dash-client-'));
+    tempRoots.push(repoRoot);
+    await fs.mkdir(path.join(repoRoot, '.aop', 'analytics'), { recursive: true });
+    await fs.mkdir(path.join(repoRoot, '.aop', 'runtime', 'worker-events'), { recursive: true });
+    await fs.writeFile(
+      path.join(repoRoot, '.aop', 'analytics', 'interactive-mode.json'),
+      JSON.stringify(
+        {
+          schema_version: 1,
+          updated_at: '2026-03-06T00:00:00.000Z',
+          totals: {
+            checkpoint_count: 3,
+            valid_count: 2,
+            invalid_count: 1,
+            skipped_count: 0,
+            files_changed_total: 9,
+          },
+          histories: {
+            checkpoint_latency_ms: [200, 300, 500],
+            validation_latency_ms: [90, 120, 150],
+            diff_capture_latency_ms: [40, 50, 60],
+          },
+          latest: {
+            recorded_at: '2026-03-06T00:00:00.000Z',
+            feature_id: 'feature_metrics',
+            checkpoint_id: 'checkpoint-003',
+            trigger: 'final',
+            validation_status: 'valid',
+            checkpoint_latency_ms: 500,
+            validation_latency_ms: 150,
+            diff_capture_latency_ms: 60,
+            files_changed: 4,
+          },
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await fs.writeFile(
+      path.join(repoRoot, '.aop', 'runtime', 'worker-events', 'run-test.jsonl'),
+      [
+        JSON.stringify({
+          ts: '2026-03-06T00:00:00.000Z',
+          role: 'builder',
+          output_types: ['PATCH'],
+          patch_count: 1,
+          plan_submission_count: 0,
+          request_count: 1,
+          note_count: 0,
+          valid: true,
+          error_code: null,
+          provider: 'codex',
+          model: 'gpt-5',
+          execution_mode: 'interactive',
+          elapsed_ms: 1200,
+        }),
+        JSON.stringify({
+          ts: '2026-03-06T00:00:10.000Z',
+          role: 'builder',
+          output_types: ['PATCH'],
+          patch_count: 1,
+          plan_submission_count: 0,
+          request_count: 4,
+          note_count: 0,
+          valid: true,
+          error_code: null,
+          provider: 'codex',
+          model: 'gpt-5',
+          execution_mode: 'deterministic',
+          elapsed_ms: 2400,
+        }),
+      ].join('\n'),
+      'utf8',
+    );
+
+    const metrics = await readInteractivePerformanceMetrics(repoRoot);
+    expect(metrics.checkpoint_count).toBe(3);
+    expect(metrics.avg_checkpoint_latency_ms).toBeCloseTo(333.3, 1);
+    expect(metrics.execution_modes.interactive_iterations).toBe(1);
+    expect(metrics.execution_modes.deterministic_iterations).toBe(1);
+    expect(metrics.execution_modes.context_request_reduction_ratio).toBeCloseTo(0.75, 2);
+    expect(metrics.latest?.checkpoint_id).toBe('checkpoint-003');
+  });
 });

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

@@ -0,0 +1,314 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+  FeatureSendMessageService,
+  type FeatureSendMessageServicePort,
+} from '../src/application/services/feature-send-message-service.js';
+import { STATUS, GATE_RESULT } from '../src/core/constants.js';
+import type { RuntimeSessionsSnapshot } from '../src/core/runtime-sessions.js';
+
+function makeSendMessageMock() {
+  return vi.fn(async (_sessionId: string, _message: string) => {});
+}
+
+function makeRuntimeSessions(
+  overrides: Partial<RuntimeSessionsSnapshot> = {},
+): RuntimeSessionsSnapshot {
+  const now = new Date().toISOString();
+  return {
+    run_id: 'run1',
+    orchestrator_session_id: 'orch-session',
+    provider: 'codex',
+    model: 'gpt-4',
+    provider_config_ref_hash: 'hash',
+    owner_instance_id: 'owner1',
+    lease_id: 'lease1',
+    started_at: now,
+    last_heartbeat_at: now,
+    lease_expires_at: now,
+    feature_sessions: {
+      feat1: {
+        planner_session_id: 'planner-sess',
+        builder_session_id: 'builder-sess',
+        qa_session_id: 'qa-sess',
+      },
+    },
+    ...overrides,
+  };
+}
+
+function makePort(
+  overrides: Partial<FeatureSendMessageServicePort> = {},
+): FeatureSendMessageServicePort {
+  return {
+    readState: vi.fn(async () => ({ frontMatter: { status: '' }, body: '', raw: '' })),
+    getRuntimeSessions: vi.fn(async () => makeRuntimeSessions()),
+    getProvider: vi.fn(() => ({
+      sendMessage: makeSendMessageMock(),
+    })),
+    ...overrides,
+  };
+}
+
+describe('FeatureSendMessageService', () => {
+  let sendMessageMock: ReturnType<typeof makeSendMessageMock>;
+
+  beforeEach(() => {
+    sendMessageMock = makeSendMessageMock();
+    vi.clearAllMocks();
+  });
+
+  it('GIVEN_null_featureId_WHEN_featureSendMessage_THEN_throws_INVALID_ARGUMENT', async () => {
+    const service = new FeatureSendMessageService(makePort());
+    await expect(service.featureSendMessage(null, 'hello')).rejects.toMatchObject({
+      normalizedResponse: expect.objectContaining({ ok: false }),
+    });
+  });
+
+  it('GIVEN_null_message_WHEN_featureSendMessage_THEN_throws_INVALID_ARGUMENT', async () => {
+    const service = new FeatureSendMessageService(makePort());
+    await expect(service.featureSendMessage('feat1', null)).rejects.toMatchObject({
+      normalizedResponse: expect.objectContaining({ ok: false }),
+    });
+  });
+
+  it('GIVEN_no_feature_session_WHEN_featureSendMessage_THEN_throws_session_not_found', async () => {
+    const port = makePort({
+      getRuntimeSessions: vi.fn(async () => makeRuntimeSessions({ feature_sessions: {} })),
+    });
+    const service = new FeatureSendMessageService(port);
+    await expect(service.featureSendMessage('feat1', 'hello')).rejects.toMatchObject({
+      normalizedResponse: { ok: false, error: { code: 'session_not_found' } },
+    });
+  });
+
+  it('GIVEN_no_provider_WHEN_featureSendMessage_THEN_throws_provider_unsupported', async () => {
+    const port = makePort({
+      getProvider: vi.fn(() => null),
+    });
+    const service = new FeatureSendMessageService(port);
+    await expect(service.featureSendMessage('feat1', 'hello')).rejects.toMatchObject({
+      normalizedResponse: { ok: false, error: { code: 'provider_unsupported' } },
+    });
+  });
+
+  it('GIVEN_status_PLANNING_WHEN_featureSendMessage_THEN_routes_to_planner', async () => {
+    const port = makePort({
+      readState: vi.fn(async () => ({
+        frontMatter: { status: STATUS.PLANNING },
+        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('planner');
+    expect(result.session_id).toBe('planner-sess');
+    expect(sendMessageMock).toHaveBeenCalledWith('planner-sess', 'hello');
+  });
+
+  it('GIVEN_status_BUILDING_WHEN_featureSendMessage_THEN_routes_to_builder', async () => {
+    const port = makePort({
+      readState: vi.fn(async () => ({
+        frontMatter: { status: STATUS.BUILDING },
+        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_status_QA_WHEN_featureSendMessage_THEN_routes_to_qa', async () => {
+    const port = makePort({
+      readState: vi.fn(async () => ({ frontMatter: { status: STATUS.QA }, 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('qa');
+    expect(result.session_id).toBe('qa-sess');
+  });
+
+  it('GIVEN_status_READY_TO_MERGE_WHEN_featureSendMessage_THEN_routes_to_qa', async () => {
+    const port = makePort({
+      readState: vi.fn(async () => ({
+        frontMatter: { status: STATUS.READY_TO_MERGE },
+        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('qa');
+  });
+
+  it('GIVEN_status_BLOCKED_fast_fail_full_not_fail_WHEN_featureSendMessage_THEN_routes_to_builder', async () => {
+    const port = makePort({
+      readState: vi.fn(async () => ({
+        frontMatter: {
+          status: STATUS.BLOCKED,
+          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_status_BLOCKED_full_fail_WHEN_featureSendMessage_THEN_routes_to_qa', async () => {
+    const port = makePort({
+      readState: vi.fn(async () => ({
+        frontMatter: {
+          status: STATUS.BLOCKED,
+          gates: { fast: GATE_RESULT.FAIL, full: GATE_RESULT.FAIL },
+        },
+        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('qa');
+    expect(result.session_id).toBe('qa-sess');
+  });
+
+  it('GIVEN_status_BLOCKED_only_fast_fail_no_full_WHEN_featureSendMessage_THEN_routes_to_builder', async () => {
+    const port = makePort({
+      readState: vi.fn(async () => ({
+        frontMatter: {
+          status: STATUS.BLOCKED,
+          gates: { fast: GATE_RESULT.FAIL },
+        },
+        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');
+  });
+
+  it('GIVEN_unknown_status_WHEN_featureSendMessage_THEN_routes_to_orchestrator', async () => {
+    const port = makePort({
+      readState: vi.fn(async () => ({
+        frontMatter: { status: 'unknown_status' },
+        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('orchestrator');
+    expect(result.session_id).toBe('orch-session');
+  });
+
+  it('GIVEN_planner_session_unassigned_WHEN_featureSendMessage_THEN_falls_back_to_orchestrator', async () => {
+    const port = makePort({
+      readState: vi.fn(async () => ({
+        frontMatter: { status: STATUS.PLANNING },
+        body: '',
+        raw: '',
+      })),
+      getRuntimeSessions: vi.fn(async () =>
+        makeRuntimeSessions({
+          feature_sessions: {
+            feat1: {
+              planner_session_id: 'unassigned',
+              builder_session_id: 'builder-sess',
+              qa_session_id: 'qa-sess',
+            },
+          },
+        }),
+      ),
+      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_builder_session_unknown_WHEN_featureSendMessage_THEN_falls_back_to_orchestrator', async () => {
+    const port = makePort({
+      readState: vi.fn(async () => ({
+        frontMatter: { status: STATUS.BUILDING },
+        body: '',
+        raw: '',
+      })),
+      getRuntimeSessions: vi.fn(async () =>
+        makeRuntimeSessions({
+          feature_sessions: {
+            feat1: {
+              planner_session_id: 'planner-sess',
+              builder_session_id: 'unknown',
+              qa_session_id: 'qa-sess',
+            },
+          },
+        }),
+      ),
+      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');
+  });
+
+  it('GIVEN_successful_send_WHEN_featureSendMessage_THEN_returns_delivery_receipt', async () => {
+    const port = makePort({
+      readState: vi.fn(async () => ({
+        frontMatter: { status: STATUS.BUILDING },
+        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.delivered).toBe(true);
+    expect(result.feature_id).toBe('feat1');
+  });
+
+  it('GIVEN_provider_without_sendMessage_WHEN_featureSendMessage_THEN_throws_provider_unsupported', async () => {
+    const port = makePort({
+      getProvider: vi.fn(() => ({})),
+    });
+    const service = new FeatureSendMessageService(port);
+    await expect(service.featureSendMessage('feat1', 'hello')).rejects.toMatchObject({
+      normalizedResponse: { ok: false, error: { code: 'provider_unsupported' } },
+    });
+  });
+
+  it('GIVEN_provider_with_getSessionInfo_active_true_WHEN_waiting_THEN_resolves_quickly', async () => {
+    const getSessionInfoMock = vi.fn(async (_sessionId: string) => ({
+      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);
+  });
+});

package/apps/control-plane/test/init-wizard.spec.ts

@@ -97,6 +97,9 @@ describe('InitCommandHandler', () => {
     expect(agentsContent).toContain('roles:');
     expect(agentsContent).toContain('default_provider: custom');
     expect(agentsContent).toContain('default_model: local-default');
+    expect(agentsContent).toContain('execution_mode: deterministic');
+    expect(agentsContent).toContain('interactive:');
+    expect(agentsContent).toContain('checkpoint_interval_ms: 30000');
     expect(agentsContent).not.toContain('provider_config_env:');
 
     const adaptersContent = await fs.readFile(
@@ -351,6 +354,7 @@ describe('InitCommandHandler', () => {
     );
     expect(agentsContent).toContain('default_provider: claude');
     expect(agentsContent).toContain('default_model: sonnet-4.5');
+    expect(agentsContent).toContain('execution_mode: deterministic');
     expect(agentsContent).not.toContain('provider_config_env:');
 
     const adaptersContent = await fs.readFile(
@@ -392,6 +396,37 @@ describe('InitCommandHandler', () => {
       'utf8',
     );
     expect(agentsContent).not.toContain('provider_config_env:');
+    expect(agentsContent).toContain('execution_mode: deterministic');
+  });
+
+  it('GIVEN_execution_mode_prompt_answered_interactive_WHEN_init_runs_THEN_agents_yaml_sets_interactive_runtime_mode', async () => {
+    await fs.mkdir(path.join(cwd, '.git'), { recursive: true });
+    await fs.writeFile(path.join(cwd, '.git', 'config'), '[core]\n', 'utf8');
+    execFileMock.mockResolvedValue({ stdout: 'origin/main\n', stderr: '' });
+
+    const prompts = makePromptFactory([
+      'main',
+      'codex',
+      'codex-default',
+      'github',
+      '3',
+      '3000',
+      'none',
+      'vitest',
+      'yes',
+      'interactive',
+    ]);
+    const handler = new InitCommandHandler(cwd, prompts.factory);
+    const result = await handler.execute({ auto: false });
+
+    expect(result.ok).toBe(true);
+    const agentsContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'agents.yaml'),
+      'utf8',
+    );
+    expect(agentsContent).toContain('execution_mode: interactive');
+    expect(agentsContent).toContain('interactive:');
+    expect(agentsContent).toContain('shadow_workspace:');
   });
 
   it('GIVEN_api_backed_mode_with_existing_env_var_WHEN_init_runs_THEN_agents_yaml_uses_that_env_var', async () => {

package/apps/control-plane/test/path-normalizers.spec.ts

@@ -0,0 +1,41 @@
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import {
+  normalizeFromWorktree,
+  normalizeRepoPathForState,
+} from '../src/core/utils/path-normalizers.js';
+
+describe('path-normalizers', () => {
+  it('normalizeRepoPathForState returns dot when absolute path is repo root', () => {
+    const repoRoot = '/repo';
+    expect(normalizeRepoPathForState(repoRoot, repoRoot)).toBe('.');
+  });
+
+  it('normalizeRepoPathForState returns repo-relative path for nested file', () => {
+    const repoRoot = '/repo';
+    const absolutePath = path.join(repoRoot, 'apps', 'control-plane', 'src', 'index.ts');
+    expect(normalizeRepoPathForState(repoRoot, absolutePath)).toBe(
+      'apps/control-plane/src/index.ts',
+    );
+  });
+
+  it('normalizeFromWorktree keeps relative path when target is inside worktree', () => {
+    const repoRoot = '/repo';
+    const worktreePath = '/repo/.worktrees/feature-a';
+    const repoRelativeFromWorktree = '.worktrees/feature-a/apps/control-plane/src/aop.ts';
+
+    expect(normalizeFromWorktree(worktreePath, repoRoot, repoRelativeFromWorktree)).toBe(
+      'apps/control-plane/src/aop.ts',
+    );
+  });
+
+  it('normalizeFromWorktree falls back to repo-relative when target is outside worktree', () => {
+    const repoRoot = '/repo';
+    const worktreePath = '/repo/.worktrees/feature-a';
+    const repoRelativeFromWorktree = 'README.md';
+
+    expect(normalizeFromWorktree(worktreePath, repoRoot, repoRelativeFromWorktree)).toBe(
+      'README.md',
+    );
+  });
+});