agentic-orchestrator 0.1.0

package/apps/control-plane/test/supervisor.unit.spec.ts

@@ -0,0 +1,522 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { ERROR_CODES } from '../src/core/error-codes.js';
+import { STATUS, TOOLS } from '../src/core/constants.js';
+import { SupervisorRuntime } from '../src/index.js';
+
+function makeRuntime(options: Record<string, unknown> = {}) {
+  const kernelState = {
+    repoRoot: '',
+    agentsConfig: { roles: {}, missing_prompt_behavior: 'ignore' }
+  };
+
+  const kernel = {
+    getRepoRoot: vi.fn(() => kernelState.repoRoot),
+    getAgentsConfig: vi.fn(() => kernelState.agentsConfig),
+    getPolicySnapshot: vi.fn(
+      (): Record<string, unknown> => ({
+        recovery: {
+          orchestrator_session_reattach_timeout_ms: 5000,
+          orphan_session_cleanup_enabled: true
+        }
+      })
+    ),
+    getRuntimeSessions: vi.fn(async () => ({
+      run_id: 'run:test',
+      owner_instance_id: 'owner:test',
+      orchestrator_session_id: 'unknown',
+      orchestrator_epoch: 0,
+      feature_sessions: {}
+    })),
+    updateOrchestratorSession: vi.fn(async () => ({ data: {} })),
+    updateFeatureSessionAssignment: vi.fn(async () => ({ data: { updated: true } })),
+    pruneFeatureSessionAssignments: vi.fn(async () => ({ data: { removed: [] } })),
+    ensureLoaded: vi.fn(async () => undefined),
+    recoverFromState: vi.fn(async () => ({ data: { recovered: true } })),
+    acquireRunLease: vi.fn(async () => ({ data: { took_over_stale: false } })),
+    renewLeases: vi.fn(async () => undefined),
+    renewRunLease: vi.fn(async () => undefined),
+    repoDiff: vi.fn(async () => ({ data: { diff: '' } }))
+  };
+
+  const provider = {
+    selection: {
+      provider: 'custom',
+      model: 'model-x',
+      provider_config_ref: null
+    },
+    createSession: vi.fn(async (role: string, featureId: string) => ({
+      session_id: `${role}-${featureId}-session`
+    })),
+    reattachSession: vi.fn(async () => null),
+    closeSession: vi.fn(async () => ({ closed: true }))
+  };
+
+  const toolClient = {
+    call: vi.fn(async (): Promise<any> => ({ ok: true, data: {} }))
+  };
+
+  const runtime = new SupervisorRuntime(kernel as any, provider as any, toolClient as any, {
+    run_id: 'run:test',
+    owner_instance_id: 'owner:test',
+    max_iterations_per_phase: 0,
+    ...options
+  });
+
+  return { runtime, kernel, provider, toolClient };
+}
+
+describe('SupervisorRuntime unit behavior', () => {
+  it('GIVEN_policy_supervisor_iterations_WHEN_runtime_created_without_cli_override_THEN_uses_policy_config', async () => {
+    const { kernel, provider, toolClient } = makeRuntime();
+    kernel.getPolicySnapshot.mockReturnValue({
+      recovery: {
+        orchestrator_session_reattach_timeout_ms: 5000,
+        orphan_session_cleanup_enabled: true
+      },
+      supervisor: {
+        max_iterations_per_phase: 4
+      }
+    });
+
+    const runtime = new SupervisorRuntime(kernel as any, provider as any, toolClient as any, {
+      run_id: 'run:test',
+      owner_instance_id: 'owner:test'
+    });
+
+    expect(runtime.maxIterationsPerPhase).toBe(4);
+  });
+
+  it('GIVEN_matching_runtime_session_WHEN_ensuring_orchestrator_session_THEN_reuses_existing_session', async () => {
+    const { runtime, kernel, provider } = makeRuntime();
+    kernel.getRuntimeSessions.mockResolvedValue({
+      run_id: 'run:test',
+      owner_instance_id: 'owner:test',
+      orchestrator_session_id: 'orch-existing',
+      orchestrator_epoch: 0,
+      feature_sessions: {}
+    });
+    provider.reattachSession.mockResolvedValue({
+      session_id: 'orch-existing',
+      role: 'orchestrator',
+      feature_id: 'global',
+      system_prompt_loaded: false
+    });
+
+    await runtime.ensureGlobalOrchestratorSession();
+
+    expect(runtime.orchestratorSessionId).toBe('orch-existing');
+    expect(runtime.runMetadata.orchestrator_reattached).toBe(true);
+    expect(provider.createSession).not.toHaveBeenCalled();
+    expect(kernel.updateOrchestratorSession).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_no_reusable_orchestrator_session_WHEN_ensuring_THEN_creates_and_persists_new_session', async () => {
+    const { runtime, kernel, provider } = makeRuntime();
+    kernel.getRuntimeSessions.mockResolvedValue({
+      run_id: 'other-run',
+      owner_instance_id: 'other-owner',
+      orchestrator_session_id: 'unknown',
+      orchestrator_epoch: 0,
+      feature_sessions: {}
+    });
+    provider.createSession.mockResolvedValue({ session_id: 'orch-new' });
+
+    await runtime.ensureGlobalOrchestratorSession();
+
+    expect(runtime.orchestratorSessionId).toBe('orch-new');
+    expect(runtime.runMetadata.orchestrator_reattached).toBe(false);
+    expect(kernel.updateOrchestratorSession).toHaveBeenCalledWith(
+      expect.objectContaining({
+        run_id: 'run:test',
+        owner_instance_id: 'owner:test',
+        orchestrator_session_id: 'orch-new',
+        increment_epoch: false
+      })
+    );
+  });
+
+  it('GIVEN_reattach_timeout_on_reusable_session_WHEN_ensuring_THEN_recreates_orchestrator_and_marks_epoch_orphan', async () => {
+    const { runtime, kernel, provider, toolClient } = makeRuntime();
+    kernel.getPolicySnapshot.mockReturnValue({
+      recovery: {
+        orchestrator_session_reattach_timeout_ms: 10,
+        orphan_session_cleanup_enabled: true
+      }
+    });
+    kernel.getRuntimeSessions.mockResolvedValue({
+      run_id: 'run:test',
+      owner_instance_id: 'owner:test',
+      orchestrator_session_id: 'orch-old',
+      orchestrator_epoch: 4,
+      feature_sessions: {}
+    });
+    provider.reattachSession.mockImplementation(
+      () =>
+        new Promise(() => {
+          // Intentionally unresolved to force timeout-based fallback.
+        })
+    );
+    provider.createSession.mockResolvedValue({ session_id: 'orch-new' });
+    toolClient.call.mockResolvedValue({ ok: true, data: {} });
+
+    await runtime.ensureGlobalOrchestratorSession();
+
+    expect(runtime.orchestratorSessionId).toBe('orch-new');
+    expect(runtime.runMetadata.orchestrator_reattached).toBe(false);
+    expect(runtime.runMetadata.orchestrator_epoch_incremented).toBe(true);
+    expect(kernel.updateOrchestratorSession).toHaveBeenCalledWith(
+      expect.objectContaining({
+        orchestrator_session_id: 'orch-new',
+        increment_epoch: true
+      })
+    );
+    expect(toolClient.call).toHaveBeenCalledWith(
+      TOOLS.FEATURE_LOG_APPEND,
+      expect.objectContaining({
+        feature_id: 'global',
+        note: expect.stringContaining('"orphan_session_id":"orch-old"')
+      }),
+      expect.objectContaining({
+        actor_type: 'orchestrator'
+      })
+    );
+  });
+
+  it('GIVEN_active_feature_assignments_WHEN_cleaning_orphans_THEN_closes_non_unassigned_sessions', async () => {
+    const { runtime, kernel, provider } = makeRuntime();
+    kernel.getRuntimeSessions.mockResolvedValue({
+      run_id: 'run:test',
+      owner_instance_id: 'owner:test',
+      orchestrator_session_id: 'orch',
+      orchestrator_epoch: 0,
+      feature_sessions: {
+        feature_a: {
+          planner_session_id: 'planner-a',
+          builder_session_id: 'builder-a',
+          qa_session_id: 'unassigned'
+        },
+        feature_b: {
+          planner_session_id: 'planner-b',
+          builder_session_id: 'builder-b',
+          qa_session_id: 'qa-b'
+        }
+      }
+    });
+    provider.closeSession.mockRejectedValueOnce(new Error('close error'));
+
+    await runtime.cleanupOrphanWorkerSessions(['feature_a']);
+
+    expect(provider.closeSession).toHaveBeenCalledTimes(2);
+    expect(provider.closeSession).toHaveBeenNthCalledWith(1, 'planner-a');
+    expect(provider.closeSession).toHaveBeenNthCalledWith(2, 'builder-a');
+  });
+
+  it('GIVEN_epoch_incremented_recovery_WHEN_cleaning_orphans_THEN_closes_all_assigned_worker_sessions', async () => {
+    const { runtime, kernel, provider } = makeRuntime();
+    runtime.runMetadata.orchestrator_epoch_incremented = true;
+    kernel.getRuntimeSessions.mockResolvedValue({
+      run_id: 'run:test',
+      owner_instance_id: 'owner:test',
+      orchestrator_session_id: 'orch',
+      orchestrator_epoch: 1,
+      feature_sessions: {
+        feature_a: {
+          planner_session_id: 'planner-a',
+          builder_session_id: 'builder-a',
+          qa_session_id: 'qa-a'
+        },
+        feature_b: {
+          planner_session_id: 'planner-b',
+          builder_session_id: 'builder-b',
+          qa_session_id: 'unassigned'
+        }
+      }
+    });
+
+    await runtime.cleanupOrphanWorkerSessions(['feature_a']);
+
+    expect(provider.closeSession).toHaveBeenCalledTimes(5);
+    expect(provider.closeSession).toHaveBeenNthCalledWith(1, 'planner-a');
+    expect(provider.closeSession).toHaveBeenNthCalledWith(2, 'builder-a');
+    expect(provider.closeSession).toHaveBeenNthCalledWith(3, 'qa-a');
+    expect(provider.closeSession).toHaveBeenNthCalledWith(4, 'planner-b');
+    expect(provider.closeSession).toHaveBeenNthCalledWith(5, 'builder-b');
+  });
+
+  it('GIVEN_missing_prompt_with_error_behavior_WHEN_loading_prompts_THEN_throws_missing_role_prompt', async () => {
+    const { runtime } = makeRuntime();
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-supervisor-prompts-'));
+    runtime.kernel.getRepoRoot = vi.fn(() => repoRoot);
+    runtime.kernel.getAgentsConfig = vi.fn(() => ({
+      roles: {
+        planner: { system_prompt_path: 'prompts/planner.md' }
+      },
+      missing_prompt_behavior: 'error'
+    }));
+
+    await expect(runtime.loadRolePrompts()).rejects.toMatchObject({
+      code: ERROR_CODES.MISSING_ROLE_PROMPT
+    });
+
+    await fs.rm(repoRoot, { recursive: true, force: true });
+  });
+
+  it('GIVEN_ignore_behavior_WHEN_loading_prompts_twice_THEN_uses_cached_prompt_bundle', async () => {
+    const { runtime } = makeRuntime();
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-supervisor-prompts-'));
+    const promptsDir = path.join(repoRoot, 'prompts');
+    await fs.mkdir(promptsDir, { recursive: true });
+    await fs.writeFile(path.join(promptsDir, 'planner.md'), 'planner prompt', 'utf8');
+    runtime.kernel.getRepoRoot = vi.fn(() => repoRoot);
+    runtime.kernel.getAgentsConfig = vi.fn(() => ({
+      roles: {
+        planner: { system_prompt_path: 'prompts/planner.md' },
+        builder: { system_prompt_path: 'prompts/missing-builder.md' }
+      },
+      missing_prompt_behavior: 'ignore'
+    }));
+
+    const first = await runtime.loadRolePrompts();
+    await fs.writeFile(path.join(promptsDir, 'planner.md'), 'updated planner prompt', 'utf8');
+    const second = await runtime.loadRolePrompts();
+
+    expect(first).toEqual({
+      planner: 'planner prompt',
+      builder: null,
+      qa: null
+    });
+    expect(second).toEqual(first);
+    await fs.rm(repoRoot, { recursive: true, force: true });
+  });
+
+  it('GIVEN_mixed_context_statuses_WHEN_running_planning_wave_THEN_submits_only_missing_plans_for_plannable_states', async () => {
+    const { runtime } = makeRuntime();
+    const callTool = vi.spyOn(runtime, 'callTool');
+    const generatePlan = vi.spyOn(runtime, 'generateInitialPlan').mockResolvedValue({ generated: true });
+
+    callTool.mockImplementation(async (_role, toolName, args) => {
+      if (toolName === TOOLS.FEATURE_GET_CONTEXT && args.feature_id === 'feature_a') {
+        return { ok: true, data: { state: { front_matter: { status: STATUS.PLANNING } }, plan: null } };
+      }
+      if (toolName === TOOLS.FEATURE_GET_CONTEXT && args.feature_id === 'feature_b') {
+        return { ok: true, data: { state: { front_matter: { status: STATUS.QA } }, plan: null } };
+      }
+      if (toolName === TOOLS.FEATURE_GET_CONTEXT && args.feature_id === 'feature_c') {
+        return { ok: true, data: { state: { front_matter: { status: STATUS.BLOCKED } }, plan: { plan_version: 1 } } };
+      }
+      return { ok: true, data: {} };
+    });
+
+    await runtime.runPlanningWave(['feature_a', 'feature_b', 'feature_c']);
+
+    expect(generatePlan).toHaveBeenCalledTimes(1);
+    expect(generatePlan).toHaveBeenCalledWith('feature_a');
+    expect(callTool).toHaveBeenCalledWith(
+      'planner',
+      TOOLS.PLAN_SUBMIT,
+      expect.objectContaining({ feature_id: 'feature_a' })
+    );
+  });
+
+  it('GIVEN_building_features_exceeding_parallel_limit_WHEN_running_build_wave_THEN_runs_fast_gates_for_limited_batch', async () => {
+    const { runtime } = makeRuntime({ max_parallel_gate_runs: 1 });
+    const callTool = vi.spyOn(runtime, 'callTool');
+
+    callTool.mockImplementation(async (_role, toolName, args) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return {
+          ok: true,
+          data: {
+            front_matter: {
+              status: args.feature_id === 'feature_c' ? STATUS.QA : STATUS.BUILDING
+            }
+          }
+        };
+      }
+      return { ok: true, data: {} };
+    });
+
+    await runtime.runBuildWave(['feature_a', 'feature_b', 'feature_c']);
+
+    const gateCalls = callTool.mock.calls.filter(
+      (call) => call[0] === 'builder' && call[1] === TOOLS.GATES_RUN
+    );
+    expect(gateCalls).toHaveLength(1);
+    expect(gateCalls[0][2]).toMatchObject({ feature_id: 'feature_a', mode: 'fast' });
+  });
+
+  it('GIVEN_qa_features_WHEN_running_qa_wave_THEN_rotates_qa_session_and_updates_assignments', async () => {
+    const { runtime, kernel, provider } = makeRuntime({ max_parallel_gate_runs: 1 });
+    runtime.orchestratorSessionId = 'orch-main';
+    runtime.sessionsByFeature.set('feature_a', {
+      planner: 'planner-old',
+      builder: 'builder-old',
+      qa: 'qa-old'
+    });
+    vi.spyOn(runtime, 'loadRolePrompts').mockResolvedValue({
+      planner: null,
+      builder: null,
+      qa: 'qa prompt'
+    });
+    vi.spyOn(runtime, 'patchFeatureCluster').mockResolvedValue();
+    const callTool = vi.spyOn(runtime, 'callTool');
+    callTool.mockImplementation(async (_role, toolName) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return { ok: true, data: { front_matter: { status: STATUS.QA } } };
+      }
+      return { ok: true, data: {} };
+    });
+    provider.createSession.mockResolvedValue({ session_id: 'qa-new' });
+
+    await runtime.runQaWave(['feature_a']);
+
+    expect(provider.closeSession).toHaveBeenCalledWith('qa-old');
+    expect(provider.createSession).toHaveBeenCalledWith('qa', 'feature_a', 'qa prompt');
+    expect(runtime.sessionsByFeature.get('feature_a')?.qa).toBe('qa-new');
+    expect(kernel.updateFeatureSessionAssignment).toHaveBeenCalledWith(
+      expect.objectContaining({
+        feature_id: 'feature_a',
+        planner_session_id: 'planner-old',
+        builder_session_id: 'builder-old',
+        qa_session_id: 'qa-new'
+      })
+    );
+  });
+
+  it('GIVEN_mutating_tool_and_role_sessions_WHEN_calling_tool_THEN_adds_operation_id_and_uses_role_session', async () => {
+    const { runtime, toolClient } = makeRuntime();
+    runtime.orchestratorSessionId = 'orch-main';
+    runtime.sessionsByFeature.set('feature_a', {
+      planner: 'planner-session',
+      builder: 'builder-session',
+      qa: 'qa-session'
+    });
+    toolClient.call.mockResolvedValueOnce({ ok: true, data: { accepted: true } });
+
+    const response = await runtime.callTool('builder', TOOLS.GATES_RUN, {
+      feature_id: 'feature_a',
+      mode: 'fast'
+    });
+
+    expect(response).toEqual({ ok: true, data: { accepted: true } });
+    expect(toolClient.call).toHaveBeenCalledWith(
+      TOOLS.GATES_RUN,
+      expect.objectContaining({
+        feature_id: 'feature_a',
+        mode: 'fast',
+        operation_id: expect.any(String)
+      }),
+      expect.objectContaining({
+        session_id: 'builder-session',
+        actor_type: 'builder'
+      })
+    );
+  });
+
+  it('GIVEN_failed_tool_response_WHEN_calling_tool_THEN_throws_normalized_error', async () => {
+    const { runtime, toolClient } = makeRuntime();
+    runtime.sessionsByFeature.set('feature_a', {
+      planner: 'planner-session',
+      builder: 'builder-session',
+      qa: 'qa-session'
+    });
+    toolClient.call.mockResolvedValue({
+      ok: false,
+      error: {
+        code: ERROR_CODES.LOCK_CONFLICT,
+        message: 'lock held',
+        details: { holder: 'feature_b' }
+      }
+    });
+
+    await expect(
+      runtime.callTool('builder', TOOLS.GATES_RUN, { feature_id: 'feature_a' })
+    ).rejects.toMatchObject({
+      code: ERROR_CODES.LOCK_CONFLICT,
+      details: { holder: 'feature_b' }
+    });
+  });
+
+  it('GIVEN_repo_diff_failure_WHEN_generating_initial_plan_THEN_uses_head_base_ref', async () => {
+    const { runtime, kernel } = makeRuntime();
+    kernel.repoDiff.mockRejectedValue(new Error('no diff'));
+
+    const plan = await runtime.generateInitialPlan('feature_plan');
+    expect(plan).toMatchObject({
+      feature_id: 'feature_plan',
+      plan_version: 1,
+      base_ref: 'HEAD',
+      gate_profile: 'default'
+    });
+  });
+
+  it('GIVEN_active_sessions_WHEN_renewing_heartbeats_THEN_renews_lock_and_run_leases', async () => {
+    const { runtime, kernel } = makeRuntime();
+    runtime.sessionsByFeature.set('feature_a', {
+      planner: 'p1',
+      builder: 'b1',
+      qa: 'q1'
+    });
+
+    await runtime.renewLeaseHeartbeats();
+
+    expect(kernel.renewLeases).toHaveBeenCalledWith(['feature_a']);
+    expect(kernel.renewRunLease).toHaveBeenCalledWith('run:test', 'owner:test');
+  });
+
+  it('GIVEN_no_orchestrator_session_WHEN_enforcing_active_feature_invariant_THEN_is_noop', async () => {
+    const { runtime } = makeRuntime();
+    const callTool = vi.spyOn(runtime, 'callTool');
+    runtime.orchestratorSessionId = null;
+
+    await runtime.enforceActiveFeatureInvariant(['feature_a']);
+
+    expect(callTool).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_aligned_and_queued_features_WHEN_enforcing_and_reconciling_THEN_only_patches_queued_feature', async () => {
+    const { runtime, kernel } = makeRuntime();
+    runtime.orchestratorSessionId = 'orch-main';
+    runtime.queue = [{ feature_id: 'feature_q' } as any];
+    const callTool = vi.spyOn(runtime, 'callTool');
+
+    callTool.mockImplementation(async (_role, toolName, args) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return {
+          ok: true,
+          data: {
+            front_matter: {
+              version: 3,
+              cluster: {
+                orchestrator_session_id: args.feature_id === 'feature_a' ? 'orch-main' : 'other'
+              }
+            }
+          }
+        } as any;
+      }
+      return { ok: true, data: {} } as any;
+    });
+
+    await runtime.enforceActiveFeatureInvariant(['feature_a']);
+    await runtime.reconcileQueuedFeatures();
+
+    const patchCalls = callTool.mock.calls.filter(([, tool]) => tool === TOOLS.FEATURE_STATE_PATCH);
+    expect(patchCalls).toHaveLength(1);
+    expect(patchCalls[0][2]).toMatchObject({ feature_id: 'feature_q' });
+    expect(kernel.updateFeatureSessionAssignment).toHaveBeenCalledWith(
+      expect.objectContaining({
+        feature_id: 'feature_q',
+        planner_session_id: 'unassigned',
+        builder_session_id: 'unassigned',
+        qa_session_id: 'unassigned'
+      })
+    );
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+});

package/apps/control-plane/test/token-auth-verifier.spec.ts

@@ -0,0 +1,111 @@
+import crypto from 'node:crypto';
+import { describe, expect, it } from 'vitest';
+import { ERROR_CODES } from '../src/core/error-codes.js';
+import { TokenAuthVerifier } from '../src/index.js';
+
+function sign(secret: string, encodedHeader: string, encodedPayload: string): string {
+  return crypto.createHmac('sha256', secret).update(`${encodedHeader}.${encodedPayload}`).digest('base64url');
+}
+
+function encode(value: unknown): string {
+  return Buffer.from(JSON.stringify(value), 'utf8').toString('base64url');
+}
+
+function expectThrownCode(action: () => unknown, code: string): void {
+  let thrown: any = null;
+  try {
+    action();
+  } catch (error) {
+    thrown = error;
+  }
+  expect(thrown?.normalizedResponse?.error?.code).toBe(code);
+}
+
+describe('TokenAuthVerifier', () => {
+  const secret = 'unit-test-secret';
+  const now = new Date('2026-01-01T00:00:00.000Z');
+  const verifier = new TokenAuthVerifier({
+    secret,
+    now: () => now,
+    ttl_seconds: 60
+  });
+
+  it('issues and verifies tokens and validates basic input shape', () => {
+    const token = verifier.issueToken({
+      run_id: 'run:1',
+      session_id: 'bootstrap:orch',
+      actor_type: 'orchestrator',
+      actor_id: 'orch'
+    });
+    const claims = verifier.verifyToken(token);
+    expect(claims.run_id).toBe('run:1');
+
+    expectThrownCode(() => verifier.verifyToken(''), ERROR_CODES.UNAUTHENTICATED);
+    expectThrownCode(() => verifier.verifyToken('invalid'), ERROR_CODES.UNAUTHENTICATED);
+  });
+
+  it('rejects signature mismatch, invalid header, and expired tokens', () => {
+    const token = verifier.issueToken({
+      run_id: 'run:2',
+      session_id: 'bootstrap:orch',
+      actor_type: 'orchestrator',
+      actor_id: 'orch'
+    });
+    const [header, payload, signature] = token.split('.');
+
+    expectThrownCode(() => verifier.verifyToken(`${header}.${payload}.${signature}x`), ERROR_CODES.UNAUTHENTICATED);
+    const tamperedSameLength = signature.slice(0, -1) + (signature.endsWith('a') ? 'b' : 'a');
+    expectThrownCode(() => verifier.verifyToken(`${header}.${payload}.${tamperedSameLength}`), ERROR_CODES.UNAUTHENTICATED);
+
+    const badHeader = encode({ alg: 'HS512', typ: 'JWT' });
+    const badHeaderSig = sign(secret, badHeader, payload);
+    expectThrownCode(() => verifier.verifyToken(`${badHeader}.${payload}.${badHeaderSig}`), ERROR_CODES.UNAUTHENTICATED);
+
+    const expiredToken = verifier.issueToken({
+      run_id: 'run:2',
+      session_id: 'bootstrap:orch',
+      actor_type: 'orchestrator',
+      actor_id: 'orch',
+      expires_at: '2025-12-31T23:59:00.000Z'
+    });
+    expectThrownCode(() => verifier.verifyToken(expiredToken), ERROR_CODES.UNAUTHENTICATED);
+  });
+
+  it('rejects invalid claim shapes and system-role non-bootstrap sessions', () => {
+    expectThrownCode(
+      () =>
+        verifier.issueToken({
+          run_id: 'run:3',
+          session_id: 'bootstrap:orch',
+          actor_type: 'orchestrator',
+          actor_id: 'orch',
+          expires_at: 'not-an-iso-date'
+        }),
+      ERROR_CODES.UNAUTHENTICATED
+    );
+
+    expectThrownCode(
+      () =>
+        verifier.issueToken({
+          run_id: 'run:3',
+          session_id: 'worker:1',
+          actor_type: 'system',
+          actor_id: 'system'
+        }),
+      ERROR_CODES.FORBIDDEN_TOOL_FOR_ROLE
+    );
+
+    const header = encode({ alg: 'HS256', typ: 'JWT' });
+    const claims = encode({
+      run_id: 'run:4',
+      session_id: 'bootstrap:orch',
+      actor_type: 'orchestrator',
+      actor_id: 'orch',
+      issued_at: now.toISOString(),
+      expires_at: new Date(now.getTime() + 30_000).toISOString(),
+      feature_scope: { bad: true }
+    });
+    const signature = sign(secret, header, claims);
+    expectThrownCode(() => verifier.verifyToken(`${header}.${claims}.${signature}`), ERROR_CODES.UNAUTHENTICATED);
+  });
+});