gru-ai 0.1.0

package/dist-server/server/parsers/task-parser.d.ts

@@ -0,0 +1,10 @@
+import type { TeamTask } from '../types.js';
+export declare function parseTeamTasks(claudeHome: string, teamName: string): TeamTask[];
+export declare function parseAllTeamTasks(claudeHome: string, teamNames: string[]): Record<string, TeamTask[]>;
+/**
+ * Parse all task directories, splitting into team-named and UUID-named (session) dirs.
+ */
+export declare function parseAllTasks(claudeHome: string, knownTeamNames: Set<string>): {
+    byTeam: Record<string, TeamTask[]>;
+    bySession: Record<string, TeamTask[]>;
+};

package/dist-server/server/parsers/task-parser.js

@@ -0,0 +1,97 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const UUID_DIR_REGEX = /^[0-9a-f]{8}-/;
+function normalizeStatus(raw) {
+    if (!raw)
+        return 'pending';
+    const lower = raw.toLowerCase().trim();
+    if (lower === 'completed' || lower === 'done')
+        return 'completed';
+    if (lower === 'in_progress' || lower === 'in-progress')
+        return 'in_progress';
+    return 'pending';
+}
+function parseRawTask(raw) {
+    return {
+        id: raw.id ?? '',
+        subject: raw.subject ?? '',
+        description: raw.description ?? '',
+        activeForm: raw.activeForm ?? '',
+        status: normalizeStatus(raw.status),
+        owner: raw.owner ?? '',
+        blocks: raw.blocks ?? [],
+        blockedBy: raw.blockedBy ?? [],
+    };
+}
+export function parseTeamTasks(claudeHome, teamName) {
+    const tasksDir = path.join(claudeHome, 'tasks', teamName);
+    try {
+        if (!fs.existsSync(tasksDir))
+            return [];
+        const entries = fs.readdirSync(tasksDir, { withFileTypes: true });
+        const tasks = [];
+        for (const entry of entries) {
+            // Skip non-JSON files
+            if (!entry.isFile() || !entry.name.endsWith('.json'))
+                continue;
+            const filePath = path.join(tasksDir, entry.name);
+            try {
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const raw = JSON.parse(content);
+                tasks.push(parseRawTask(raw));
+            }
+            catch {
+                // Skip malformed files
+            }
+        }
+        return tasks;
+    }
+    catch {
+        return [];
+    }
+}
+export function parseAllTeamTasks(claudeHome, teamNames) {
+    const result = {};
+    for (const teamName of teamNames) {
+        result[teamName] = parseTeamTasks(claudeHome, teamName);
+    }
+    return result;
+}
+/**
+ * Parse all task directories, splitting into team-named and UUID-named (session) dirs.
+ */
+export function parseAllTasks(claudeHome, knownTeamNames) {
+    const tasksRoot = path.join(claudeHome, 'tasks');
+    const byTeam = {};
+    const bySession = {};
+    let dirs;
+    try {
+        dirs = fs.readdirSync(tasksRoot).filter((d) => {
+            try {
+                return fs.statSync(path.join(tasksRoot, d)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    catch {
+        return { byTeam, bySession };
+    }
+    for (const dirName of dirs) {
+        const tasks = parseTeamTasks(claudeHome, dirName);
+        if (tasks.length === 0)
+            continue;
+        if (knownTeamNames.has(dirName)) {
+            byTeam[dirName] = tasks;
+        }
+        else if (UUID_DIR_REGEX.test(dirName)) {
+            bySession[dirName] = tasks;
+        }
+        else {
+            // Unknown non-UUID dir — include in byTeam as a fallback
+            byTeam[dirName] = tasks;
+        }
+    }
+    return { byTeam, bySession };
+}

package/dist-server/server/parsers/team-parser.d.ts

@@ -0,0 +1,3 @@
+import type { Team } from '../types.js';
+export declare function parseTeamConfig(filePath: string): Team | null;
+export declare function parseAllTeams(claudeHome: string): Team[];

package/dist-server/server/parsers/team-parser.js

@@ -0,0 +1,67 @@
+import fs from 'node:fs';
+import path from 'node:path';
+function parseTimestamp(raw) {
+    if (typeof raw === 'number')
+        return new Date(raw).toISOString();
+    if (typeof raw === 'string')
+        return raw;
+    return new Date().toISOString();
+}
+function parseMember(raw) {
+    return {
+        name: raw.name ?? 'unnamed',
+        agentId: raw.agentId ?? '',
+        agentType: raw.agentType ?? 'unknown',
+        model: raw.model ?? '',
+        tmuxPaneId: raw.tmuxPaneId ?? '',
+        cwd: raw.cwd ?? '',
+        color: raw.color ?? '',
+        isActive: raw.isActive ?? false,
+        backendType: raw.backendType ?? '',
+        joinedAt: parseTimestamp(raw.joinedAt),
+    };
+}
+export function parseTeamConfig(filePath) {
+    try {
+        if (!fs.existsSync(filePath))
+            return null;
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const raw = JSON.parse(content);
+        const members = (raw.members ?? []).map(parseMember);
+        return {
+            name: raw.name ?? path.basename(path.dirname(filePath)),
+            description: raw.description ?? '',
+            members,
+            createdAt: parseTimestamp(raw.createdAt),
+            leadAgentId: raw.leadAgentId ?? '',
+            leadSessionId: raw.leadSessionId ?? '',
+            stale: false,
+        };
+    }
+    catch (err) {
+        console.error(`[team-parser] Error parsing ${filePath}:`, err);
+        return null;
+    }
+}
+export function parseAllTeams(claudeHome) {
+    const teamsDir = path.join(claudeHome, 'teams');
+    const teams = [];
+    try {
+        if (!fs.existsSync(teamsDir))
+            return [];
+        const entries = fs.readdirSync(teamsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const configPath = path.join(teamsDir, entry.name, 'config.json');
+            const team = parseTeamConfig(configPath);
+            if (team) {
+                teams.push(team);
+            }
+        }
+    }
+    catch (err) {
+        console.error(`[team-parser] Error scanning teams directory:`, err);
+    }
+    return teams;
+}

package/dist-server/server/platform/__tests__/claude-code.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist-server/server/platform/__tests__/claude-code.test.js

@@ -0,0 +1,311 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { ClaudeCodeAdapter } from '../claude-code.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+let tmpDir;
+/** Write a JSONL file from an array of entry objects. */
+function writeJsonl(filePath, entries) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const content = entries.map((e) => JSON.stringify(e)).join('\n') + '\n';
+    fs.writeFileSync(filePath, content, 'utf-8');
+}
+const ts = (offset) => `2026-02-23T10:00:${String(offset).padStart(2, '0')}Z`;
+function userPrompt(text, extra = {}) {
+    return {
+        type: 'user',
+        message: { role: 'user', content: [{ type: 'text', text }] },
+        timestamp: ts(0),
+        ...extra,
+    };
+}
+function assistantText(text, extra = {}) {
+    return {
+        type: 'assistant',
+        message: { role: 'assistant', content: [{ type: 'text', text }] },
+        timestamp: ts(1),
+        ...extra,
+    };
+}
+function assistantToolUse(toolName, input = {}) {
+    return {
+        type: 'assistant',
+        message: {
+            role: 'assistant',
+            content: [
+                { type: 'text', text: 'Let me check.' },
+                { type: 'tool_use', name: toolName, input },
+            ],
+        },
+        timestamp: ts(2),
+    };
+}
+function turnEnd() {
+    return { type: 'system', subtype: 'turn_duration', timestamp: ts(4) };
+}
+/** Create a stub AggregatorHandle for factory method tests. */
+function stubAggregator() {
+    return {
+        refreshSessions() { },
+        updateSessionFromFileState() { },
+        refreshTeams() { },
+        refreshTasks() { },
+    };
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-code-adapter-test-'));
+});
+after(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+// ===========================================================================
+// 1. Constructor
+// ===========================================================================
+describe('ClaudeCodeAdapter constructor', () => {
+    it('creates adapter with empty state maps', () => {
+        const adapter = new ClaudeCodeAdapter(tmpDir);
+        assert.equal(adapter.fileStates.size, 0, 'fileStates should be empty');
+        assert.equal(adapter.parentAgentMapCache.size, 0, 'parentAgentMapCache should be empty');
+    });
+});
+// ===========================================================================
+// 2. getPlatformCapabilities
+// ===========================================================================
+describe('getPlatformCapabilities', () => {
+    it('returns correct feature flags for Claude Code', () => {
+        const adapter = new ClaudeCodeAdapter(tmpDir);
+        const caps = adapter.getPlatformCapabilities();
+        assert.equal(caps.supportsFileWatching, true);
+        assert.equal(caps.supportsIncrementalReads, true);
+        assert.equal(caps.supportsCLISpawn, true);
+        assert.equal(caps.supportsMCP, true);
+        assert.equal(caps.supportsSubagents, true);
+        assert.equal(caps.supportsTokenTracking, false);
+    });
+});
+// ===========================================================================
+// 3. discoverSessionFiles
+// ===========================================================================
+describe('discoverSessionFiles', () => {
+    it('discovers JSONL session files from a mock claudeHome', () => {
+        const claudeHome = path.join(tmpDir, 'discover-test');
+        const projectDir = path.join(claudeHome, 'projects', 'test-project');
+        fs.mkdirSync(projectDir, { recursive: true });
+        // Create a session JSONL file
+        const sessionFile = path.join(projectDir, 'abc123.jsonl');
+        writeJsonl(sessionFile, [
+            userPrompt('Hello', { sessionId: 'abc123' }),
+        ]);
+        // Create a non-JSONL file that should be ignored
+        fs.writeFileSync(path.join(projectDir, 'notes.txt'), 'not a session');
+        const adapter = new ClaudeCodeAdapter(claudeHome);
+        const discovered = adapter.discoverSessionFiles();
+        assert.ok(discovered instanceof Map, 'should return a Map');
+        assert.equal(discovered.size, 1, 'should find exactly 1 session file');
+        const entry = discovered.get(sessionFile);
+        assert.ok(entry, 'should contain the JSONL file path as key');
+        assert.equal(entry.sessionId, 'abc123');
+        assert.equal(entry.isSubagent, false);
+    });
+});
+// ===========================================================================
+// 4. getAllFileStates
+// ===========================================================================
+describe('getAllFileStates', () => {
+    it('returns empty map initially (before any bootstrap)', () => {
+        const adapter = new ClaudeCodeAdapter(path.join(tmpDir, 'empty-states'));
+        const states = adapter.getAllFileStates();
+        assert.ok(states instanceof Map, 'should return a Map');
+        assert.equal(states.size, 0, 'should be empty before any initialization');
+    });
+});
+// ===========================================================================
+// 5. getAgentState
+// ===========================================================================
+describe('getAgentState', () => {
+    it('maps machineState=working to "working"', () => {
+        const claudeHome = path.join(tmpDir, 'agent-state-test');
+        const projectDir = path.join(claudeHome, 'projects', 'test-project');
+        fs.mkdirSync(projectDir, { recursive: true });
+        const sessionFile = path.join(projectDir, 'sess-working.jsonl');
+        writeJsonl(sessionFile, [
+            userPrompt('Do something', { sessionId: 'sess-working' }),
+            assistantToolUse('Read', { file_path: '/foo.ts' }),
+        ]);
+        const adapter = new ClaudeCodeAdapter(claudeHome);
+        adapter.initializeAllFileStates();
+        const state = adapter.getOrBootstrap(sessionFile);
+        assert.ok(state, 'should bootstrap the session');
+        assert.equal(state.machineState, 'working');
+        assert.equal(adapter.getAgentState(state), 'working');
+    });
+    it('maps machineState=needs_input to "needs_input"', () => {
+        const claudeHome = path.join(tmpDir, 'agent-state-test-2');
+        const projectDir = path.join(claudeHome, 'projects', 'test-project');
+        fs.mkdirSync(projectDir, { recursive: true });
+        const sessionFile = path.join(projectDir, 'sess-input.jsonl');
+        writeJsonl(sessionFile, [
+            userPrompt('Help', { sessionId: 'sess-input' }),
+            assistantText('Should I proceed?'),
+        ]);
+        const adapter = new ClaudeCodeAdapter(claudeHome);
+        const state = adapter.getOrBootstrap(sessionFile);
+        assert.ok(state);
+        assert.equal(state.machineState, 'needs_input');
+        assert.equal(adapter.getAgentState(state), 'needs_input');
+    });
+    it('maps machineState=done to "done"', () => {
+        const claudeHome = path.join(tmpDir, 'agent-state-test-3');
+        const projectDir = path.join(claudeHome, 'projects', 'test-project');
+        fs.mkdirSync(projectDir, { recursive: true });
+        const sessionFile = path.join(projectDir, 'sess-done.jsonl');
+        writeJsonl(sessionFile, [
+            userPrompt('Explain', { sessionId: 'sess-done' }),
+            assistantText('Here is the answer.'),
+            turnEnd(),
+        ]);
+        const adapter = new ClaudeCodeAdapter(claudeHome);
+        const state = adapter.getOrBootstrap(sessionFile);
+        assert.ok(state);
+        assert.equal(state.machineState, 'done');
+        assert.equal(adapter.getAgentState(state), 'done');
+    });
+});
+// ===========================================================================
+// 6. toSessionActivity
+// ===========================================================================
+describe('toSessionActivity', () => {
+    it('returns null for states without sessionId', () => {
+        const claudeHome = path.join(tmpDir, 'activity-null-test');
+        const projectDir = path.join(claudeHome, 'projects', 'test-project');
+        fs.mkdirSync(projectDir, { recursive: true });
+        const sessionFile = path.join(projectDir, 'no-session-id.jsonl');
+        writeJsonl(sessionFile, [
+            // No sessionId in any entry
+            { type: 'user', message: { role: 'user', content: [{ type: 'text', text: 'Hi' }] }, timestamp: ts(0) },
+        ]);
+        const adapter = new ClaudeCodeAdapter(claudeHome);
+        const state = adapter.getOrBootstrap(sessionFile);
+        assert.ok(state);
+        assert.equal(state.sessionId, undefined);
+        const activity = adapter.toSessionActivity(state);
+        assert.equal(activity, null);
+    });
+    it('returns activity object for states with sessionId', () => {
+        const claudeHome = path.join(tmpDir, 'activity-valid-test');
+        const projectDir = path.join(claudeHome, 'projects', 'test-project');
+        fs.mkdirSync(projectDir, { recursive: true });
+        const sessionFile = path.join(projectDir, 'has-session.jsonl');
+        writeJsonl(sessionFile, [
+            userPrompt('Check file', { sessionId: 'sess-activity' }),
+            assistantToolUse('Read', { file_path: '/src/index.ts' }),
+        ]);
+        const adapter = new ClaudeCodeAdapter(claudeHome);
+        const state = adapter.getOrBootstrap(sessionFile);
+        assert.ok(state);
+        // Make it look recent so active=true
+        state.mtimeMs = Date.now();
+        const activity = adapter.toSessionActivity(state);
+        assert.ok(activity);
+        assert.equal(activity.sessionId, 'sess-activity');
+        assert.equal(activity.tool, 'Read');
+        assert.equal(activity.active, true);
+    });
+});
+// ===========================================================================
+// 7. loadConfig
+// ===========================================================================
+describe('loadConfig', () => {
+    it('returns a valid ConductorConfig', () => {
+        const adapter = new ClaudeCodeAdapter(tmpDir);
+        const config = adapter.loadConfig();
+        assert.ok(config, 'config should not be null');
+        assert.ok(Array.isArray(config.projects), 'projects should be an array');
+        assert.ok(typeof config.claudeHome === 'string', 'claudeHome should be a string');
+        assert.ok(config.server, 'server config should exist');
+        assert.ok(typeof config.server.port === 'number', 'server.port should be a number');
+    });
+});
+// ===========================================================================
+// 8. createSessionWatcher
+// ===========================================================================
+describe('createSessionWatcher', () => {
+    it('returns object with start/stop/ready', () => {
+        const claudeHome = path.join(tmpDir, 'watcher-test');
+        fs.mkdirSync(claudeHome, { recursive: true });
+        const adapter = new ClaudeCodeAdapter(claudeHome);
+        const agg = stubAggregator();
+        const watcher = adapter.createSessionWatcher(agg);
+        assert.ok(watcher, 'watcher should not be null');
+        assert.equal(typeof watcher.start, 'function', 'should have start()');
+        assert.equal(typeof watcher.stop, 'function', 'should have stop()');
+        assert.equal(typeof watcher.ready, 'boolean', 'should have ready property');
+        assert.equal(watcher.ready, false, 'should not be ready before start');
+    });
+});
+// ===========================================================================
+// 9. createMetadataWatcher
+// ===========================================================================
+describe('createMetadataWatcher', () => {
+    it('returns a ClaudeWatcher instance (not null)', () => {
+        const claudeHome = path.join(tmpDir, 'meta-watcher-test');
+        fs.mkdirSync(claudeHome, { recursive: true });
+        const adapter = new ClaudeCodeAdapter(claudeHome);
+        const agg = stubAggregator();
+        const watcher = adapter.createMetadataWatcher(agg);
+        assert.ok(watcher !== null, 'Claude Code should always return a metadata watcher');
+        assert.equal(typeof watcher.start, 'function');
+        assert.equal(typeof watcher.stop, 'function');
+    });
+});
+// ===========================================================================
+// 10. processFileUpdate + removeFileState (instance isolation)
+// ===========================================================================
+describe('Instance isolation', () => {
+    it('two adapters maintain separate fileStates', () => {
+        const claudeHome1 = path.join(tmpDir, 'iso-test-1');
+        const claudeHome2 = path.join(tmpDir, 'iso-test-2');
+        const projectDir1 = path.join(claudeHome1, 'projects', 'proj');
+        const projectDir2 = path.join(claudeHome2, 'projects', 'proj');
+        fs.mkdirSync(projectDir1, { recursive: true });
+        fs.mkdirSync(projectDir2, { recursive: true });
+        const file1 = path.join(projectDir1, 's1.jsonl');
+        const file2 = path.join(projectDir2, 's2.jsonl');
+        writeJsonl(file1, [userPrompt('A', { sessionId: 'iso-1' })]);
+        writeJsonl(file2, [userPrompt('B', { sessionId: 'iso-2' })]);
+        const adapter1 = new ClaudeCodeAdapter(claudeHome1);
+        const adapter2 = new ClaudeCodeAdapter(claudeHome2);
+        adapter1.initializeAllFileStates();
+        adapter2.initializeAllFileStates();
+        // Each adapter sees only its own sessions
+        assert.equal(adapter1.getAllFileStates().size, 1);
+        assert.equal(adapter2.getAllFileStates().size, 1);
+        const state1 = adapter1.getOrBootstrap(file1);
+        assert.ok(state1);
+        assert.equal(state1.sessionId, 'iso-1');
+        const state2 = adapter2.getOrBootstrap(file2);
+        assert.ok(state2);
+        assert.equal(state2.sessionId, 'iso-2');
+        // Remove from adapter1 should not affect adapter2
+        adapter1.removeFileState(file1);
+        assert.equal(adapter1.getAllFileStates().size, 0);
+        assert.equal(adapter2.getAllFileStates().size, 1);
+    });
+});
+// ===========================================================================
+// 11. discoverProjects
+// ===========================================================================
+describe('discoverProjects', () => {
+    it('returns an array (possibly empty for temp dir)', () => {
+        const adapter = new ClaudeCodeAdapter(tmpDir);
+        const projects = adapter.discoverProjects();
+        assert.ok(Array.isArray(projects), 'should return an array');
+    });
+});

package/dist-server/server/platform/claude-code.d.ts

@@ -0,0 +1,34 @@
+/**
+ * ClaudeCodeAdapter -- PlatformAdapter implementation for Claude Code.
+ *
+ * Wraps existing session-state and session-scanner logic behind the
+ * PlatformAdapter interface (Strangler Fig pattern). Singleton state
+ * (fileStates Map, parentAgentMapCache) is moved to instance properties.
+ */
+import type { PlatformAdapter, PlatformCapabilities, AggregatorHandle, AgentState, SessionWatcher as SessionWatcherInterface, MetadataWatcher as MetadataWatcherInterface } from './types.js';
+import type { SessionActivity, ProjectConfig, ConductorConfig } from '../types.js';
+import type { SessionFileState, DiscoveredFile } from '../parsers/session-state.js';
+export declare class ClaudeCodeAdapter implements PlatformAdapter {
+    /** Instance-level session file state map (replaces module-level singleton). */
+    readonly fileStates: Map<string, SessionFileState>;
+    /** Instance-level parent agent map cache (replaces module-level singleton). */
+    readonly parentAgentMapCache: Map<string, {
+        mtime: number;
+        map: Map<string, string>;
+    }>;
+    private readonly claudeHome;
+    constructor(claudeHome: string);
+    discoverSessionFiles(projectFilter?: string): Map<string, DiscoveredFile>;
+    initializeAllFileStates(projectFilter?: string): Map<string, DiscoveredFile>;
+    processFileUpdate(filePath: string): SessionFileState | null;
+    getOrBootstrap(filePath: string): SessionFileState | null;
+    removeFileState(filePath: string): void;
+    getAllFileStates(): Map<string, SessionFileState>;
+    toSessionActivity(state: SessionFileState): SessionActivity | null;
+    getAgentState(state: SessionFileState): AgentState;
+    createSessionWatcher(aggregator: AggregatorHandle, projectFilter?: string): SessionWatcherInterface;
+    createMetadataWatcher(aggregator: AggregatorHandle): MetadataWatcherInterface | null;
+    discoverProjects(): ProjectConfig[];
+    loadConfig(): ConductorConfig;
+    getPlatformCapabilities(): PlatformCapabilities;
+}

package/dist-server/server/platform/claude-code.js

@@ -0,0 +1,94 @@
+/**
+ * ClaudeCodeAdapter -- PlatformAdapter implementation for Claude Code.
+ *
+ * Wraps existing session-state and session-scanner logic behind the
+ * PlatformAdapter interface (Strangler Fig pattern). Singleton state
+ * (fileStates Map, parentAgentMapCache) is moved to instance properties.
+ */
+import { initializeAllFileStates, discoverSessionFiles, getAllFileStates as getAllFileStatesRaw, getOrBootstrap as getOrBootstrapRaw, removeFileState as removeFileStateRaw, processFileUpdate as processFileUpdateRaw, toSessionActivity as toSessionActivityRaw, machineStateToLastEntryType, } from '../parsers/session-state.js';
+import { discoverProjects, loadConfig } from '../config.js';
+import { SessionWatcher } from '../watchers/session-watcher.js';
+import { ClaudeWatcher } from '../watchers/claude-watcher.js';
+export class ClaudeCodeAdapter {
+    /** Instance-level session file state map (replaces module-level singleton). */
+    fileStates = new Map();
+    /** Instance-level parent agent map cache (replaces module-level singleton). */
+    parentAgentMapCache = new Map();
+    claudeHome;
+    constructor(claudeHome) {
+        this.claudeHome = claudeHome;
+    }
+    // -------------------------------------------------------------------------
+    // Core state methods
+    // -------------------------------------------------------------------------
+    discoverSessionFiles(projectFilter) {
+        return discoverSessionFiles(this.claudeHome, projectFilter);
+    }
+    initializeAllFileStates(projectFilter) {
+        return initializeAllFileStates(this.claudeHome, projectFilter, this.fileStates);
+    }
+    processFileUpdate(filePath) {
+        return processFileUpdateRaw(filePath, this.fileStates);
+    }
+    getOrBootstrap(filePath) {
+        return getOrBootstrapRaw(filePath, this.fileStates);
+    }
+    removeFileState(filePath) {
+        removeFileStateRaw(filePath, this.fileStates);
+    }
+    getAllFileStates() {
+        return getAllFileStatesRaw(this.fileStates);
+    }
+    // -------------------------------------------------------------------------
+    // Conversion methods
+    // -------------------------------------------------------------------------
+    toSessionActivity(state) {
+        return toSessionActivityRaw(state);
+    }
+    getAgentState(state) {
+        const lastEntryType = machineStateToLastEntryType(state);
+        switch (lastEntryType) {
+            case 'assistant-tool':
+                return 'working';
+            case 'assistant-question':
+                return 'needs_input';
+            case 'assistant-text':
+                return 'done';
+            case 'user':
+                return 'working';
+            default:
+                return 'unknown';
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Factory methods
+    // -------------------------------------------------------------------------
+    createSessionWatcher(aggregator, projectFilter) {
+        return new SessionWatcher(aggregator, this.claudeHome, projectFilter, this);
+    }
+    createMetadataWatcher(aggregator) {
+        return new ClaudeWatcher(aggregator, this.claudeHome);
+    }
+    // -------------------------------------------------------------------------
+    // Config methods
+    // -------------------------------------------------------------------------
+    discoverProjects() {
+        return discoverProjects(this.claudeHome);
+    }
+    loadConfig() {
+        return loadConfig();
+    }
+    // -------------------------------------------------------------------------
+    // Capability method
+    // -------------------------------------------------------------------------
+    getPlatformCapabilities() {
+        return {
+            supportsFileWatching: true,
+            supportsIncrementalReads: true,
+            supportsCLISpawn: true,
+            supportsMCP: true,
+            supportsSubagents: true,
+            supportsTokenTracking: false,
+        };
+    }
+}

package/dist-server/server/platform/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Platform adapter module -- re-exports all types from the platform boundary.
+ */
+export type { AggregatorHandle, AgentState, PlatformCapabilities, SessionWatcher, MetadataWatcher, PlatformAdapter, } from './types.js';
+export { ClaudeCodeAdapter } from './claude-code.js';

package/dist-server/server/platform/index.js

@@ -0,0 +1 @@
+export { ClaudeCodeAdapter } from './claude-code.js';