vellum 0.2.14 → 0.3.2

package/src/__tests__/session-skill-tools.test.ts

@@ -1,2431 +0,0 @@
-import { describe, test, expect, beforeEach, afterAll, mock } from 'bun:test';
-import * as realFs from 'node:fs';
-import type { Message, ToolDefinition, ToolUseContent, ToolResultContent } from '../providers/types.js';
-import type { SkillSummary, SkillToolManifest } from '../config/skills.js';
-import type { Tool } from '../tools/types.js';
-import { RiskLevel } from '../permissions/types.js';
-import {
-  BROWSER_TOOL_NAMES,
-  buildSkillLoadHistory,
-  assertBrowserToolsPresent,
-  assertBrowserToolsAbsent,
-} from './test-support/browser-skill-harness.js';
-
-// ---------------------------------------------------------------------------
-// Mock state — controlled by tests
-// ---------------------------------------------------------------------------
-
-let mockCatalog: SkillSummary[] = [];
-let mockManifests: Record<string, SkillToolManifest | null> = {};
-let mockRegisteredTools: Map<string, Tool[]> = new Map();
-let mockUnregisteredSkillIds: string[] = [];
-let mockSkillRefCount: Map<string, number> = new Map();
-/** Per-skill version hash overrides. When set, computeSkillVersionHash returns this value. */
-let mockVersionHashes: Record<string, string> = {};
-/** Skill IDs for which computeSkillVersionHash should throw (simulates unreadable directories). */
-let mockVersionHashErrors: Set<string> = new Set();
-
-// ---------------------------------------------------------------------------
-// Mocks — must be set up before importing the module under test
-// ---------------------------------------------------------------------------
-
-mock.module('../config/skills.js', () => ({
-  loadSkillCatalog: () => mockCatalog,
-}));
-
-mock.module('../skills/active-skill-tools.js', () => {
-  // Shared parsing logic for both deriveActiveSkills and deriveActiveSkillIds
-  const parseMarkers = (messages: Message[]) => {
-    // Two-pass approach matching real implementation:
-    // 1. Collect tool_use IDs where name === 'skill_load'
-    const skillLoadUseIds = new Set<string>();
-    for (const msg of messages) {
-      for (const block of msg.content) {
-        if (block.type === 'tool_use' && block.name === 'skill_load') {
-          skillLoadUseIds.add(block.id);
-        }
-      }
-    }
-
-    // 2. Parse markers only from tool_result blocks whose tool_use_id matches
-    const re = /<loaded_skill\s+id="([^"]+)"(?:\s+version="([^"]+)")?\s*\/>/g;
-    const seen = new Set<string>();
-    const entries: Array<{ id: string; version?: string }> = [];
-    for (const msg of messages) {
-      for (const block of msg.content) {
-        if (block.type !== 'tool_result') continue;
-        if (!skillLoadUseIds.has(block.tool_use_id)) continue;
-        const text = block.content;
-        if (!text) continue;
-        for (const match of text.matchAll(re)) {
-          if (!seen.has(match[1])) {
-            seen.add(match[1]);
-            const entry: { id: string; version?: string } = { id: match[1] };
-            if (match[2]) {
-              entry.version = match[2];
-            }
-            entries.push(entry);
-          }
-        }
-      }
-    }
-    return entries;
-  };
-
-  return {
-    deriveActiveSkills: (messages: Message[]) => parseMarkers(messages),
-    deriveActiveSkillIds: (messages: Message[]) =>
-      parseMarkers(messages).map((e) => e.id),
-  };
-});
-
-mock.module('../skills/tool-manifest.js', () => ({
-  parseToolManifestFile: (filePath: string) => {
-    // Extract skill ID from path: /skills/<id>/TOOLS.json → <id>
-    const parts = filePath.split('/');
-    const skillId = parts[parts.length - 2];
-    const manifest = mockManifests[skillId];
-    if (!manifest) {
-      throw new Error(`Mock: no manifest for skill "${skillId}"`);
-    }
-    return manifest;
-  },
-}));
-
-mock.module('../tools/skills/skill-tool-factory.js', () => ({
-  createSkillToolsFromManifest: (
-    entries: SkillToolManifest['tools'],
-    skillId: string,
-    _skillDir: string,
-    versionHash: string,
-    bundled?: boolean,
-  ): Tool[] => {
-    return entries.map((entry) => ({
-      name: entry.name,
-      description: entry.description,
-      category: entry.category,
-      defaultRiskLevel: RiskLevel.Medium,
-      origin: 'skill' as const,
-      ownerSkillId: skillId,
-      ownerSkillVersionHash: versionHash,
-      ownerSkillBundled: bundled ?? undefined,
-      getDefinition: () => ({
-        name: entry.name,
-        description: entry.description,
-        input_schema: entry.input_schema as object,
-      }),
-      execute: async () => ({ content: '', isError: false }),
-    }));
-  },
-}));
-
-mock.module('../tools/registry.js', () => ({
-  registerSkillTools: (tools: Tool[]) => {
-    const skillIds = new Set<string>();
-    for (const tool of tools) {
-      const skillId = tool.ownerSkillId!;
-      skillIds.add(skillId);
-      const existing = mockRegisteredTools.get(skillId) ?? [];
-      existing.push(tool);
-      mockRegisteredTools.set(skillId, existing);
-    }
-    for (const id of skillIds) {
-      mockSkillRefCount.set(id, (mockSkillRefCount.get(id) ?? 0) + 1);
-    }
-  },
-  unregisterSkillTools: (skillId: string) => {
-    mockUnregisteredSkillIds.push(skillId);
-    const current = mockSkillRefCount.get(skillId) ?? 0;
-    if (current > 1) {
-      mockSkillRefCount.set(skillId, current - 1);
-      return;
-    }
-    mockSkillRefCount.delete(skillId);
-    mockRegisteredTools.delete(skillId);
-  },
-  getTool: (name: string): Tool | undefined => {
-    // Return the last matching tool to match production behavior where
-    // re-registering a tool overwrites the previous entry (last wins).
-    let found: Tool | undefined;
-    for (const tools of mockRegisteredTools.values()) {
-      for (const tool of tools) {
-        if (tool.name === name) found = tool;
-      }
-    }
-    return found;
-  },
-  getSkillToolNames: () => {
-    const names: string[] = [];
-    for (const tools of mockRegisteredTools.values()) {
-      for (const tool of tools) {
-        names.push(tool.name);
-      }
-    }
-    return names;
-  },
-}));
-
-// Stub existsSync so TOOLS.json existence checks pass for skills that have manifests
-mock.module('node:fs', () => ({
-  ...realFs,
-  existsSync: (p: string) => {
-    if (typeof p === 'string' && p.endsWith('TOOLS.json')) {
-      const parts = p.split('/');
-      const skillId = parts[parts.length - 2];
-      return skillId in mockManifests;
-    }
-    return realFs.existsSync(p);
-  },
-}));
-
-mock.module('../skills/version-hash.js', () => ({
-  computeSkillVersionHash: (skillDir: string) => {
-    const parts = skillDir.split('/');
-    const skillId = parts[parts.length - 1];
-    if (mockVersionHashErrors.has(skillId)) {
-      throw new Error(`EACCES: permission denied, scandir '${skillDir}'`);
-    }
-    if (skillId in mockVersionHashes) {
-      return mockVersionHashes[skillId];
-    }
-    return `v1:default-hash-${skillId}`;
-  },
-}));
-
-mock.module('../util/logger.js', () => ({
-  getLogger: () => ({
-    info: () => {},
-    warn: () => {},
-    debug: () => {},
-    error: () => {},
-  }),
-}));
-
-// ---------------------------------------------------------------------------
-// Import module under test (after mocks)
-// ---------------------------------------------------------------------------
-
-const { projectSkillTools, resetSkillToolProjection } = await import(
-  '../daemon/session-skill-tools.js'
-);
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeSkill(id: string, dir?: string): SkillSummary {
-  return {
-    id,
-    name: id,
-    description: `Skill ${id}`,
-    directoryPath: dir ?? `/skills/${id}`,
-    skillFilePath: `/skills/${id}/SKILL.md`,
-    userInvocable: true,
-    disableModelInvocation: false,
-    source: 'managed',
-  };
-}
-
-function makeManifest(toolNames: string[]): SkillToolManifest {
-  return {
-    version: 1,
-    tools: toolNames.map((name) => ({
-      name,
-      description: `Tool ${name}`,
-      category: 'test',
-      risk: 'medium' as const,
-      input_schema: { type: 'object', properties: {} },
-      executor: 'run.ts',
-      execution_target: 'host' as const,
-    })),
-  };
-}
-
-let toolUseCounter = 0;
-
-/**
- * Creates a pair of messages representing a skill_load tool_use followed by
- * its tool_result with the given content (typically a `<loaded_skill>` marker).
- */
-function skillLoadMessages(content: string): Message[] {
-  const id = `sl-${++toolUseCounter}`;
-  return [
-    {
-      role: 'assistant',
-      content: [{ type: 'tool_use', id, name: 'skill_load', input: {} }],
-    },
-    {
-      role: 'user',
-      content: [{ type: 'tool_result', tool_use_id: id, content }],
-    },
-  ];
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-afterAll(() => { mock.restore(); });
-
-describe('projectSkillTools', () => {
-  let sessionState: Map<string, string>;
-
-  beforeEach(() => {
-    mockCatalog = [];
-    mockManifests = {};
-    mockRegisteredTools = new Map();
-    mockUnregisteredSkillIds = [];
-    mockSkillRefCount = new Map();
-    mockSkillRefCount = new Map();
-    mockVersionHashes = {};
-    mockVersionHashErrors = new Set();
-    sessionState = new Map<string, string>();
-  });
-
-  test('no active skills returns empty projection', () => {
-    const result = projectSkillTools([], { previouslyActiveSkillIds: sessionState });
-
-    expect(result.toolDefinitions).toEqual([]);
-    expect(result.allowedToolNames.size).toBe(0);
-  });
-
-  test('active skill with valid manifest returns tool definitions', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run', 'deploy_status']) };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    expect(result.toolDefinitions).toHaveLength(2);
-    expect(result.toolDefinitions.map((d) => d.name)).toEqual([
-      'deploy_run',
-      'deploy_status',
-    ]);
-    expect(result.allowedToolNames).toEqual(
-      new Set(['deploy_run', 'deploy_status']),
-    );
-  });
-
-  test('multiple active skills are projected', () => {
-    mockCatalog = [makeSkill('deploy'), makeSkill('oncall')];
-    mockManifests = {
-      deploy: makeManifest(['deploy_run']),
-      oncall: makeManifest(['oncall_page']),
-    };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-      ...skillLoadMessages('<loaded_skill id="oncall" />'),
-    ];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    expect(result.toolDefinitions).toHaveLength(2);
-    expect(result.allowedToolNames).toEqual(
-      new Set(['deploy_run', 'oncall_page']),
-    );
-  });
-
-  test('preactivated skill IDs are included', () => {
-    mockCatalog = [makeSkill('deploy'), makeSkill('oncall')];
-    mockManifests = {
-      deploy: makeManifest(['deploy_run']),
-      oncall: makeManifest(['oncall_page']),
-    };
-
-    // Only deploy is in history; oncall is preactivated
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    const result = projectSkillTools(history, {
-      preactivatedSkillIds: ['oncall'],
-      previouslyActiveSkillIds: sessionState,
-    });
-
-    expect(result.toolDefinitions).toHaveLength(2);
-    expect(result.allowedToolNames).toEqual(
-      new Set(['deploy_run', 'oncall_page']),
-    );
-  });
-
-  test('skill deactivation: previously active skill is unregistered when removed from history', () => {
-    mockCatalog = [makeSkill('deploy'), makeSkill('oncall')];
-    mockManifests = {
-      deploy: makeManifest(['deploy_run']),
-      oncall: makeManifest(['oncall_page']),
-    };
-
-    // First turn: both skills active
-    const history1: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-      ...skillLoadMessages('<loaded_skill id="oncall" />'),
-    ];
-    projectSkillTools(history1, { previouslyActiveSkillIds: sessionState });
-
-    // Second turn: only deploy remains active (oncall marker gone)
-    mockUnregisteredSkillIds = [];
-    const history2: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-    const result = projectSkillTools(history2, { previouslyActiveSkillIds: sessionState });
-
-    expect(mockUnregisteredSkillIds).toContain('oncall');
-    expect(result.allowedToolNames).toEqual(new Set(['deploy_run']));
-  });
-
-  test('invalid/missing manifest is gracefully handled', () => {
-    mockCatalog = [makeSkill('broken')];
-    // No manifest registered for "broken", so parseToolManifestFile will throw
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="broken" />'),
-    ];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    // Should not throw, just return empty projection for that skill
-    expect(result.toolDefinitions).toEqual([]);
-    expect(result.allowedToolNames.size).toBe(0);
-  });
-
-  test('skill ID not in catalog is gracefully skipped', () => {
-    mockCatalog = []; // empty catalog
-    mockManifests = {};
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="nonexistent" />'),
-    ];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    expect(result.toolDefinitions).toEqual([]);
-    expect(result.allowedToolNames.size).toBe(0);
-  });
-
-  test('skill with catalog miss on turn 1 is registered when catalog is populated on turn 2', () => {
-    // Turn 1: skill is active but NOT in the catalog — should not be tracked
-    mockCatalog = []; // empty catalog
-    mockManifests = {};
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    const result1 = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(result1.toolDefinitions).toEqual([]);
-    expect(sessionState.has('deploy')).toBe(false);
-
-    // Turn 2: catalog now has the skill — should register successfully
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run']) };
-
-    const result2 = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(result2.toolDefinitions).toHaveLength(1);
-    expect(result2.toolDefinitions[0].name).toBe('deploy_run');
-    expect(result2.allowedToolNames.has('deploy_run')).toBe(true);
-    expect(sessionState.has('deploy')).toBe(true);
-
-    // Verify registerSkillTools was called (tool is in the registry)
-    expect(mockRegisteredTools.has('deploy')).toBe(true);
-  });
-
-  test('skill with manifest failure on turn 1 is registered when manifest is available on turn 2', () => {
-    mockCatalog = [makeSkill('deploy')];
-    // No manifest — will fail to load
-    mockManifests = {};
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    const result1 = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(result1.toolDefinitions).toEqual([]);
-    expect(sessionState.has('deploy')).toBe(false);
-
-    // Turn 2: manifest now available
-    mockManifests = { deploy: makeManifest(['deploy_run']) };
-
-    const result2 = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(result2.toolDefinitions).toHaveLength(1);
-    expect(result2.toolDefinitions[0].name).toBe('deploy_run');
-    expect(sessionState.has('deploy')).toBe(true);
-    expect(mockRegisteredTools.has('deploy')).toBe(true);
-  });
-
-  test('previously-registered skill that transiently fails is unregistered to prevent refcount leak', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run']) };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    // Turn 1: skill registered successfully
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(sessionState.has('deploy')).toBe(true);
-    expect(mockSkillRefCount.get('deploy')).toBe(1);
-
-    // Turn 2: manifest transiently fails — skill should be unregistered
-    mockManifests = {};
-    mockUnregisteredSkillIds = [];
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(sessionState.has('deploy')).toBe(false);
-    expect(mockUnregisteredSkillIds).toContain('deploy');
-    // Ref count should be 0 (properly decremented)
-    expect(mockSkillRefCount.has('deploy')).toBe(false);
-
-    // Turn 3: manifest recovers — skill re-registered with correct ref count
-    mockManifests = { deploy: makeManifest(['deploy_run']) };
-    mockUnregisteredSkillIds = [];
-    const result3 = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(result3.toolDefinitions).toHaveLength(1);
-    expect(sessionState.has('deploy')).toBe(true);
-    // Ref count should be exactly 1, not 2
-    expect(mockSkillRefCount.get('deploy')).toBe(1);
-  });
-
-  test('skill version hash change triggers unregister and re-register', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run']) };
-    mockVersionHashes = { deploy: 'v1:hash-aaa' };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    // Turn 1: skill registered with hash-aaa
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(sessionState.has('deploy')).toBe(true);
-    expect(sessionState.get('deploy')).toBe('v1:hash-aaa');
-    expect(mockSkillRefCount.get('deploy')).toBe(1);
-
-    // Turn 2: hash changes — should unregister old and re-register new
-    mockVersionHashes = { deploy: 'v1:hash-bbb' };
-    mockUnregisteredSkillIds = [];
-    const result2 = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(result2.toolDefinitions).toHaveLength(1);
-    expect(result2.toolDefinitions[0].name).toBe('deploy_run');
-    expect(sessionState.get('deploy')).toBe('v1:hash-bbb');
-    // Unregister was called for the stale version
-    expect(mockUnregisteredSkillIds).toContain('deploy');
-    // Ref count should remain 1 (unregister decremented, re-register incremented)
-    expect(mockSkillRefCount.get('deploy')).toBe(1);
-  });
-
-  test('skill version hash unchanged skips re-registration', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run']) };
-    mockVersionHashes = { deploy: 'v1:stable-hash' };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    // Turn 1: skill registered
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(mockSkillRefCount.get('deploy')).toBe(1);
-
-    // Turn 2: same hash — should NOT call registerSkillTools again
-    mockUnregisteredSkillIds = [];
-    const result2 = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(result2.toolDefinitions).toHaveLength(1);
-    expect(mockUnregisteredSkillIds).not.toContain('deploy');
-    // Ref count should still be 1 (no additional registration)
-    expect(mockSkillRefCount.get('deploy')).toBe(1);
-  });
-
-  test('preactivated IDs merge with context-derived IDs (dedup)', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run']) };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    // deploy is both in history AND preactivated — should not duplicate
-    const result = projectSkillTools(history, {
-      preactivatedSkillIds: ['deploy'],
-      previouslyActiveSkillIds: sessionState,
-    });
-
-    expect(result.toolDefinitions).toHaveLength(1);
-    expect(result.allowedToolNames).toEqual(new Set(['deploy_run']));
-  });
-
-  test('no markers in history with preactivated IDs still projects tools', () => {
-    mockCatalog = [makeSkill('oncall')];
-    mockManifests = { oncall: makeManifest(['oncall_page']) };
-
-    const result = projectSkillTools([], {
-      preactivatedSkillIds: ['oncall'],
-      previouslyActiveSkillIds: sessionState,
-    });
-
-    expect(result.toolDefinitions).toHaveLength(1);
-    expect(result.allowedToolNames).toEqual(new Set(['oncall_page']));
-  });
-
-  test('concurrent sessions do not interfere with each other', () => {
-    mockCatalog = [makeSkill('deploy'), makeSkill('oncall')];
-    mockManifests = {
-      deploy: makeManifest(['deploy_run']),
-      oncall: makeManifest(['oncall_page']),
-    };
-
-    const sessionA = new Map<string, string>();
-    const sessionB = new Map<string, string>();
-
-    // Session A activates deploy
-    const historyA: Message[] = [...skillLoadMessages('<loaded_skill id="deploy" />')];
-    const resultA = projectSkillTools(historyA, { previouslyActiveSkillIds: sessionA });
-    expect(resultA.allowedToolNames.has('deploy_run')).toBe(true);
-
-    // Session B activates oncall — should NOT unregister deploy from session A
-    mockUnregisteredSkillIds = [];
-    const historyB: Message[] = [...skillLoadMessages('<loaded_skill id="oncall" />')];
-    projectSkillTools(historyB, { previouslyActiveSkillIds: sessionB });
-    expect(mockUnregisteredSkillIds).not.toContain('deploy');
-
-    // Session A's state should still track deploy
-    expect(sessionA.has('deploy')).toBe(true);
-    expect(sessionB.has('oncall')).toBe(true);
-  });
-
-  test('disposing session A while session B uses the same skill does NOT remove tools', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run']) };
-
-    const sessionA = new Map<string, string>();
-    const sessionB = new Map<string, string>();
-
-    const history: Message[] = [...skillLoadMessages('<loaded_skill id="deploy" />')];
-
-    // Both sessions activate deploy
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionA });
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionB });
-
-    // Ref count should be 2
-    expect(mockSkillRefCount.get('deploy')).toBe(2);
-
-    // Session A tears down
-    resetSkillToolProjection(sessionA);
-
-    // Tools should still be registered (ref count decremented but > 0)
-    expect(mockRegisteredTools.has('deploy')).toBe(true);
-    expect(mockSkillRefCount.get('deploy')).toBe(1);
-
-    // Session B can still project the skill tools
-    const resultB = projectSkillTools(history, { previouslyActiveSkillIds: sessionB });
-    expect(resultB.allowedToolNames.has('deploy_run')).toBe(true);
-  });
-
-  test('tools ARE removed when the last session using them disposes', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run']) };
-
-    const sessionA = new Map<string, string>();
-    const sessionB = new Map<string, string>();
-
-    const history: Message[] = [...skillLoadMessages('<loaded_skill id="deploy" />')];
-
-    // Both sessions activate deploy
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionA });
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionB });
-
-    // Both sessions tear down
-    resetSkillToolProjection(sessionA);
-    expect(mockRegisteredTools.has('deploy')).toBe(true);
-
-    resetSkillToolProjection(sessionB);
-    expect(mockRegisteredTools.has('deploy')).toBe(false);
-    expect(mockSkillRefCount.has('deploy')).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// resolveTools callback integration tests
-// ---------------------------------------------------------------------------
-
-describe('resolveTools callback (session wiring)', () => {
-  // Simulates the resolveTools callback wired in the Session constructor:
-  //   (history) => [...baseToolDefs, ...projectSkillTools(history).toolDefinitions]
-  const baseToolDefs: ToolDefinition[] = [
-    { name: 'file_read', description: 'Read a file', input_schema: { type: 'object', properties: {} } },
-    { name: 'bash', description: 'Run a shell command', input_schema: { type: 'object', properties: {} } },
-  ];
-
-  let sessionState: Map<string, string>;
-
-  function makeResolveTools(base: ToolDefinition[]) {
-    return (history: Message[]): ToolDefinition[] => {
-      const projection = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-      return [...base, ...projection.toolDefinitions];
-    };
-  }
-
-  beforeEach(() => {
-    mockCatalog = [];
-    mockManifests = {};
-    mockRegisteredTools = new Map();
-    mockUnregisteredSkillIds = [];
-    mockSkillRefCount = new Map();
-    mockSkillRefCount = new Map();
-    mockVersionHashes = {};
-    mockVersionHashErrors = new Set();
-    sessionState = new Map<string, string>();
-  });
-
-  test('returns only base tools when no skills are active', () => {
-    const resolveTools = makeResolveTools(baseToolDefs);
-    const result = resolveTools([]);
-
-    expect(result).toHaveLength(2);
-    expect(result.map((d) => d.name)).toEqual(['file_read', 'bash']);
-  });
-
-  test('combines base tools with projected skill tools', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run', 'deploy_status']) };
-
-    const resolveTools = makeResolveTools(baseToolDefs);
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    const result = resolveTools(history);
-
-    expect(result).toHaveLength(4);
-    expect(result.map((d) => d.name)).toEqual([
-      'file_read',
-      'bash',
-      'deploy_run',
-      'deploy_status',
-    ]);
-  });
-
-  test('skill tools appear after base tools and do not replace them', () => {
-    mockCatalog = [makeSkill('oncall')];
-    mockManifests = { oncall: makeManifest(['oncall_page']) };
-
-    const resolveTools = makeResolveTools(baseToolDefs);
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="oncall" />'),
-    ];
-
-    const result = resolveTools(history);
-
-    // Base tools come first, skill tools are appended
-    expect(result[0].name).toBe('file_read');
-    expect(result[1].name).toBe('bash');
-    expect(result[2].name).toBe('oncall_page');
-  });
-
-  test('multiple skills add all their tools alongside base tools', () => {
-    mockCatalog = [makeSkill('deploy'), makeSkill('oncall')];
-    mockManifests = {
-      deploy: makeManifest(['deploy_run']),
-      oncall: makeManifest(['oncall_page', 'oncall_ack']),
-    };
-
-    const resolveTools = makeResolveTools(baseToolDefs);
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-      ...skillLoadMessages('<loaded_skill id="oncall" />'),
-    ];
-
-    const result = resolveTools(history);
-
-    expect(result).toHaveLength(5);
-    const names = result.map((d) => d.name);
-    expect(names).toContain('file_read');
-    expect(names).toContain('bash');
-    expect(names).toContain('deploy_run');
-    expect(names).toContain('oncall_page');
-    expect(names).toContain('oncall_ack');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tests — allowed tool set merging with core tools
-// ---------------------------------------------------------------------------
-
-describe('allowed tool set merging', () => {
-  const CORE_TOOL_NAMES = new Set(['bash', 'file_read', 'file_write', 'file_edit']);
-  let sessionState: Map<string, string>;
-
-  beforeEach(() => {
-    mockCatalog = [];
-    mockManifests = {};
-    mockRegisteredTools = new Map();
-    mockUnregisteredSkillIds = [];
-    mockSkillRefCount = new Map();
-    mockSkillRefCount = new Map();
-    mockVersionHashes = {};
-    mockVersionHashErrors = new Set();
-    sessionState = new Map<string, string>();
-  });
-
-  /**
-   * Simulates the merging logic from session.ts:
-   * union of core tool names + projected skill tool names.
-   */
-  function buildAllowedSet(projection: { allowedToolNames: Set<string> }): Set<string> {
-    const merged = new Set(CORE_TOOL_NAMES);
-    for (const name of projection.allowedToolNames) {
-      merged.add(name);
-    }
-    return merged;
-  }
-
-  test('core tools are always included even with no active skills', () => {
-    const projection = projectSkillTools([], { previouslyActiveSkillIds: sessionState });
-    const allowed = buildAllowedSet(projection);
-
-    for (const core of CORE_TOOL_NAMES) {
-      expect(allowed.has(core)).toBe(true);
-    }
-  });
-
-  test('active skill tools are included alongside core tools', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run', 'deploy_status']) };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    const projection = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    const allowed = buildAllowedSet(projection);
-
-    // Core tools present
-    for (const core of CORE_TOOL_NAMES) {
-      expect(allowed.has(core)).toBe(true);
-    }
-    // Active skill tools present
-    expect(allowed.has('deploy_run')).toBe(true);
-    expect(allowed.has('deploy_status')).toBe(true);
-  });
-
-  test('inactive skill tools are NOT in the allowed set', () => {
-    mockCatalog = [makeSkill('deploy'), makeSkill('oncall')];
-    mockManifests = {
-      deploy: makeManifest(['deploy_run']),
-      oncall: makeManifest(['oncall_page']),
-    };
-
-    // Only deploy is active
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    const projection = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    const allowed = buildAllowedSet(projection);
-
-    expect(allowed.has('deploy_run')).toBe(true);
-    // oncall_page is not active — not in projection, not in allowed set
-    expect(allowed.has('oncall_page')).toBe(false);
-  });
-
-  test('allowed set updates when skills activate and deactivate', () => {
-    mockCatalog = [makeSkill('deploy'), makeSkill('oncall')];
-    mockManifests = {
-      deploy: makeManifest(['deploy_run']),
-      oncall: makeManifest(['oncall_page']),
-    };
-
-    // Turn 1: both active
-    const history1: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-      ...skillLoadMessages('<loaded_skill id="oncall" />'),
-    ];
-    const projection1 = projectSkillTools(history1, { previouslyActiveSkillIds: sessionState });
-    const allowed1 = buildAllowedSet(projection1);
-
-    expect(allowed1.has('deploy_run')).toBe(true);
-    expect(allowed1.has('oncall_page')).toBe(true);
-
-    // Turn 2: only deploy remains
-    const history2: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-    const projection2 = projectSkillTools(history2, { previouslyActiveSkillIds: sessionState });
-    const allowed2 = buildAllowedSet(projection2);
-
-    expect(allowed2.has('deploy_run')).toBe(true);
-    expect(allowed2.has('oncall_page')).toBe(false);
-    // Core tools still present
-    for (const core of CORE_TOOL_NAMES) {
-      expect(allowed2.has(core)).toBe(true);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// End-to-end mid-run activation tests
-// ---------------------------------------------------------------------------
-
-// ── Security invariant (PR 34): skill_load is the permission gate ──
-// In strict mode, skill_load requires an explicit trust rule before the
-// tool executor emits a <loaded_skill> marker. Without that marker in
-// the conversation history, projectSkillTools will never activate the
-// skill's tools. The permission enforcement lives in checker.ts; the
-// tests here verify that tool activation only occurs when markers are
-// present — meaning the permission check already succeeded.
-
-describe('skill activation requires loaded_skill marker (security invariant)', () => {
-  let sessionState: Map<string, string>;
-
-  beforeEach(() => {
-    mockCatalog = [];
-    mockManifests = {};
-    mockRegisteredTools = new Map();
-    mockUnregisteredSkillIds = [];
-    mockSkillRefCount = new Map();
-    mockVersionHashes = {};
-    mockVersionHashErrors = new Set();
-    sessionState = new Map<string, string>();
-  });
-
-  test('skill_load tool_use without tool_result marker does not activate skill tools', () => {
-    mockCatalog = [makeSkill('gated')];
-    mockManifests = { gated: makeManifest(['gated_action']) };
-
-    // History has a skill_load call but NO tool_result with a
-    // <loaded_skill> marker — simulating a permission denial or pending
-    // prompt in strict mode where the tool never executed.
-    const history: Message[] = [
-      {
-        role: 'assistant',
-        content: [{ type: 'tool_use', id: 'sl-gate-1', name: 'skill_load', input: { skill_id: 'gated' } }],
-      },
-      {
-        role: 'user',
-        content: [{ type: 'tool_result', tool_use_id: 'sl-gate-1', content: 'Permission denied.' }],
-      },
-    ];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(result.toolDefinitions).toHaveLength(0);
-    expect(result.allowedToolNames.size).toBe(0);
-  });
-
-  test('skill_load with valid marker activates skill tools (approved path)', () => {
-    mockCatalog = [makeSkill('approved')];
-    mockManifests = { approved: makeManifest(['approved_action']) };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="approved" />'),
-    ];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(result.toolDefinitions).toHaveLength(1);
-    expect(result.toolDefinitions[0].name).toBe('approved_action');
-    expect(result.allowedToolNames.has('approved_action')).toBe(true);
-  });
-});
-
-describe('mid-run skill tool activation (end-to-end)', () => {
-  const baseToolDefs: ToolDefinition[] = [
-    { name: 'file_read', description: 'Read a file', input_schema: { type: 'object', properties: {} } },
-    { name: 'bash', description: 'Run a shell command', input_schema: { type: 'object', properties: {} } },
-  ];
-
-  const CORE_TOOL_NAMES = new Set(['bash', 'file_read', 'file_write', 'file_edit']);
-  let sessionState: Map<string, string>;
-
-  function makeResolveTools(base: ToolDefinition[]) {
-    return (history: Message[]) => {
-      const projection = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-      return {
-        toolDefinitions: [...base, ...projection.toolDefinitions],
-        allowedToolNames: new Set([...CORE_TOOL_NAMES, ...projection.allowedToolNames]),
-      };
-    };
-  }
-
-  beforeEach(() => {
-    mockCatalog = [];
-    mockManifests = {};
-    mockRegisteredTools = new Map();
-    mockUnregisteredSkillIds = [];
-    mockSkillRefCount = new Map();
-    mockSkillRefCount = new Map();
-    mockVersionHashes = {};
-    mockVersionHashErrors = new Set();
-    sessionState = new Map<string, string>();
-  });
-
-  test('Turn 1 calls skill_load → Turn 2 sees added tool', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run']) };
-
-    const resolveTools = makeResolveTools(baseToolDefs);
-
-    // Turn 1: no skill markers in history yet
-    const historyTurn1: Message[] = [
-      { role: 'user', content: [{ type: 'text', text: 'Please deploy' }] },
-      { role: 'assistant', content: [{ type: 'text', text: 'Let me load the deploy skill.' }] },
-    ];
-
-    const turn1Result = resolveTools(historyTurn1);
-    expect(turn1Result.toolDefinitions.map((d) => d.name)).toEqual(['file_read', 'bash']);
-    expect(turn1Result.allowedToolNames.has('deploy_run')).toBe(false);
-
-    // Simulate skill_load output appended as a tool result in the same run
-    const historyTurn2: Message[] = [
-      ...historyTurn1,
-      {
-        role: 'assistant',
-        content: [{ type: 'tool_use', id: 'skill-load-1', name: 'skill_load', input: { skill_id: 'deploy' } }],
-      },
-      {
-        role: 'user',
-        content: [
-          { type: 'tool_result', tool_use_id: 'skill-load-1', content: '<loaded_skill id="deploy" />' },
-        ],
-      },
-    ];
-
-    const turn2Result = resolveTools(historyTurn2);
-    expect(turn2Result.toolDefinitions.map((d) => d.name)).toEqual([
-      'file_read',
-      'bash',
-      'deploy_run',
-    ]);
-    expect(turn2Result.allowedToolNames.has('deploy_run')).toBe(true);
-  });
-
-  test('activation succeeds without requiring a new user message', () => {
-    mockCatalog = [makeSkill('monitor')];
-    mockManifests = { monitor: makeManifest(['monitor_check', 'monitor_alert']) };
-
-    const resolveTools = makeResolveTools(baseToolDefs);
-
-    // History contains only the initial user message and the assistant's
-    // tool_use that triggered skill_load, followed by the tool result.
-    // No second user message is present — the agent loop re-projects
-    // tools between turns within the same run.
-    const history: Message[] = [
-      { role: 'user', content: [{ type: 'text', text: 'Monitor the service' }] },
-      {
-        role: 'assistant',
-        content: [{ type: 'tool_use', id: 'tu-1', name: 'skill_load', input: { skill_id: 'monitor' } }],
-      },
-      {
-        role: 'user',
-        content: [
-          { type: 'tool_result', tool_use_id: 'tu-1', content: '<loaded_skill id="monitor" />' },
-        ],
-      },
-    ];
-
-    const result = resolveTools(history);
-
-    // Skill tools appear without needing another user message
-    expect(result.toolDefinitions.map((d) => d.name)).toContain('monitor_check');
-    expect(result.toolDefinitions.map((d) => d.name)).toContain('monitor_alert');
-    expect(result.allowedToolNames.has('monitor_check')).toBe(true);
-    expect(result.allowedToolNames.has('monitor_alert')).toBe(true);
-
-    // Core tools remain accessible
-    for (const core of CORE_TOOL_NAMES) {
-      expect(result.allowedToolNames.has(core)).toBe(true);
-    }
-  });
-
-  test('multiple skills can activate in sequence across turns', () => {
-    mockCatalog = [makeSkill('deploy'), makeSkill('oncall'), makeSkill('metrics')];
-    mockManifests = {
-      deploy: makeManifest(['deploy_run']),
-      oncall: makeManifest(['oncall_page']),
-      metrics: makeManifest(['metrics_query', 'metrics_dashboard']),
-    };
-
-    const resolveTools = makeResolveTools(baseToolDefs);
-
-    // Step 1: Load skill A (deploy)
-    const historyAfterA: Message[] = [
-      { role: 'user', content: [{ type: 'text', text: 'I need to deploy and check oncall' }] },
-      {
-        role: 'assistant',
-        content: [{ type: 'tool_use', id: 'tu-1', name: 'skill_load', input: { skill_id: 'deploy' } }],
-      },
-      {
-        role: 'user',
-        content: [
-          { type: 'tool_result', tool_use_id: 'tu-1', content: '<loaded_skill id="deploy" />' },
-        ],
-      },
-    ];
-
-    const resultA = resolveTools(historyAfterA);
-    const namesA = resultA.toolDefinitions.map((d) => d.name);
-    expect(namesA).toContain('deploy_run');
-    expect(namesA).not.toContain('oncall_page');
-    expect(namesA).not.toContain('metrics_query');
-
-    // Step 2: Load skill B (oncall) — deploy should remain active
-    const historyAfterB: Message[] = [
-      ...historyAfterA,
-      {
-        role: 'assistant',
-        content: [{ type: 'tool_use', id: 'tu-2', name: 'skill_load', input: { skill_id: 'oncall' } }],
-      },
-      {
-        role: 'user',
-        content: [
-          { type: 'tool_result', tool_use_id: 'tu-2', content: '<loaded_skill id="oncall" />' },
-        ],
-      },
-    ];
-
-    const resultB = resolveTools(historyAfterB);
-    const namesB = resultB.toolDefinitions.map((d) => d.name);
-    expect(namesB).toContain('deploy_run');
-    expect(namesB).toContain('oncall_page');
-    expect(namesB).not.toContain('metrics_query');
-
-    // Step 3: Load skill C (metrics) — all three should be active
-    const historyAfterC: Message[] = [
-      ...historyAfterB,
-      {
-        role: 'assistant',
-        content: [{ type: 'tool_use', id: 'tu-3', name: 'skill_load', input: { skill_id: 'metrics' } }],
-      },
-      {
-        role: 'user',
-        content: [
-          { type: 'tool_result', tool_use_id: 'tu-3', content: '<loaded_skill id="metrics" />' },
-        ],
-      },
-    ];
-
-    const resultC = resolveTools(historyAfterC);
-    const namesC = resultC.toolDefinitions.map((d) => d.name);
-    expect(namesC).toContain('deploy_run');
-    expect(namesC).toContain('oncall_page');
-    expect(namesC).toContain('metrics_query');
-    expect(namesC).toContain('metrics_dashboard');
-
-    // Verify allowed tool names include all skill tools plus core tools
-    expect(resultC.allowedToolNames.has('deploy_run')).toBe(true);
-    expect(resultC.allowedToolNames.has('oncall_page')).toBe(true);
-    expect(resultC.allowedToolNames.has('metrics_query')).toBe(true);
-    expect(resultC.allowedToolNames.has('metrics_dashboard')).toBe(true);
-    for (const core of CORE_TOOL_NAMES) {
-      expect(resultC.allowedToolNames.has(core)).toBe(true);
-    }
-  });
-});
-
-// Context-derived deactivation regression tests
-// ---------------------------------------------------------------------------
-
-describe('context-derived deactivation regression', () => {
-  const baseToolDefs: ToolDefinition[] = [
-    { name: 'file_read', description: 'Read a file', input_schema: { type: 'object', properties: {} } },
-    { name: 'bash', description: 'Run a shell command', input_schema: { type: 'object', properties: {} } },
-  ];
-
-  const CORE_TOOL_NAMES = new Set(['bash', 'file_read', 'file_write', 'file_edit']);
-  let sessionState: Map<string, string>;
-
-  function makeResolveTools(base: ToolDefinition[]) {
-    return (history: Message[]) => {
-      const projection = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-      return {
-        toolDefinitions: [...base, ...projection.toolDefinitions],
-        allowedToolNames: new Set([...CORE_TOOL_NAMES, ...projection.allowedToolNames]),
-      };
-    };
-  }
-
-  beforeEach(() => {
-    mockCatalog = [];
-    mockManifests = {};
-    mockRegisteredTools = new Map();
-    mockUnregisteredSkillIds = [];
-    mockSkillRefCount = new Map();
-    mockSkillRefCount = new Map();
-    mockVersionHashes = {};
-    mockVersionHashErrors = new Set();
-    sessionState = new Map<string, string>();
-  });
-
-  test('tool definitions shrink when skill load marker is removed from history', () => {
-    mockCatalog = [makeSkill('deploy'), makeSkill('oncall')];
-    mockManifests = {
-      deploy: makeManifest(['deploy_run']),
-      oncall: makeManifest(['oncall_page', 'oncall_ack']),
-    };
-
-    const resolveTools = makeResolveTools(baseToolDefs);
-
-    // Turn 1: both skills active
-    const history1: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-      ...skillLoadMessages('<loaded_skill id="oncall" />'),
-    ];
-    const result1 = resolveTools(history1);
-    expect(result1.toolDefinitions).toHaveLength(5); // 2 base + 3 skill tools
-    expect(result1.toolDefinitions.map((d) => d.name)).toContain('oncall_page');
-    expect(result1.toolDefinitions.map((d) => d.name)).toContain('oncall_ack');
-
-    // Turn 2: oncall marker removed from history (truncated)
-    const history2: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-    const result2 = resolveTools(history2);
-
-    // Tool definitions should only have base + deploy tools
-    expect(result2.toolDefinitions).toHaveLength(3); // 2 base + 1 skill tool
-    expect(result2.toolDefinitions.map((d) => d.name)).not.toContain('oncall_page');
-    expect(result2.toolDefinitions.map((d) => d.name)).not.toContain('oncall_ack');
-    expect(result2.toolDefinitions.map((d) => d.name)).toContain('deploy_run');
-  });
-
-  test('executor blocks the tool after deactivation — allowedToolNames excludes it', () => {
-    mockCatalog = [makeSkill('deploy'), makeSkill('oncall')];
-    mockManifests = {
-      deploy: makeManifest(['deploy_run']),
-      oncall: makeManifest(['oncall_page']),
-    };
-
-    const resolveTools = makeResolveTools(baseToolDefs);
-
-    // Turn 1: both skills active, both tools allowed
-    const history1: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-      ...skillLoadMessages('<loaded_skill id="oncall" />'),
-    ];
-    const result1 = resolveTools(history1);
-    expect(result1.allowedToolNames.has('oncall_page')).toBe(true);
-    expect(result1.allowedToolNames.has('deploy_run')).toBe(true);
-
-    // Turn 2: oncall marker gone — its tool should be blocked
-    const history2: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-    const result2 = resolveTools(history2);
-
-    // oncall_page is no longer in allowedToolNames — executor would block it
-    expect(result2.allowedToolNames.has('oncall_page')).toBe(false);
-    // deploy_run remains allowed
-    expect(result2.allowedToolNames.has('deploy_run')).toBe(true);
-    // Core tools remain allowed
-    for (const core of CORE_TOOL_NAMES) {
-      expect(result2.allowedToolNames.has(core)).toBe(true);
-    }
-  });
-
-  test('unregisterSkillTools is called for deactivated skill', () => {
-    mockCatalog = [makeSkill('deploy'), makeSkill('oncall')];
-    mockManifests = {
-      deploy: makeManifest(['deploy_run']),
-      oncall: makeManifest(['oncall_page']),
-    };
-
-    // Turn 1: both active
-    const history1: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-      ...skillLoadMessages('<loaded_skill id="oncall" />'),
-    ];
-    projectSkillTools(history1, { previouslyActiveSkillIds: sessionState });
-
-    // Clear tracking before turn 2
-    mockUnregisteredSkillIds = [];
-
-    // Turn 2: deploy marker gone
-    const history2: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="oncall" />'),
-    ];
-    projectSkillTools(history2, { previouslyActiveSkillIds: sessionState });
-
-    expect(mockUnregisteredSkillIds).toContain('deploy');
-    expect(mockUnregisteredSkillIds).not.toContain('oncall');
-  });
-
-  test('all skills deactivate when all markers leave history', () => {
-    mockCatalog = [makeSkill('deploy'), makeSkill('oncall')];
-    mockManifests = {
-      deploy: makeManifest(['deploy_run']),
-      oncall: makeManifest(['oncall_page']),
-    };
-
-    const resolveTools = makeResolveTools(baseToolDefs);
-
-    // Turn 1: both skills active
-    const history1: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-      ...skillLoadMessages('<loaded_skill id="oncall" />'),
-    ];
-    const result1 = resolveTools(history1);
-    expect(result1.toolDefinitions).toHaveLength(4); // 2 base + 2 skill
-
-    // Clear tracking before turn 2
-    mockUnregisteredSkillIds = [];
-
-    // Turn 2: all markers gone (e.g. context window fully truncated)
-    const history2: Message[] = [
-      { role: 'user', content: [{ type: 'text', text: 'Continue working' }] },
-    ];
-    const result2 = resolveTools(history2);
-
-    // Only base tools remain
-    expect(result2.toolDefinitions).toHaveLength(2);
-    expect(result2.toolDefinitions.map((d) => d.name)).toEqual(['file_read', 'bash']);
-
-    // Both skills were unregistered
-    expect(mockUnregisteredSkillIds).toContain('deploy');
-    expect(mockUnregisteredSkillIds).toContain('oncall');
-
-    // No skill tools in allowed set
-    expect(result2.allowedToolNames.has('deploy_run')).toBe(false);
-    expect(result2.allowedToolNames.has('oncall_page')).toBe(false);
-
-    // Core tools still present
-    for (const core of CORE_TOOL_NAMES) {
-      expect(result2.allowedToolNames.has(core)).toBe(true);
-    }
-  });
-
-  test('skill can reactivate after deactivation', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = {
-      deploy: makeManifest(['deploy_run']),
-    };
-
-    const resolveTools = makeResolveTools(baseToolDefs);
-
-    // Turn 1: deploy active
-    const history1: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-    const result1 = resolveTools(history1);
-    expect(result1.allowedToolNames.has('deploy_run')).toBe(true);
-
-    // Turn 2: marker gone — deactivated
-    const history2: Message[] = [];
-    const result2 = resolveTools(history2);
-    expect(result2.allowedToolNames.has('deploy_run')).toBe(false);
-
-    // Turn 3: marker reappears — reactivated
-    const history3: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-    const result3 = resolveTools(history3);
-    expect(result3.allowedToolNames.has('deploy_run')).toBe(true);
-    expect(result3.toolDefinitions.map((d) => d.name)).toContain('deploy_run');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Slash preactivation tests
-// ---------------------------------------------------------------------------
-
-describe('slash preactivation through session processing', () => {
-  let sessionState: Map<string, string>;
-
-  beforeEach(() => {
-    mockCatalog = [];
-    mockManifests = {};
-    mockRegisteredTools = new Map();
-    mockUnregisteredSkillIds = [];
-    mockSkillRefCount = new Map();
-    mockSkillRefCount = new Map();
-    mockVersionHashes = {};
-    mockVersionHashErrors = new Set();
-    sessionState = new Map<string, string>();
-  });
-
-  test('slash-known skill has its tools available on first projection (turn-0)', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run', 'deploy_status']) };
-
-    // Empty history — no loaded_skill markers yet. The skill is preactivated
-    // via slash resolution, so its tools should be available immediately.
-    const emptyHistory: Message[] = [];
-
-    const result = projectSkillTools(emptyHistory, {
-      preactivatedSkillIds: ['deploy'],
-      previouslyActiveSkillIds: sessionState,
-    });
-
-    expect(result.toolDefinitions).toHaveLength(2);
-    expect(result.toolDefinitions.map((d) => d.name)).toEqual([
-      'deploy_run',
-      'deploy_status',
-    ]);
-    expect(result.allowedToolNames).toEqual(
-      new Set(['deploy_run', 'deploy_status']),
-    );
-  });
-
-  test('preactivation is request-scoped — does not persist to unrelated runs', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run']) };
-
-    // First request: preactivated via slash command
-    const result1 = projectSkillTools([], {
-      preactivatedSkillIds: ['deploy'],
-      previouslyActiveSkillIds: sessionState,
-    });
-    expect(result1.toolDefinitions).toHaveLength(1);
-    expect(result1.allowedToolNames.has('deploy_run')).toBe(true);
-
-    // Second request: no preactivation, no history markers.
-    // Without preactivated IDs, the skill should not appear.
-    const result2 = projectSkillTools([], { previouslyActiveSkillIds: sessionState });
-
-    expect(result2.toolDefinitions).toHaveLength(0);
-    expect(result2.allowedToolNames.has('deploy_run')).toBe(false);
-  });
-
-  test('preactivated skill tools merge with history-derived skills on turn-0', () => {
-    mockCatalog = [makeSkill('deploy'), makeSkill('oncall')];
-    mockManifests = {
-      deploy: makeManifest(['deploy_run']),
-      oncall: makeManifest(['oncall_page']),
-    };
-
-    // History has an oncall marker from a previous exchange
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="oncall" />'),
-    ];
-
-    // deploy is preactivated via slash, oncall is from history
-    const result = projectSkillTools(history, {
-      preactivatedSkillIds: ['deploy'],
-      previouslyActiveSkillIds: sessionState,
-    });
-
-    expect(result.toolDefinitions).toHaveLength(2);
-    expect(result.allowedToolNames).toEqual(
-      new Set(['deploy_run', 'oncall_page']),
-    );
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Bundled skill pipeline integration tests
-// ---------------------------------------------------------------------------
-
-const GMAIL_TOOL_NAMES = [
-  'gmail_search',
-  'gmail_list_messages',
-  'gmail_get_message',
-  'gmail_mark_read',
-  'gmail_draft',
-  'gmail_archive',
-  'gmail_batch_archive',
-  'gmail_label',
-  'gmail_batch_label',
-  'gmail_trash',
-  'gmail_send',
-  'gmail_unsubscribe',
-] as const;
-
-describe('bundled skill: gmail', () => {
-  let sessionState: Map<string, string>;
-
-  beforeEach(() => {
-    mockCatalog = [];
-    mockManifests = {};
-    mockRegisteredTools = new Map();
-    mockUnregisteredSkillIds = [];
-    mockSkillRefCount = new Map();
-    mockSkillRefCount = new Map();
-    mockVersionHashes = {};
-    mockVersionHashErrors = new Set();
-    sessionState = new Map<string, string>();
-  });
-
-  test('gmail skill activation via loaded_skill marker projects all 12 tool definitions', () => {
-    mockCatalog = [makeSkill('gmail', '/path/to/bundled-skills/gmail')];
-    mockManifests = { gmail: makeManifest([...GMAIL_TOOL_NAMES]) };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="gmail" />'),
-    ];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    expect(result.toolDefinitions).toHaveLength(12);
-    expect(result.toolDefinitions.map((d) => d.name)).toEqual([...GMAIL_TOOL_NAMES]);
-    expect(result.allowedToolNames).toEqual(new Set(GMAIL_TOOL_NAMES));
-  });
-
-  test('gmail tools are NOT available when gmail skill is not in active context', () => {
-    mockCatalog = [makeSkill('gmail', '/path/to/bundled-skills/gmail')];
-    mockManifests = { gmail: makeManifest([...GMAIL_TOOL_NAMES]) };
-
-    // No loaded_skill marker for gmail in history
-    const history: Message[] = [
-      { role: 'user', content: [{ type: 'text', text: 'Hello' }] },
-    ];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    expect(result.toolDefinitions).toHaveLength(0);
-    expect(result.allowedToolNames.size).toBe(0);
-    for (const name of GMAIL_TOOL_NAMES) {
-      expect(result.allowedToolNames.has(name)).toBe(false);
-    }
-  });
-});
-
-describe('bundled skill: claude-code', () => {
-  let sessionState: Map<string, string>;
-
-  beforeEach(() => {
-    mockCatalog = [];
-    mockManifests = {};
-    mockRegisteredTools = new Map();
-    mockUnregisteredSkillIds = [];
-    mockSkillRefCount = new Map();
-    mockSkillRefCount = new Map();
-    mockVersionHashes = {};
-    mockVersionHashErrors = new Set();
-    sessionState = new Map<string, string>();
-  });
-
-  test('claude-code skill activation produces claude_code tool definition', () => {
-    mockCatalog = [makeSkill('claude-code', '/path/to/bundled-skills/claude-code')];
-    mockManifests = { 'claude-code': makeManifest(['claude_code']) };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="claude-code" />'),
-    ];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    expect(result.toolDefinitions).toHaveLength(1);
-    expect(result.toolDefinitions[0].name).toBe('claude_code');
-    expect(result.allowedToolNames).toEqual(new Set(['claude_code']));
-  });
-
-  test('claude_code tool is absent when claude-code skill is not active', () => {
-    mockCatalog = [makeSkill('claude-code', '/path/to/bundled-skills/claude-code')];
-    mockManifests = { 'claude-code': makeManifest(['claude_code']) };
-
-    const history: Message[] = [
-      { role: 'user', content: [{ type: 'text', text: 'Hello' }] },
-    ];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    expect(result.toolDefinitions).toHaveLength(0);
-    expect(result.allowedToolNames.has('claude_code')).toBe(false);
-  });
-});
-
-describe('bundled skill: weather', () => {
-  let sessionState: Map<string, string>;
-
-  beforeEach(() => {
-    mockCatalog = [];
-    mockManifests = {};
-    mockRegisteredTools = new Map();
-    mockUnregisteredSkillIds = [];
-    mockSkillRefCount = new Map();
-    mockSkillRefCount = new Map();
-    mockVersionHashes = {};
-    mockVersionHashErrors = new Set();
-    sessionState = new Map<string, string>();
-  });
-
-  test('weather skill activation produces get_weather tool definition', () => {
-    mockCatalog = [makeSkill('weather', '/path/to/bundled-skills/weather')];
-    mockManifests = { weather: makeManifest(['get_weather']) };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="weather" />'),
-    ];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    expect(result.toolDefinitions).toHaveLength(1);
-    expect(result.toolDefinitions[0].name).toBe('get_weather');
-    expect(result.allowedToolNames).toEqual(new Set(['get_weather']));
-  });
-
-  test('get_weather tool is absent when weather skill is not active', () => {
-    mockCatalog = [makeSkill('weather', '/path/to/bundled-skills/weather')];
-    mockManifests = { weather: makeManifest(['get_weather']) };
-
-    const history: Message[] = [
-      { role: 'user', content: [{ type: 'text', text: 'Hello' }] },
-    ];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    expect(result.toolDefinitions).toHaveLength(0);
-    expect(result.allowedToolNames.has('get_weather')).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Bundled skill: app-builder
-// ---------------------------------------------------------------------------
-
-const APP_BUILDER_TOOL_NAMES = [
-  'app_create',
-  'app_list',
-  'app_query',
-  'app_update',
-  'app_delete',
-  'app_file_list',
-  'app_file_read',
-  'app_file_edit',
-  'app_file_write',
-] as const;
-
-describe('bundled skill: app-builder', () => {
-  let sessionState: Map<string, string>;
-
-  beforeEach(() => {
-    mockCatalog = [];
-    mockManifests = {};
-    mockRegisteredTools = new Map();
-    mockUnregisteredSkillIds = [];
-    mockSkillRefCount = new Map();
-    mockVersionHashes = {};
-    mockVersionHashErrors = new Set();
-    sessionState = new Map<string, string>();
-  });
-
-  test('app-builder skill activation projects all 9 canonical non-proxy tool definitions', () => {
-    mockCatalog = [makeSkill('app-builder', '/path/to/bundled-skills/app-builder')];
-    mockManifests = { 'app-builder': makeManifest([...APP_BUILDER_TOOL_NAMES]) };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="app-builder" />'),
-    ];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    expect(result.toolDefinitions).toHaveLength(9);
-    expect(result.toolDefinitions.map((d) => d.name)).toEqual([...APP_BUILDER_TOOL_NAMES]);
-    expect(result.allowedToolNames).toEqual(new Set(APP_BUILDER_TOOL_NAMES));
-  });
-
-  test('app-builder tools are NOT available when skill is not in active context', () => {
-    mockCatalog = [makeSkill('app-builder', '/path/to/bundled-skills/app-builder')];
-    mockManifests = { 'app-builder': makeManifest([...APP_BUILDER_TOOL_NAMES]) };
-
-    const history: Message[] = [
-      { role: 'user', content: [{ type: 'text', text: 'Hello' }] },
-    ];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    expect(result.toolDefinitions).toHaveLength(0);
-    expect(result.allowedToolNames.size).toBe(0);
-    for (const name of APP_BUILDER_TOOL_NAMES) {
-      expect(result.allowedToolNames.has(name)).toBe(false);
-    }
-  });
-
-  test('skill-projected app tools use host execution (script runners)', () => {
-    mockCatalog = [makeSkill('app-builder', '/path/to/bundled-skills/app-builder')];
-    mockManifests = { 'app-builder': makeManifest([...APP_BUILDER_TOOL_NAMES]) };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="app-builder" />'),
-    ];
-
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    const tools = mockRegisteredTools.get('app-builder');
-    expect(tools).toBeDefined();
-    expect(tools!.length).toBe(9);
-
-    // All tools should have skill origin metadata
-    for (const tool of tools!) {
-      expect(tool.origin).toBe('skill');
-      expect(tool.ownerSkillId).toBe('app-builder');
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Bundled skill: browser
-// ---------------------------------------------------------------------------
-
-describe('bundled skill: browser', () => {
-  let sessionState: Map<string, string>;
-
-  beforeEach(() => {
-    mockCatalog = [];
-    mockManifests = {};
-    mockRegisteredTools = new Map();
-    mockUnregisteredSkillIds = [];
-    mockSkillRefCount = new Map();
-    mockVersionHashes = {};
-    mockVersionHashErrors = new Set();
-    sessionState = new Map<string, string>();
-  });
-
-  test('browser skill activation via loaded_skill marker projects all 10 tool definitions', () => {
-    mockCatalog = [makeSkill('browser', '/path/to/bundled-skills/browser')];
-    mockManifests = { browser: makeManifest([...BROWSER_TOOL_NAMES]) };
-
-    const history: Message[] = [
-      ...buildSkillLoadHistory('browser', 'v1:testhash'),
-    ];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    expect(result.toolDefinitions).toHaveLength(10);
-    expect(result.toolDefinitions.map((d) => d.name)).toEqual([...BROWSER_TOOL_NAMES]);
-    expect(result.allowedToolNames).toEqual(new Set(BROWSER_TOOL_NAMES));
-  });
-
-  test('browser tools are NOT available when browser skill is not in active context', () => {
-    mockCatalog = [makeSkill('browser', '/path/to/bundled-skills/browser')];
-    mockManifests = { browser: makeManifest([...BROWSER_TOOL_NAMES]) };
-
-    const history: Message[] = [
-      { role: 'user', content: [{ type: 'text', text: 'Hello' }] },
-    ];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    expect(result.toolDefinitions).toHaveLength(0);
-    expect(result.allowedToolNames.size).toBe(0);
-    for (const name of BROWSER_TOOL_NAMES) {
-      expect(result.allowedToolNames.has(name)).toBe(false);
-    }
-  });
-
-  test('browser skill tools have skill origin metadata', () => {
-    mockCatalog = [makeSkill('browser', '/path/to/bundled-skills/browser')];
-    mockManifests = { browser: makeManifest([...BROWSER_TOOL_NAMES]) };
-
-    const history: Message[] = [
-      ...buildSkillLoadHistory('browser', 'v1:testhash'),
-    ];
-
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    const tools = mockRegisteredTools.get('browser');
-    expect(tools).toBeDefined();
-    expect(tools!.length).toBe(10);
-
-    for (const tool of tools!) {
-      expect(tool.origin).toBe('skill');
-      expect(tool.ownerSkillId).toBe('browser');
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tamper detection regression tests
-// ---------------------------------------------------------------------------
-
-describe('tamper detection', () => {
-  let sessionState: Map<string, string>;
-
-  beforeEach(() => {
-    mockCatalog = [];
-    mockManifests = {};
-    mockRegisteredTools = new Map();
-    mockUnregisteredSkillIds = [];
-    mockSkillRefCount = new Map();
-    mockVersionHashes = {};
-    mockVersionHashErrors = new Set();
-    sessionState = new Map<string, string>();
-  });
-
-  test('file mutation after projection invalidates the stored hash, causing re-registration on next turn', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run']) };
-    mockVersionHashes = { deploy: 'v1:original-file-hash' };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    // Turn 1: project with original hash
-    const result1 = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(result1.toolDefinitions).toHaveLength(1);
-    expect(result1.toolDefinitions[0].name).toBe('deploy_run');
-    expect(sessionState.get('deploy')).toBe('v1:original-file-hash');
-
-    // Simulate file mutation on disk — the hash changes
-    mockVersionHashes = { deploy: 'v1:tampered-file-hash' };
-
-    // Turn 2: re-project detects hash drift and re-registers
-    mockUnregisteredSkillIds = [];
-    const result2 = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    // Tools are still available (re-registered with new hash)
-    expect(result2.toolDefinitions).toHaveLength(1);
-    expect(result2.toolDefinitions[0].name).toBe('deploy_run');
-
-    // Old tools were unregistered before new ones registered
-    expect(mockUnregisteredSkillIds).toContain('deploy');
-
-    // Session state now tracks the new hash
-    expect(sessionState.get('deploy')).toBe('v1:tampered-file-hash');
-
-    // Refcount stays at 1 (unregister decremented, re-register incremented)
-    expect(mockSkillRefCount.get('deploy')).toBe(1);
-  });
-
-  test('unmodified skill file does NOT trigger re-registration across multiple turns', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run']) };
-    mockVersionHashes = { deploy: 'v1:stable-content-hash' };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    // Turn 1: initial projection
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(mockSkillRefCount.get('deploy')).toBe(1);
-
-    // Turns 2-4: hash stays the same, no re-registration should occur
-    for (let turn = 2; turn <= 4; turn++) {
-      mockUnregisteredSkillIds = [];
-      const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-      expect(result.toolDefinitions).toHaveLength(1);
-      expect(mockUnregisteredSkillIds).not.toContain('deploy');
-      expect(mockSkillRefCount.get('deploy')).toBe(1);
-    }
-  });
-
-  test('re-projection after tamper produces tools with the updated hash', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run', 'deploy_status']) };
-    mockVersionHashes = { deploy: 'v1:hash-before-edit' };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    // Turn 1: initial projection
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(sessionState.get('deploy')).toBe('v1:hash-before-edit');
-
-    // Simulate tamper: file changes on disk
-    mockVersionHashes = { deploy: 'v1:hash-after-edit' };
-
-    // Turn 2: re-projection picks up the new hash
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    expect(result.toolDefinitions).toHaveLength(2);
-    expect(result.allowedToolNames).toEqual(new Set(['deploy_run', 'deploy_status']));
-    expect(sessionState.get('deploy')).toBe('v1:hash-after-edit');
-  });
-
-  test('multiple skills with only one tampered triggers selective re-registration', () => {
-    mockCatalog = [makeSkill('deploy'), makeSkill('oncall')];
-    mockManifests = {
-      deploy: makeManifest(['deploy_run']),
-      oncall: makeManifest(['oncall_page']),
-    };
-    mockVersionHashes = {
-      deploy: 'v1:deploy-hash-v1',
-      oncall: 'v1:oncall-hash-v1',
-    };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-      ...skillLoadMessages('<loaded_skill id="oncall" />'),
-    ];
-
-    // Turn 1: both skills registered
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(sessionState.get('deploy')).toBe('v1:deploy-hash-v1');
-    expect(sessionState.get('oncall')).toBe('v1:oncall-hash-v1');
-
-    // Tamper only deploy
-    mockVersionHashes = {
-      deploy: 'v1:deploy-hash-v2-tampered',
-      oncall: 'v1:oncall-hash-v1', // unchanged
-    };
-    mockUnregisteredSkillIds = [];
-
-    // Turn 2: only deploy should be re-registered
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    expect(result.toolDefinitions).toHaveLength(2);
-    expect(result.allowedToolNames).toEqual(new Set(['deploy_run', 'oncall_page']));
-
-    // Only deploy was unregistered (for re-registration), oncall was untouched
-    expect(mockUnregisteredSkillIds).toContain('deploy');
-    expect(mockUnregisteredSkillIds).not.toContain('oncall');
-
-    // Hashes updated accordingly
-    expect(sessionState.get('deploy')).toBe('v1:deploy-hash-v2-tampered');
-    expect(sessionState.get('oncall')).toBe('v1:oncall-hash-v1');
-  });
-
-  test('hash failure (e.g., unreadable directory) causes fallback re-registration', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run']) };
-    mockVersionHashes = { deploy: 'v1:initial-hash' };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(sessionState.get('deploy')).toBe('v1:initial-hash');
-
-    // Make computeSkillVersionHash throw to exercise the catch branch
-    // in session-skill-tools.ts that falls back to `unknown-${Date.now()}`
-    mockVersionHashErrors.add('deploy');
-    mockUnregisteredSkillIds = [];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(result.toolDefinitions).toHaveLength(1);
-
-    // The exception triggers re-registration since the fallback hash
-    // (`unknown-<timestamp>`) will never match the stored hash
-    expect(mockUnregisteredSkillIds).toContain('deploy');
-    expect(sessionState.get('deploy')).toMatch(/^unknown-\d+$/);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// resetSkillToolProjection tests
-// ---------------------------------------------------------------------------
-
-describe('resetSkillToolProjection', () => {
-  beforeEach(() => {
-    mockCatalog = [];
-    mockManifests = {};
-    mockRegisteredTools = new Map();
-    mockUnregisteredSkillIds = [];
-    mockSkillRefCount = new Map();
-    mockVersionHashes = {};
-    mockVersionHashErrors = new Set();
-  });
-
-  test('unregisters all tracked skills and clears the map', () => {
-    mockCatalog = [makeSkill('deploy'), makeSkill('oncall')];
-    mockManifests = {
-      deploy: makeManifest(['deploy_run']),
-      oncall: makeManifest(['oncall_page']),
-    };
-
-    const trackedIds = new Map<string, string>();
-
-    // Activate both skills
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-      ...skillLoadMessages('<loaded_skill id="oncall" />'),
-    ];
-    projectSkillTools(history, { previouslyActiveSkillIds: trackedIds });
-    expect(trackedIds.size).toBe(2);
-
-    mockUnregisteredSkillIds = [];
-    resetSkillToolProjection(trackedIds);
-
-    expect(mockUnregisteredSkillIds).toContain('deploy');
-    expect(mockUnregisteredSkillIds).toContain('oncall');
-    expect(trackedIds.size).toBe(0);
-  });
-
-  test('no-op when called with undefined', () => {
-    mockUnregisteredSkillIds = [];
-    resetSkillToolProjection(undefined);
-    expect(mockUnregisteredSkillIds).toHaveLength(0);
-  });
-
-  test('no-op when called with empty map', () => {
-    mockUnregisteredSkillIds = [];
-    resetSkillToolProjection(new Map());
-    expect(mockUnregisteredSkillIds).toHaveLength(0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Versioned marker integration tests
-// ---------------------------------------------------------------------------
-
-describe('versioned markers through session projection', () => {
-  let sessionState: Map<string, string>;
-
-  beforeEach(() => {
-    mockCatalog = [];
-    mockManifests = {};
-    mockRegisteredTools = new Map();
-    mockUnregisteredSkillIds = [];
-    mockSkillRefCount = new Map();
-    mockVersionHashes = {};
-    mockVersionHashErrors = new Set();
-    sessionState = new Map<string, string>();
-  });
-
-  test('versioned marker activates skill tools the same as legacy marker', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run']) };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" version="v1:abc123" />'),
-    ];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    expect(result.toolDefinitions).toHaveLength(1);
-    expect(result.toolDefinitions[0].name).toBe('deploy_run');
-    expect(result.allowedToolNames).toEqual(new Set(['deploy_run']));
-  });
-
-  test('mixed legacy and versioned markers both project tools', () => {
-    mockCatalog = [makeSkill('deploy'), makeSkill('oncall')];
-    mockManifests = {
-      deploy: makeManifest(['deploy_run']),
-      oncall: makeManifest(['oncall_page']),
-    };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-      ...skillLoadMessages('<loaded_skill id="oncall" version="v1:deadbeef" />'),
-    ];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    expect(result.toolDefinitions).toHaveLength(2);
-    expect(result.allowedToolNames).toEqual(new Set(['deploy_run', 'oncall_page']));
-  });
-
-  test('versioned marker skill deactivates when removed from history', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run']) };
-
-    // Turn 1: versioned skill active
-    const history1: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" version="v1:abc123" />'),
-    ];
-    projectSkillTools(history1, { previouslyActiveSkillIds: sessionState });
-    expect(sessionState.has('deploy')).toBe(true);
-
-    // Turn 2: marker removed
-    mockUnregisteredSkillIds = [];
-    const result2 = projectSkillTools([], { previouslyActiveSkillIds: sessionState });
-    expect(result2.toolDefinitions).toEqual([]);
-    expect(mockUnregisteredSkillIds).toContain('deploy');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Hash change re-prompt regression tests (PR 35)
-// Verify that version hash changes trigger re-registration and that the
-// session state accurately tracks the new hash, which downstream components
-// use to decide whether cached approvals still apply.
-// ---------------------------------------------------------------------------
-
-describe('hash change re-prompt regressions (PR 35)', () => {
-  let sessionState: Map<string, string>;
-
-  beforeEach(() => {
-    mockCatalog = [];
-    mockManifests = {};
-    mockRegisteredTools = new Map();
-    mockUnregisteredSkillIds = [];
-    mockSkillRefCount = new Map();
-    mockVersionHashes = {};
-    mockVersionHashErrors = new Set();
-    sessionState = new Map<string, string>();
-  });
-
-  test('approve v1, edit skill (hash changes), v2 triggers re-registration with new hash', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run']) };
-    mockVersionHashes = { deploy: 'v1:approved-hash' };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    // Turn 1: skill approved and registered with v1 hash
-    const result1 = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(result1.toolDefinitions).toHaveLength(1);
-    expect(sessionState.get('deploy')).toBe('v1:approved-hash');
-    expect(mockSkillRefCount.get('deploy')).toBe(1);
-
-    // Simulate skill edit — hash changes on disk
-    mockVersionHashes = { deploy: 'v2:edited-hash' };
-    mockUnregisteredSkillIds = [];
-
-    // Turn 2: projection detects hash drift, unregisters old, re-registers new
-    const result2 = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    expect(result2.toolDefinitions).toHaveLength(1);
-    expect(result2.toolDefinitions[0].name).toBe('deploy_run');
-
-    // Old version was unregistered
-    expect(mockUnregisteredSkillIds).toContain('deploy');
-
-    // Session state updated to the new hash
-    expect(sessionState.get('deploy')).toBe('v2:edited-hash');
-
-    // Ref count balanced (unregister decremented, re-register incremented)
-    expect(mockSkillRefCount.get('deploy')).toBe(1);
-  });
-
-  test('two consecutive edits each trigger re-registration with correct hash', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run']) };
-    mockVersionHashes = { deploy: 'v1:first-version' };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    // Turn 1: initial registration
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(sessionState.get('deploy')).toBe('v1:first-version');
-
-    // Edit 1: hash changes to v2
-    mockVersionHashes = { deploy: 'v2:second-version' };
-    mockUnregisteredSkillIds = [];
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(sessionState.get('deploy')).toBe('v2:second-version');
-    expect(mockUnregisteredSkillIds).toContain('deploy');
-
-    // Edit 2: hash changes to v3
-    mockVersionHashes = { deploy: 'v3:third-version' };
-    mockUnregisteredSkillIds = [];
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(sessionState.get('deploy')).toBe('v3:third-version');
-    expect(mockUnregisteredSkillIds).toContain('deploy');
-
-    // Ref count stays at 1 through all edits
-    expect(mockSkillRefCount.get('deploy')).toBe(1);
-  });
-
-  test('hash change in one skill does not affect co-active skill with stable hash', () => {
-    mockCatalog = [makeSkill('deploy'), makeSkill('oncall')];
-    mockManifests = {
-      deploy: makeManifest(['deploy_run']),
-      oncall: makeManifest(['oncall_page']),
-    };
-    mockVersionHashes = {
-      deploy: 'v1:deploy-stable',
-      oncall: 'v1:oncall-original',
-    };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-      ...skillLoadMessages('<loaded_skill id="oncall" />'),
-    ];
-
-    // Turn 1: both skills registered
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    expect(sessionState.get('deploy')).toBe('v1:deploy-stable');
-    expect(sessionState.get('oncall')).toBe('v1:oncall-original');
-
-    // Edit only oncall
-    mockVersionHashes = {
-      deploy: 'v1:deploy-stable', // unchanged
-      oncall: 'v2:oncall-edited',
-    };
-    mockUnregisteredSkillIds = [];
-
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    // Only oncall was re-registered
-    expect(mockUnregisteredSkillIds).toContain('oncall');
-    expect(mockUnregisteredSkillIds).not.toContain('deploy');
-
-    // Hashes updated correctly
-    expect(sessionState.get('deploy')).toBe('v1:deploy-stable');
-    expect(sessionState.get('oncall')).toBe('v2:oncall-edited');
-  });
-
-  test('registered tools carry updated ownerSkillId after hash change re-registration', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run']) };
-    mockVersionHashes = { deploy: 'v1:pre-edit' };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    // Turn 1
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    const toolsV1 = mockRegisteredTools.get('deploy');
-    expect(toolsV1).toBeDefined();
-    expect(toolsV1!.length).toBe(1);
-    expect(toolsV1![0].ownerSkillId).toBe('deploy');
-
-    // Edit
-    mockVersionHashes = { deploy: 'v2:post-edit' };
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    // After re-registration, tools should still be associated with the skill
-    const toolsV2 = mockRegisteredTools.get('deploy');
-    expect(toolsV2).toBeDefined();
-    expect(toolsV2!.length).toBeGreaterThanOrEqual(1);
-    expect(toolsV2![0].ownerSkillId).toBe('deploy');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Version hash plumbing regression tests
-// Verify that createSkillToolsFromManifest receives the computed hash and
-// that projected tools carry ownerSkillVersionHash, which downstream
-// components (executor.ts) use to build policy context.
-// ---------------------------------------------------------------------------
-
-describe('version hash plumbing to projected tools', () => {
-  let sessionState: Map<string, string>;
-
-  beforeEach(() => {
-    mockCatalog = [];
-    mockManifests = {};
-    mockRegisteredTools = new Map();
-    mockUnregisteredSkillIds = [];
-    mockSkillRefCount = new Map();
-    mockVersionHashes = {};
-    mockVersionHashErrors = new Set();
-    sessionState = new Map<string, string>();
-  });
-
-  test('projected tools carry ownerSkillVersionHash matching the computed hash', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run', 'deploy_status']) };
-    mockVersionHashes = { deploy: 'v1:secure-hash-abc' };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    const tools = mockRegisteredTools.get('deploy');
-    expect(tools).toBeDefined();
-    expect(tools!.length).toBe(2);
-
-    // Every tool created for this skill must carry the version hash
-    for (const tool of tools!) {
-      expect(tool.ownerSkillVersionHash).toBe('v1:secure-hash-abc');
-    }
-  });
-
-  test('after hash change re-registration, new tools carry the updated hash', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run']) };
-    mockVersionHashes = { deploy: 'v1:hash-before' };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    // Turn 1: register with original hash
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    const toolsV1 = mockRegisteredTools.get('deploy');
-    expect(toolsV1).toBeDefined();
-    expect(toolsV1![0].ownerSkillVersionHash).toBe('v1:hash-before');
-
-    // Simulate file edit — hash changes
-    mockVersionHashes = { deploy: 'v2:hash-after' };
-
-    // Turn 2: re-registration with new hash
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    const toolsV2 = mockRegisteredTools.get('deploy');
-    expect(toolsV2).toBeDefined();
-
-    // The most recently registered tool should carry the new hash
-    const lastTool = toolsV2![toolsV2!.length - 1];
-    expect(lastTool.ownerSkillVersionHash).toBe('v2:hash-after');
-  });
-
-  test('tools for multiple co-active skills each carry their own version hash', () => {
-    mockCatalog = [makeSkill('deploy'), makeSkill('oncall')];
-    mockManifests = {
-      deploy: makeManifest(['deploy_run']),
-      oncall: makeManifest(['oncall_page']),
-    };
-    mockVersionHashes = {
-      deploy: 'v1:deploy-hash-123',
-      oncall: 'v1:oncall-hash-456',
-    };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-      ...skillLoadMessages('<loaded_skill id="oncall" />'),
-    ];
-
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    const deployTools = mockRegisteredTools.get('deploy');
-    expect(deployTools).toBeDefined();
-    expect(deployTools![0].ownerSkillVersionHash).toBe('v1:deploy-hash-123');
-
-    const oncallTools = mockRegisteredTools.get('oncall');
-    expect(oncallTools).toBeDefined();
-    expect(oncallTools![0].ownerSkillVersionHash).toBe('v1:oncall-hash-456');
-  });
-
-  test('default hash is used and plumbed when no explicit hash override is set', () => {
-    mockCatalog = [makeSkill('deploy')];
-    mockManifests = { deploy: makeManifest(['deploy_run']) };
-    // No mockVersionHashes override — mock returns 'v1:default-hash-deploy'
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    const tools = mockRegisteredTools.get('deploy');
-    expect(tools).toBeDefined();
-    expect(tools![0].ownerSkillVersionHash).toBe('v1:default-hash-deploy');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Child skill includes: no auto-activation
-// ---------------------------------------------------------------------------
-
-describe('includes metadata does not auto-activate child skill tools', () => {
-  let sessionState: Map<string, string>;
-
-  beforeEach(() => {
-    mockCatalog = [];
-    mockManifests = {};
-    mockRegisteredTools = new Map();
-    mockUnregisteredSkillIds = [];
-    mockSkillRefCount = new Map();
-    mockVersionHashes = {};
-    mockVersionHashErrors = new Set();
-    sessionState = new Map<string, string>();
-  });
-
-  test('parent with includes — only parent tools projected when only parent marker present', () => {
-    // Parent skill declares child in its includes metadata
-    const parentSkill = makeSkill('parent-skill');
-    parentSkill.includes = ['child-skill'];
-
-    mockCatalog = [parentSkill, makeSkill('child-skill')];
-    mockManifests = {
-      'parent-skill': makeManifest(['parent_action']),
-      'child-skill': makeManifest(['child_action']),
-    };
-
-    // Only parent marker in history — child is NOT loaded
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="parent-skill" />'),
-    ];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    // Only parent tools should be projected
-    expect(result.toolDefinitions).toHaveLength(1);
-    expect(result.toolDefinitions[0].name).toBe('parent_action');
-    expect(result.allowedToolNames).toEqual(new Set(['parent_action']));
-
-    // Child tools must NOT be present
-    expect(result.allowedToolNames.has('child_action')).toBe(false);
-  });
-
-  test('child tools appear only after explicit child loaded_skill marker', () => {
-    const parentSkill = makeSkill('parent-skill');
-    parentSkill.includes = ['child-skill'];
-
-    mockCatalog = [parentSkill, makeSkill('child-skill')];
-    mockManifests = {
-      'parent-skill': makeManifest(['parent_action']),
-      'child-skill': makeManifest(['child_action']),
-    };
-
-    // Both parent AND child markers present — both should be active
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="parent-skill" />'),
-      ...skillLoadMessages('<loaded_skill id="child-skill" />'),
-    ];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    expect(result.toolDefinitions).toHaveLength(2);
-    expect(result.allowedToolNames).toEqual(new Set(['parent_action', 'child_action']));
-  });
-
-  test('child tools are absent even with deep include chain — only markers matter', () => {
-    const grandparent = makeSkill('grandparent');
-    grandparent.includes = ['parent'];
-    const parent = makeSkill('parent');
-    parent.includes = ['child'];
-
-    mockCatalog = [grandparent, parent, makeSkill('child')];
-    mockManifests = {
-      grandparent: makeManifest(['gp_action']),
-      parent: makeManifest(['parent_action']),
-      child: makeManifest(['child_action']),
-    };
-
-    // Only grandparent marker — despite transitive includes, only grandparent tools active
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="grandparent" />'),
-    ];
-
-    const result = projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    expect(result.toolDefinitions).toHaveLength(1);
-    expect(result.toolDefinitions[0].name).toBe('gp_action');
-    expect(result.allowedToolNames.has('parent_action')).toBe(false);
-    expect(result.allowedToolNames.has('child_action')).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Browser skill migration harness — validates shared test helpers
-// ---------------------------------------------------------------------------
-
-describe('browser skill migration harness', () => {
-  test('buildSkillLoadHistory creates valid skill_load history', () => {
-    const history = buildSkillLoadHistory('browser', 'v1:abc123');
-    expect(history).toHaveLength(2);
-    expect(history[0].role).toBe('assistant');
-    expect(history[1].role).toBe('user');
-    // Verify tool_use block
-    const toolUse = history[0].content[0] as ToolUseContent;
-    expect(toolUse.type).toBe('tool_use');
-    expect(toolUse.name).toBe('skill_load');
-    // Verify tool_result has marker
-    const toolResult = history[1].content[0] as ToolResultContent;
-    expect(toolResult.type).toBe('tool_result');
-    expect(toolResult.content).toContain('<loaded_skill id="browser" version="v1:abc123" />');
-  });
-
-  test('buildSkillLoadHistory generates unique tool_use IDs per call', () => {
-    const h1 = buildSkillLoadHistory('browser', 'v1:abc');
-    const h2 = buildSkillLoadHistory('browser', 'v1:def');
-    const id1 = (h1[0].content[0] as { id: string }).id;
-    const id2 = (h2[0].content[0] as { id: string }).id;
-    expect(id1).not.toBe(id2);
-  });
-
-  test('BROWSER_TOOL_NAMES contains all 10 browser tools', () => {
-    expect(BROWSER_TOOL_NAMES).toHaveLength(10);
-    expect(BROWSER_TOOL_NAMES).toContain('browser_navigate');
-    expect(BROWSER_TOOL_NAMES).toContain('browser_fill_credential');
-  });
-
-  test('assertBrowserToolsPresent passes when all tools present', () => {
-    expect(() => assertBrowserToolsPresent([...BROWSER_TOOL_NAMES, 'extra_tool'])).not.toThrow();
-  });
-
-  test('assertBrowserToolsPresent fails when tool missing', () => {
-    expect(() => assertBrowserToolsPresent(['browser_navigate'])).toThrow();
-  });
-
-  test('assertBrowserToolsAbsent passes when no browser tools present', () => {
-    expect(() => assertBrowserToolsAbsent(['file_read', 'web_search'])).not.toThrow();
-  });
-
-  test('assertBrowserToolsAbsent fails when browser tool present', () => {
-    expect(() => assertBrowserToolsAbsent(['browser_navigate'])).toThrow();
-  });
-});