agentic-orchestrator 0.1.28 → 0.2.0

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

@@ -0,0 +1,138 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const ORIGINAL_ARGV = [...process.argv];
+const ORIGINAL_AOP_ROOT = process.env.AOP_ROOT;
+const ORIGINAL_EXIT_CODE = process.exitCode;
+
+function resetProcessState(): void {
+  process.argv = [...ORIGINAL_ARGV];
+  process.exitCode = ORIGINAL_EXIT_CODE;
+  if (typeof ORIGINAL_AOP_ROOT === 'string') {
+    process.env.AOP_ROOT = ORIGINAL_AOP_ROOT;
+  } else {
+    delete process.env.AOP_ROOT;
+  }
+}
+
+describe('dashboard-runtime.ts entrypoint', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.clearAllMocks();
+    resetProcessState();
+  });
+
+  afterEach(() => {
+    vi.resetModules();
+    vi.restoreAllMocks();
+    resetProcessState();
+  });
+
+  it('uses explicit repo-root and instance-id flags when present', async () => {
+    const startMock = vi.fn().mockResolvedValue(undefined);
+    const runnerConstructor = vi.fn(function DashboardRuntimeRunnerMock() {
+      return { start: startMock };
+    });
+    const computeInstanceId = vi.fn(() => 'derived-instance');
+    const defaultConfigPath = vi.fn(() => '/unused/config');
+
+    vi.doMock('../src/application/services/instance-isolation-service.js', () => ({
+      computeInstanceId,
+      defaultConfigPath,
+    }));
+    vi.doMock('../src/cli/dashboard-runtime-runner.js', () => ({
+      DashboardRuntimeRunner: runnerConstructor,
+    }));
+
+    process.argv = [
+      ORIGINAL_ARGV[0] ?? 'node',
+      ORIGINAL_ARGV[1] ?? 'dashboard-runtime.ts',
+      '--repo-root',
+      '/repo-root',
+      '--instance-id',
+      'instance-123',
+    ];
+
+    await import('../src/cli/dashboard-runtime.js');
+    await new Promise((resolve) => setImmediate(resolve));
+
+    expect(defaultConfigPath).not.toHaveBeenCalled();
+    expect(computeInstanceId).not.toHaveBeenCalled();
+    expect(runnerConstructor).toHaveBeenCalledWith({
+      repoRoot: '/repo-root',
+      instanceId: 'instance-123',
+      env: process.env,
+    });
+    expect(startMock).toHaveBeenCalledTimes(1);
+    expect(process.exitCode).toBe(ORIGINAL_EXIT_CODE);
+  });
+
+  it('falls back to AOP_ROOT and derived instance id when flags are absent', async () => {
+    const startMock = vi.fn().mockResolvedValue(undefined);
+    const runnerConstructor = vi.fn(function DashboardRuntimeRunnerMock() {
+      return { start: startMock };
+    });
+    const computeInstanceId = vi.fn(() => 'derived-instance');
+    const defaultConfigPath = vi.fn((repoRoot: string) => `${repoRoot}/config/policy.yaml`);
+
+    vi.doMock('../src/application/services/instance-isolation-service.js', () => ({
+      computeInstanceId,
+      defaultConfigPath,
+    }));
+    vi.doMock('../src/cli/dashboard-runtime-runner.js', () => ({
+      DashboardRuntimeRunner: runnerConstructor,
+    }));
+
+    process.argv = [ORIGINAL_ARGV[0] ?? 'node', ORIGINAL_ARGV[1] ?? 'dashboard-runtime.ts'];
+    process.env.AOP_ROOT = '/env-root';
+
+    await import('../src/cli/dashboard-runtime.js');
+    await new Promise((resolve) => setImmediate(resolve));
+
+    expect(defaultConfigPath).toHaveBeenCalledWith('/env-root');
+    expect(computeInstanceId).toHaveBeenCalledWith('/env-root/config/policy.yaml');
+    expect(runnerConstructor).toHaveBeenCalledWith({
+      repoRoot: '/env-root',
+      instanceId: 'derived-instance',
+      env: process.env,
+    });
+    expect(startMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('logs failures and sets process exit code when the runner start fails', async () => {
+    const startMock = vi.fn().mockRejectedValue(new Error('runtime boom'));
+    const runnerConstructor = vi.fn(function DashboardRuntimeRunnerMock() {
+      return { start: startMock };
+    });
+    const computeInstanceId = vi.fn(() => 'derived-instance');
+    const defaultConfigPath = vi.fn(() => '/cwd/config/policy.yaml');
+    const cwdSpy = vi.spyOn(process, 'cwd').mockReturnValue('/cwd-root');
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    vi.doMock('../src/application/services/instance-isolation-service.js', () => ({
+      computeInstanceId,
+      defaultConfigPath,
+    }));
+    vi.doMock('../src/cli/dashboard-runtime-runner.js', () => ({
+      DashboardRuntimeRunner: runnerConstructor,
+    }));
+
+    process.argv = [
+      ORIGINAL_ARGV[0] ?? 'node',
+      ORIGINAL_ARGV[1] ?? 'dashboard-runtime.ts',
+      '--repo-root',
+      '   ',
+      '--instance-id',
+      '   ',
+    ];
+    delete process.env.AOP_ROOT;
+
+    await import('../src/cli/dashboard-runtime.js');
+    await new Promise((resolve) => setImmediate(resolve));
+
+    expect(cwdSpy).toHaveBeenCalled();
+    expect(defaultConfigPath).toHaveBeenCalledWith('/cwd-root');
+    expect(computeInstanceId).toHaveBeenCalledWith('/cwd/config/policy.yaml');
+    expect(consoleErrorSpy).toHaveBeenCalledWith('runtime boom');
+    expect(process.exitCode).toBe(1);
+  });
+});

package/apps/control-plane/test/dashboard-ui-utils.spec.ts

@@ -15,6 +15,7 @@ import {
   parseDashboardRouteState,
   parseFiltersFromSearchParams,
   parseUnifiedDiff,
+  sortFeaturesForTriage,
   sparklinePath,
   sparklinePoints,
   truncateText,
@@ -42,14 +43,14 @@ function feature(overrides: Partial<FeatureSummary>): FeatureSummary {
 
 describe('dashboard utilities', () => {
   it('applies quick filters deterministically', () => {
-    const active = applyQuickFilter('active');
-    expect(active.phases).toEqual(['planning', 'building', 'qa', 'ready_to_merge']);
+    const needsMe = applyQuickFilter('needs_me');
+    expect(needsMe.activities).toEqual(['waiting_input']);
 
-    const awaitingInput = applyQuickFilter('awaiting_input');
-    expect(awaitingInput.activities).toEqual(['waiting_input']);
+    const waitingOnDependencies = applyQuickFilter('waiting_on_dependencies');
+    expect(waitingOnDependencies.quickFilter).toBe('waiting_on_dependencies');
 
-    const ciFailing = applyQuickFilter('ci_failing');
-    expect(ciFailing.ciFailuresOnly).toBe(true);
+    const ready = applyQuickFilter('ready');
+    expect(ready.phases).toEqual(['ready_to_merge']);
   });
 
   it('filters feature collections by search, phase, activity, gates, and ci', () => {
@@ -110,11 +111,13 @@ describe('dashboard utilities', () => {
 
     const counts = computeSummaryCounts(payload);
     expect(counts).toEqual({
-      active: 2,
-      blocked: 1,
-      awaitingInput: 1,
-      readyToMerge: 1,
-      ciFailing: 1,
+      needsMe: 1,
+      atRisk: 1,
+      ready: 1,
+      stalled: 0,
+      waitingOnDependencies: 0,
+      waitingOnCi: 0,
+      recentlyChanged: 0,
     });
   });
 
@@ -252,7 +255,7 @@ describe('dashboard utilities', () => {
         enabled: false,
         authorized: true,
       }),
-    ).toBe(false);
+    ).toBe(true);
   });
 
   it('computes deterministic keyboard focus transitions across board columns', () => {
@@ -268,4 +271,45 @@ describe('dashboard utilities', () => {
     expect(getNextFocusedFeatureId(columns, 'feature_c', 'ArrowLeft')).toBe('feature_a');
     expect(getNextFocusedFeatureId(columns, null, 'ArrowRight')).toBe('feature_c');
   });
+
+  it('filters merged and task-first states without unstable client reconstruction', () => {
+    const features = [
+      feature({
+        feature_id: 'recent',
+        attention_reasons: ['Recently Changed'],
+        last_meaningful_change_at: '2026-03-05T00:00:00Z',
+      }),
+      feature({
+        feature_id: 'deps',
+        attention_reasons: ['Waiting On Dependencies'],
+      }),
+      feature({
+        feature_id: 'merged_feature',
+        phase: 'merged',
+      }),
+    ];
+
+    expect(
+      filterFeatures(features, {
+        ...createDefaultFilters(),
+        quickFilter: 'recently_changed',
+      }).map((item) => item.feature_id),
+    ).toEqual(['recent']);
+    expect(
+      filterFeatures(features, {
+        ...createDefaultFilters(),
+        phases: ['merged'] as FeatureSummary['phase'][],
+      }).map((item) => item.feature_id),
+    ).toEqual(['merged_feature']);
+  });
+
+  it('ranks attention-heavy work ahead of default triage ordering', () => {
+    const sorted = sortFeaturesForTriage([
+      feature({ feature_id: 'recent', attention_reasons: ['Recently Changed'] }),
+      feature({ feature_id: 'needs_me', activity_state: 'waiting_input', waiting_input_count: 1 }),
+      feature({ feature_id: 'ready', phase: 'ready_to_merge' }),
+    ]);
+
+    expect(sorted.map((item) => item.feature_id)).toEqual(['needs_me', 'ready', 'recent']);
+  });
 });

package/apps/control-plane/test/dependency-scheduler.spec.ts

@@ -6,7 +6,7 @@ import {
   addToDepBlocked,
   resolveDepBlocked,
 } from '../src/application/services/dependency-scheduler-service.js';
-import { makeTempRepo, writeFeatureSpec } from './helpers.js';
+import { makeTempRepo, verifyFeatureIntake, writeFeatureSpec } from './helpers.js';
 
 let repoRoot: string;
 
@@ -118,6 +118,8 @@ describe('N4: Dependency-Aware Feature Scheduling', () => {
       await writeFeatureSpec(repoRoot, 'feat-child');
       await kernel.invoke('feature.init', { feature_id: 'feat-parent' }, ORCH_CTX);
       await kernel.invoke('feature.init', { feature_id: 'feat-child' }, ORCH_CTX);
+      await verifyFeatureIntake(kernel, 'feat-parent');
+      await verifyFeatureIntake(kernel, 'feat-child');
 
       // Set depends_on in feat-child's state
       await kernel.updateState('feat-child', null, async (fm: Record<string, unknown>) => ({
@@ -142,6 +144,8 @@ describe('N4: Dependency-Aware Feature Scheduling', () => {
       await writeFeatureSpec(repoRoot, 'feat-child2');
       await kernel.invoke('feature.init', { feature_id: 'feat-merged-dep' }, ORCH_CTX);
       await kernel.invoke('feature.init', { feature_id: 'feat-child2' }, ORCH_CTX);
+      await verifyFeatureIntake(kernel, 'feat-merged-dep');
+      await verifyFeatureIntake(kernel, 'feat-child2');
 
       // Mark feat-merged-dep as merged directly in index
       await kernel.withIndexLock(async () => {
@@ -170,6 +174,8 @@ describe('N4: Dependency-Aware Feature Scheduling', () => {
       await writeFeatureSpec(repoRoot, 'feat-waiter');
       await kernel.invoke('feature.init', { feature_id: 'feat-blocker' }, ORCH_CTX);
       await kernel.invoke('feature.init', { feature_id: 'feat-waiter' }, ORCH_CTX);
+      await verifyFeatureIntake(kernel, 'feat-blocker');
+      await verifyFeatureIntake(kernel, 'feat-waiter');
 
       await kernel.updateState('feat-waiter', null, async (fm: Record<string, unknown>) => ({
         frontMatter: { ...fm, depends_on: ['feat-blocker'] },

package/apps/control-plane/test/env-file.spec.ts

@@ -0,0 +1,76 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import {
+  readEnvFileValues,
+  readNonEmptyEnvValue,
+  upsertEnvFileValue,
+} from '../src/cli/env-file.js';
+
+async function makeTempDir(): Promise<string> {
+  return await fs.mkdtemp(path.join(os.tmpdir(), 'aop-env-file-'));
+}
+
+describe('env-file helpers', () => {
+  it('reads env values while ignoring invalid lines', async () => {
+    const tmpDir = await makeTempDir();
+    try {
+      const envPath = path.join(tmpDir, '.env');
+      await fs.writeFile(
+        envPath,
+        [
+          '',
+          '# comment',
+          'export FOO=bar',
+          'BAZ="quoted value"',
+          "SINGLE='single value'",
+          'INVALID KEY=oops',
+          '9INVALID=nope',
+          '=missingkey',
+          'EMPTY=',
+        ].join('\n'),
+        'utf8',
+      );
+
+      const values = await readEnvFileValues(envPath);
+      expect(values).toMatchObject({
+        FOO: 'bar',
+        BAZ: 'quoted value',
+        SINGLE: 'single value',
+        EMPTY: '',
+      });
+      expect(values.INVALID).toBeUndefined();
+    } finally {
+      await fs.rm(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('prefers runtime env values and falls back to file values', () => {
+    const runtimeEnv = { TOKEN: 'runtime', EMPTY: '   ' };
+    const fileValues = { TOKEN: 'file', FALLBACK: 'file-value' };
+
+    expect(readNonEmptyEnvValue('TOKEN', runtimeEnv, fileValues)).toBe('runtime');
+    expect(readNonEmptyEnvValue('FALLBACK', runtimeEnv, fileValues)).toBe('file-value');
+    expect(readNonEmptyEnvValue('MISSING', runtimeEnv, fileValues)).toBeNull();
+    expect(readNonEmptyEnvValue('EMPTY', runtimeEnv, fileValues)).toBeNull();
+  });
+
+  it('upserts env values by creating, appending, and replacing entries', async () => {
+    const tmpDir = await makeTempDir();
+    try {
+      const envPath = path.join(tmpDir, '.env');
+
+      await upsertEnvFileValue(envPath, 'PRIMARY', 'alpha');
+      await upsertEnvFileValue(envPath, 'SECONDARY', 'two words');
+      await upsertEnvFileValue(envPath, 'PRIMARY', 'beta');
+
+      const content = await fs.readFile(envPath, 'utf8');
+      expect(content).toContain('PRIMARY=beta');
+      expect(content).toContain('SECONDARY="two words"');
+      expect(content.endsWith('\n')).toBe(true);
+    } finally {
+      await fs.rm(tmpDir, { recursive: true, force: true });
+    }
+  });
+});