principles-disciple 1.8.1 → 1.8.3

package/tests/core/local-worker-routing.test.ts

@@ -0,0 +1,757 @@
+/**
+ * Local Worker Routing Policy — Tests
+ * ====================================
+ *
+ * Tests for task classification and routing decision logic.
+ *
+ * Test organization:
+ *   - Without deployment: classification-only tests (reader_eligible, editor_eligible, high_entropy, risk, ambiguous)
+ *   - With deployment enabled: full route_local decision
+ *   - With deployment disabled: stay_main with deployment_unavailable
+ *   - Helper functions: canRouteToProfile, isAnyLocalRoutingEnabled, listEnabledProfiles
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import {
+  classifyTask,
+  canRouteToProfile,
+  isAnyLocalRoutingEnabled,
+  listEnabledProfiles,
+  type RoutingInput,
+  type RoutingDecision,
+} from '../../src/core/local-worker-routing.js';
+import {
+  registerTrainingRun,
+  startTrainingRun,
+  completeTrainingRun,
+  registerCheckpoint,
+  attachEvalSummary,
+  markCheckpointDeployable,
+} from '../../src/core/model-training-registry.js';
+import {
+  advancePromotion,
+  DEFAULT_BASELINE_METRICS,
+} from '../../src/core/promotion-gate.js';
+import {
+  bindCheckpointToWorkerProfile,
+  enableRoutingForProfile,
+  disableRoutingForProfile,
+} from '../../src/core/model-deployment-registry.js';
+
+// ---------------------------------------------------------------------------
+// Test Fixtures
+// ---------------------------------------------------------------------------
+
+function makeTmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'pd-routing-test-'));
+}
+
+function rmdir(dir: string): void {
+  try {
+    if (fs.existsSync(dir)) {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  } catch {
+    // Ignore
+  }
+}
+
+/** Set up a fully deployable reader-family checkpoint and bind to local-reader */
+function setupReaderDeployment(tmpDir: string, routingEnabled = false): string {
+  const run = registerTrainingRun(tmpDir, {
+    targetModelFamily: 'claude-reader-latest',
+    datasetFingerprint: 'sha256-rdr',
+    exportId: 'export-rdr',
+    sampleCount: 10,
+    configFingerprint: 'cfg-v1',
+  });
+  const ck = registerCheckpoint(tmpDir, {
+    trainRunId: run.trainRunId,
+    targetModelFamily: 'claude-reader-latest',
+    artifactPath: '/ck/reader.safetensors',
+  });
+  attachEvalSummary(tmpDir, ck.checkpointId, {
+    evalId: 'eval-rdr',
+    checkpointId: ck.checkpointId,
+    targetModelFamily: 'claude-reader-latest',
+    benchmarkId: 'bench',
+    mode: 'reduced_prompt',
+    baselineScore: 0.5,
+    candidateScore: 0.65,
+    delta: 0.15,
+    verdict: 'pass',
+  });
+  startTrainingRun(tmpDir, run.trainRunId);
+  completeTrainingRun(tmpDir, run.trainRunId);
+  markCheckpointDeployable(tmpDir, ck.checkpointId, true);
+  advancePromotion(tmpDir, {
+    checkpointId: ck.checkpointId,
+    targetProfile: 'local-reader',
+    baselineMetrics: DEFAULT_BASELINE_METRICS,
+    orchestratorReviewPassed: true,
+    reviewNote: 'Test approval',
+  });
+  bindCheckpointToWorkerProfile(tmpDir, 'local-reader', ck.checkpointId, 'reader deployment');
+  if (routingEnabled) {
+    enableRoutingForProfile(tmpDir, 'local-reader');
+  }
+  return ck.checkpointId;
+}
+
+/** Set up a fully deployable editor-family checkpoint and bind to local-editor */
+function setupEditorDeployment(tmpDir: string, routingEnabled = false): string {
+  const run = registerTrainingRun(tmpDir, {
+    targetModelFamily: 'gpt-editor-v4',
+    datasetFingerprint: 'sha256-edt',
+    exportId: 'export-edt',
+    sampleCount: 10,
+    configFingerprint: 'cfg-v1',
+  });
+  const ck = registerCheckpoint(tmpDir, {
+    trainRunId: run.trainRunId,
+    targetModelFamily: 'gpt-editor-v4',
+    artifactPath: '/ck/editor.safetensors',
+  });
+  attachEvalSummary(tmpDir, ck.checkpointId, {
+    evalId: 'eval-edt',
+    checkpointId: ck.checkpointId,
+    targetModelFamily: 'gpt-editor-v4',
+    benchmarkId: 'bench',
+    mode: 'reduced_prompt',
+    baselineScore: 0.5,
+    candidateScore: 0.7,
+    delta: 0.2,
+    verdict: 'pass',
+  });
+  startTrainingRun(tmpDir, run.trainRunId);
+  completeTrainingRun(tmpDir, run.trainRunId);
+  markCheckpointDeployable(tmpDir, ck.checkpointId, true);
+  advancePromotion(tmpDir, {
+    checkpointId: ck.checkpointId,
+    targetProfile: 'local-editor',
+    baselineMetrics: DEFAULT_BASELINE_METRICS,
+    orchestratorReviewPassed: true,
+    reviewNote: 'Test approval',
+  });
+  bindCheckpointToWorkerProfile(tmpDir, 'local-editor', ck.checkpointId, 'editor deployment');
+  if (routingEnabled) {
+    enableRoutingForProfile(tmpDir, 'local-editor');
+  }
+  return ck.checkpointId;
+}
+
+describe('LocalWorkerRouting reader_eligible classification', () => {
+  let tmpDir: string;
+  beforeEach(() => { tmpDir = makeTmpDir(); });
+  afterEach(() => { rmdir(tmpDir); });
+
+  it('classifies "read_file" taskIntent as reader_eligible', () => {
+    const decision = classifyTask({ taskIntent: 'read_file', taskDescription: 'Read the config file' }, tmpDir);
+    expect(decision.classification).toBe('deployment_unavailable'); // eligible but no deployment
+    expect(decision.decision).toBe('stay_main'); // No deployment
+    expect(decision.deploymentCheck.performed).toBe(true);
+    expect(decision.deploymentCheck.routingEnabled).toBe(false);
+  });
+
+  it('classifies "grep" taskIntent as reader_eligible', () => {
+    const decision = classifyTask({ taskIntent: 'grep', taskDescription: 'Find all occurrences of foo in src/' }, tmpDir);
+    expect(decision.classification).toBe('deployment_unavailable');
+  });
+
+  it('classifies "summarize" taskIntent as reader_eligible', () => {
+    const decision = classifyTask({ taskIntent: 'summarize', taskDescription: 'Summarize the changelog' }, tmpDir);
+    expect(decision.classification).toBe('deployment_unavailable');
+  });
+
+  it('classifies "inspect" keyword in description as reader_eligible', () => {
+    const decision = classifyTask({ taskIntent: 'read', taskDescription: 'inspect the package.json for dependencies' }, tmpDir);
+    expect(decision.classification).toBe('deployment_unavailable');
+  });
+
+  it('classifies with only taskIntent (no description) as reader_eligible', () => {
+    const decision = classifyTask({ taskIntent: 'grep' }, tmpDir);
+    expect(decision.classification).toBe('deployment_unavailable');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: Editor-Eligible Classification (no deployment)
+// ---------------------------------------------------------------------------
+
+describe('LocalWorkerRouting editor_eligible classification', () => {
+  let tmpDir: string;
+  beforeEach(() => { tmpDir = makeTmpDir(); });
+  afterEach(() => { rmdir(tmpDir); });
+
+  it('classifies "edit" taskIntent as editor_eligible', () => {
+    const decision = classifyTask({ taskIntent: 'edit_file', taskDescription: 'Edit the config to add new key' }, tmpDir);
+    expect(decision.classification).toBe('deployment_unavailable'); // eligible but no deployment
+    expect(decision.decision).toBe('stay_main'); // No deployment
+  });
+
+  it('classifies "fix" taskIntent as editor_eligible', () => {
+    const decision = classifyTask({ taskIntent: 'fix', taskDescription: 'Fix the typo in README.md' }, tmpDir);
+    expect(decision.classification).toBe('deployment_unavailable');
+  });
+
+  it('classifies "replace" keyword in description as editor_eligible', () => {
+    const decision = classifyTask({ taskIntent: 'replace', taskDescription: 'Replace all old API calls with new ones' }, tmpDir);
+    expect(decision.classification).toBe('deployment_unavailable');
+  });
+
+  it('classifies "add" keyword as editor_eligible', () => {
+    const decision = classifyTask({ taskIntent: 'add', taskDescription: 'add logging to the function' }, tmpDir);
+    expect(decision.classification).toBe('deployment_unavailable');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: High-Entropy Rejection
+// ---------------------------------------------------------------------------
+
+describe('LocalWorkerRouting high_entropy_disallowed', () => {
+  let tmpDir: string;
+  beforeEach(() => { tmpDir = makeTmpDir(); });
+  afterEach(() => { rmdir(tmpDir); });
+
+  it('rejects "design" taskIntent as high_entropy', () => {
+    const decision = classifyTask({ taskIntent: 'design_system', taskDescription: 'Design the new architecture' }, tmpDir);
+    expect(decision.classification).toBe('high_entropy_disallowed');
+    expect(decision.decision).toBe('stay_main');
+    expect(decision.blockers.length).toBeGreaterThan(0);
+  });
+
+  it('rejects "plan" keyword as high_entropy', () => {
+    const decision = classifyTask({ taskIntent: 'plan', taskDescription: 'Plan the refactoring approach' }, tmpDir);
+    expect(decision.classification).toBe('high_entropy_disallowed');
+  });
+
+  it('rejects "architect" keyword as high_entropy', () => {
+    const decision = classifyTask({ taskIntent: 'architect', taskDescription: 'Architect the microservices layout' }, tmpDir);
+    expect(decision.classification).toBe('high_entropy_disallowed');
+  });
+
+  it('rejects "research" keyword as high_entropy', () => {
+    const decision = classifyTask({ taskIntent: 'research', taskDescription: 'Research the best approach for this problem' }, tmpDir);
+    expect(decision.classification).toBe('high_entropy_disallowed');
+  });
+
+  it('rejects "investigate" keyword as high_entropy', () => {
+    const decision = classifyTask({ taskIntent: 'investigate', taskDescription: 'Investigate the memory leak' }, tmpDir);
+    // Note: "investigate" is high entropy but "fix" is editor-eligible
+    expect(decision.classification).toBe('high_entropy_disallowed');
+  });
+
+  it('rejects complexity hint "multi_step" as high_entropy', () => {
+    const decision = classifyTask({
+      taskIntent: 'fix',
+      taskDescription: 'Fix the bug',
+      complexityHints: ['multi_step', 'cross_file'],
+    }, tmpDir);
+    expect(decision.classification).toBe('high_entropy_disallowed');
+  });
+
+  it('rejects "ambiguous" complexity hint as high_entropy', () => {
+    const decision = classifyTask({
+      taskIntent: 'fix',
+      taskDescription: 'Improve the code',
+      complexityHints: ['ambiguous'],
+    }, tmpDir);
+    expect(decision.classification).toBe('high_entropy_disallowed');
+  });
+
+  it('high_entropy blocks even with editor-eligible keywords', () => {
+    // "design" + "edit" → high_entropy wins
+    const decision = classifyTask({
+      taskIntent: 'edit',
+      taskDescription: 'design and edit the new module',
+    }, tmpDir);
+    expect(decision.classification).toBe('high_entropy_disallowed');
+  });
+
+  it('rejects large-scale multi-file editing (4+ files) as high_entropy', () => {
+    // Bounded scope: 1-3 files → editor_eligible
+    // Too broad: 4+ files → high_entropy_disallowed (requires main agent coordination)
+    const decision = classifyTask({
+      taskIntent: 'edit',
+      taskDescription: 'Fix the bug across multiple modules',
+      requestedFiles: [
+        'src/auth/login.ts',
+        'src/auth/session.ts',
+        'src/auth/middleware.ts',
+        'src/auth/guards.ts',
+      ],
+    }, tmpDir);
+    expect(decision.classification).toBe('high_entropy_disallowed');
+    expect(decision.blockers[0]).toContain('large-scale multi-file edit');
+    expect(decision.decision).toBe('stay_main');
+  });
+
+  it('allows bounded multi-file editing (1-3 files) as editor_eligible', () => {
+    const decision = classifyTask({
+      taskIntent: 'edit',
+      taskDescription: 'Fix the bug in auth files',
+      requestedFiles: [
+        'src/auth/login.ts',
+        'src/auth/session.ts',
+      ],
+    }, tmpDir);
+    // Raw classification is editor_eligible; no deployment → final is deployment_unavailable
+    expect(decision.classification).toBe('deployment_unavailable');
+    expect(decision.decision).toBe('stay_main'); // no deployment
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: Risk Disallowed
+// ---------------------------------------------------------------------------
+
+describe('LocalWorkerRouting risk_disallowed', () => {
+  let tmpDir: string;
+  beforeEach(() => { tmpDir = makeTmpDir(); });
+  afterEach(() => { rmdir(tmpDir); });
+
+  it('rejects bash tool as risk', () => {
+    const decision = classifyTask({
+      taskIntent: 'run',
+      taskDescription: 'Execute a bash command',
+      requestedTools: ['bash'],
+    }, tmpDir);
+    expect(decision.classification).toBe('risk_disallowed');
+    expect(decision.decision).toBe('stay_main');
+    expect(decision.blockers).toContain('risk tool requested (bash/exec/sudo/DROP/DELETE)');
+  });
+
+  it('rejects rm/destroy tools as risk', () => {
+    const decision = classifyTask({
+      taskIntent: 'process',
+      requestedTools: ['rm', 'delete'],
+      riskSignals: ['destructive'],
+    }, tmpDir);
+    expect(decision.classification).toBe('risk_disallowed');
+  });
+
+  it('rejects production file as risk', () => {
+    const decision = classifyTask({
+      taskIntent: 'edit',
+      requestedFiles: ['production-config.yaml', '.env'],
+    }, tmpDir);
+    expect(decision.classification).toBe('risk_disallowed');
+    expect(decision.blockers).toContain('risk file pattern detected (production/secrets/.git/node_modules)');
+  });
+
+  it('rejects .git/config as risk file', () => {
+    const decision = classifyTask({
+      taskIntent: 'edit',
+      requestedFiles: ['.git/config'],
+    }, tmpDir);
+    expect(decision.classification).toBe('risk_disallowed');
+  });
+
+  it('rejects explicit riskSignals as risk', () => {
+    const decision = classifyTask({
+      taskIntent: 'edit',
+      riskSignals: ['destructive', 'irreversible'],
+    }, tmpDir);
+    expect(decision.classification).toBe('risk_disallowed');
+    expect(decision.blockers).toContain('risk tool requested (bash/exec/sudo/DROP/DELETE)');
+  });
+
+  it('risk blocks even reader-eligible tasks', () => {
+    // bash + read → risk wins
+    const decision = classifyTask({
+      taskIntent: 'grep',
+      taskDescription: 'Search for pattern in files',
+      requestedTools: ['bash'],
+    }, tmpDir);
+    expect(decision.classification).toBe('risk_disallowed');
+  });
+
+  it('rejects node_modules as risk file', () => {
+    const decision = classifyTask({
+      taskIntent: 'edit',
+      requestedFiles: ['node_modules/some/package.json'],
+    }, tmpDir);
+    expect(decision.classification).toBe('risk_disallowed');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: Ambiguous Scope
+// ---------------------------------------------------------------------------
+
+describe('LocalWorkerRouting ambiguous_scope', () => {
+  let tmpDir: string;
+  beforeEach(() => { tmpDir = makeTmpDir(); });
+  afterEach(() => { rmdir(tmpDir); });
+
+  it('rejects very short generic taskDescription as ambiguous', () => {
+    const decision = classifyTask({ taskIntent: 'process', taskDescription: 'fix it' }, tmpDir);
+    expect(decision.classification).toBe('ambiguous_scope');
+  });
+
+  it('rejects "todo" as ambiguous', () => {
+    const decision = classifyTask({ taskIntent: 'todo', taskDescription: 'todo' }, tmpDir);
+    expect(decision.classification).toBe('ambiguous_scope');
+  });
+
+  it('rejects "improve" as ambiguous', () => {
+    const decision = classifyTask({ taskIntent: 'improve', taskDescription: 'improve' }, tmpDir);
+    expect(decision.classification).toBe('ambiguous_scope');
+  });
+
+  it('rejects open-ended question words as ambiguous', () => {
+    const decision = classifyTask({
+      taskIntent: 'analyze',
+      taskDescription: 'Should we refactor this or rewrite it?',
+    }, tmpDir);
+    expect(decision.classification).toBe('ambiguous_scope');
+    expect(decision.blockers).toContain('open-ended question words detected');
+  });
+
+  it('rejects when no intent and no description', () => {
+    const decision = classifyTask({}, tmpDir);
+    expect(decision.classification).toBe('ambiguous_scope');
+  });
+
+  it('does NOT classify a detailed description as ambiguous', () => {
+    const decision = classifyTask({
+      taskIntent: 'fix',
+      taskDescription: 'Fix the null pointer exception thrown when parsing the config file in parseConfig()',
+    }, tmpDir);
+    // Task is editor_eligible (fix keyword in intent and description)
+    // No deployment exists, so final classification is deployment_unavailable
+    expect(decision.classification).toBe('deployment_unavailable');
+    expect(decision.decision).toBe('stay_main'); // no deployment exists
+  });
+
+  it('DEBUG: detailed fix description classification', () => {
+    const decision = classifyTask({
+      taskIntent: 'fix',
+      taskDescription: 'Fix the null pointer exception thrown when parsing the config file in parseConfig()',
+    }, tmpDir);
+    // Same as above — editor_eligible but no deployment → deployment_unavailable
+    expect(decision.classification).toBe('deployment_unavailable');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: Deployment Availability (no deployment at all)
+// ---------------------------------------------------------------------------
+
+describe('LocalWorkerRouting deployment_unavailable', () => {
+  let tmpDir: string;
+  beforeEach(() => { tmpDir = makeTmpDir(); });
+  afterEach(() => { rmdir(tmpDir); });
+
+  it('returns deployment_unavailable when no deployment exists', () => {
+    const decision = classifyTask({ taskIntent: 'read_file', taskDescription: 'read the config' }, tmpDir);
+    expect(decision.classification).toBe('deployment_unavailable');
+    expect(decision.decision).toBe('stay_main');
+    expect(decision.deploymentCheck.performed).toBe(true);
+    expect(decision.deploymentCheck.routingEnabled).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: Routing with Enabled Deployment
+// ---------------------------------------------------------------------------
+
+describe('LocalWorkerRouting with enabled deployment', () => {
+  let tmpDir: string;
+  beforeEach(() => { tmpDir = makeTmpDir(); });
+  afterEach(() => { rmdir(tmpDir); });
+
+  it('reader task routes to local-reader when deployment is enabled', () => {
+    setupReaderDeployment(tmpDir, true);
+
+    const decision = classifyTask({ taskIntent: 'read_file', taskDescription: 'read the config' }, tmpDir);
+
+    expect(decision.decision).toBe('route_local');
+    expect(decision.targetProfile).toBe('local-reader');
+    expect(decision.classification).toBe('reader_eligible');
+    expect(decision.deploymentCheck.routingEnabled).toBe(true);
+    expect(decision.blockers).toHaveLength(0);
+  });
+
+  it('editor task routes to local-editor when deployment is enabled', () => {
+    setupEditorDeployment(tmpDir, true);
+
+    const decision = classifyTask({ taskIntent: 'edit', taskDescription: 'edit the config' }, tmpDir);
+
+    expect(decision.decision).toBe('route_local');
+    expect(decision.targetProfile).toBe('local-editor');
+    expect(decision.classification).toBe('editor_eligible');
+    expect(decision.blockers).toHaveLength(0);
+  });
+
+  it('reader task still blocked as high_entropy even with enabled deployment', () => {
+    setupReaderDeployment(tmpDir, true);
+
+    const decision = classifyTask({
+      taskIntent: 'design',
+      taskDescription: 'Design the new system architecture',
+    }, tmpDir);
+
+    expect(decision.decision).toBe('stay_main');
+    expect(decision.classification).toBe('high_entropy_disallowed');
+  });
+
+  it('reader task blocked as risk even with enabled deployment', () => {
+    setupReaderDeployment(tmpDir, true);
+
+    const decision = classifyTask({
+      taskIntent: 'grep',
+      requestedTools: ['bash'],
+    }, tmpDir);
+
+    expect(decision.decision).toBe('stay_main');
+    expect(decision.classification).toBe('risk_disallowed');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: Routing with Disabled Deployment
+// ---------------------------------------------------------------------------
+
+describe('LocalWorkerRouting with disabled deployment (routing=false)', () => {
+  let tmpDir: string;
+  beforeEach(() => { tmpDir = makeTmpDir(); });
+  afterEach(() => { rmdir(tmpDir); });
+
+  it('reader-eligible task stays_main when routing is disabled', () => {
+    setupReaderDeployment(tmpDir, false); // routingEnabled = false
+
+    const decision = classifyTask({ taskIntent: 'read_file', taskDescription: 'read the config' }, tmpDir);
+
+    expect(decision.decision).toBe('stay_main');
+    expect(decision.classification).toBe('deployment_unavailable');
+    expect(decision.deploymentCheck.routingEnabled).toBe(false);
+    expect(decision.reason).toContain('routing is not enabled');
+  });
+
+  it('editor-eligible task stays_main when routing is disabled', () => {
+    setupEditorDeployment(tmpDir, false);
+
+    const decision = classifyTask({ taskIntent: 'edit', taskDescription: 'edit the file' }, tmpDir);
+
+    expect(decision.decision).toBe('stay_main');
+    expect(decision.classification).toBe('deployment_unavailable');
+  });
+
+  it('re-enabling routing allows route_local again', () => {
+    setupReaderDeployment(tmpDir, false);
+    enableRoutingForProfile(tmpDir, 'local-reader');
+
+    const decision = classifyTask({ taskIntent: 'read_file' }, tmpDir);
+    expect(decision.decision).toBe('route_local');
+    expect(decision.targetProfile).toBe('local-reader');
+  });
+
+  it('stays_main when active checkpoint has been revoked (no longer deployable)', () => {
+    // Set up deployment with routing enabled
+    const ckId = setupReaderDeployment(tmpDir, true);
+
+    // Verify it routes successfully first
+    const before = classifyTask({ taskIntent: 'read_file' }, tmpDir);
+    expect(before.decision).toBe('route_local');
+
+    // Revoke the checkpoint — it no longer passes evaluation
+    markCheckpointDeployable(tmpDir, ckId, false);
+
+    // Routing must now be blocked — governance: revoked checkpoints must not be used
+    const after = classifyTask({ taskIntent: 'read_file' }, tmpDir);
+    expect(after.decision).toBe('stay_main');
+    expect(after.classification).toBe('deployment_unavailable');
+    expect(after.deploymentCheck.checkpointDeployable).toBe(false);
+    expect(after.blockers.some((b: string) => b.includes('no longer deployable'))).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: canRouteToProfile helper
+// ---------------------------------------------------------------------------
+
+describe('LocalWorkerRouting canRouteToProfile', () => {
+  let tmpDir: string;
+  beforeEach(() => { tmpDir = makeTmpDir(); });
+  afterEach(() => { rmdir(tmpDir); });
+
+  it('returns true when profile has enabled deployment and task is eligible', () => {
+    setupReaderDeployment(tmpDir, true);
+
+    const result = canRouteToProfile({ taskIntent: 'read_file', taskDescription: 'read config' }, tmpDir, 'local-reader');
+    expect(result).toBe(true);
+  });
+
+  it('returns false when no deployment exists', () => {
+    const result = canRouteToProfile({ taskIntent: 'read_file' }, tmpDir, 'local-reader');
+    expect(result).toBe(false);
+  });
+
+  it('returns false when task is high-entropy', () => {
+    setupReaderDeployment(tmpDir, true);
+
+    const result = canRouteToProfile({ taskIntent: 'design', taskDescription: 'Design the system' }, tmpDir, 'local-reader');
+    expect(result).toBe(false);
+  });
+
+  it('returns false when routing is disabled', () => {
+    setupReaderDeployment(tmpDir, false);
+
+    const result = canRouteToProfile({ taskIntent: 'read_file' }, tmpDir, 'local-reader');
+    expect(result).toBe(false);
+  });
+
+  it('returns false for editor profile on reader task', () => {
+    setupEditorDeployment(tmpDir, true);
+
+    const result = canRouteToProfile({ taskIntent: 'read_file', taskDescription: 'read config' }, tmpDir, 'local-editor');
+    expect(result).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: isAnyLocalRoutingEnabled / listEnabledProfiles
+// ---------------------------------------------------------------------------
+
+describe('LocalWorkerRouting isAnyLocalRoutingEnabled / listEnabledProfiles', () => {
+  let tmpDir: string;
+  beforeEach(() => { tmpDir = makeTmpDir(); });
+  afterEach(() => { rmdir(tmpDir); });
+
+  it('returns false when no deployments exist', () => {
+    expect(isAnyLocalRoutingEnabled(tmpDir)).toBe(false);
+    expect(listEnabledProfiles(tmpDir)).toEqual([]);
+  });
+
+  it('returns false when deployments exist but routing is disabled', () => {
+    setupReaderDeployment(tmpDir, false);
+    setupEditorDeployment(tmpDir, false);
+
+    expect(isAnyLocalRoutingEnabled(tmpDir)).toBe(false);
+    expect(listEnabledProfiles(tmpDir)).toEqual([]);
+  });
+
+  it('returns true and lists profile when routing is enabled', () => {
+    setupReaderDeployment(tmpDir, true);
+
+    expect(isAnyLocalRoutingEnabled(tmpDir)).toBe(true);
+    expect(listEnabledProfiles(tmpDir)).toEqual(['local-reader']);
+  });
+
+  it('lists multiple enabled profiles', () => {
+    setupReaderDeployment(tmpDir, true);
+    setupEditorDeployment(tmpDir, true);
+
+    const enabled = listEnabledProfiles(tmpDir);
+    expect(enabled).toContain('local-reader');
+    expect(enabled).toContain('local-editor');
+    expect(enabled).toHaveLength(2);
+  });
+
+  it('only lists profiles with routing enabled (not just bound)', () => {
+    setupReaderDeployment(tmpDir, true); // enabled
+    setupEditorDeployment(tmpDir, false); // bound but disabled
+
+    const enabled = listEnabledProfiles(tmpDir);
+    expect(enabled).toEqual(['local-reader']);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: targetProfile override
+// ---------------------------------------------------------------------------
+
+describe('LocalWorkerRouting targetProfile override', () => {
+  let tmpDir: string;
+  beforeEach(() => { tmpDir = makeTmpDir(); });
+  afterEach(() => { rmdir(tmpDir); });
+
+  it('uses targetProfile from input when specified', () => {
+    setupEditorDeployment(tmpDir, true); // Only editor is enabled
+
+    // Reader deployment doesn't exist but we explicitly target reader
+    const decision = classifyTask({
+      taskIntent: 'read_file',
+      taskDescription: 'read the config',
+      targetProfile: 'local-reader',
+    }, tmpDir);
+
+    // Reader deployment doesn't exist → deployment_unavailable
+    expect(decision.decision).toBe('stay_main');
+    expect(decision.classification).toBe('deployment_unavailable');
+  });
+
+  it('rejects editor task targeting local-reader (profile-task mismatch)', () => {
+    // Both deployments enabled
+    setupReaderDeployment(tmpDir, true);
+    setupEditorDeployment(tmpDir, true);
+
+    // Editor-eligible task but explicitly targeting local-reader
+    const decision = classifyTask({
+      taskIntent: 'edit',
+      taskDescription: 'Edit the file',
+      targetProfile: 'local-reader',
+    }, tmpDir);
+
+    // MUST reject: editor task cannot route to reader profile
+    expect(decision.decision).toBe('stay_main');
+    expect(decision.classification).toBe('profile_mismatch');
+    expect(decision.blockers).toContainEqual(expect.stringContaining('profile mismatch'));
+  });
+
+  it('accepts editor task targeting local-editor (correct profile)', () => {
+    setupEditorDeployment(tmpDir, true);
+
+    const decision = classifyTask({
+      taskIntent: 'edit',
+      taskDescription: 'Edit the file',
+      targetProfile: 'local-editor',
+    }, tmpDir);
+
+    expect(decision.decision).toBe('route_local');
+    expect(decision.targetProfile).toBe('local-editor');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: Decision Explainability
+// ---------------------------------------------------------------------------
+
+describe('LocalWorkerRouting explainability', () => {
+  let tmpDir: string;
+  beforeEach(() => { tmpDir = makeTmpDir(); });
+  afterEach(() => { rmdir(tmpDir); });
+
+  it('always provides a reason string', () => {
+    setupReaderDeployment(tmpDir, true);
+
+    const decision = classifyTask({ taskIntent: 'read_file' }, tmpDir);
+    expect(typeof decision.reason).toBe('string');
+    expect(decision.reason.length).toBeGreaterThan(0);
+  });
+
+  it('blockers is empty when route_local', () => {
+    setupReaderDeployment(tmpDir, true);
+
+    const decision = classifyTask({ taskIntent: 'read_file' }, tmpDir);
+    expect(decision.blockers).toEqual([]);
+  });
+
+  it('blockers is non-empty when stay_main', () => {
+    const decision = classifyTask({ taskIntent: 'design', taskDescription: 'Design the system' }, tmpDir);
+    expect(decision.blockers.length).toBeGreaterThan(0);
+  });
+
+  it('provides deployment check details', () => {
+    const decision = classifyTask({ taskIntent: 'read_file' }, tmpDir);
+    expect(decision.deploymentCheck).toBeDefined();
+    expect('performed' in decision.deploymentCheck).toBe(true);
+    expect('profileAvailable' in decision.deploymentCheck).toBe(true);
+    expect('routingEnabled' in decision.deploymentCheck).toBe(true);
+  });
+});