agentic-orchestrator 0.1.2 → 0.1.4

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

@@ -0,0 +1,422 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('../src/core/git.js', () => ({
+  runGit: vi.fn()
+}));
+
+import { runGit } from '../src/core/git.js';
+import { FeatureDeletionService } from '../src/application/services/feature-deletion-service.js';
+import { ERROR_CODES } from '../src/core/error-codes.js';
+import type { RuntimeSessionsSnapshot } from '../src/core/runtime-sessions.js';
+
+function commandResult(overrides: Partial<{
+  code: number;
+  signal: NodeJS.Signals | null;
+  stdout: string;
+  stderr: string;
+  timeout: boolean;
+}> = {}) {
+  return { code: 0, signal: null, stdout: '', stderr: '', timeout: false, ...overrides };
+}
+
+function makeStaleRunLease(): RuntimeSessionsSnapshot {
+  const now = new Date().toISOString();
+  return {
+    run_id: 'none',
+    orchestrator_session_id: 'unknown',
+    provider: 'unknown',
+    model: 'unknown',
+    provider_config_ref_hash: 'hash',
+    owner_instance_id: 'none',
+    lease_id: 'none',
+    started_at: now,
+    last_heartbeat_at: now,
+    lease_expires_at: now,
+    feature_sessions: {}
+  };
+}
+
+describe('FeatureDeletionService git failure paths', () => {
+  let repoRoot: string;
+  let featureDir: string;
+  let worktreeDir: string;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-del-'));
+    featureDir = path.join(repoRoot, '.aop', 'features', 'feature_x');
+    worktreeDir = path.join(repoRoot, '.worktrees', 'feature_x');
+    await fs.mkdir(featureDir, { recursive: true });
+    await fs.mkdir(worktreeDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(repoRoot, { recursive: true, force: true });
+  });
+
+  function makeMockPort() {
+    const staleRunLease = makeStaleRunLease();
+    return {
+      getRepoRoot: () => repoRoot,
+      featurePath: (_featureId: string) => featureDir,
+      worktreePath: (_featureId: string) => worktreeDir,
+      statePath: (_featureId: string) => path.join(featureDir, 'state.md'),
+      readState: vi.fn(async () => ({ frontMatter: {}, body: '' })),
+      withIndexLock: async <T>(op: () => Promise<T>) => await op(),
+      readIndex: vi.fn(async () => ({
+        version: 1,
+        active: ['feature_x'],
+        blocked: [],
+        merged: [],
+        locks: {},
+        lock_leases: {},
+        blocked_queue: [],
+        updated_at: new Date().toISOString()
+      })),
+      writeIndex: vi.fn(async () => {}),
+      readRunLease: vi.fn(async () => ({ ...staleRunLease })),
+      writeRunLease: vi.fn(async () => {}),
+      normalizeRuntimeSessions: vi.fn(() => staleRunLease),
+      isRunLeaseFresh: vi.fn(() => false),
+      locksRelease: vi.fn(async () => {})
+    };
+  }
+
+  it('GIVEN_worktree_exists_WHEN_runGit_worktree_remove_fails_THEN_throws_GIT_FAILURE', async () => {
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult({ code: 1 }))                          // show-ref → no branch
+      .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'not a worktree' })); // worktree remove fails
+
+    const service = new FeatureDeletionService(makeMockPort());
+
+    await expect(
+      service.featureDelete('feature_x', { dryRun: false, confirm: true, removeWorktree: true, removeBranch: 'none' })
+    ).rejects.toMatchObject({
+      normalizedResponse: expect.objectContaining({
+        ok: false,
+        error: expect.objectContaining({ code: ERROR_CODES.GIT_FAILURE })
+      })
+    });
+  });
+
+  it('GIVEN_branch_exists_WHEN_branch_removed_safely_succeeds_THEN_summary_branch_removed_true', async () => {
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult({ code: 0 })) // show-ref → branch exists
+      .mockResolvedValueOnce(commandResult({ code: 0 })); // branch -d succeeds
+
+    const service = new FeatureDeletionService(makeMockPort());
+
+    const result = await service.featureDelete('feature_x', {
+      dryRun: false,
+      confirm: true,
+      removeWorktree: false,
+      removeBranch: 'safe'
+    });
+
+    expect(result.data.summary.branch_removed).toBe(true);
+    expect(vi.mocked(runGit)).toHaveBeenCalledWith(repoRoot, ['branch', '-d', 'feature_x']);
+  });
+
+  it('GIVEN_branch_exists_WHEN_runGit_branch_remove_fails_THEN_throws_GIT_FAILURE', async () => {
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult({ code: 0 }))                           // show-ref → branch exists
+      .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'branch not merged' })); // branch -d fails
+
+    const service = new FeatureDeletionService(makeMockPort());
+
+    await expect(
+      service.featureDelete('feature_x', { dryRun: false, confirm: true, removeWorktree: false, removeBranch: 'safe' })
+    ).rejects.toMatchObject({
+      normalizedResponse: expect.objectContaining({
+        ok: false,
+        error: expect.objectContaining({ code: ERROR_CODES.GIT_FAILURE })
+      })
+    });
+  });
+
+  it('GIVEN_branch_exists_WHEN_force_remove_mode_THEN_uses_dash_capital_D_arg', async () => {
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult({ code: 0 })) // show-ref → branch exists
+      .mockResolvedValueOnce(commandResult({ code: 0 })); // branch -D succeeds
+
+    const service = new FeatureDeletionService(makeMockPort());
+
+    const result = await service.featureDelete('feature_x', {
+      dryRun: false,
+      confirm: true,
+      removeWorktree: false,
+      removeBranch: 'force'
+    });
+
+    expect(result.data.summary.branch_removed).toBe(true);
+    expect(vi.mocked(runGit)).toHaveBeenCalledWith(repoRoot, ['branch', '-D', 'feature_x']);
+  });
+});
+
+describe('FeatureDeletionService input validation paths', () => {
+  let repoRoot: string;
+  let featureDir: string;
+  let worktreeDir: string;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-del-val-'));
+    featureDir = path.join(repoRoot, '.aop', 'features', 'feature_x');
+    worktreeDir = path.join(repoRoot, '.worktrees', 'feature_x');
+    await fs.mkdir(featureDir, { recursive: true });
+    await fs.mkdir(worktreeDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(repoRoot, { recursive: true, force: true });
+  });
+
+  function makeMockPort() {
+    const staleRunLease = makeStaleRunLease();
+    return {
+      getRepoRoot: () => repoRoot,
+      featurePath: (_featureId: string) => featureDir,
+      worktreePath: (_featureId: string) => worktreeDir,
+      statePath: (_featureId: string) => path.join(featureDir, 'state.md'),
+      readState: vi.fn(async () => ({ frontMatter: {}, body: '' })),
+      withIndexLock: async <T>(op: () => Promise<T>) => await op(),
+      readIndex: vi.fn(async () => ({
+        version: 1,
+        active: ['feature_x'],
+        blocked: [],
+        merged: [],
+        locks: {},
+        lock_leases: {},
+        blocked_queue: [],
+        updated_at: new Date().toISOString()
+      })),
+      writeIndex: vi.fn(async () => {}),
+      readRunLease: vi.fn(async () => ({ ...staleRunLease })),
+      writeRunLease: vi.fn(async () => {}),
+      normalizeRuntimeSessions: vi.fn(() => staleRunLease),
+      isRunLeaseFresh: vi.fn(() => false),
+      locksRelease: vi.fn(async () => {})
+    };
+  }
+
+  it('GIVEN_null_feature_id_WHEN_featureDelete_called_THEN_throws_INVALID_ARGUMENT', async () => {
+    const service = new FeatureDeletionService(makeMockPort());
+
+    await expect(
+      service.featureDelete(null)
+    ).rejects.toMatchObject({
+      normalizedResponse: expect.objectContaining({
+        ok: false,
+        error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT })
+      })
+    });
+  });
+
+  it('GIVEN_invalid_feature_id_format_WHEN_featureDelete_called_THEN_throws_INVALID_ARGUMENT', async () => {
+    const service = new FeatureDeletionService(makeMockPort());
+
+    await expect(
+      service.featureDelete('INVALID FEATURE ID!')
+    ).rejects.toMatchObject({
+      normalizedResponse: expect.objectContaining({
+        ok: false,
+        error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT })
+      })
+    });
+  });
+
+  it('GIVEN_invalid_remove_branch_value_WHEN_featureDelete_called_THEN_throws_INVALID_ARGUMENT', async () => {
+    const service = new FeatureDeletionService(makeMockPort());
+
+    await expect(
+      service.featureDelete('feature_x', { removeBranch: 'invalid-mode' })
+    ).rejects.toMatchObject({
+      normalizedResponse: expect.objectContaining({
+        ok: false,
+        error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT })
+      })
+    });
+  });
+
+  it('GIVEN_dry_run_false_and_confirm_false_WHEN_featureDelete_called_THEN_throws_INVALID_ARGUMENT', async () => {
+    const service = new FeatureDeletionService(makeMockPort());
+
+    await expect(
+      service.featureDelete('feature_x', { dryRun: false, confirm: false, removeBranch: 'none' })
+    ).rejects.toMatchObject({
+      normalizedResponse: expect.objectContaining({
+        ok: false,
+        error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT })
+      })
+    });
+  });
+
+  it('GIVEN_dry_run_true_WHEN_featureDelete_called_THEN_returns_plan_without_applying_changes', async () => {
+    vi.mocked(runGit).mockResolvedValue(commandResult({ code: 1 })); // no branch
+
+    const service = new FeatureDeletionService(makeMockPort());
+
+    const result = await service.featureDelete('feature_x', { dryRun: true, removeBranch: 'none' });
+
+    expect(result.data.dry_run).toBe(true);
+    expect(result.data.plan).toBeDefined();
+    expect(result.data.applied).toBeUndefined();
+  });
+
+  it('GIVEN_fresh_run_lease_WHEN_featureDelete_called_THEN_throws_RUN_ALREADY_ACTIVE', async () => {
+    vi.mocked(runGit).mockResolvedValue(commandResult({ code: 1 })); // no branch
+
+    const now = new Date().toISOString();
+    const freshLease: RuntimeSessionsSnapshot = {
+      run_id: 'run:active',
+      orchestrator_session_id: 'orch-1',
+      provider: 'custom',
+      model: 'model-x',
+      provider_config_ref_hash: 'hash',
+      owner_instance_id: 'owner:1',
+      lease_id: 'lease:1',
+      started_at: now,
+      last_heartbeat_at: now,
+      lease_expires_at: new Date(Date.now() + 60_000).toISOString(),
+      feature_sessions: {}
+    };
+
+    const port = makeMockPort();
+    port.readRunLease.mockResolvedValue(freshLease);
+    port.isRunLeaseFresh.mockReturnValue(true);
+
+    const service = new FeatureDeletionService(port);
+
+    await expect(
+      service.featureDelete('feature_x', { dryRun: false, confirm: true, removeBranch: 'none' })
+    ).rejects.toMatchObject({
+      normalizedResponse: expect.objectContaining({
+        ok: false,
+        error: expect.objectContaining({ code: ERROR_CODES.RUN_ALREADY_ACTIVE })
+      })
+    });
+  });
+
+  it('GIVEN_non_dry_run_with_no_branch_and_no_worktree_WHEN_featureDelete_called_THEN_removes_feature_dir', async () => {
+    vi.mocked(runGit).mockResolvedValue(commandResult({ code: 1 })); // no branch
+
+    const service = new FeatureDeletionService(makeMockPort());
+
+    const result = await service.featureDelete('feature_x', {
+      dryRun: false,
+      confirm: true,
+      removeWorktree: false,
+      removeBranch: 'none'
+    });
+
+    expect(result.data.dry_run).toBe(false);
+    expect(result.data.summary.feature_dir_removed).toBe(true);
+  });
+});
+
+describe('FeatureDeletionService readLockResourcesFromIndex and normalizeFeatureSessions branches', () => {
+  let repoRoot: string;
+  let featureDir: string;
+  let worktreeDir: string;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-del-extra-'));
+    featureDir = path.join(repoRoot, '.aop', 'features', 'feature_lock_lease');
+    worktreeDir = path.join(repoRoot, '.worktrees', 'feature_lock_lease');
+    await fs.mkdir(featureDir, { recursive: true });
+    await fs.mkdir(worktreeDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(repoRoot, { recursive: true, force: true });
+  });
+
+  it('GIVEN_lock_leases_with_holder_matching_featureId_WHEN_featureDelete_THEN_lock_released', async () => {
+    vi.mocked(runGit).mockResolvedValue(commandResult({ code: 1 }));
+
+    const staleRunLease = makeStaleRunLease();
+    const port = {
+      getRepoRoot: () => repoRoot,
+      featurePath: () => featureDir,
+      worktreePath: () => worktreeDir,
+      statePath: () => path.join(featureDir, 'state.md'),
+      readState: vi.fn(async () => ({ frontMatter: {}, body: '' })),
+      withIndexLock: async <T>(op: () => Promise<T>) => await op(),
+      readIndex: vi.fn(async () => ({
+        version: 1,
+        active: ['feature_lock_lease'],
+        blocked: [],
+        merged: [],
+        locks: {},
+        lock_leases: {
+          openapi: { holder: 'feature_lock_lease', expires_at: new Date().toISOString() }
+        },
+        blocked_queue: [],
+        updated_at: new Date().toISOString()
+      })),
+      writeIndex: vi.fn(async () => {}),
+      readRunLease: vi.fn(async () => ({ ...staleRunLease })),
+      writeRunLease: vi.fn(async () => {}),
+      normalizeRuntimeSessions: vi.fn(() => staleRunLease),
+      isRunLeaseFresh: vi.fn(() => false),
+      locksRelease: vi.fn(async () => {})
+    };
+
+    const service = new FeatureDeletionService(port);
+    const result = await service.featureDelete('feature_lock_lease', {
+      dryRun: false,
+      confirm: true,
+      removeWorktree: false,
+      removeBranch: 'none'
+    });
+
+    expect(result.data.summary.locks_released).toContain('openapi');
+  });
+
+  it('GIVEN_feature_sessions_is_undefined_WHEN_normalizeFeatureSessions_called_THEN_returns_empty_object', async () => {
+    vi.mocked(runGit).mockResolvedValue(commandResult({ code: 1 }));
+
+    const staleRunLease = {
+      ...makeStaleRunLease(),
+      feature_sessions: undefined as unknown as Record<string, unknown>
+    };
+    const port = {
+      getRepoRoot: () => repoRoot,
+      featurePath: () => featureDir,
+      worktreePath: () => worktreeDir,
+      statePath: () => path.join(featureDir, 'state.md'),
+      readState: vi.fn(async () => ({ frontMatter: {}, body: '' })),
+      withIndexLock: async <T>(op: () => Promise<T>) => await op(),
+      readIndex: vi.fn(async () => ({
+        version: 1,
+        active: ['feature_lock_lease'],
+        blocked: [],
+        merged: [],
+        locks: {},
+        lock_leases: {},
+        blocked_queue: [],
+        updated_at: new Date().toISOString()
+      })),
+      writeIndex: vi.fn(async () => {}),
+      readRunLease: vi.fn(async () => ({ ...staleRunLease })),
+      writeRunLease: vi.fn(async () => {}),
+      normalizeRuntimeSessions: vi.fn(() => ({ ...staleRunLease })),
+      isRunLeaseFresh: vi.fn(() => false),
+      locksRelease: vi.fn(async () => {})
+    };
+
+    const service = new FeatureDeletionService(port);
+    const result = await service.featureDelete('feature_lock_lease', {
+      dryRun: false,
+      confirm: true,
+      removeWorktree: false,
+      removeBranch: 'none'
+    });
+
+    expect(result.data.summary.runtime_session_assignment_removed).toBe(false);
+  });
+});

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

@@ -0,0 +1,202 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs/promises';
+import { FeatureLifecycleService } from '../src/application/services/feature-lifecycle-service.js';
+import type { FeatureLifecycleServicePort } from '../src/application/services/feature-lifecycle-service.js';
+
+function makeTmpDir(): string {
+  return path.join(os.tmpdir(), `aop-lifecycle-test-${process.pid}-${Date.now()}`);
+}
+
+function makePort(overrides: Partial<FeatureLifecycleServicePort> = {}): FeatureLifecycleServicePort {
+  const repoRoot = '/tmp/repo';
+  const featuresDir = '/tmp/repo/.aop/features';
+
+  return {
+    getRepoRoot: vi.fn(() => repoRoot),
+    getFeaturesDir: vi.fn(() => featuresDir),
+    featurePath: vi.fn((id) => `${featuresDir}/${id}`),
+    statePath: vi.fn((id) => `${featuresDir}/${id}/state.md`),
+    qaIndexPath: vi.fn((id) => `${featuresDir}/${id}/qa_test_index.json`),
+    decisionsPath: vi.fn((id) => `${featuresDir}/${id}/decisions.md`),
+    specPath: vi.fn((id) => `${featuresDir}/${id}/spec.md`),
+    ensureFeatureLayout: vi.fn(async () => {}),
+    repoEnsureWorktree: vi.fn(async () => ({ data: { worktree_path_abs: `/tmp/worktrees/f1` } })),
+    makeDefaultState: vi.fn(() => ({ feature_id: 'f1', status: 'planning', version: 0 })),
+    writeState: vi.fn(async () => {}),
+    withIndexLock: vi.fn(async (op: () => Promise<unknown>) => await op()),
+    readIndex: vi.fn(async () => ({ active: [], blocked: [], version: 0, updated_at: '' })),
+    writeIndex: vi.fn(async () => {}),
+    featureStateGet: vi.fn(async () => ({ data: { front_matter: { version: 1, status: 'planning' }, body: '' } })),
+    planGet: vi.fn(async () => ({ data: { plan: { files: {} } } })),
+    qaTestIndexGet: vi.fn(async () => ({ data: { items: [] } })),
+    evidenceLatest: vi.fn(async () => ({ data: { latest: null } })),
+    ...overrides
+  };
+}
+
+describe('FeatureLifecycleService', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('featureDiscoverSpecs', () => {
+    it('GIVEN_features_dir_does_not_exist_WHEN_featureDiscoverSpecs_called_THEN_returns_empty_specs', async () => {
+      const tmpDir = makeTmpDir();
+      const port = makePort({
+        getRepoRoot: vi.fn(() => tmpDir),
+        getFeaturesDir: vi.fn(() => path.join(tmpDir, '.aop', 'features'))
+      });
+      const service = new FeatureLifecycleService(port);
+      const result = await service.featureDiscoverSpecs();
+      expect(result.data.specs).toEqual([]);
+    });
+
+    it('GIVEN_features_dir_with_spec_files_WHEN_featureDiscoverSpecs_called_THEN_returns_specs', async () => {
+      const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-lc-'));
+      try {
+        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
+        await fs.mkdir(f1, { recursive: true });
+        await fs.mkdir(f2, { recursive: true });
+        await fs.writeFile(path.join(f1, 'spec.md'), '# Feature A', 'utf8');
+
+        const port = makePort({
+          getRepoRoot: vi.fn(() => tmpDir),
+          getFeaturesDir: vi.fn(() => featuresDir)
+        });
+        const service = new FeatureLifecycleService(port);
+        const result = await service.featureDiscoverSpecs();
+        expect(result.data.specs).toHaveLength(1);
+        expect(result.data.specs[0].feature_id).toBe('feature_a');
+      } finally {
+        await fs.rm(tmpDir, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe('featureInit', () => {
+    it('GIVEN_null_featureId_WHEN_featureInit_called_THEN_throws_INVALID_ARGUMENT', async () => {
+      const service = new FeatureLifecycleService(makePort());
+      await expect(service.featureInit(null)).rejects.toMatchObject({
+        normalizedResponse: { error: { code: 'invalid_argument' } }
+      });
+    });
+
+    it('GIVEN_valid_featureId_with_no_existing_state_WHEN_featureInit_called_THEN_creates_state_and_qa_index', async () => {
+      const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-lc2-'));
+      try {
+        const port = makePort({
+          getRepoRoot: vi.fn(() => tmpDir),
+          statePath: vi.fn(() => path.join(tmpDir, 'nonexistent-state.md')),
+          qaIndexPath: vi.fn(() => path.join(tmpDir, 'nonexistent-qa.json'))
+        });
+        const service = new FeatureLifecycleService(port);
+        const result = await service.featureInit('test_feature');
+        expect(result.data.initialized).toBe(true);
+        expect(port.writeState).toHaveBeenCalledOnce();
+        expect(port.writeIndex).toHaveBeenCalledOnce();
+      } finally {
+        await fs.rm(tmpDir, { recursive: true, force: true });
+      }
+    });
+
+    it('GIVEN_featureId_with_existing_state_and_qa_index_WHEN_featureInit_called_THEN_skips_creation', async () => {
+      const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-lc3-'));
+      try {
+        await fs.writeFile(path.join(tmpDir, 'state.md'), '---\nfeature_id: f1\n---', 'utf8');
+        await fs.writeFile(path.join(tmpDir, 'qa.json'), '{}', 'utf8');
+
+        const port = makePort({
+          getRepoRoot: vi.fn(() => tmpDir),
+          statePath: vi.fn(() => path.join(tmpDir, 'state.md')),
+          qaIndexPath: vi.fn(() => path.join(tmpDir, 'qa.json'))
+        });
+        const service = new FeatureLifecycleService(port);
+        await service.featureInit('f1');
+        expect(port.writeState).not.toHaveBeenCalled();
+      } finally {
+        await fs.rm(tmpDir, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe('featureGetContext', () => {
+    it('GIVEN_featureId_with_no_spec_file_WHEN_featureGetContext_called_THEN_spec_is_empty_string', async () => {
+      const port = makePort({
+        specPath: vi.fn(() => '/nonexistent/spec.md')
+      });
+      const service = new FeatureLifecycleService(port);
+      const result = await service.featureGetContext('f1');
+      expect(result.data.spec).toBe('');
+      expect(result.data.feature_id).toBe('f1');
+    });
+
+    it('GIVEN_featureId_with_evidence_WHEN_featureGetContext_called_THEN_latest_evidence_included', async () => {
+      const evidence = { gate_profile: 'fast', passed: true };
+      const port = makePort({
+        evidenceLatest: vi.fn(async () => ({ data: { latest: evidence } })),
+        specPath: vi.fn(() => '/nonexistent/spec.md')
+      });
+      const service = new FeatureLifecycleService(port);
+      const result = await service.featureGetContext('f1');
+      expect(result.data.latest_evidence).toEqual(evidence);
+    });
+  });
+
+  describe('featureLogAppend', () => {
+    it('GIVEN_featureId_and_note_WHEN_featureLogAppend_called_THEN_line_appended_to_log', async () => {
+      const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-lc4-'));
+      try {
+        const logPath = path.join(tmpDir, 'decisions.md');
+        const port = makePort({
+          getRepoRoot: vi.fn(() => tmpDir),
+          decisionsPath: vi.fn(() => logPath)
+        });
+        const service = new FeatureLifecycleService(port);
+        const result = await service.featureLogAppend('f1', 'starting build', { actorType: 'orchestrator', actorId: 'orch-1' });
+        expect(result.data.appended).toBe(true);
+        const content = await fs.readFile(logPath, 'utf8');
+        expect(content).toContain('[orchestrator:orch-1] starting build');
+      } finally {
+        await fs.rm(tmpDir, { recursive: true, force: true });
+      }
+    });
+  });
+});
+
+describe('ToolRouter and ToolHandlerRegistry', () => {
+  it('GIVEN_registered_handler_WHEN_route_called_THEN_handler_invoked', async () => {
+    const { ToolHandlerRegistry, ToolRouter } = await import('../src/application/tools/tool-router.js');
+    const registry = new ToolHandlerRegistry();
+    const handler = vi.fn(async () => ({ ok: true }));
+    registry.register('test.tool', handler);
+
+    const unknownHandler = vi.fn(async () => ({ error: 'unknown' }));
+    const router = new ToolRouter(registry, unknownHandler);
+
+    const result = await router.route('test.tool', { arg: 1 }, { actorType: 'orchestrator', actorId: 'o1' });
+    expect(handler).toHaveBeenCalledWith({ arg: 1 }, { actorType: 'orchestrator', actorId: 'o1' });
+    expect(result).toEqual({ ok: true });
+    expect(unknownHandler).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_no_handler_registered_WHEN_route_called_THEN_unknown_handler_invoked', async () => {
+    const { ToolHandlerRegistry, ToolRouter } = await import('../src/application/tools/tool-router.js');
+    const registry = new ToolHandlerRegistry();
+    const unknownHandler = vi.fn(async (name: string) => ({ error: `unknown: ${name}` }));
+    const router = new ToolRouter(registry, unknownHandler);
+
+    const result = await router.route('nonexistent.tool', {}, { actorType: 'builder', actorId: 'b1' });
+    expect(unknownHandler).toHaveBeenCalledWith('nonexistent.tool');
+    expect(result).toEqual({ error: 'unknown: nonexistent.tool' });
+  });
+
+  it('GIVEN_registry_WHEN_lookup_called_for_unregistered_tool_THEN_returns_undefined', async () => {
+    const { ToolHandlerRegistry } = await import('../src/application/tools/tool-router.js');
+    const registry = new ToolHandlerRegistry();
+    expect(registry.lookup('missing.tool')).toBeUndefined();
+  });
+});

package/apps/control-plane/test/git-spawn-error.spec.ts

@@ -0,0 +1,24 @@
+import { vi, it, expect, describe } from 'vitest';
+import type * as ChildProcess from 'node:child_process';
+
+vi.mock('node:child_process', async (importOriginal) => {
+  const actual = await importOriginal<typeof ChildProcess>();
+  return {
+    ...actual,
+    spawn: vi.fn().mockImplementationOnce(() => {
+      throw new Error('spawn sync error');
+    })
+  };
+});
+
+import { NodeCommandRunner } from '../src/core/git.js';
+
+describe('NodeCommandRunner spawn error', () => {
+  it('GIVEN_spawn_throws_synchronously_WHEN_run_called_THEN_returns_code_127', async () => {
+    const runner = new NodeCommandRunner();
+    const result = await runner.run('git', ['status']);
+    expect(result.code).toBe(127);
+    expect(result.stderr).toBe('spawn sync error');
+    expect(result.timeout).toBe(false);
+  });
+});