agentic-orchestrator 0.1.28 → 0.2.1

package/packages/web-dashboard/test/lib/dashboard-runtime-client.spec.ts

@@ -0,0 +1,144 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import {
+  isDashboardRuntimeAvailable,
+  resolveDashboardRuntimeInstanceId,
+  submitDashboardRuntimeCommand,
+} from '@/lib/dashboard-runtime-client.js';
+
+function runtimeRoot(repoRoot: string): string {
+  return path.join(repoRoot, '.aop', 'runtime', resolveDashboardRuntimeInstanceId(repoRoot));
+}
+
+describe('dashboard-runtime-client', () => {
+  let repoRoot: string | null = null;
+
+  afterEach(async () => {
+    if (repoRoot) {
+      await fs.rm(repoRoot, { recursive: true, force: true });
+      repoRoot = null;
+    }
+  });
+
+  it('computes a deterministic runtime instance id from the repo root', () => {
+    expect(resolveDashboardRuntimeInstanceId('/tmp/example')).toBe(
+      resolveDashboardRuntimeInstanceId('/tmp/example'),
+    );
+    expect(resolveDashboardRuntimeInstanceId('/tmp/example')).not.toBe(
+      resolveDashboardRuntimeInstanceId('/tmp/other'),
+    );
+  });
+
+  it('reports availability when the dashboard runtime heartbeat is fresh', async () => {
+    repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-dashboard-runtime-'));
+    await fs.mkdir(runtimeRoot(repoRoot), { recursive: true });
+    await fs.writeFile(
+      path.join(runtimeRoot(repoRoot), 'dashboard-runtime-state.json'),
+      JSON.stringify({
+        version: 1,
+        instance_id: resolveDashboardRuntimeInstanceId(repoRoot),
+        started_at: new Date().toISOString(),
+        last_heartbeat_at: new Date().toISOString(),
+        pid: process.pid,
+        status: 'running',
+      }),
+      'utf8',
+    );
+
+    await expect(isDashboardRuntimeAvailable(repoRoot)).resolves.toBe(true);
+  });
+
+  it('enqueues a command and waits for the dashboard runtime result envelope', async () => {
+    repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-dashboard-runtime-'));
+    const root = runtimeRoot(repoRoot);
+    await fs.mkdir(root, { recursive: true });
+    await fs.writeFile(
+      path.join(root, 'dashboard-runtime-state.json'),
+      JSON.stringify({
+        version: 1,
+        instance_id: resolveDashboardRuntimeInstanceId(repoRoot),
+        started_at: new Date().toISOString(),
+        last_heartbeat_at: new Date().toISOString(),
+        pid: process.pid,
+        status: 'running',
+      }),
+      'utf8',
+    );
+
+    const responsePromise = submitDashboardRuntimeCommand(
+      'feature.resume',
+      'feature_a',
+      { takeover_stale_run: true },
+      repoRoot,
+      { timeoutMs: 2_000 },
+    );
+
+    const queuePath = path.join(root, 'dashboard-runtime-commands.json');
+    let snapshotRaw = '';
+    for (let attempt = 0; attempt < 20; attempt += 1) {
+      try {
+        snapshotRaw = await fs.readFile(queuePath, 'utf8');
+        if (snapshotRaw.length > 0) {
+          break;
+        }
+      } catch {
+        // wait for the queue file to be written
+      }
+      await new Promise((resolve) => {
+        setTimeout(resolve, 50);
+      });
+    }
+
+    const snapshot = JSON.parse(snapshotRaw) as {
+      items: Array<{ request_id: string }>;
+    };
+    const requestId = snapshot.items[0]?.request_id;
+    expect(typeof requestId).toBe('string');
+
+    await fs.writeFile(
+      queuePath,
+      JSON.stringify(
+        {
+          version: 1,
+          instance_id: resolveDashboardRuntimeInstanceId(repoRoot),
+          updated_at: new Date().toISOString(),
+          items: [
+            {
+              request_id: requestId,
+              command: 'feature.resume',
+              feature_id: 'feature_a',
+              args: { takeover_stale_run: true },
+              status: 'completed',
+              requested_at: new Date().toISOString(),
+              processed_at: new Date().toISOString(),
+              result: {
+                ok: true,
+                data: {
+                  command: 'resume',
+                  handoff_started: true,
+                  handoff_target: 'runtime',
+                  started: true,
+                },
+              },
+            },
+          ],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+
+    await expect(responsePromise).resolves.toEqual({
+      ok: true,
+      data: {
+        command: 'resume',
+        handoff_started: true,
+        handoff_target: 'runtime',
+        started: true,
+      },
+    });
+  });
+});

package/packages/web-dashboard/test/lib/focus-detail-derivations.spec.ts

@@ -0,0 +1,314 @@
+import { describe, expect, it } from 'vitest';
+import {
+  buildActionableRisks,
+  buildPlanProgressSummary,
+  buildRevisionSummary,
+  buildVerificationSummary,
+  resolveActiveRole,
+  resolveRecommendedAction,
+} from '@/lib/focus-detail-derivations.js';
+import type { FeatureCheckpoint, FeatureSummary } from '@/lib/types.js';
+
+function buildFeature(overrides: Partial<FeatureSummary> = {}): FeatureSummary {
+  return {
+    id: 'feature_track_c',
+    feature_id: 'feature_track_c',
+    status: 'qa',
+    phase: 'qa',
+    role_status: {
+      planner: 'done',
+      builder: 'done',
+      qa: 'running',
+    },
+    activity_state: 'active',
+    last_updated: '2026-03-16T20:30:00.000Z',
+    phase_entered_at: '2026-03-16T19:00:00.000Z',
+    ...overrides,
+  };
+}
+
+const checkpoints: FeatureCheckpoint[] = [
+  {
+    checkpoint_id: 'cp-002',
+    timestamp: '2026-03-16T20:20:00.000Z',
+    files_changed: ['src/b.ts'],
+    validation_status: 'invalid',
+    violations: ['src/b.ts missing branch'],
+    diff_snapshot: '.aop/features/feature_track_c/checkpoints/cp-002.diff',
+  },
+  {
+    checkpoint_id: 'cp-001',
+    timestamp: '2026-03-16T20:10:00.000Z',
+    files_changed: ['src/a.ts'],
+    validation_status: 'valid',
+    violations: [],
+    diff_snapshot: '.aop/features/feature_track_c/checkpoints/cp-001.diff',
+  },
+];
+
+describe('focus detail derivations', () => {
+  it('derives estimated plan progress when explicit tasks are absent', () => {
+    const summary = buildPlanProgressSummary({
+      feature: buildFeature(),
+      plan: { summary: 'Ship Track C', files: { modify: ['src/a.ts'] } },
+      checkpoints,
+      gateEvidence: {
+        mode: 'merge',
+        overall: 'fail',
+        finished_at: '2026-03-16T20:25:00.000Z',
+        steps: [],
+      },
+      qaTestIndex: {
+        feature_id: 'feature_track_c',
+        version: 1,
+        items: [
+          {
+            path: 'src/a.ts',
+            status: 'passed',
+            required_tests: ['src/a.spec.ts'],
+            last_run_at: '2026-03-16T20:24:00.000Z',
+          },
+        ],
+      },
+    });
+
+    expect(summary.estimated).toBe(true);
+    expect(summary.current_task?.title).toBe('Validate gates and QA evidence');
+    expect(summary.blocked_tasks).toBeGreaterThanOrEqual(1);
+    expect(summary.next_tasks[0]?.title).toBe('Resolve review and merge blockers');
+  });
+
+  it('prefers explicit evidence over phase fallback in verification summary', () => {
+    const summary = buildVerificationSummary({
+      feature: buildFeature({ phase: 'ready_to_merge', gates: { merge: 'fail' } }),
+      gateEvidence: {
+        mode: 'merge',
+        overall: 'fail',
+        finished_at: '2026-03-16T20:25:00.000Z',
+        steps: [
+          {
+            name: 'npm run verify',
+            command: 'npm run verify',
+            status: 'fail',
+            exit_code: 1,
+            duration_ms: 1000,
+            output_tail: ['typecheck failed'],
+          },
+        ],
+      },
+      qaTestIndex: null,
+      usageBurn: {
+        current_tokens_used: 2000,
+        projected_final_tokens: 4000,
+        projected_completion_at: null,
+        budget_limit_tokens: 10000,
+        will_exceed_budget: false,
+        confidence: 'medium',
+        usage_points: [],
+        historical_ratio: null,
+        derived_usd: null,
+        last_updated_at: '2026-03-16T20:25:00.000Z',
+      },
+    });
+
+    expect(summary.readiness).toBe('at_risk');
+    expect(summary.blockers[0]?.detail).toContain('typecheck failed');
+    expect(summary.items[0]?.status).toBe('at_risk');
+  });
+
+  it('builds revision and risk summaries with decision-useful content', () => {
+    const revisions = buildRevisionSummary({
+      feature: buildFeature({
+        revision_of: 1,
+        revision_reason: 'failed merge gate',
+        pr: {
+          pending_review_threads: 2,
+        },
+      }),
+      plan: {
+        plan_version: 2,
+        summary: 'Track C remediation',
+        files: { create: [], modify: ['src/a.ts', 'src/b.ts'], delete: [] },
+      },
+      checkpoints,
+      gateHistory: [
+        {
+          id: 'gate-1',
+          file: 'latest-merge.json',
+          mode: 'merge',
+          profile: 'default',
+          overall: 'fail',
+          finished_at: '2026-03-16T20:25:00.000Z',
+          step_count: 1,
+          failing_step_count: 1,
+          duration_ms: 1000,
+          steps: [
+            {
+              name: 'npm run verify',
+              status: 'fail',
+              output_tail: ['verification failed'],
+            },
+          ],
+        },
+      ],
+    });
+    const risks = buildActionableRisks(
+      { risk: ['Merge conflicts likely in auth files', 'Coverage retry could stay flaky'] },
+      buildFeature(),
+    );
+
+    expect(revisions[0]?.headline).toContain('gate');
+    expect(revisions.some((entry) => entry.type === 'checkpoint')).toBe(true);
+    expect(risks[0]?.severity).toBe('high');
+    expect(risks[1]?.severity).toBe('medium');
+  });
+
+  it('recommends the highest-signal next action', () => {
+    const action = resolveRecommendedAction({
+      feature: buildFeature({ activity_state: 'waiting_input' }),
+      verification_summary: null,
+      plan_progress: null,
+    });
+
+    expect(action).toBe('Answer the pending human-input request.');
+  });
+
+  it('recommends resume for retrying recovery states before generic blocked/building guidance', () => {
+    const action = resolveRecommendedAction({
+      feature: buildFeature({
+        phase: 'building',
+        activity_state: 'unknown',
+        recovery: {
+          state: 'retrying',
+          cause: 'provider_output_invalid',
+          role: 'planner',
+        },
+      }),
+      verification_summary: null,
+      plan_progress: null,
+    });
+
+    expect(action).toBe('Resume the planner workflow to continue recovery.');
+  });
+
+  it('keeps ready_to_merge recommendations in review flow even when stale recovery metadata exists', () => {
+    const action = resolveRecommendedAction({
+      feature: buildFeature({
+        phase: 'ready_to_merge',
+        recovery: {
+          state: 'retrying',
+          cause: 'provider_output_invalid',
+          role: 'planner',
+        },
+      }),
+      verification_summary: null,
+      plan_progress: null,
+    });
+
+    expect(action).toBe('Review the final evidence and make the merge decision.');
+  });
+
+  it('prefers a running live snapshot over historical worker events when resolving the active role', () => {
+    const role = resolveActiveRole({
+      feature: buildFeature({ phase: 'qa' }),
+      live_output_snapshots: [
+        {
+          role: 'planner',
+          session_id: null,
+          provider: null,
+          model: null,
+          execution_mode: null,
+          status: 'idle',
+          started_at: null,
+          ended_at: null,
+          updated_at: null,
+          size_bytes: 0,
+        },
+        {
+          role: 'builder',
+          session_id: 'builder-1',
+          provider: 'claude',
+          model: 'sonnet-4-6',
+          execution_mode: 'interactive',
+          status: 'idle',
+          started_at: '2026-03-16T20:00:00.000Z',
+          ended_at: '2026-03-16T20:10:00.000Z',
+          updated_at: '2026-03-16T20:10:00.000Z',
+          size_bytes: 120,
+        },
+        {
+          role: 'qa',
+          session_id: 'qa-1',
+          provider: 'openai',
+          model: 'gpt-5.4',
+          execution_mode: 'interactive',
+          status: 'running',
+          started_at: '2026-03-16T20:15:00.000Z',
+          ended_at: null,
+          updated_at: '2026-03-16T20:16:00.000Z',
+          size_bytes: 512,
+        },
+      ],
+      worker_summary: {
+        entries: [
+          {
+            ts: '2026-03-16T20:12: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: 'claude',
+            model: 'sonnet-4-6',
+          },
+        ],
+        by_role: [],
+      },
+    });
+
+    expect(role).toBe('qa');
+  });
+
+  it('falls back to the execution phase when no live worker is running', () => {
+    const role = resolveActiveRole({
+      feature: buildFeature({ phase: 'qa' }),
+      live_output_snapshots: [
+        {
+          role: 'planner',
+          session_id: null,
+          provider: null,
+          model: null,
+          execution_mode: null,
+          status: 'idle',
+          started_at: null,
+          ended_at: null,
+          updated_at: null,
+          size_bytes: 0,
+        },
+      ],
+      worker_summary: {
+        entries: [
+          {
+            ts: '2026-03-16T20:12: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: 'claude',
+            model: 'sonnet-4-6',
+          },
+        ],
+        by_role: [],
+      },
+    });
+
+    expect(role).toBe('qa');
+  });
+});

package/packages/web-dashboard/test/lib/focus-view.spec.ts

@@ -0,0 +1,248 @@
+import { describe, expect, it } from 'vitest';
+import {
+  coerceFocusTab,
+  getDefaultFocusTab,
+  getFocusLazyGroup,
+  getNextActivatedLazyGroups,
+  getPinnedFocusActions,
+  resolveFocusActiveTab,
+  getVisibleFocusTabs,
+  isFocusTabLazy,
+  isFocusTabVisible,
+  shouldMountFocusTab,
+} from '@/lib/focus-view.js';
+import type { FeatureDetail, FeatureSummary } from '@/lib/types.js';
+
+function buildFeature(overrides: Partial<FeatureSummary> = {}): FeatureSummary {
+  return {
+    id: 'feature_focus',
+    feature_id: 'feature_focus',
+    status: 'building',
+    phase: 'building',
+    last_updated: '2026-03-16T19:59:00.000Z',
+    activity_state: 'active',
+    ...overrides,
+  };
+}
+
+function buildDetail(overrides?: {
+  feature?: Partial<FeatureSummary>;
+  diff?: string;
+  plan?: Record<string, unknown> | null;
+  gateEvidence?: FeatureDetail['gate_evidence'];
+  qaTestIndex?: FeatureDetail['qa_test_index'];
+  reviewBrief?: FeatureDetail['review_brief'];
+  checkpoints?: FeatureDetail['checkpoints'];
+}): FeatureDetail {
+  return {
+    feature: buildFeature(overrides?.feature),
+    plan: overrides?.plan ?? { summary: 'plan' },
+    diff: overrides?.diff ?? '',
+    evidence: [],
+    gate_evidence: overrides?.gateEvidence ?? null,
+    qa_test_index: overrides?.qaTestIndex ?? null,
+    review_brief: overrides?.reviewBrief ?? null,
+    checkpoints: overrides?.checkpoints ?? [],
+    execution_mode: 'deterministic',
+  };
+}
+
+describe('focus-view helpers', () => {
+  it('uses phase-aware default tabs and falls back safely', () => {
+    expect(getDefaultFocusTab(buildDetail({ feature: { phase: 'intake' } }))).toBe('intake');
+    expect(getDefaultFocusTab(buildDetail({ feature: { phase: 'planning' } }))).toBe('planning');
+    expect(getDefaultFocusTab(buildDetail({ feature: { phase: 'building' }, diff: 'diff' }))).toBe(
+      'changes',
+    );
+    expect(getDefaultFocusTab(buildDetail({ feature: { phase: 'qa' } }))).toBe('gates_qa');
+    expect(getDefaultFocusTab(buildDetail({ feature: { phase: 'ready_to_merge' } }))).toBe(
+      'review',
+    );
+    expect(getDefaultFocusTab(buildDetail({ feature: { phase: 'blocked' } }))).toBe('overview');
+    expect(getDefaultFocusTab(buildDetail({ feature: { phase: 'merged' } }))).toBe('history');
+    expect(getDefaultFocusTab(buildDetail({ feature: { phase: 'unknown' } }))).toBe('overview');
+    expect(getDefaultFocusTab(null)).toBe('overview');
+  });
+
+  it('keeps waiting-input features on overview even during review phases', () => {
+    expect(
+      getDefaultFocusTab(
+        buildDetail({
+          feature: {
+            phase: 'ready_to_merge',
+            activity_state: 'waiting_input',
+            waiting_input_count: 1,
+          },
+        }),
+      ),
+    ).toBe('overview');
+
+    expect(
+      getDefaultFocusTab(
+        buildDetail({
+          feature: {
+            phase: 'qa',
+            activity_state: 'waiting_input',
+            waiting_input_count: 1,
+          },
+        }),
+      ),
+    ).toBe('overview');
+  });
+
+  it('keeps history and transcript on the same lazy-load group', () => {
+    expect(getFocusLazyGroup('history')).toBe('history_log');
+    expect(getFocusLazyGroup('transcript')).toBe('history_log');
+    expect(isFocusTabLazy('history')).toBe(true);
+    expect(isFocusTabLazy('transcript')).toBe(true);
+  });
+
+  it('maps review and gates tabs into the shared review_qa lazy-load group', () => {
+    expect(getFocusLazyGroup('gates_qa')).toBe('review_qa');
+    expect(getFocusLazyGroup('review')).toBe('review_qa');
+  });
+
+  it('shows the review pinned action for ready_to_merge and qa', () => {
+    expect(getPinnedFocusActions(buildDetail({ feature: { phase: 'ready_to_merge' } }))).toEqual([
+      { id: 'review', label: 'Review decision', targetTab: 'review' },
+    ]);
+
+    expect(getPinnedFocusActions(buildDetail({ feature: { phase: 'qa' } }))).toEqual([
+      { id: 'review', label: 'Review workspace', targetTab: 'review' },
+    ]);
+  });
+
+  it('prefers human input pinned actions over review actions when input is waiting', () => {
+    expect(
+      getPinnedFocusActions(
+        buildDetail({
+          feature: {
+            phase: 'ready_to_merge',
+            activity_state: 'waiting_input',
+            waiting_input_count: 1,
+          },
+        }),
+      ),
+    ).toEqual([{ id: 'human_input', label: 'Answer required', targetTab: 'review' }]);
+  });
+
+  it('returns no pinned action for building and non-action phases', () => {
+    expect(getPinnedFocusActions(buildDetail({ feature: { phase: 'building' } }))).toEqual([]);
+    expect(getPinnedFocusActions(buildDetail({ feature: { phase: 'merged' } }))).toEqual([]);
+    expect(getPinnedFocusActions(buildDetail({ feature: { phase: 'planning' } }))).toEqual([]);
+  });
+
+  it('coerces unavailable requested tabs back to the phase default', () => {
+    const planning = buildDetail({
+      feature: { phase: 'planning' },
+      diff: '',
+      gateEvidence: null,
+      qaTestIndex: null,
+      reviewBrief: null,
+      checkpoints: [],
+    });
+
+    expect(coerceFocusTab(planning, 'review')).toBe('planning');
+    expect(coerceFocusTab(planning, 'overview')).toBe('overview');
+  });
+
+  it('recomputes the active tab from the phase default until a user picks a tab', () => {
+    const planning = buildDetail({
+      feature: { phase: 'planning', activity_state: 'active', waiting_input_count: 0 },
+      diff: '',
+      gateEvidence: null,
+      qaTestIndex: null,
+      reviewBrief: null,
+      checkpoints: [],
+    });
+
+    expect(resolveFocusActiveTab(planning, 'overview', undefined, false)).toBe('planning');
+    expect(resolveFocusActiveTab(planning, 'overview', undefined, true)).toBe('overview');
+  });
+
+  it('honors a deferred initial tab once detail makes it visible', () => {
+    const historyDetail = buildDetail({
+      feature: { phase: 'planning' },
+      diff: '',
+      gateEvidence: null,
+      qaTestIndex: null,
+      reviewBrief: null,
+      checkpoints: [],
+    });
+
+    expect(resolveFocusActiveTab(historyDetail, 'overview', 'transcript', false)).toBe(
+      'transcript',
+    );
+  });
+
+  it('tracks lazy-group activation without double mounting shared history/transcript sources', () => {
+    const activated = getNextActivatedLazyGroups([], 'history');
+
+    expect(activated).toEqual(['history_log']);
+    expect(getNextActivatedLazyGroups(activated, 'transcript')).toEqual(['history_log']);
+    expect(shouldMountFocusTab('transcript', 'history', activated)).toBe(true);
+    expect(shouldMountFocusTab('review', 'history', activated)).toBe(false);
+  });
+
+  it('centralizes visibility for changes, gates, and review tabs', () => {
+    const detail = buildDetail({
+      feature: { phase: 'qa' },
+      diff: 'diff',
+      gateEvidence: { mode: 'full', overall: 'pass', steps: [] },
+    });
+
+    expect(isFocusTabVisible(detail, 'changes')).toBe(true);
+    expect(isFocusTabVisible(detail, 'gates_qa')).toBe(true);
+    expect(isFocusTabVisible(detail, 'review')).toBe(true);
+    expect(getVisibleFocusTabs(detail).map((tab) => tab.id)).toContain('runtime');
+  });
+
+  it('hides optional tabs when their supporting data is absent', () => {
+    const detail = buildDetail({
+      feature: { phase: 'planning' },
+      diff: '',
+      gateEvidence: null,
+      qaTestIndex: null,
+      reviewBrief: null,
+      checkpoints: [],
+    });
+
+    expect(isFocusTabVisible(detail, 'changes')).toBe(false);
+    expect(isFocusTabVisible(detail, 'gates_qa')).toBe(false);
+    expect(isFocusTabVisible(detail, 'review')).toBe(false);
+    expect(getVisibleFocusTabs(detail).map((tab) => tab.id)).toEqual([
+      'overview',
+      'planning',
+      'runtime',
+      'history',
+      'transcript',
+    ]);
+  });
+
+  it('keeps both Intake and Plan tabs visible while intake is active', () => {
+    const detail = buildDetail({
+      feature: {
+        phase: 'intake',
+        activity_state: 'waiting_input',
+        waiting_input_count: 1,
+        resume_status: 'intake',
+      },
+      plan: null,
+      diff: '',
+      gateEvidence: null,
+      qaTestIndex: null,
+      reviewBrief: null,
+      checkpoints: [],
+    });
+
+    expect(getVisibleFocusTabs(detail).map((tab) => `${tab.id}:${tab.label}`)).toEqual([
+      'overview:Overview',
+      'intake:Intake',
+      'planning:Plan',
+      'runtime:Runtime',
+      'history:History',
+      'transcript:Transcript',
+    ]);
+    expect(getDefaultFocusTab(detail)).toBe('intake');
+  });
+});