create-claude-workspace 1.1.152 → 2.1.0

package/dist/scheduler/loop.mjs

@@ -0,0 +1,435 @@
+// ─── Main orchestration loop: pipeline state machine ───
+// Picks tasks, assigns to workers, advances through plan→implement→test→review→commit→merge.
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { parseTodoMd, updateTaskCheckbox } from './tasks/parser.mjs';
+import { buildGraph, getParallelBatches, isPhaseComplete, getNextPhase, isProjectComplete } from './tasks/queue.mjs';
+import { writeState, appendEvent, createEvent, rotateLog } from './state/state.mjs';
+import { recordSession, getSession, clearSession } from './state/session.mjs';
+import { createWorktree, commitInWorktree, getChangedFiles, cleanupWorktree, mergeToMain, syncMain, pushWorktree } from './git/manager.mjs';
+import { scanAgents } from './agents/health-checker.mjs';
+import { watchPipeline, detectCIPlatform } from './git/ci-watcher.mjs';
+import { createRelease } from './git/release.mjs';
+import { processInbox, addTaskMessageToTask } from './tasks/inbox.mjs';
+import { buildPlanPrompt, buildImplementPrompt, buildTestPrompt, buildReviewPrompt, buildReworkPrompt, } from './agents/prompt-builder.mjs';
+const MAX_REVIEW_CYCLES = 5;
+const MAX_BUILD_FIXES = 3;
+const MAX_CI_FIXES = 3;
+/**
+ * Run one iteration of the scheduler loop.
+ * Returns true if work was done, false if idle.
+ */
+export async function runIteration(deps) {
+    const { pool, orchestrator, state, opts, logger } = deps;
+    const projectDir = opts.projectDir;
+    // Rotate log if needed
+    rotateLog(projectDir);
+    // Process inbox — immediate, non-blocking
+    const inboxMessages = processInbox(projectDir);
+    for (const msg of inboxMessages) {
+        if (msg.type === 'add-task') {
+            const addMsg = msg;
+            const nextId = `inbox-${Date.now()}`;
+            const newTask = addTaskMessageToTask(addMsg, state.currentPhase, nextId);
+            logger.info(`[inbox] New task: ${newTask.title}`);
+            appendEvent(projectDir, createEvent('task_started', { taskId: nextId, detail: `inbox: ${newTask.title}` }));
+            // Task will be picked up when we load tasks below
+        }
+        else if (msg.type === 'message') {
+            const freeMsg = msg;
+            logger.info(`[inbox] User message: ${freeMsg.text}`);
+            // Forward to orchestrator for interpretation
+            try {
+                const slot = pool.idleSlot();
+                if (slot) {
+                    await orchestrator.consult(`User sent this message during autonomous development:\n\n"${freeMsg.text}"\n\nAcknowledge and adjust your approach if needed. Respond briefly.`);
+                }
+            }
+            catch { /* best-effort */ }
+        }
+        else if (msg.type === 'stop') {
+            logger.info('[inbox] Stop requested by user');
+            return false;
+        }
+        else if (msg.type === 'pause') {
+            logger.info('[inbox] Pause requested — waiting for resume');
+            // Caller (scheduler.mts) handles pause state
+        }
+    }
+    // Load tasks
+    const todoPath = resolve(projectDir, '.claude/scheduler/tasks.json');
+    const todoMdPath = resolve(projectDir, 'TODO.md');
+    let tasks;
+    if (existsSync(todoPath)) {
+        tasks = loadTasksJson(todoPath);
+    }
+    else if (existsSync(todoMdPath)) {
+        // Fallback: parse TODO.md
+        const content = readFileSync(todoMdPath, 'utf-8');
+        tasks = parseTodoMd(content);
+    }
+    else {
+        logger.info('No tasks found (no tasks.json or TODO.md)');
+        return false;
+    }
+    // Check project completion
+    if (isProjectComplete(tasks)) {
+        logger.info('All tasks complete.');
+        return false;
+    }
+    // Scan agents
+    const agents = scanAgents(projectDir);
+    // Build dependency graph
+    const graph = buildGraph(tasks);
+    const cycle = graph.findCycle();
+    if (cycle) {
+        logger.error(`Dependency cycle detected: ${cycle.join(' → ')}`);
+        return false;
+    }
+    // Get runnable tasks
+    const runnable = graph.runnable();
+    if (runnable.length === 0) {
+        logger.info('No runnable tasks (all blocked by dependencies)');
+        return false;
+    }
+    // Check for phase transition
+    const currentPhase = state.currentPhase;
+    if (isPhaseComplete(tasks, currentPhase)) {
+        const next = getNextPhase(tasks);
+        if (next !== null && next !== currentPhase) {
+            logger.info(`Phase ${currentPhase} complete → advancing to Phase ${next}`);
+            state.currentPhase = next;
+            // Release for completed phase
+            const phaseTasks = tasks.filter(t => t.phase === currentPhase && t.status === 'done');
+            if (phaseTasks.length > 0) {
+                const release = createRelease(projectDir, phaseTasks, currentPhase);
+                if (release) {
+                    logger.info(`Release ${release.version} created for Phase ${currentPhase}`);
+                    appendEvent(projectDir, createEvent('release', { detail: release.version }));
+                }
+            }
+            appendEvent(projectDir, createEvent('phase_transition', { detail: `Phase ${currentPhase} → ${next}` }));
+            writeState(projectDir, state);
+        }
+    }
+    // Get parallel batches
+    const batches = getParallelBatches(runnable);
+    if (batches.length === 0)
+        return false;
+    const batch = batches[0];
+    const availableSlots = opts.concurrency - pool.activeCount();
+    const tasksToRun = batch.slice(0, availableSlots);
+    const queued = batch.length - tasksToRun.length;
+    if (tasksToRun.length === 0) {
+        logger.info(`All ${opts.concurrency} workers busy. ${batch.length} tasks queued.`);
+        return false;
+    }
+    if (queued > 0) {
+        logger.info(`Starting ${tasksToRun.length} tasks, ${queued} queued (waiting for workers)`);
+    }
+    // Process each task through the pipeline
+    let workDone = false;
+    for (const task of tasksToRun) {
+        const slot = pool.idleSlot();
+        if (!slot)
+            break;
+        try {
+            const success = await runTaskPipeline(task, slot.id, agents, deps);
+            workDone = true;
+            if (success) {
+                task.status = 'done';
+                state.completedTasks.push(task.id);
+                updateTodoFile(projectDir, task, 'done');
+                appendEvent(projectDir, createEvent('task_completed', { taskId: task.id }));
+            }
+            else {
+                task.status = 'skipped';
+                state.skippedTasks.push(task.id);
+                updateTodoFile(projectDir, task, 'skipped');
+                appendEvent(projectDir, createEvent('task_skipped', { taskId: task.id }));
+            }
+        }
+        catch (err) {
+            logger.error(`Task ${task.id} failed: ${err.message}`);
+            task.status = 'skipped';
+            state.skippedTasks.push(task.id);
+            updateTodoFile(projectDir, task, 'skipped');
+            appendEvent(projectDir, createEvent('error', { taskId: task.id, detail: err.message }));
+        }
+        writeState(projectDir, state);
+    }
+    state.iteration++;
+    writeState(projectDir, state);
+    return workDone;
+}
+// ─── Pipeline execution ───
+async function runTaskPipeline(task, workerId, agents, deps) {
+    const { pool, orchestrator, state, opts, logger } = deps;
+    const projectDir = opts.projectDir;
+    // Create worktree
+    const slug = taskToSlug(task);
+    const worktreePath = createWorktree(projectDir, slug);
+    logger.info(`[${task.id}] Worktree created: ${slug}`);
+    // Initialize pipeline state
+    const pipeline = {
+        taskId: task.id,
+        workerId,
+        worktreePath,
+        step: 'plan',
+        architectPlan: null,
+        apiContract: null,
+        reviewFindings: null,
+        testingSection: null,
+        reviewCycles: 0,
+        ciFixes: 0,
+        buildFixes: 0,
+        assignedAgent: null,
+    };
+    state.pipelines[task.id] = pipeline;
+    try {
+        // Route task to agent
+        const routing = await orchestrator.routeTask(task, 'plan', agents);
+        pipeline.assignedAgent = routing.agent;
+        if (routing.create) {
+            // Auto-create new agent
+            await createAgentFile(projectDir, routing.create);
+            pipeline.assignedAgent = routing.create.name;
+            appendEvent(projectDir, createEvent('agent_created', { agentType: routing.create.name }));
+        }
+        // STEP 1: Plan
+        pipeline.step = 'plan';
+        appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'plan' }));
+        const planResult = await spawnAgent(pool, workerId, {
+            agent: pipeline.assignedAgent ?? undefined,
+            cwd: worktreePath,
+            prompt: buildPlanPrompt({ task, worktreePath, projectDir }),
+            model: getAgentModel(pipeline.assignedAgent, agents),
+        }, state, task.id, logger);
+        if (!planResult.success) {
+            logger.error(`[${task.id}] Planning failed: ${planResult.error}`);
+            return false;
+        }
+        pipeline.architectPlan = planResult.output;
+        pipeline.testingSection = extractSection(planResult.output, 'TESTING');
+        // Check for split recommendation
+        if (task.complexity === 'L' && planResult.output.includes('SPLIT RECOMMENDATION') && !planResult.output.includes('No split needed')) {
+            logger.info(`[${task.id}] L-task split recommended — deferring to decomposition`);
+            // TODO: implement decomposition flow
+        }
+        // STEP 2: Implement
+        pipeline.step = 'implement';
+        appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'implement' }));
+        const implResult = await spawnAgent(pool, workerId, {
+            agent: pipeline.assignedAgent ?? undefined,
+            cwd: worktreePath,
+            prompt: buildImplementPrompt({
+                task, worktreePath, projectDir,
+                architectPlan: pipeline.architectPlan,
+                apiContract: pipeline.apiContract ?? undefined,
+            }),
+            model: getAgentModel(pipeline.assignedAgent, agents),
+        }, state, task.id, logger);
+        if (!implResult.success) {
+            logger.error(`[${task.id}] Implementation failed: ${implResult.error}`);
+            return false;
+        }
+        // STEP 3: Test
+        pipeline.step = 'test';
+        appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'test' }));
+        const changedFiles = getChangedFiles(worktreePath);
+        const testRouting = await orchestrator.routeTask(task, 'test', agents);
+        const testResult = await spawnAgent(pool, workerId, {
+            agent: testRouting.agent ?? undefined,
+            cwd: worktreePath,
+            prompt: buildTestPrompt({
+                task, worktreePath, projectDir, changedFiles,
+                testingSection: pipeline.testingSection ?? undefined,
+            }),
+            model: getAgentModel(testRouting.agent, agents),
+        }, state, task.id, logger);
+        if (!testResult.success) {
+            pipeline.buildFixes++;
+            if (pipeline.buildFixes >= MAX_BUILD_FIXES) {
+                logger.error(`[${task.id}] Tests failed ${MAX_BUILD_FIXES} times — skipping`);
+                return false;
+            }
+            // Try to fix via orchestrator
+            const decision = await orchestrator.handleFailure(task.title, 'test', testResult.error ?? 'Tests failed', pipeline.buildFixes);
+            if (decision.action === 'skip')
+                return false;
+        }
+        // STEP 4: Review
+        pipeline.step = 'review';
+        appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'review' }));
+        const reviewRouting = await orchestrator.routeTask(task, 'review', agents);
+        let reviewPassed = false;
+        while (pipeline.reviewCycles < MAX_REVIEW_CYCLES && !reviewPassed) {
+            pipeline.reviewCycles++;
+            const reviewResult = await spawnAgent(pool, workerId, {
+                agent: reviewRouting.agent ?? undefined,
+                cwd: worktreePath,
+                prompt: buildReviewPrompt({
+                    task, worktreePath, projectDir,
+                    changedFiles: getChangedFiles(worktreePath),
+                    testingSection: pipeline.testingSection ?? undefined,
+                }),
+                model: getAgentModel(reviewRouting.agent, agents),
+            }, state, task.id, logger);
+            if (reviewResult.output.includes('**PASS**') || reviewResult.output.includes('PASS')) {
+                reviewPassed = true;
+            }
+            else {
+                pipeline.reviewFindings = reviewResult.output;
+                if (pipeline.reviewCycles >= MAX_REVIEW_CYCLES) {
+                    logger.warn(`[${task.id}] Review limit (${MAX_REVIEW_CYCLES}) reached — proceeding anyway`);
+                    reviewPassed = true;
+                }
+                else {
+                    // Rework
+                    pipeline.step = 'rework';
+                    appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'rework' }));
+                    await spawnAgent(pool, workerId, {
+                        agent: pipeline.assignedAgent ?? undefined,
+                        cwd: worktreePath,
+                        prompt: buildReworkPrompt({
+                            task, worktreePath, projectDir,
+                            reviewFindings: pipeline.reviewFindings,
+                        }),
+                        model: getAgentModel(pipeline.assignedAgent, agents),
+                    }, state, task.id, logger);
+                    pipeline.step = 're-review';
+                }
+            }
+        }
+        // STEP 5: Commit
+        pipeline.step = 'commit';
+        appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'commit' }));
+        const commitMsg = `feat: ${task.title}${task.issueMarker ? ` (${task.issueMarker})` : ''}`;
+        const sha = commitInWorktree(worktreePath, commitMsg);
+        if (!sha) {
+            logger.warn(`[${task.id}] Nothing to commit`);
+        }
+        // STEP 6: Push + CI watch
+        const ciPlatform = detectCIPlatform(projectDir);
+        if (ciPlatform !== 'none') {
+            const pushed = pushWorktree(worktreePath);
+            if (pushed) {
+                pipeline.step = 'ci-watch';
+                appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'ci-watch' }));
+                const ciResult = await watchPipeline(slug, ciPlatform, projectDir, logger);
+                appendEvent(projectDir, createEvent('ci_status', { taskId: task.id, detail: ciResult.status }));
+                if (ciResult.status === 'failed' && pipeline.ciFixes < MAX_CI_FIXES) {
+                    logger.warn(`[${task.id}] CI failed — fix attempt ${pipeline.ciFixes + 1}/${MAX_CI_FIXES}`);
+                    pipeline.ciFixes++;
+                    // Could spawn agent to fix CI, for now log and continue
+                }
+            }
+        }
+        // STEP 7: Merge
+        pipeline.step = 'merge';
+        appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'merge' }));
+        // Sync main before merge
+        syncMain(projectDir);
+        const mergeResult = mergeToMain(projectDir, slug);
+        if (mergeResult.success) {
+            logger.info(`[${task.id}] Merged to main (${mergeResult.sha?.slice(0, 7)})`);
+            appendEvent(projectDir, createEvent('merge_completed', { taskId: task.id, detail: mergeResult.sha ?? '' }));
+        }
+        else if (mergeResult.conflict) {
+            logger.warn(`[${task.id}] Merge conflict — consulting orchestrator`);
+            const decision = await orchestrator.handleMergeConflict(task.title, []);
+            if (decision.action === 'skip')
+                return false;
+            // For rebase: would need to rebase in worktree and retry
+        }
+        else {
+            logger.error(`[${task.id}] Merge failed: ${mergeResult.error}`);
+            return false;
+        }
+        // Cleanup
+        cleanupWorktree(projectDir, worktreePath, slug);
+        pipeline.step = 'done';
+        clearSession(state, task.id);
+        delete state.pipelines[task.id];
+        return true;
+    }
+    catch (err) {
+        logger.error(`[${task.id}] Pipeline error: ${err.message}`);
+        delete state.pipelines[task.id];
+        return false;
+    }
+}
+// ─── Helpers ───
+async function spawnAgent(pool, slotId, opts, state, taskId, logger) {
+    // Check for existing session (resume on crash)
+    const existingSession = getSession(state, taskId);
+    const result = await pool.spawn(slotId, {
+        ...opts,
+        resume: existingSession ?? undefined,
+    });
+    // Record session for crash recovery
+    if (result.sessionId) {
+        recordSession(state, taskId, result.sessionId);
+    }
+    return result;
+}
+function taskToSlug(task) {
+    const sanitized = task.title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 40);
+    return `feat/${task.id}-${sanitized}`;
+}
+function getAgentModel(agentName, agents) {
+    if (!agentName)
+        return undefined;
+    const agent = agents.find(a => a.name === agentName);
+    return agent?.model;
+}
+function extractSection(output, section) {
+    const pattern = new RegExp(`### ${section}\\s*\\n([\\s\\S]*?)(?=\\n### |$)`, 'i');
+    const match = output.match(pattern);
+    return match ? match[1].trim() : null;
+}
+function loadTasksJson(path) {
+    const content = readFileSync(path, 'utf-8');
+    const data = JSON.parse(content);
+    if (data.phases) {
+        // Structured format
+        return data.phases.flatMap((phase) => (phase.tasks ?? []).map((t) => ({
+            ...t,
+            phase: phase.id ?? 0,
+            dependsOn: t.dependsOn ?? [],
+            issueMarker: t.issueMarker ?? null,
+            kitUpgrade: t.kitUpgrade ?? false,
+            lineNumber: t.lineNumber ?? 0,
+            changelog: t.changelog ?? 'added',
+        })));
+    }
+    // Flat array format
+    return data;
+}
+function updateTodoFile(projectDir, task, status) {
+    const todoMdPath = resolve(projectDir, 'TODO.md');
+    if (task.lineNumber > 0 && existsSync(todoMdPath)) {
+        const content = readFileSync(todoMdPath, 'utf-8');
+        const updated = updateTaskCheckbox(content, task.lineNumber, status);
+        writeFileSync(todoMdPath, updated, 'utf-8');
+    }
+}
+async function createAgentFile(projectDir, agent) {
+    const agentsDir = resolve(projectDir, '.claude', 'agents');
+    if (!existsSync(agentsDir))
+        mkdirSync(agentsDir, { recursive: true });
+    const content = `---
+name: ${agent.name}
+description: ${agent.description}
+model: ${agent.model}
+steps: ${agent.steps.join(', ')}
+---
+
+${agent.prompt}
+`;
+    writeFileSync(resolve(agentsDir, `${agent.name}.md`), content, 'utf-8');
+}

package/dist/scheduler/loop.spec.js

@@ -0,0 +1,139 @@
+import { describe, it, expect } from 'vitest';
+import { emptyState } from './state/state.mjs';
+// ─── Unit tests for helper functions ───
+// The scheduler-loop module's main function (runIteration) requires full
+// SDK + git infrastructure. Integration tests cover that.
+// Here we test the pure logic helpers.
+// We test the helper functions by importing them.
+// Note: Since helpers are not exported, we test via the public interface
+// or test the patterns used.
+describe('scheduler-loop module structure', () => {
+    it('exports runIteration function', async () => {
+        const mod = await import('./loop.mjs');
+        expect(typeof mod.runIteration).toBe('function');
+    });
+});
+// ─── Test taskToSlug pattern ───
+describe('task slug generation', () => {
+    it('generates valid git branch names', () => {
+        // Test the pattern used by taskToSlug
+        const title = 'Create auth API endpoint';
+        const sanitized = title
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-|-$/g, '')
+            .slice(0, 40);
+        expect(sanitized).toBe('create-auth-api-endpoint');
+        expect(sanitized).not.toMatch(/[^a-z0-9-]/);
+    });
+    it('truncates long titles', () => {
+        const title = 'This is a very long task title that should be truncated for git branch names';
+        const sanitized = title
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-|-$/g, '')
+            .slice(0, 40);
+        expect(sanitized.length).toBeLessThanOrEqual(40);
+    });
+    it('handles special characters', () => {
+        const title = 'Fix @scope/package (v2.0) — breaking!';
+        const sanitized = title
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-|-$/g, '')
+            .slice(0, 40);
+        expect(sanitized).toBe('fix-scope-package-v2-0-breaking');
+    });
+});
+// ─── Test extractSection pattern ───
+describe('section extraction', () => {
+    it('extracts a section from structured output', () => {
+        const output = `### EXISTING CODE
+Some existing code info
+
+### TESTING
+Test the auth endpoint with mocked DB.
+Skip E2E for this task.
+
+### PITFALLS
+Watch for race conditions.`;
+        const pattern = /### TESTING\s*\n([\s\S]*?)(?=\n### |$)/i;
+        const match = output.match(pattern);
+        expect(match).not.toBeNull();
+        expect(match[1].trim()).toBe('Test the auth endpoint with mocked DB.\nSkip E2E for this task.');
+    });
+    it('returns null when section not found', () => {
+        const output = '### OTHER\nSome content';
+        const pattern = /### TESTING\s*\n([\s\S]*?)(?=\n### |$)/i;
+        expect(output.match(pattern)).toBeNull();
+    });
+});
+// ─── Test loadTasksJson pattern ───
+describe('tasks.json loading', () => {
+    it('handles flat array format', () => {
+        const data = [
+            { id: 'p0-1', title: 'Task 1', phase: 0, type: 'backend', complexity: 'S', status: 'todo' },
+        ];
+        expect(data[0].id).toBe('p0-1');
+    });
+    it('handles structured phases format', () => {
+        const data = {
+            phases: [
+                {
+                    id: 0,
+                    name: 'Foundation',
+                    tasks: [
+                        { id: 'p0-1', title: 'Init', type: 'fullstack', complexity: 'S', status: 'todo' },
+                    ],
+                },
+            ],
+        };
+        const tasks = data.phases.flatMap(phase => (phase.tasks ?? []).map(t => ({ ...t, phase: phase.id })));
+        expect(tasks).toHaveLength(1);
+        expect(tasks[0].phase).toBe(0);
+    });
+});
+// ─── State management ───
+describe('pipeline state tracking', () => {
+    it('initializes pipeline with correct defaults', () => {
+        const state = emptyState(2);
+        state.pipelines['p1-1'] = {
+            taskId: 'p1-1',
+            workerId: 0,
+            worktreePath: '/tmp/wt',
+            step: 'plan',
+            architectPlan: null,
+            apiContract: null,
+            reviewFindings: null,
+            testingSection: null,
+            reviewCycles: 0,
+            ciFixes: 0,
+            buildFixes: 0,
+            assignedAgent: null,
+        };
+        expect(state.pipelines['p1-1'].step).toBe('plan');
+        expect(state.pipelines['p1-1'].reviewCycles).toBe(0);
+    });
+    it('tracks review cycles', () => {
+        const pipeline = {
+            taskId: 'p1-1',
+            workerId: 0,
+            worktreePath: '/tmp/wt',
+            step: 'review',
+            architectPlan: null,
+            apiContract: null,
+            reviewFindings: null,
+            testingSection: null,
+            reviewCycles: 0,
+            ciFixes: 0,
+            buildFixes: 0,
+            assignedAgent: null,
+        };
+        pipeline.reviewCycles++;
+        expect(pipeline.reviewCycles).toBe(1);
+        pipeline.reviewCycles++;
+        expect(pipeline.reviewCycles).toBe(2);
+        // Max is 5
+        expect(pipeline.reviewCycles < 5).toBe(true);
+    });
+});

package/dist/scheduler/state/session.mjs

@@ -0,0 +1,14 @@
+// ─── Session ID tracking per task for --resume on crash/restart ───
+// Thin wrapper over SchedulerState.sessionMap.
+export function recordSession(state, taskId, sessionId) {
+    state.sessionMap[taskId] = sessionId;
+}
+export function getSession(state, taskId) {
+    return state.sessionMap[taskId] ?? null;
+}
+export function clearSession(state, taskId) {
+    delete state.sessionMap[taskId];
+}
+export function clearAllSessions(state) {
+    state.sessionMap = {};
+}

package/dist/scheduler/state/session.spec.js

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { recordSession, getSession, clearSession, clearAllSessions } from './session.mjs';
+import { emptyState } from './state.mjs';
+describe('session-manager', () => {
+    it('records and retrieves a session', () => {
+        const state = emptyState(1);
+        recordSession(state, 'p1-1', 'session-abc');
+        expect(getSession(state, 'p1-1')).toBe('session-abc');
+    });
+    it('returns null for unknown task', () => {
+        const state = emptyState(1);
+        expect(getSession(state, 'p1-99')).toBeNull();
+    });
+    it('clears a specific session', () => {
+        const state = emptyState(1);
+        recordSession(state, 'p1-1', 'session-abc');
+        recordSession(state, 'p1-2', 'session-def');
+        clearSession(state, 'p1-1');
+        expect(getSession(state, 'p1-1')).toBeNull();
+        expect(getSession(state, 'p1-2')).toBe('session-def');
+    });
+    it('overwrites existing session', () => {
+        const state = emptyState(1);
+        recordSession(state, 'p1-1', 'session-old');
+        recordSession(state, 'p1-1', 'session-new');
+        expect(getSession(state, 'p1-1')).toBe('session-new');
+    });
+    it('clears all sessions', () => {
+        const state = emptyState(1);
+        recordSession(state, 'p1-1', 'a');
+        recordSession(state, 'p1-2', 'b');
+        clearAllSessions(state);
+        expect(getSession(state, 'p1-1')).toBeNull();
+        expect(getSession(state, 'p1-2')).toBeNull();
+    });
+});