agentic-orchestrator 0.1.27 → 0.2.0

package/packages/web-dashboard/test/components/overview-tab.spec.tsx

@@ -0,0 +1,236 @@
+/** @vitest-environment node */
+import React from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import { describe, expect, it, vi } from 'vitest';
+import { OverviewTab } from '@/components/focus/tabs/OverviewTab';
+import { buildCollisionRadar, deriveCollisionRisk } from '@/lib/collision-radar.js';
+import type { FeatureDetail, FeatureSummary } from '@/lib/types.js';
+
+vi.mock('@/components/human-input-panel', () => ({
+  HumanInputPanel: () => <div>Human Input</div>,
+}));
+
+vi.mock('@/components/qa-coverage-map', () => ({
+  QaCoverageMap: () => <div>Coverage & Confidence</div>,
+}));
+
+vi.mock('@/components/review-brief-panel', () => ({
+  ReviewBriefPanel: () => <div>Review Brief</div>,
+}));
+
+function buildFeature(overrides: Partial<FeatureSummary> = {}): FeatureSummary {
+  return {
+    id: 'feature_focus',
+    feature_id: 'feature_focus',
+    status: 'building',
+    phase: 'building',
+    phase_entered_at: '2026-03-16T18:00:00.000Z',
+    branch: 'feature/feature_focus',
+    activity_state: 'active',
+    role_status: {
+      planner: 'done',
+      builder: 'running',
+      qa: 'ready',
+    },
+    last_updated: '2026-03-16T18:30:00.000Z',
+    ...overrides,
+  };
+}
+
+function buildDetail(): FeatureDetail {
+  return {
+    feature: buildFeature(),
+    plan: { goal: 'Ship the missing Track B card', risk: ['Merge conflicts likely in auth files'] },
+    diff: '',
+    evidence: [],
+    verification_summary: {
+      last_evaluated_at: '2026-03-16T18:30:00.000Z',
+      readiness: 'at_risk',
+      blockers: [
+        {
+          id: 'merge-gate',
+          label: 'Merge gate evidence',
+          severity: 'high',
+          source: 'gate',
+          detail: 'Latest merge validation failed.',
+          artifact_ref: 'latest-merge.json',
+        },
+      ],
+      verified_requirements: 0,
+      at_risk_requirements: 2,
+      unverified_requirements: 1,
+      items: [
+        {
+          id: 'merge-gate',
+          label: 'Merge gate evidence',
+          status: 'at_risk',
+          source: 'gate',
+          detail: 'Latest merge validation failed.',
+          artifact_ref: 'latest-merge.json',
+          last_evidence_at: '2026-03-16T18:25:00.000Z',
+        },
+      ],
+    },
+    revision_summary: [
+      {
+        id: 'plan-v2',
+        timestamp: '2026-03-16T18:20:00.000Z',
+        type: 'plan_update',
+        headline: 'Plan v2 added QA remediation',
+        detail: 'Added two remediation tasks after failed merge validation.',
+        file_count: 3,
+        jump_to: 'planning',
+      },
+    ],
+    actionable_risks: [
+      {
+        id: 'risk-1',
+        severity: 'high',
+        statement: 'Merge conflicts likely in auth files',
+        impact: 'This can block merge or invalidate confidence in the feature.',
+        mitigation: 'Investigate the blocker now and record fresh evidence before continuing.',
+        owner_role: 'builder',
+        freshness: 'derived',
+        derived: true,
+      },
+    ],
+    collision_radar: {
+      this_feature_files: ['src/auth/login.ts', 'src/api/auth/routes.ts'],
+      entries: [
+        {
+          path: 'src/auth/login.ts',
+          depth: 2,
+          competing_features: ['feat/auth-tokens'],
+          risk: 'high',
+        },
+        {
+          path: 'src/api/auth/routes.ts',
+          depth: 3,
+          competing_features: ['feat/route-cleanup'],
+          risk: 'low',
+        },
+      ],
+      high_count: 1,
+      medium_count: 0,
+      low_count: 1,
+    },
+    role_performance: [
+      {
+        role: 'builder',
+        role_status: 'running',
+        provider: 'claude',
+        model: 'sonnet-4-6',
+        total_events: 3,
+        sample_size: 4,
+        summary: 'Running slower and making more requests than average.',
+        metrics: {
+          elapsed_ms: { actual: 724000, average: 502000, ratio: 1.44 },
+          request_count: { actual: 47, average: 31, ratio: 1.52 },
+          patch_count: { actual: 8, average: 4, ratio: 2 },
+          plan_submission_count: { actual: 0, average: 0, ratio: null },
+        },
+      },
+    ],
+    genealogy: {
+      feature_id: 'feature_focus',
+      nodes: [
+        {
+          id: 'feature_focus',
+          label: 'feature_focus',
+          kind: 'feature',
+          timestamp: '2026-03-16T18:00:00.000Z',
+          status: 'building',
+        },
+      ],
+    },
+    intake: {
+      summary: {
+        status: 'awaiting_input',
+        bootstrap_manifest_version: 2,
+        verified_manifest_version: null,
+        open_ambiguity_count: 3,
+        last_verified_at: null,
+        promotion_basis: null,
+      },
+      review: {
+        status: 'needs_user_input',
+        questions_open: 1,
+        questions_resolved: 2,
+        ambiguity_count: 3,
+      },
+    },
+  };
+}
+
+describe('OverviewTab', () => {
+  it('renders the decision-first overview sections and keeps collision radar collapsed by default', () => {
+    const markup = renderToStaticMarkup(
+      <OverviewTab
+        detail={buildDetail()}
+        project="alpha"
+        flakySuspects={[]}
+        qaIndex={null}
+        reviewBrief={null}
+        refreshDetail={async () => undefined}
+        refreshStatus={async () => undefined}
+        addToast={() => undefined}
+      />,
+    );
+
+    expect(markup).toContain('Not ready');
+    expect(markup).toContain('Requirements Intake');
+    expect(markup).toContain('Planner intake is waiting on operator clarification');
+    expect(markup).toContain('Open Ambiguities');
+    expect(markup).toContain('tracked ambiguities 3');
+    expect(markup).toContain('Verification Summary');
+    expect(markup).toContain('Recent Material Changes');
+    expect(markup).toContain('Actionable Risks');
+    expect(markup).toContain('Collision Radar');
+    expect(markup).toContain('merge conflict likely');
+    expect(markup).not.toContain('<details class="section" open');
+    expect(markup).toContain('Diagnostics');
+  });
+
+  it('derives collision radar entries across exact, directory, and top-level module overlaps', () => {
+    const entries = deriveCollisionRisk(
+      ['src/auth/login.ts', 'src/auth/session.ts', 'src/api/auth/routes.ts'],
+      {
+        'feat/auth-tokens': ['src/auth/login.ts'],
+        'feat/db-schema': ['src/auth/store.ts'],
+        'feat/route-cleanup': ['src/api/cleanup.ts'],
+      },
+    );
+
+    expect(entries).toEqual([
+      {
+        path: 'src/auth/login.ts',
+        depth: 2,
+        competing_features: ['feat/auth-tokens'],
+        risk: 'high',
+      },
+      {
+        path: 'src/auth/session.ts',
+        depth: 2,
+        competing_features: ['feat/auth-tokens', 'feat/db-schema'],
+        risk: 'medium',
+      },
+      {
+        path: 'src/api/auth/routes.ts',
+        depth: 3,
+        competing_features: ['feat/route-cleanup'],
+        risk: 'low',
+      },
+    ]);
+  });
+
+  it('normalizes duplicate collision inputs when building the snapshot summary', () => {
+    const snapshot = buildCollisionRadar(['src/a.ts', 'src/a.ts', ''], {
+      'feat/a': ['src/a.ts'],
+    });
+
+    expect(snapshot.this_feature_files).toEqual(['src/a.ts']);
+    expect(snapshot.high_count).toBe(1);
+    expect(snapshot.medium_count).toBe(0);
+    expect(snapshot.low_count).toBe(0);
+  });
+});

package/packages/web-dashboard/test/components/planning-tab.spec.tsx

@@ -0,0 +1,202 @@
+/** @vitest-environment node */
+import React from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import { describe, expect, it } from 'vitest';
+import { PlanningTab } from '@/components/focus/tabs/PlanningTab';
+import type { FeaturePlanningWorkspace } from '@/lib/types.js';
+
+function buildWorkspace(): FeaturePlanningWorkspace {
+  return {
+    lifecycle: {
+      current_subphase: 'post_planning',
+      current_owner: 'planner',
+      last_updated_at: '2026-03-17T22:00:00.000Z',
+      banner_state: 'accepted_plan_stale',
+      lifecycle_steps: [
+        {
+          id: 'source_spec',
+          label: 'Source Spec',
+          status: 'complete',
+          detail: 'Original launch spec is available.',
+        },
+        {
+          id: 'bootstrap_manifest',
+          label: 'Bootstrap Manifest',
+          status: 'complete',
+          detail: 'Bootstrap manifest v1 normalized the source spec.',
+        },
+        {
+          id: 'verified_manifest',
+          label: 'Verified Manifest',
+          status: 'complete',
+          detail: 'Verified manifest v3 is the requirements contract of record.',
+        },
+        {
+          id: 'accepted_plan',
+          label: 'Accepted Plan',
+          status: 'blocked',
+          detail: 'Accepted plan exists but must be reconciled to the current verified manifest.',
+        },
+        {
+          id: 'execution',
+          label: 'Execution',
+          status: 'current',
+          detail: 'Execution is active in building.',
+        },
+      ],
+      next_action: 'Reconcile the accepted plan and plan trace to the current verified manifest.',
+      primary_detail: 'Plan v2 is still bound to verified manifest v2, but intake has verified v3.',
+    },
+    intake_handoff: {
+      verified_manifest_version: 3,
+      promotion_basis: 'human_review_confirmed',
+      last_verified_at: '2026-03-17T20:30:00.000Z',
+      open_ambiguity_count: 0,
+    },
+    status: 'stale',
+    accepted_plan_version: 2,
+    accepted_at: '2026-03-17T21:00:00.000Z',
+    gate_profile: 'default',
+    task_count: 2,
+    risk_count: 1,
+    current_focus: 'Accepted plan needs reconciliation',
+    current_focus_detail:
+      'Plan v2 is still bound to verified manifest v2, but intake has verified v3.',
+    next_tasks: [
+      {
+        id: 'reconcile-plan',
+        title: 'Reconcile the accepted plan to the current verified manifest',
+        status: 'blocked',
+        owner_role: 'planner',
+      },
+      {
+        id: 'repair-trace',
+        title: 'Repair plan trace coverage for the changed obligations',
+        status: 'pending',
+        owner_role: 'planner',
+      },
+    ],
+    blocked_tasks: [
+      {
+        id: 'reconcile-plan',
+        title: 'Reconcile the accepted plan to the current verified manifest',
+        status: 'blocked',
+        owner_role: 'planner',
+      },
+    ],
+    file_scope: {
+      create: 1,
+      modify: 2,
+      delete: 0,
+      sample_paths: ['src/new.ts', 'src/updated.ts'],
+    },
+    trace_coverage: {
+      total_obligations: 4,
+      mapped: 2,
+      unmapped: 1,
+      deferred: 1,
+      out_of_scope: 0,
+      missing_verification_intent: 1,
+      unmapped_ids: ['OBL-203'],
+    },
+    trace_contract: {
+      valid: false,
+      missing_obligation_ids: ['OBL-203'],
+      unknown_obligation_ids: [],
+      duplicate_obligation_ids: [],
+      invalid_mappings: ['OBL-017'],
+      invalid_mapping_details: [
+        {
+          obligation_id: 'OBL-017',
+          reason: 'missing_planned_paths',
+          planned_paths: [],
+        },
+      ],
+    },
+    freshness: {
+      source_verified_manifest_version: 2,
+      current_verified_manifest_version: 3,
+      stale: true,
+      reason: 'Plan v2 is still bound to verified manifest v2, but intake has verified v3.',
+    },
+    accepted_plan_summary: {
+      summary: 'Ship the role-aware profile override contract.',
+      acceptance_criteria: ['Planner, builder, and qa may select different providers.'],
+      scoped_files: ['src/new.ts', 'src/updated.ts'],
+      risks: ['Usage telemetry may remain unavailable for some providers.'],
+      owners: ['planner', 'builder'],
+      tasks: [
+        {
+          id: 'task-1',
+          title: 'Bind per-role provider overrides to runtime selection',
+          status: 'in_progress',
+          owner_role: 'planner',
+        },
+      ],
+    },
+    empty_plan_reason: null,
+    artifacts: [
+      {
+        id: 'verified_manifest',
+        label: 'Verified Manifest',
+        format: 'json',
+        path: '.aop/features/feature_focus/spec.manifest.verified.json',
+        version: 3,
+        updated_at: '2026-03-17T20:30:00.000Z',
+        raw_content: '{\n  "manifest_version": 3\n}',
+        primary: true,
+        authority_label: 'Contract of record',
+        empty_state: 'No verified manifest',
+      },
+      {
+        id: 'plan_markdown',
+        label: 'Plan Markdown',
+        format: 'markdown',
+        path: '.aop/features/feature_focus/plan.md',
+        version: 2,
+        updated_at: '2026-03-17T21:00:00.000Z',
+        raw_content: '# Plan',
+        primary: true,
+        authority_label: 'Planner baseline',
+        empty_state: 'No plan markdown',
+      },
+      {
+        id: 'plan_json',
+        label: 'Plan JSON',
+        format: 'json',
+        path: '.aop/features/feature_focus/plan.json',
+        version: 2,
+        updated_at: '2026-03-17T21:00:00.000Z',
+        raw_content: '{\n  "plan_version": 2\n}',
+        primary: true,
+        authority_label: 'Accepted execution contract',
+        empty_state: 'No plan json',
+      },
+    ],
+  };
+}
+
+describe('PlanningTab', () => {
+  it('renders planning contract health, trace coverage, and planning artifacts', () => {
+    const markup = renderToStaticMarkup(
+      <PlanningTab featureId="feature_focus" project="alpha" initialWorkspace={buildWorkspace()} />,
+    );
+
+    expect(markup).toContain('Accepted plan is stale');
+    expect(markup).toContain('Execution Planning Summary');
+    expect(markup).toContain('Plan Contract Health');
+    expect(markup).toContain('Plan Trace Coverage');
+    expect(markup).toContain('Current trace findings:');
+    expect(markup).toContain('Current Planning Focus');
+    expect(markup).toContain('Amend Accepted Plan');
+    expect(markup).toContain('OBL-017');
+    expect(markup).toContain('Submit Amendment');
+    expect(markup).toContain('Accepted Execution Plan');
+    expect(markup).toContain('Planning Artifacts');
+    expect(markup).toContain('Verified Manifest');
+    expect(markup).toContain('Plan Markdown');
+    expect(markup).toContain('Plan JSON');
+    expect(markup).toContain('OBL-203');
+    expect(markup).not.toContain('Resolve review and merge blockers');
+  });
+});

package/packages/web-dashboard/test/components/review-tab.spec.tsx

@@ -0,0 +1,169 @@
+/** @vitest-environment node */
+import React from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import { describe, expect, it } from 'vitest';
+import { ReviewTab } from '@/components/focus/tabs/ReviewTab';
+import type { FeatureDetail, FeatureSummary } from '@/lib/types.js';
+
+function buildFeature(overrides: Partial<FeatureSummary> = {}): FeatureSummary {
+  return {
+    id: 'feature_review',
+    feature_id: 'feature_review',
+    status: 'ready_to_merge',
+    phase: 'ready_to_merge',
+    phase_entered_at: '2026-03-18T18:00:00.000Z',
+    client_status_label: 'Ready to Merge',
+    branch: 'feature/feature_review',
+    activity_state: 'idle',
+    role_status: {
+      planner: 'done',
+      builder: 'done',
+      qa: 'done',
+    },
+    pr: {
+      review_decision: 'pending',
+      ci_status: 'success',
+      merge_ready: true,
+    },
+    last_updated: '2026-03-18T18:10:00.000Z',
+    ...overrides,
+  };
+}
+
+function buildDetail(): FeatureDetail {
+  return {
+    feature: buildFeature(),
+    plan: { summary: 'Ship review diff visibility' },
+    diff: [
+      'diff --git a/src/a.ts b/src/a.ts',
+      '@@ -1 +1 @@',
+      '-old',
+      '+new',
+      'diff --git a/src/b.ts b/src/b.ts',
+      '@@ -3 +3 @@',
+      '-before',
+      '+after',
+      '',
+    ].join('\n'),
+    evidence: [],
+    review_brief: null,
+    revision_summary: [
+      {
+        id: 'review-1',
+        timestamp: '2026-03-18T18:05:00.000Z',
+        type: 'review_event',
+        headline: 'Review requested',
+        detail: 'Operator is reviewing merge readiness.',
+      },
+    ],
+  };
+}
+
+describe('ReviewTab', () => {
+  it('locks review submission until the merge gate has passed', () => {
+    const markup = renderToStaticMarkup(
+      <ReviewTab
+        detail={buildDetail()}
+        project="alpha"
+        reviewDraft={{
+          reviewMessage: '',
+          approvalToken: '',
+          mergeStrategy: 'merge_commit',
+        }}
+        onReviewDraftChange={() => undefined}
+        refreshDetail={async () => undefined}
+        refreshStatus={async () => undefined}
+        addToast={() => undefined}
+      />,
+    );
+
+    expect(markup).toContain('Combined Worktree Diff');
+    expect(markup).toContain('Merge Gate');
+    expect(markup).toContain('Run Merge Gate');
+    expect(markup).toContain(
+      'Review submission is locked until the merge gate completes successfully.',
+    );
+    expect(markup).toContain('Review the current live worktree diff before approving merge.');
+    expect(markup).toContain('src/a.ts');
+    expect(markup).toContain('Open Raw Patch');
+    expect(markup).toContain('/api/features/feature_review/diff?project=alpha');
+    expect(markup).toContain('Review Decision');
+    expect(markup).not.toContain('Approval token');
+    expect(markup).not.toContain('Merge strategy');
+    expect(markup).not.toContain('>Approve<');
+  });
+
+  it('shows approval controls after the merge gate passes', () => {
+    const markup = renderToStaticMarkup(
+      <ReviewTab
+        detail={{
+          ...buildDetail(),
+          feature: buildFeature({
+            gates: {
+              merge: 'pass',
+            },
+          }),
+        }}
+        project="alpha"
+        reviewDraft={{
+          reviewMessage: '',
+          approvalToken: '',
+          mergeStrategy: 'merge_commit',
+        }}
+        onReviewDraftChange={() => undefined}
+        refreshDetail={async () => undefined}
+        refreshStatus={async () => undefined}
+        addToast={() => undefined}
+      />,
+    );
+
+    expect(markup).toContain('Approval token');
+    expect(markup).toContain('Merge strategy');
+    expect(markup).toContain('>Approve &amp; Merge<');
+  });
+
+  it('shows send-back-to-QA guidance for blocked merge repair failures', () => {
+    const markup = renderToStaticMarkup(
+      <ReviewTab
+        detail={{
+          ...buildDetail(),
+          feature: buildFeature({
+            status: 'blocked',
+            phase: 'blocked',
+            gates: {
+              merge: 'fail',
+            },
+            merge_repair: {
+              attempts: 2,
+              max_attempts: 5,
+              active: true,
+              requested_at: '2026-03-18T18:12:00.000Z',
+              last_failed_at: '2026-03-18T18:11:00.000Z',
+              last_gate_evidence_path: '.aop/features/feature_review/evidence/gate-merge.json',
+              last_failure_summary: 'Typecheck failed after reconciliation',
+              reviewer_message: null,
+              exhausted_at: null,
+            },
+          }),
+        }}
+        project="alpha"
+        reviewDraft={{
+          reviewMessage: 'Please fix the merge gate failures',
+          approvalToken: '',
+          mergeStrategy: 'merge_commit',
+        }}
+        onReviewDraftChange={() => undefined}
+        refreshDetail={async () => undefined}
+        refreshStatus={async () => undefined}
+        addToast={() => undefined}
+      />,
+    );
+
+    expect(markup).toContain('Merge Gate');
+    expect(markup).toContain('Failed');
+    expect(markup).toContain('Send Back to QA');
+    expect(markup).toContain('Attempts used: 2/5');
+    expect(markup).toContain('continue repair attempt 3/5');
+    expect(markup).not.toContain('>Approve<');
+  });
+});

package/packages/web-dashboard/test/components/role-log-viewer.spec.ts

@@ -0,0 +1,42 @@
+/** @vitest-environment node */
+import { describe, expect, it } from 'vitest';
+import { buildPrettyLogEntries } from '@/components/focus/RoleLogViewer';
+
+describe('RoleLogViewer', () => {
+  it('formats jsonl log content into readable entries', () => {
+    const entries = buildPrettyLogEntries(
+      [
+        JSON.stringify({
+          ts: '2026-03-16T20:00:00.000Z',
+          role: 'builder',
+          event_type: 'worker_completed',
+          provider: 'claude',
+          model: 'sonnet-4-6',
+          request_count: 3,
+          message: 'Patch wave completed',
+        }),
+      ].join('\n'),
+    );
+
+    expect(entries).toHaveLength(1);
+    expect(entries[0]?.headline).toBe('worker_completed');
+    expect(entries[0]?.body).toBe('Patch wave completed');
+    expect(entries[0]?.badges).toEqual(['builder']);
+    expect(entries[0]?.meta).toEqual(
+      expect.arrayContaining([
+        { label: 'Provider', value: 'claude' },
+        { label: 'Model', value: 'sonnet-4-6' },
+        { label: 'Requests', value: '3' },
+      ]),
+    );
+  });
+
+  it('preserves plain text lines when json parsing is unavailable', () => {
+    const entries = buildPrettyLogEntries('planner started\nplain text warning');
+
+    expect(entries).toHaveLength(2);
+    expect(entries[0]?.headline).toBe('Line 1');
+    expect(entries[0]?.body).toBe('planner started');
+    expect(entries[1]?.badges).toEqual(['plain']);
+  });
+});

package/packages/web-dashboard/test/components/runtime-inspector.spec.tsx

@@ -0,0 +1,22 @@
+/** @vitest-environment node */
+import React from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import { describe, expect, it } from 'vitest';
+import { RuntimeInspectorPanel } from '@/components/features/runtime-inspector/RuntimeInspectorPanel';
+
+describe('RuntimeInspectorPanel', () => {
+  it('renders the runtime inspector shell', () => {
+    const markup = renderToStaticMarkup(
+      <RuntimeInspectorPanel featureId="feature_ui" project="" />,
+    );
+    expect(markup).toContain('Run Review');
+    expect(markup).toContain('Review what the runtime attempted');
+  });
+
+  it('renders the empty run history message on first paint', () => {
+    const markup = renderToStaticMarkup(
+      <RuntimeInspectorPanel featureId="feature_ui" project="" />,
+    );
+    expect(markup).toContain('No runs recorded for this feature yet.');
+  });
+});