@winspan/claude-forge 8.50.6 → 8.51.1

package/tests/integration/claudemd-generator.test.ts

@@ -0,0 +1,90 @@
+/**
+ * Integration test for ClaudeMdGenerator — safety-net for L1 SWARM_PROTOCOL extraction.
+ *
+ * Anchors the SWARM section content (open → projectContent boundary) via SHA256
+ * so that the .md file extraction must produce byte-for-byte identical output.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { ClaudeMdGenerator } from '../../src/claudemd/claudemd-generator.js';
+
+// SWARM section SHA256, captured against the literal-string implementation
+// before extracting to swarm-protocol.md. After extraction, this MUST stay equal.
+const SWARM_SECTION_SHA256 =
+  '260dfe1e48fdecc324419a6330428eaa3597e3fd6e6262cf66cdcf301ca32e18';
+
+/**
+ * Minimal stub for ClaudeProvider — only `complete` is exercised by generate().
+ */
+function makeFailingAi(): any {
+  return {
+    complete: async () => {
+      throw new Error('forced AI failure (safety-net)');
+    },
+  };
+}
+
+describe('ClaudeMdGenerator (safety-net)', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'claudemd-gen-'));
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('generates fallback CLAUDE.md containing all SWARM_PROTOCOL anchors', async () => {
+    const gen = new ClaudeMdGenerator(makeFailingAi());
+    const output = await gen.generate(tmpDir);
+
+    // ── Key field anchors (SWARM section) ──────────────────────────────
+    expect(output).toContain('# claude-forge 工作区规范');
+    expect(output).toContain('## 自检');
+    expect(output).toContain('Two-Phase Workflow');
+    expect(output).toContain('harness-hotfix');
+    expect(output).toContain('refactor-safe');
+    expect(output).toContain('hybrid-feature-with-safety');
+
+    // ── Total line count ≥ 200 (SWARM ~223 lines + fallback) ───────────
+    const lineCount = output.split('\n').length;
+    expect(lineCount).toBeGreaterThanOrEqual(200);
+  });
+
+  it('SWARM section hash is stable across literal/file-loaded implementations', async () => {
+    const gen = new ClaudeMdGenerator(makeFailingAi());
+    const output = await gen.generate(tmpDir);
+
+    // Split SWARM from projectContent: fallback always starts with sectionOverview ("## 项目概述").
+    // SWARM_PROTOCOL ends with "\n" + "\n\n" separator, so the boundary is the first
+    // "\n\n## 项目概述" occurrence — everything before that is the SWARM section.
+    const boundary = output.indexOf('\n\n## 项目概述');
+    expect(boundary).toBeGreaterThan(0);
+
+    // Include the trailing newline of SWARM_PROTOCOL (it ends with `\n`), exclude the `\n\n` separator.
+    const swarmSection = output.slice(0, boundary + 1);
+
+    const hash = createHash('sha256').update(swarmSection, 'utf-8').digest('hex');
+
+    // Print for first-run baseline capture (visible with --reporter=verbose).
+    // eslint-disable-next-line no-console
+    console.log('[safety-net] SWARM_SECTION_SHA256 =', hash);
+    // eslint-disable-next-line no-console
+    console.log('[safety-net] SWARM section length =', swarmSection.length, 'bytes');
+
+    // Sanity: SWARM section must be substantial.
+    expect(swarmSection.length).toBeGreaterThan(4000);
+    expect(swarmSection.startsWith('# claude-forge 工作区规范')).toBe(true);
+    expect(swarmSection.endsWith('（由 daemon 自动更新，记录最近任务上下文）\n\n')).toBe(true);
+
+    // If a known hash is set (non-placeholder), assert equality.
+    // The placeholder below is the all-zero-ish string used on first run; replaced
+    // automatically by the orchestration script once baseline is captured.
+    expect(hash).toBe(SWARM_SECTION_SHA256);
+  });
+});

package/tests/integration/web-analytics.integration.test.ts

@@ -0,0 +1,133 @@
+/**
+ * Integration safety-net for web analytics endpoints.
+ *
+ * Purpose: lock the wiring of the 3 analytics routes (drift / weekly report /
+ * insights) before migrating their backing classes from `daemon/services/` to
+ * `web/analytics/`. We assert HTTP 200 + presence of key response fields only;
+ * business-correctness coverage is out of scope.
+ *
+ * If any endpoint regresses to a 4xx/5xx response, this test fails and blocks
+ * the H6 migration commit.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import express, { type Application } from 'express';
+import request from 'supertest';
+import { SQLiteStorage } from '../../src/core/storage/sqlite.js';
+import { registerDriftRoutes } from '../../src/web/routes/drift.js';
+import { registerReportsRoutes } from '../../src/web/routes/reports.js';
+import { registerInsightsRoutes } from '../../src/web/routes/insights.js';
+
+const FIXTURE_SESSION = 'sess-analytics-fixture';
+const FIXTURE_PROJECT = '/tmp/proj-analytics-fixture';
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+/**
+ * Seed a small but deterministic dataset so the analytics endpoints have
+ * something to aggregate. H2 Phase 1 enhancement: in addition to shape checks
+ * we assert key aggregated values to lock the current behaviour before the
+ * weekly-report / anti-pattern / drift inline SQL is migrated to Operations.
+ */
+function seedFixtureData(storage: SQLiteStorage): void {
+  // 4 events on the current (active) day so weekly/insights see them.
+  storage.writeEvent({
+    session_id: FIXTURE_SESSION, project_path: FIXTURE_PROJECT, timestamp: nowIso(),
+    hook_type: 'UserPromptSubmit', user_prompt: 'do work',
+  });
+  storage.writeEvent({
+    session_id: FIXTURE_SESSION, project_path: FIXTURE_PROJECT, timestamp: nowIso(),
+    hook_type: 'PreToolUse', tool_name: 'Bash', tool_input: { command: 'ls' },
+  });
+  storage.writeEvent({
+    session_id: FIXTURE_SESSION, project_path: FIXTURE_PROJECT, timestamp: nowIso(),
+    hook_type: 'PreToolUse', tool_name: 'Edit', tool_input: { file_path: '/a.ts' },
+  });
+  storage.writeEvent({
+    session_id: FIXTURE_SESSION, project_path: FIXTURE_PROJECT, timestamp: nowIso(),
+    hook_type: 'PostToolUse', tool_name: 'Edit', tool_output: 'ok',
+  });
+}
+
+describe('Web analytics endpoints (safety-net)', () => {
+  let app: Application;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    storage = new SQLiteStorage(':memory:');
+    app = express();
+    app.use(express.json());
+    registerDriftRoutes(app, { storage });
+    registerReportsRoutes(app, { storage });
+    registerInsightsRoutes(app, { storage });
+  });
+
+  afterEach(() => {
+    storage.close();
+  });
+
+  it('GET /api/drift/report returns a DriftReport shape', async () => {
+    const res = await request(app).get('/api/drift/report');
+    expect(res.status).toBe(200);
+    expect(res.body).toHaveProperty('generatedAt');
+    expect(res.body).toHaveProperty('period');
+    expect(res.body).toHaveProperty('checks');
+    expect(res.body).toHaveProperty('overallScore');
+    expect(Array.isArray(res.body.checks)).toBe(true);
+  });
+
+  it('GET /api/reports/weekly returns a WeeklyReport shape', async () => {
+    const res = await request(app).get('/api/reports/weekly');
+    expect(res.status).toBe(200);
+    expect(res.body).toHaveProperty('generatedAt');
+    expect(res.body).toHaveProperty('week');
+    expect(res.body).toHaveProperty('overview');
+    // overview should at least exist as an object with numeric fields
+    expect(typeof res.body.overview).toBe('object');
+  });
+
+  it('GET /api/insights returns insights summary + patterns array', async () => {
+    const res = await request(app).get('/api/insights');
+    expect(res.status).toBe(200);
+    expect(res.body).toHaveProperty('generatedAt');
+    expect(res.body).toHaveProperty('windowDays');
+    expect(res.body).toHaveProperty('summary');
+    expect(res.body).toHaveProperty('patterns');
+    expect(Array.isArray(res.body.patterns)).toBe(true);
+    expect(res.body.summary).toHaveProperty('total');
+  });
+
+  // ── H2 Phase 1 value-level safety-net ────────────────────────────────────
+
+  it('GET /api/reports/weekly reflects seeded events in overview.totalEvents', async () => {
+    seedFixtureData(storage);
+    const res = await request(app).get('/api/reports/weekly').query({ weekOffset: 0 });
+    expect(res.status).toBe(200);
+    // overview is aggregated from events within the active ISO week. The
+    // seed inserts 4 events on the current timestamp → they MUST be inside
+    // the current week range. activeProjects MUST include the fixture path.
+    expect(res.body.overview.totalEvents).toBe(4);
+    expect(res.body.overview.totalSessions).toBe(1);
+    expect(res.body.overview.activeProjects).toContain(FIXTURE_PROJECT);
+    // Tools section: 1x Bash + 1x Edit (PreToolUse aggregation)
+    expect(res.body.tools.totalCalls).toBeGreaterThanOrEqual(2);
+    const toolNames = res.body.tools.topTools.map((t: { name: string }) => t.name);
+    expect(toolNames).toContain('Bash');
+    expect(toolNames).toContain('Edit');
+  });
+
+  it('GET /api/insights summary.total equals patterns.length', async () => {
+    seedFixtureData(storage);
+    const res = await request(app).get('/api/insights').query({ days: 7 });
+    expect(res.status).toBe(200);
+    // Whatever patterns the detector returns, summary.total MUST match the
+    // patterns array length (locks the route's summarisation logic).
+    expect(res.body.summary.total).toBe(res.body.patterns.length);
+    // Severity buckets MUST exist as numeric fields.
+    expect(typeof res.body.summary.critical).toBe('number');
+    expect(typeof res.body.summary.warn).toBe('number');
+    expect(typeof res.body.summary.info).toBe('number');
+  });
+});

package/tests/integration/web-stats.integration.test.ts

@@ -0,0 +1,135 @@
+/**
+ * Integration safety-net for /api/stats.
+ *
+ * H2 Phase 1: lock the shape and baseline aggregation behaviour of the
+ * dashboard stats endpoint before migrating its inline SQL into the
+ * EventOperations / SessionOperations / SkillOperations layers.
+ *
+ * Coverage:
+ *   - Status 200 + presence of totalEvents / totalSessions / toolUsage /
+ *     dailyActivity / skillInvocations fields
+ *   - dailyActivity entry shape (date / eventCount / sessionCount)
+ *   - Tool usage aggregation with fixture data
+ *   - Skill invocation count with fixture data
+ *
+ * If this test fails, the H2 refactor commit must be reverted.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import express, { type Application } from 'express';
+import request from 'supertest';
+import { SQLiteStorage } from '../../src/core/storage/sqlite.js';
+import { registerStatsRoutes } from '../../src/web/routes/stats.js';
+
+const SESSION = 'sess-stats-int';
+const PROJECT = '/tmp/proj-stats-int';
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+describe('GET /api/stats (safety-net)', () => {
+  let app: Application;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    storage = new SQLiteStorage(':memory:');
+    app = express();
+    app.use(express.json());
+    registerStatsRoutes(app, { storage });
+  });
+
+  afterEach(() => {
+    storage.close();
+  });
+
+  it('returns the expected response shape with empty database', async () => {
+    const res = await request(app).get('/api/stats');
+    expect(res.status).toBe(200);
+
+    expect(res.body).toHaveProperty('totalEvents');
+    expect(res.body).toHaveProperty('totalSessions');
+    expect(res.body).toHaveProperty('toolUsage');
+    expect(res.body).toHaveProperty('dailyActivity');
+    expect(res.body).toHaveProperty('skillInvocations');
+
+    expect(typeof res.body.totalEvents).toBe('number');
+    expect(typeof res.body.totalSessions).toBe('number');
+    expect(typeof res.body.toolUsage).toBe('object');
+    expect(Array.isArray(res.body.dailyActivity)).toBe(true);
+    expect(typeof res.body.skillInvocations).toBe('number');
+
+    expect(res.body.totalEvents).toBe(0);
+    expect(res.body.totalSessions).toBe(0);
+    expect(res.body.skillInvocations).toBe(0);
+  });
+
+  it('aggregates totalEvents, totalSessions and toolUsage from events', async () => {
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'UserPromptSubmit', user_prompt: 'hi',
+    });
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Bash', tool_input: { command: 'ls' },
+    });
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Bash', tool_input: { command: 'pwd' },
+    });
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Edit', tool_input: { file_path: '/x' },
+    });
+
+    const res = await request(app).get('/api/stats');
+    expect(res.status).toBe(200);
+
+    expect(res.body.totalEvents).toBe(4);
+    expect(res.body.totalSessions).toBe(1);
+    expect(res.body.toolUsage.Bash).toBe(2);
+    expect(res.body.toolUsage.Edit).toBe(1);
+    expect(res.body.toolUsage).not.toHaveProperty('UserPromptSubmit');
+  });
+
+  it('dailyActivity entries have date / eventCount / sessionCount fields', async () => {
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Read',
+    });
+
+    const res = await request(app).get('/api/stats');
+    expect(res.status).toBe(200);
+    expect(res.body.dailyActivity.length).toBeGreaterThanOrEqual(1);
+
+    const entry = res.body.dailyActivity[0];
+    expect(entry).toHaveProperty('date');
+    expect(entry).toHaveProperty('eventCount');
+    expect(entry).toHaveProperty('sessionCount');
+    expect(typeof entry.date).toBe('string');
+    expect(typeof entry.eventCount).toBe('number');
+    expect(typeof entry.sessionCount).toBe('number');
+    expect(entry.eventCount).toBeGreaterThanOrEqual(1);
+  });
+
+  it('counts skill invocations independently of events', async () => {
+    storage.writeSkillInvocation({
+      id: 'si-int-1', route_request_id: null, session_id: SESSION,
+      agent_id: null, skill_id: 'official-tdd',
+      invocation_type: 'dynamic', reason: null,
+      workflow: null, phase: null, feature_slug: null, artifact_path: null,
+      depth: 0, success: 1, error: null, timestamp: Date.now(),
+    });
+    storage.writeSkillInvocation({
+      id: 'si-int-2', route_request_id: null, session_id: SESSION,
+      agent_id: null, skill_id: 'official-debug',
+      invocation_type: 'dynamic', reason: null,
+      workflow: null, phase: null, feature_slug: null, artifact_path: null,
+      depth: 0, success: 1, error: null, timestamp: Date.now(),
+    });
+
+    const res = await request(app).get('/api/stats');
+    expect(res.status).toBe(200);
+    expect(res.body.skillInvocations).toBe(2);
+  });
+});

package/tests/integration/web-trace.integration.test.ts

@@ -0,0 +1,175 @@
+/**
+ * Integration safety-net for /api/trace/:commit.
+ *
+ * H2 Phase 1: lock the response shape + error branches before migrating
+ * trace's inline SQL (event_breakdown / agent_calls / skills aggregation)
+ * into EventOperations / SkillOperations.
+ *
+ * Approach: spin up a real tmp git repository, create a commit, optionally
+ * attach a git note containing `forge-session: <id>`, then assert each
+ * branch of the route handler.
+ *
+ * Coverage:
+ *   - 400 when ?project query is missing / non-absolute / not a directory /
+ *     not a git repo
+ *   - 404 when commit ref cannot be resolved
+ *   - 200 with empty sessions[] when HEAD has no git note
+ *   - 200 with non-empty sessions[] (shape validated) when a note links to
+ *     a session row in storage
+ */
+
+import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
+import express, { type Application } from 'express';
+import request from 'supertest';
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { SQLiteStorage } from '../../src/core/storage/sqlite.js';
+import { registerTraceRoutes } from '../../src/web/routes/trace.js';
+
+const SESSION = 'sess-trace-int-abcdef01';
+
+function git(args: string[], cwd: string): string {
+  return execFileSync('git', args, {
+    cwd, stdio: 'pipe', timeout: 10000,
+    env: {
+      ...process.env,
+      GIT_AUTHOR_NAME: 'forge-test',
+      GIT_AUTHOR_EMAIL: 'forge@test.local',
+      GIT_COMMITTER_NAME: 'forge-test',
+      GIT_COMMITTER_EMAIL: 'forge@test.local',
+    },
+  }).toString().trim();
+}
+
+describe('GET /api/trace/:commit (safety-net)', () => {
+  let app: Application;
+  let storage: SQLiteStorage;
+  let repoDir: string;
+  let nonGitDir: string;
+  let commitWithNote: string;
+  let commitWithoutNote: string;
+
+  beforeAll(() => {
+    // 1) tmp git repo with two commits
+    repoDir = fs.mkdtempSync(path.join(os.tmpdir(), 'forge-trace-repo-'));
+    git(['init', '-q', '-b', 'main'], repoDir);
+    fs.writeFileSync(path.join(repoDir, 'a.txt'), 'one');
+    git(['add', '.'], repoDir);
+    git(['commit', '-q', '-m', 'first commit'], repoDir);
+    commitWithoutNote = git(['rev-parse', 'HEAD'], repoDir);
+
+    fs.writeFileSync(path.join(repoDir, 'b.txt'), 'two');
+    git(['add', '.'], repoDir);
+    git(['commit', '-q', '-m', 'second commit'], repoDir);
+    commitWithNote = git(['rev-parse', 'HEAD'], repoDir);
+
+    // Attach a git note to the second commit so the route can resolve a session
+    git(['notes', 'add', '-m', `forge-session: ${SESSION}`, commitWithNote], repoDir);
+
+    // 2) a sibling tmp directory that is *not* a git repo
+    nonGitDir = fs.mkdtempSync(path.join(os.tmpdir(), 'forge-trace-nogit-'));
+  });
+
+  afterAll(() => {
+    try { fs.rmSync(repoDir, { recursive: true, force: true }); } catch { /* ignore */ }
+    try { fs.rmSync(nonGitDir, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  beforeEach(() => {
+    storage = new SQLiteStorage(':memory:');
+    app = express();
+    app.use(express.json());
+    registerTraceRoutes(app, { storage });
+  });
+
+  afterEach(() => {
+    storage.close();
+  });
+
+  it('returns 400 when ?project query parameter is missing', async () => {
+    const res = await request(app).get(`/api/trace/${commitWithNote}`);
+    expect(res.status).toBe(400);
+    expect(res.body.error).toMatch(/project/i);
+  });
+
+  it('returns 400 when project path is relative', async () => {
+    const res = await request(app)
+      .get(`/api/trace/${commitWithNote}`)
+      .query({ project: 'relative/path' });
+    expect(res.status).toBe(400);
+    expect(res.body.error).toMatch(/absolute/i);
+  });
+
+  it('returns 400 when project path is not a git repo', async () => {
+    const res = await request(app)
+      .get(`/api/trace/${commitWithNote}`)
+      .query({ project: nonGitDir });
+    expect(res.status).toBe(400);
+    expect(res.body.error).toMatch(/git repository/i);
+  });
+
+  it('returns 404 when commit cannot be resolved', async () => {
+    const res = await request(app)
+      .get('/api/trace/nonexistent-commit-ref-zzz')
+      .query({ project: repoDir });
+    expect(res.status).toBe(404);
+    expect(res.body.error).toMatch(/resolve commit/i);
+  });
+
+  it('returns 200 with empty sessions[] when HEAD has no git note', async () => {
+    const res = await request(app)
+      .get(`/api/trace/${commitWithoutNote}`)
+      .query({ project: repoDir });
+    expect(res.status).toBe(200);
+    expect(res.body.commit).toBe(commitWithoutNote);
+    expect(typeof res.body.message).toBe('string');
+    expect(Array.isArray(res.body.sessions)).toBe(true);
+    expect(res.body.sessions).toEqual([]);
+  });
+
+  it('returns 200 with sessions[] entries when commit has a forge-session note', async () => {
+    // Seed storage so the session resolves; route looks up by session_id /
+    // session_id startsWith
+    storage.writeEvent({
+      session_id: SESSION,
+      project_path: repoDir,
+      timestamp: new Date().toISOString(),
+      hook_type: 'UserPromptSubmit',
+      user_prompt: 'hello',
+    });
+    storage.writeEvent({
+      session_id: SESSION,
+      project_path: repoDir,
+      timestamp: new Date().toISOString(),
+      hook_type: 'PreToolUse',
+      tool_name: 'Bash',
+      tool_input: { command: 'ls' },
+    });
+
+    const res = await request(app)
+      .get(`/api/trace/${commitWithNote}`)
+      .query({ project: repoDir });
+
+    expect(res.status).toBe(200);
+    expect(res.body.commit).toBe(commitWithNote);
+    expect(Array.isArray(res.body.sessions)).toBe(true);
+    expect(res.body.sessions.length).toBe(1);
+
+    const session = res.body.sessions[0];
+    // Session should have been found and hydrated with detail fields
+    expect(session.session_id).toBe(SESSION);
+    expect(session.found).toBe(true);
+    expect(session).toHaveProperty('event_count');
+    expect(session).toHaveProperty('event_breakdown');
+    expect(session).toHaveProperty('agent_calls');
+    expect(session).toHaveProperty('skills');
+    expect(typeof session.event_breakdown).toBe('object');
+    expect(Array.isArray(session.agent_calls)).toBe(true);
+    expect(Array.isArray(session.skills)).toBe(true);
+    // We wrote one PreToolUse + one UserPromptSubmit
+    expect(session.event_breakdown.PreToolUse).toBe(1);
+    expect(session.event_breakdown.UserPromptSubmit).toBe(1);
+  });
+});

package/tests/unit/core/forge-paths.test.ts

@@ -0,0 +1,99 @@
+/**
+ * Unit tests for FORGE_PATHS (src/core/constants.ts)
+ *
+ * Verifies that every path method returns a value prefixed by FORGE_HOME
+ * and matches the expected sub-path.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { join } from 'node:path';
+import { FORGE_HOME, FORGE_PATHS } from '../../../src/core/constants.js';
+
+describe('FORGE_PATHS', () => {
+  describe('existing methods', () => {
+    it('home() returns FORGE_HOME', () => {
+      expect(FORGE_PATHS.home()).toBe(FORGE_HOME);
+    });
+
+    it('config() returns FORGE_HOME/config.yaml', () => {
+      expect(FORGE_PATHS.config()).toBe(join(FORGE_HOME, 'config.yaml'));
+      expect(FORGE_PATHS.config().startsWith(FORGE_HOME)).toBe(true);
+    });
+
+    it('database() returns FORGE_HOME/data.db', () => {
+      expect(FORGE_PATHS.database()).toBe(join(FORGE_HOME, 'data.db'));
+      expect(FORGE_PATHS.database().startsWith(FORGE_HOME)).toBe(true);
+    });
+
+    it('logs() returns FORGE_HOME/logs', () => {
+      expect(FORGE_PATHS.logs()).toBe(join(FORGE_HOME, 'logs'));
+      expect(FORGE_PATHS.logs().startsWith(FORGE_HOME)).toBe(true);
+    });
+  });
+
+  describe('daemon runtime files', () => {
+    it('daemonSocket() returns FORGE_HOME/daemon.sock', () => {
+      expect(FORGE_PATHS.daemonSocket()).toBe(join(FORGE_HOME, 'daemon.sock'));
+      expect(FORGE_PATHS.daemonSocket().startsWith(FORGE_HOME)).toBe(true);
+    });
+
+    it('daemonPid() returns FORGE_HOME/daemon.pid', () => {
+      expect(FORGE_PATHS.daemonPid()).toBe(join(FORGE_HOME, 'daemon.pid'));
+      expect(FORGE_PATHS.daemonPid().startsWith(FORGE_HOME)).toBe(true);
+    });
+
+    it('daemonToken() returns FORGE_HOME/daemon.token', () => {
+      expect(FORGE_PATHS.daemonToken()).toBe(join(FORGE_HOME, 'daemon.token'));
+      expect(FORGE_PATHS.daemonToken().startsWith(FORGE_HOME)).toBe(true);
+    });
+
+    it('daemonLog() returns FORGE_HOME/daemon.log', () => {
+      expect(FORGE_PATHS.daemonLog()).toBe(join(FORGE_HOME, 'daemon.log'));
+      expect(FORGE_PATHS.daemonLog().startsWith(FORGE_HOME)).toBe(true);
+    });
+
+    it('daemonStdout() returns FORGE_HOME/daemon-stdout.log', () => {
+      expect(FORGE_PATHS.daemonStdout()).toBe(join(FORGE_HOME, 'daemon-stdout.log'));
+      expect(FORGE_PATHS.daemonStdout().startsWith(FORGE_HOME)).toBe(true);
+    });
+
+    it('daemonStderr() returns FORGE_HOME/daemon-stderr.log', () => {
+      expect(FORGE_PATHS.daemonStderr()).toBe(join(FORGE_HOME, 'daemon-stderr.log'));
+      expect(FORGE_PATHS.daemonStderr().startsWith(FORGE_HOME)).toBe(true);
+    });
+  });
+
+  describe('subdirs', () => {
+    it('hooks() returns FORGE_HOME/hooks', () => {
+      expect(FORGE_PATHS.hooks()).toBe(join(FORGE_HOME, 'hooks'));
+      expect(FORGE_PATHS.hooks().startsWith(FORGE_HOME)).toBe(true);
+    });
+
+    it('queue() returns FORGE_HOME/queue', () => {
+      expect(FORGE_PATHS.queue()).toBe(join(FORGE_HOME, 'queue'));
+      expect(FORGE_PATHS.queue().startsWith(FORGE_HOME)).toBe(true);
+    });
+
+    it('queueDead() returns FORGE_HOME/queue/dead', () => {
+      expect(FORGE_PATHS.queueDead()).toBe(join(FORGE_HOME, 'queue', 'dead'));
+      expect(FORGE_PATHS.queueDead().startsWith(FORGE_HOME)).toBe(true);
+    });
+  });
+
+  describe('patchable targets', () => {
+    it('routingYaml() returns FORGE_HOME/routing.yaml', () => {
+      expect(FORGE_PATHS.routingYaml()).toBe(join(FORGE_HOME, 'routing.yaml'));
+      expect(FORGE_PATHS.routingYaml().startsWith(FORGE_HOME)).toBe(true);
+    });
+
+    it("backups('skills') returns FORGE_HOME/backups/skills", () => {
+      expect(FORGE_PATHS.backups('skills')).toBe(join(FORGE_HOME, 'backups', 'skills'));
+      expect(FORGE_PATHS.backups('skills').startsWith(FORGE_HOME)).toBe(true);
+    });
+
+    it("backups('routing') returns FORGE_HOME/backups/routing", () => {
+      expect(FORGE_PATHS.backups('routing')).toBe(join(FORGE_HOME, 'backups', 'routing'));
+      expect(FORGE_PATHS.backups('routing').startsWith(FORGE_HOME)).toBe(true);
+    });
+  });
+});