agentic-orchestrator 0.1.28 → 0.2.0

package/apps/control-plane/test/retry-resume-decision.spec.ts

@@ -0,0 +1,133 @@
+import { describe, it, expect } from 'vitest';
+import {
+  mergeFailureRequiresRepairLoop,
+  shouldAttemptAutoResumeAfterRetry,
+} from '../src/cli/retry-resume-decision.js';
+
+describe('shouldAttemptAutoResumeAfterRetry', () => {
+  it('GIVEN_retry_failed_WHEN_checked_THEN_returns_no_attempt', () => {
+    const result = shouldAttemptAutoResumeAfterRetry({ ok: false });
+    expect(result).toEqual({ attempt: false, skippedReason: 'retry_failed' });
+  });
+
+  it('GIVEN_waiting_for_input_WHEN_checked_THEN_returns_attempt', () => {
+    const result = shouldAttemptAutoResumeAfterRetry({
+      ok: true,
+      data: { waiting_for_input: true },
+    });
+    expect(result).toEqual({ attempt: true });
+  });
+
+  it('GIVEN_reroute_status_set_and_not_retry_executed_WHEN_checked_THEN_returns_attempt', () => {
+    const result = shouldAttemptAutoResumeAfterRetry({
+      ok: true,
+      data: { reroute_status: 'building', retry_executed: false },
+    });
+    expect(result).toEqual({ attempt: true });
+  });
+
+  it('GIVEN_retry_executed_true_WHEN_checked_THEN_returns_no_attempt', () => {
+    const result = shouldAttemptAutoResumeAfterRetry({
+      ok: true,
+      data: { retry_executed: true },
+    });
+    expect(result).toEqual({ attempt: false, skippedReason: 'retry_completed_in_place' });
+  });
+
+  it('GIVEN_ok_with_no_data_WHEN_checked_THEN_returns_no_resume_required', () => {
+    const result = shouldAttemptAutoResumeAfterRetry({ ok: true });
+    expect(result).toEqual({ attempt: false, skippedReason: 'no_resume_required' });
+  });
+
+  it('GIVEN_ok_with_empty_reroute_status_WHEN_checked_THEN_returns_no_resume_required', () => {
+    const result = shouldAttemptAutoResumeAfterRetry({
+      ok: true,
+      data: { reroute_status: '' },
+    });
+    expect(result).toEqual({ attempt: false, skippedReason: 'no_resume_required' });
+  });
+});
+
+describe('mergeFailureRequiresRepairLoop', () => {
+  it('GIVEN_merge_disabled_with_reconciliation_WHEN_checked_THEN_returns_feature_id', () => {
+    const payload = {
+      ok: false,
+      error: {
+        code: 'merge_disabled',
+        details: {
+          reconciliation_attempted: true,
+          recovery_available: true,
+          feature_id: 'my-feature',
+        },
+      },
+    };
+    expect(mergeFailureRequiresRepairLoop(payload)).toBe('my-feature');
+  });
+
+  it('GIVEN_ok_response_WHEN_checked_THEN_returns_null', () => {
+    const payload = { ok: true, data: {} };
+    expect(mergeFailureRequiresRepairLoop(payload)).toBeNull();
+  });
+
+  it('GIVEN_non_merge_disabled_error_WHEN_checked_THEN_returns_null', () => {
+    const payload = {
+      ok: false,
+      error: { code: 'some_other_error', details: {} },
+    };
+    expect(mergeFailureRequiresRepairLoop(payload)).toBeNull();
+  });
+
+  it('GIVEN_merge_disabled_without_reconciliation_WHEN_checked_THEN_returns_null', () => {
+    const payload = {
+      ok: false,
+      error: {
+        code: 'merge_disabled',
+        details: {
+          reconciliation_attempted: false,
+          recovery_available: true,
+          feature_id: 'my-feature',
+        },
+      },
+    };
+    expect(mergeFailureRequiresRepairLoop(payload)).toBeNull();
+  });
+
+  it('GIVEN_merge_disabled_with_recovery_unavailable_WHEN_checked_THEN_returns_null', () => {
+    const payload = {
+      ok: false,
+      error: {
+        code: 'merge_disabled',
+        details: {
+          reconciliation_attempted: true,
+          recovery_available: false,
+          feature_id: 'my-feature',
+        },
+      },
+    };
+    expect(mergeFailureRequiresRepairLoop(payload)).toBeNull();
+  });
+
+  it('GIVEN_merge_disabled_with_empty_feature_id_WHEN_checked_THEN_returns_null', () => {
+    const payload = {
+      ok: false,
+      error: {
+        code: 'merge_disabled',
+        details: {
+          reconciliation_attempted: true,
+          recovery_available: true,
+          feature_id: '  ',
+        },
+      },
+    };
+    expect(mergeFailureRequiresRepairLoop(payload)).toBeNull();
+  });
+
+  it('GIVEN_null_input_WHEN_checked_THEN_returns_null', () => {
+    expect(mergeFailureRequiresRepairLoop(null)).toBeNull();
+  });
+
+  it('GIVEN_non_object_input_WHEN_checked_THEN_returns_null', () => {
+    expect(mergeFailureRequiresRepairLoop('string')).toBeNull();
+    expect(mergeFailureRequiresRepairLoop(42)).toBeNull();
+  });
+});

package/apps/control-plane/test/rollback-command-handler.spec.ts

@@ -0,0 +1,334 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, expect, it, vi } from 'vitest';
+
+vi.mock('../src/core/git.js', () => ({
+  runGit: vi.fn(async () => ({ code: 0, stdout: '', stderr: '', signal: null, timeout: false })),
+}));
+
+import { runGit } from '../src/core/git.js';
+import { RollbackCommandHandler } from '../src/cli/rollback-command-handler.js';
+import { ERROR_CODES } from '../src/core/error-codes.js';
+
+function buildState(frontMatter: Record<string, unknown>): string {
+  const yaml = Object.entries(frontMatter)
+    .map(([k, v]) => `${k}: ${JSON.stringify(v)}`)
+    .join('\n');
+  return `---\n${yaml}\n---\nbody`;
+}
+
+describe('RollbackCommandHandler', () => {
+  it('throws INVALID_CLI_ARGS for missing feature id or checkpoint', async () => {
+    const handler = new RollbackCommandHandler('/tmp/repo');
+
+    await expect(handler.execute({} as any)).rejects.toMatchObject({
+      code: ERROR_CODES.INVALID_CLI_ARGS,
+    });
+    await expect(
+      handler.execute({ feature_id: 'bad id', checkpoint: 'c1' } as any),
+    ).rejects.toMatchObject({ code: ERROR_CODES.INVALID_CLI_ARGS });
+  });
+
+  it('throws FILE_NOT_FOUND when feature state is missing', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rollback-no-state-'));
+    const handler = new RollbackCommandHandler(repoRoot);
+    await expect(
+      handler.execute({ feature_id: 'feat', checkpoint: 'c1', dry_run: false } as any),
+    ).rejects.toMatchObject({ code: ERROR_CODES.FILE_NOT_FOUND });
+  });
+
+  it('throws when checkpoint not found', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rollback-missing-'));
+    const statePath = path.join(repoRoot, '.aop', 'features', 'feat', 'state.md');
+    await fs.mkdir(path.dirname(statePath), { recursive: true });
+    await fs.writeFile(
+      statePath,
+      buildState({ checkpoints: [], worktree_path: path.join(repoRoot, '.worktrees', 'feat') }),
+      'utf8',
+    );
+
+    const handler = new RollbackCommandHandler(repoRoot);
+    await expect(
+      handler.execute({ feature_id: 'feat', checkpoint: 'missing', dry_run: false } as any),
+    ).rejects.toMatchObject({ code: ERROR_CODES.INVALID_CLI_ARGS });
+  });
+
+  it('returns dry-run preview with resolved paths', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rollback-dry-'));
+    const checkpointPath = path.join(
+      repoRoot,
+      '.aop',
+      'features',
+      'feat',
+      'checkpoints',
+      'c1.diff',
+    );
+    await fs.mkdir(path.dirname(checkpointPath), { recursive: true });
+    await fs.writeFile(checkpointPath, 'diff --git a b', 'utf8');
+    const worktreePath = path.join(repoRoot, '.worktrees', 'feat');
+    await fs.mkdir(worktreePath, { recursive: true });
+
+    const statePath = path.join(repoRoot, '.aop', 'features', 'feat', 'state.md');
+    await fs.writeFile(
+      statePath,
+      buildState({
+        checkpoints: [
+          {
+            checkpoint_id: 'c1',
+            diff_snapshot: path.relative(repoRoot, checkpointPath),
+            validation_status: 'valid',
+            timestamp: 'now',
+          },
+        ],
+        worktree_path: worktreePath,
+      }),
+      'utf8',
+    );
+
+    const handler = new RollbackCommandHandler(repoRoot);
+    const result = (await handler.execute({
+      feature_id: 'feat',
+      checkpoint: 'c1',
+      dry_run: true,
+    } as any)) as any;
+
+    expect(result.ok).toBe(true);
+    expect(result.data?.dry_run).toBe(true);
+    expect(result.data?.worktree_path).toBe(worktreePath);
+    expect(result.data?.checkpoint_path).toBe(checkpointPath);
+  });
+
+  it('throws FILE_NOT_FOUND when checkpoint diff snapshot is missing', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rollback-missing-file-'));
+    const statePath = path.join(repoRoot, '.aop', 'features', 'feat', 'state.md');
+    await fs.mkdir(path.dirname(statePath), { recursive: true });
+    await fs.writeFile(
+      statePath,
+      buildState({
+        checkpoints: [
+          {
+            checkpoint_id: 'c1',
+            diff_snapshot: 'missing.diff',
+            validation_status: 'valid',
+            timestamp: 'now',
+          },
+        ],
+      }),
+      'utf8',
+    );
+
+    const handler = new RollbackCommandHandler(repoRoot);
+    await expect(
+      handler.execute({ feature_id: 'feat', checkpoint: 'c1', dry_run: false } as any),
+    ).rejects.toMatchObject({ code: ERROR_CODES.FILE_NOT_FOUND });
+  });
+
+  it('filters out invalid checkpoint entries during parsing', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rollback-invalid-entry-'));
+    const statePath = path.join(repoRoot, '.aop', 'features', 'feat', 'state.md');
+    await fs.mkdir(path.dirname(statePath), { recursive: true });
+    const diffPath = path.join(repoRoot, '.aop', 'features', 'feat', 'checkpoints', 'c1.diff');
+    await fs.mkdir(path.dirname(diffPath), { recursive: true });
+    await fs.writeFile(diffPath, 'diff --git a b', 'utf8');
+    await fs.writeFile(
+      statePath,
+      buildState({
+        checkpoints: [
+          'bad-entry',
+          {
+            checkpoint_id: 'c1',
+            diff_snapshot: diffPath,
+            timestamp: 'now',
+            validation_status: 'valid',
+          },
+        ],
+      }),
+      'utf8',
+    );
+
+    const handler = new RollbackCommandHandler(repoRoot);
+    await expect(
+      handler.execute({ feature_id: 'feat', checkpoint: 'c1', dry_run: true } as any),
+    ).resolves.toMatchObject({ ok: true });
+  });
+
+  it('treats checkpoint path equal to repo root as inside', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rollback-root-path-'));
+    const statePath = path.join(repoRoot, '.aop', 'features', 'feat', 'state.md');
+    await fs.mkdir(path.dirname(statePath), { recursive: true });
+    await fs.writeFile(
+      statePath,
+      buildState({
+        checkpoints: [
+          {
+            checkpoint_id: 'c1',
+            diff_snapshot: '.',
+            validation_status: 'valid',
+            timestamp: 'now',
+          },
+        ],
+      }),
+      'utf8',
+    );
+
+    const handler = new RollbackCommandHandler(repoRoot);
+    const result = await handler.execute({
+      feature_id: 'feat',
+      checkpoint: 'c1',
+      dry_run: true,
+    } as any);
+    expect(result).toMatchObject({ ok: true });
+  });
+
+  it('filters checkpoint entries with wrong types and reports missing checkpoint', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rollback-wrong-types-'));
+    const statePath = path.join(repoRoot, '.aop', 'features', 'feat', 'state.md');
+    await fs.mkdir(path.dirname(statePath), { recursive: true });
+    await fs.writeFile(
+      statePath,
+      buildState({
+        checkpoints: [
+          {
+            checkpoint_id: 123,
+            diff_snapshot: 456,
+            timestamp: 789,
+            validation_status: 'maybe',
+          },
+        ],
+      }),
+      'utf8',
+    );
+
+    const handler = new RollbackCommandHandler(repoRoot);
+    await expect(
+      handler.execute({ feature_id: 'feat', checkpoint: 'missing', dry_run: false } as any),
+    ).rejects.toMatchObject({ code: ERROR_CODES.INVALID_CLI_ARGS });
+  });
+
+  it('guards against checkpoint path escaping repository', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rollback-escape-'));
+    const statePath = path.join(repoRoot, '.aop', 'features', 'feat', 'state.md');
+    await fs.mkdir(path.dirname(statePath), { recursive: true });
+    await fs.writeFile(
+      statePath,
+      buildState({
+        checkpoints: [
+          {
+            checkpoint_id: 'c1',
+            diff_snapshot: '../escape.diff',
+            validation_status: 'valid',
+            timestamp: 'now',
+          },
+        ],
+      }),
+      'utf8',
+    );
+
+    const handler = new RollbackCommandHandler(repoRoot);
+    await expect(
+      handler.execute({ feature_id: 'feat', checkpoint: 'c1', dry_run: false } as any),
+    ).rejects.toMatchObject({ code: ERROR_CODES.INVALID_CLI_ARGS });
+  });
+
+  it('fails with GIT_FAILURE when patch apply fails', async () => {
+    vi.mocked(runGit).mockResolvedValueOnce({
+      code: 1,
+      stderr: 'apply failed',
+      stdout: '',
+      signal: null,
+      timeout: false,
+    });
+
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rollback-fail-'));
+    const checkpointPath = path.join(
+      repoRoot,
+      '.aop',
+      'features',
+      'feat',
+      'checkpoints',
+      'c1.diff',
+    );
+    await fs.mkdir(path.dirname(checkpointPath), { recursive: true });
+    await fs.writeFile(checkpointPath, 'diff --git a b', 'utf8');
+    const worktreePath = path.join(repoRoot, '.worktrees', 'feat');
+    await fs.mkdir(worktreePath, { recursive: true });
+    const statePath = path.join(repoRoot, '.aop', 'features', 'feat', 'state.md');
+    await fs.writeFile(
+      statePath,
+      buildState({
+        checkpoints: [
+          {
+            checkpoint_id: 'c1',
+            diff_snapshot: path.relative(repoRoot, checkpointPath),
+            validation_status: 'invalid',
+            timestamp: 'now',
+          },
+        ],
+        worktree_path: worktreePath,
+      }),
+      'utf8',
+    );
+
+    const handler = new RollbackCommandHandler(repoRoot);
+
+    await expect(
+      handler.execute({ feature_id: 'feat', checkpoint: 'c1', dry_run: false } as any),
+    ).rejects.toMatchObject({
+      code: ERROR_CODES.GIT_FAILURE,
+      details: { checkpoint_path: checkpointPath },
+    });
+  });
+
+  it('applies rollback successfully when git apply succeeds', async () => {
+    vi.mocked(runGit).mockResolvedValue({
+      code: 0,
+      stderr: '',
+      stdout: '',
+      signal: null,
+      timeout: false,
+    });
+
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rollback-success-'));
+    const checkpointPath = path.join(
+      repoRoot,
+      '.aop',
+      'features',
+      'feat',
+      'checkpoints',
+      'c1.diff',
+    );
+    await fs.mkdir(path.dirname(checkpointPath), { recursive: true });
+    await fs.writeFile(checkpointPath, 'diff --git a b', 'utf8');
+    const worktreePath = path.join(repoRoot, '.worktrees', 'feat');
+    await fs.mkdir(worktreePath, { recursive: true });
+    const statePath = path.join(repoRoot, '.aop', 'features', 'feat', 'state.md');
+    await fs.writeFile(
+      statePath,
+      buildState({
+        checkpoints: [
+          {
+            checkpoint_id: 'c1',
+            diff_snapshot: path.relative(repoRoot, checkpointPath),
+            validation_status: 'valid',
+            timestamp: 'now',
+          },
+        ],
+        worktree_path: worktreePath,
+      }),
+      'utf8',
+    );
+
+    const handler = new RollbackCommandHandler(repoRoot);
+    const result = await handler.execute({
+      feature_id: 'feat',
+      checkpoint: 'c1',
+      dry_run: false,
+    } as any);
+
+    expect(result).toMatchObject({
+      ok: true,
+      data: { applied: true, checkpoint_id: 'c1', worktree_path: worktreePath },
+    });
+  });
+});

package/apps/control-plane/test/rollback-command.spec.ts

@@ -135,6 +135,78 @@ describe('RollbackCommandHandler', () => {
     ).rejects.toMatchObject({ code: ERROR_CODES.INVALID_CLI_ARGS });
   });
 
+  it('throws invalid_cli_args when checkpoint path resolves outside repo root', async () => {
+    const repoRoot = await initRepo('aop-rollback-outside-root-');
+    tempRoots.push(repoRoot);
+    const featureId = 'feature_outside';
+    const statePath = path.join(repoRoot, '.aop', 'features', featureId, 'state.md');
+    await fs.mkdir(path.dirname(statePath), { recursive: true });
+    await fs.writeFile(
+      statePath,
+      [
+        '---',
+        `feature_id: ${featureId}`,
+        'version: 1',
+        'status: building',
+        'checkpoints:',
+        '  - checkpoint_id: checkpoint-outside',
+        '    timestamp: 2026-03-06T00:00:00.000Z',
+        '    files_changed: []',
+        '    validation_status: valid',
+        '    violations: []',
+        '    diff_snapshot: ../outside.diff',
+        '---',
+        '',
+      ].join('\n'),
+      'utf8',
+    );
+
+    const handler = new RollbackCommandHandler(repoRoot);
+    await expect(
+      handler.execute({
+        command: 'rollback',
+        feature_id: featureId,
+        checkpoint: 'checkpoint-outside',
+      }),
+    ).rejects.toMatchObject({ code: ERROR_CODES.INVALID_CLI_ARGS });
+  });
+
+  it('throws file_not_found when diff snapshot is missing', async () => {
+    const repoRoot = await initRepo('aop-rollback-missing-diff-');
+    tempRoots.push(repoRoot);
+    const featureId = 'feature_missing_diff';
+    const statePath = path.join(repoRoot, '.aop', 'features', featureId, 'state.md');
+    await fs.mkdir(path.dirname(statePath), { recursive: true });
+    await fs.writeFile(
+      statePath,
+      [
+        '---',
+        `feature_id: ${featureId}`,
+        'version: 1',
+        'status: building',
+        'checkpoints:',
+        '  - checkpoint_id: checkpoint-missing',
+        '    timestamp: 2026-03-06T00:00:00.000Z',
+        '    files_changed: []',
+        '    validation_status: valid',
+        '    violations: []',
+        '    diff_snapshot: .aop/features/feature_missing_diff/checkpoints/checkpoint-missing.diff',
+        '---',
+        '',
+      ].join('\n'),
+      'utf8',
+    );
+
+    const handler = new RollbackCommandHandler(repoRoot);
+    await expect(
+      handler.execute({
+        command: 'rollback',
+        feature_id: featureId,
+        checkpoint: 'checkpoint-missing',
+      }),
+    ).rejects.toMatchObject({ code: ERROR_CODES.FILE_NOT_FOUND });
+  });
+
   it('returns preview payload when dry-run is true', async () => {
     const repoRoot = await initRepo('aop-rollback-dry-run-');
     tempRoots.push(repoRoot);
@@ -161,6 +233,54 @@ describe('RollbackCommandHandler', () => {
     expect(tracked).toBe('changed\n');
   });
 
+  it('uses custom message and default worktree path in dry-run', async () => {
+    const repoRoot = await initRepo('aop-rollback-dry-run-message-');
+    tempRoots.push(repoRoot);
+    const featureId = 'feature_message';
+    const checkpointId = 'checkpoint-010';
+    const checkpointRelPath = path
+      .join('.aop', 'features', featureId, 'checkpoints', `${checkpointId}.diff`)
+      .replaceAll('\\', '/');
+    const checkpointAbsPath = path.join(repoRoot, checkpointRelPath);
+    await fs.mkdir(path.dirname(checkpointAbsPath), { recursive: true });
+    await fs.writeFile(checkpointAbsPath, '', 'utf8');
+
+    const statePath = path.join(repoRoot, '.aop', 'features', featureId, 'state.md');
+    await fs.mkdir(path.dirname(statePath), { recursive: true });
+    await fs.writeFile(
+      statePath,
+      [
+        '---',
+        `feature_id: ${featureId}`,
+        'version: 1',
+        'status: building',
+        'checkpoints:',
+        `  - checkpoint_id: ${checkpointId}`,
+        '    timestamp: 2026-03-06T00:00:00.000Z',
+        '    files_changed: []',
+        '    validation_status: valid',
+        '    violations: []',
+        `    diff_snapshot: ${checkpointRelPath}`,
+        '---',
+        '',
+      ].join('\n'),
+      'utf8',
+    );
+
+    const handler = new RollbackCommandHandler(repoRoot);
+    const result = (await handler.execute({
+      command: 'rollback',
+      feature_id: featureId,
+      checkpoint: checkpointId,
+      dry_run: true,
+      message: 'custom preview message',
+    })) as { ok: boolean; data: Record<string, unknown> };
+
+    expect(result.ok).toBe(true);
+    expect(result.data.message).toBe('custom preview message');
+    expect(result.data.worktree_path).toBe(path.join(repoRoot, '.worktrees', featureId));
+  });
+
   it('applies inverse checkpoint patch in worktree', async () => {
     const repoRoot = await initRepo('aop-rollback-apply-');
     tempRoots.push(repoRoot);