create-claude-workspace 1.1.151 → 2.0.0

package/dist/scripts/lib/formatter.mjs

@@ -1,309 +0,0 @@
-// ─── Beautiful terminal output for autonomous loop ───
-import { appendFileSync } from 'node:fs';
-// ─── ANSI colors ───
-const c = {
-    reset: '\x1b[0m',
-    bold: '\x1b[1m',
-    dim: '\x1b[2m',
-    italic: '\x1b[3m',
-    // Foreground
-    black: '\x1b[30m',
-    red: '\x1b[31m',
-    green: '\x1b[32m',
-    yellow: '\x1b[33m',
-    blue: '\x1b[34m',
-    magenta: '\x1b[35m',
-    cyan: '\x1b[36m',
-    white: '\x1b[37m',
-    // Bright foreground
-    gray: '\x1b[90m',
-    brightRed: '\x1b[91m',
-    brightGreen: '\x1b[92m',
-    brightYellow: '\x1b[93m',
-    brightBlue: '\x1b[94m',
-    brightMagenta: '\x1b[95m',
-    brightCyan: '\x1b[96m',
-    // Background
-    bgBlue: '\x1b[44m',
-    bgMagenta: '\x1b[45m',
-    bgCyan: '\x1b[46m',
-    bgGray: '\x1b[100m',
-};
-// ─── Agent colors (rotating) ───
-const AGENT_COLORS = [c.brightCyan, c.brightMagenta, c.brightGreen, c.brightYellow, c.brightBlue, c.brightRed];
-const agentColorMap = new Map();
-let colorIndex = 0;
-function agentColor(name) {
-    if (!agentColorMap.has(name)) {
-        agentColorMap.set(name, AGENT_COLORS[colorIndex % AGENT_COLORS.length]);
-        colorIndex++;
-    }
-    return agentColorMap.get(name);
-}
-// ─── Tool icons ───
-const TOOL_ICONS = {
-    Bash: '⚡',
-    Read: '📖',
-    Write: '✏️',
-    Edit: '🔧',
-    Glob: '🔍',
-    Grep: '🔎',
-    Agent: '🤖',
-    TodoRead: '📋',
-    TodoWrite: '📝',
-    WebSearch: '🌐',
-    WebFetch: '🌐',
-    AskUserQuestion: '❓',
-};
-function toolIcon(name) {
-    return TOOL_ICONS[name] || '⚙️';
-}
-// ─── Time formatting ───
-function ts() {
-    return new Date().toLocaleTimeString('en-GB', { hour12: false });
-}
-function duration(ms) {
-    if (ms < 1000)
-        return `${ms}ms`;
-    if (ms < 60_000)
-        return `${(ms / 1000).toFixed(1)}s`;
-    if (ms < 3600_000)
-        return `${(ms / 60_000).toFixed(1)}m`;
-    return `${(ms / 3600_000).toFixed(1)}h`;
-}
-// ─── Formatting helpers ───
-function truncate(s, max) {
-    const clean = s.replace(/\n/g, ' ').trim();
-    return clean.length > max ? clean.slice(0, max) + '…' : clean;
-}
-function formatPath(path) {
-    // Shorten long paths: /project/libs/shared/ui/src/lib/component.ts → .../ui/src/lib/component.ts
-    const short = path.replace(/^\/project\//, '');
-    return `${c.cyan}${short}${c.reset}`;
-}
-function formatCommand(cmd) {
-    const short = truncate(cmd, 80);
-    return `${c.yellow}${short}${c.reset}`;
-}
-// ─── Main formatter class ───
-export class Formatter {
-    logFile;
-    iterStartTime = 0;
-    totalTokens = { input: 0, output: 0 };
-    toolCalls = 0;
-    agentStack = [];
-    constructor(logFile) {
-        this.logFile = logFile;
-    }
-    // ── Raw log (file only, no formatting) ──
-    fileLog(msg) {
-        if (!this.logFile)
-            return;
-        try {
-            appendFileSync(this.logFile, `[${new Date().toISOString()}] ${msg}\n`);
-        }
-        catch { /* */ }
-    }
-    // ── Print to console + file ──
-    print(formatted, raw) {
-        console.log(formatted);
-        this.fileLog(raw || formatted.replace(/\x1b\[[0-9;]*m/g, ''));
-    }
-    // ─── Public API ───
-    banner() {
-        this.print('');
-        this.print(`${c.bold}${c.cyan}  ╔══════════════════════════════════════════════╗${c.reset}`);
-        this.print(`${c.bold}${c.cyan}  ║   ${c.white}Claude Starter Kit — Autonomous Loop${c.cyan}       ║${c.reset}`);
-        this.print(`${c.bold}${c.cyan}  ╚══════════════════════════════════════════════╝${c.reset}`);
-        this.print('');
-    }
-    info(msg) {
-        this.print(`  ${c.gray}${ts()}${c.reset}  ${c.blue}ℹ${c.reset}  ${msg}`);
-    }
-    warn(msg) {
-        this.print(`  ${c.gray}${ts()}${c.reset}  ${c.yellow}⚠${c.reset}  ${c.yellow}${msg}${c.reset}`);
-    }
-    error(msg) {
-        this.print(`  ${c.gray}${ts()}${c.reset}  ${c.red}✗${c.reset}  ${c.red}${msg}${c.reset}`);
-    }
-    success(msg) {
-        this.print(`  ${c.gray}${ts()}${c.reset}  ${c.green}✓${c.reset}  ${c.green}${msg}${c.reset}`);
-    }
-    iterationStart(i, max) {
-        this.iterStartTime = Date.now();
-        this.toolCalls = 0;
-        const pct = Math.round((i / max) * 100);
-        const bar = progressBar(pct, 20);
-        this.print('');
-        this.print(`  ${c.bold}${c.white}─── Iteration ${i}/${max} ${c.gray}${bar} ${pct}%${c.reset}`);
-        this.print('');
-    }
-    iterationEnd() {
-        const elapsed = Date.now() - this.iterStartTime;
-        const tokens = this.totalTokens.input + this.totalTokens.output;
-        this.print('');
-        this.print(`  ${c.gray}──── ${duration(elapsed)} │ ${this.toolCalls} tools │ ${formatTokens(tokens)} tokens ────${c.reset}`);
-    }
-    // ─── SDK Message handling ───
-    handleMessage(message) {
-        const msg = message;
-        switch (message.type) {
-            case 'assistant':
-                this.handleAssistant(msg);
-                break;
-            case 'user':
-                this.handleToolResult(msg);
-                break;
-            case 'system':
-                this.handleSystem(msg);
-                break;
-            case 'result':
-                this.handleResult(msg);
-                break;
-            default:
-                // Silently skip unknown types (stream_event, etc.)
-                break;
-        }
-    }
-    handleAssistant(msg) {
-        const content = msg.message?.content;
-        if (!Array.isArray(content))
-            return;
-        for (const block of content) {
-            if (block.type === 'text' && block.text?.trim()) {
-                const text = truncate(block.text, 300);
-                const indent = this.indent();
-                this.print(`${indent}${c.white}${text}${c.reset}`, `TEXT: ${text}`);
-            }
-            if (block.type === 'tool_use') {
-                this.handleToolUse(block);
-            }
-        }
-        // Track tokens from usage
-        if (msg.message?.usage) {
-            this.totalTokens.input += msg.message.usage.input_tokens || 0;
-            this.totalTokens.output += msg.message.usage.output_tokens || 0;
-        }
-    }
-    handleToolUse(block) {
-        this.toolCalls++;
-        const name = block.name || 'unknown';
-        const icon = toolIcon(name);
-        const input = block.input || {};
-        const indent = this.indent();
-        if (name === 'Agent') {
-            // Agent delegation — show agent name and description
-            const agentType = input.subagent_type || input.type || 'agent';
-            const desc = truncate(input.description || input.prompt || '', 60);
-            const col = agentColor(agentType);
-            this.agentStack.push(agentType);
-            this.print(`${indent}${icon}  ${col}${c.bold}${agentType}${c.reset} ${c.gray}${desc}${c.reset}`, `AGENT: ${agentType} — ${desc}`);
-            return;
-        }
-        // Format based on tool type
-        let detail = '';
-        if (name === 'Bash') {
-            detail = formatCommand(input.command || '');
-        }
-        else if (name === 'Read') {
-            detail = formatPath(input.file_path || '');
-        }
-        else if (name === 'Write' || name === 'Edit') {
-            detail = formatPath(input.file_path || '');
-        }
-        else if (name === 'Glob') {
-            detail = `${c.cyan}${input.pattern || ''}${c.reset}`;
-        }
-        else if (name === 'Grep') {
-            detail = `${c.cyan}/${input.pattern || ''}/`;
-            if (input.path)
-                detail += ` ${c.gray}in ${input.path}`;
-            detail += c.reset;
-        }
-        else if (name === 'TodoWrite') {
-            detail = `${c.gray}updating task list${c.reset}`;
-        }
-        else if (name === 'TodoRead') {
-            detail = `${c.gray}reading task list${c.reset}`;
-        }
-        else {
-            const summary = truncate(JSON.stringify(input), 80);
-            detail = `${c.gray}${summary}${c.reset}`;
-        }
-        this.print(`${indent}${c.gray}${ts()}${c.reset}  ${icon}  ${c.bold}${name}${c.reset}  ${detail}`, `TOOL: ${name} ${JSON.stringify(input).slice(0, 200)}`);
-    }
-    handleToolResult(msg) {
-        const content = msg.message?.content;
-        if (!Array.isArray(content))
-            return;
-        for (const block of content) {
-            if (block.type !== 'tool_result')
-                continue;
-            const output = String(block.content || '').trim();
-            const isError = block.is_error === true;
-            const indent = this.indent();
-            if (isError) {
-                const short = truncate(output, 120);
-                this.print(`${indent}       ${c.red}✗ ${short}${c.reset}`, `ERROR: ${short}`);
-            }
-            else if (output && output.length > 0) {
-                // Show short results inline, skip very long ones
-                if (output.length < 200) {
-                    const short = truncate(output, 120);
-                    this.print(`${indent}       ${c.green}✓${c.reset} ${c.gray}${short}${c.reset}`, `RESULT: ${short}`);
-                }
-                else {
-                    const lines = output.split('\n').length;
-                    this.print(`${indent}       ${c.green}✓${c.reset} ${c.gray}${lines} lines${c.reset}`, `RESULT: (${lines} lines)`);
-                }
-            }
-        }
-    }
-    handleSystem(msg) {
-        if (msg.subtype === 'task_progress') {
-            const desc = msg.description || '';
-            if (desc) {
-                const indent = this.indent();
-                this.print(`${indent}       ${c.dim}${truncate(desc, 80)}${c.reset}`, `PROGRESS: ${desc}`);
-            }
-            return;
-        }
-        // Other system messages
-        const text = msg.message || JSON.stringify(msg).slice(0, 150);
-        this.info(`${c.dim}${truncate(String(text), 120)}${c.reset}`);
-    }
-    handleResult(msg) {
-        const sessionId = msg.session_id;
-        if (sessionId) {
-            this.fileLog(`SESSION: ${sessionId}`);
-        }
-        this.success('Iteration complete');
-    }
-    // ─── Helpers ───
-    indent() {
-        const depth = this.agentStack.length;
-        if (depth === 0)
-            return '  ';
-        return '  ' + '│ '.repeat(depth);
-    }
-    // Reset agent stack between iterations
-    resetAgentStack() {
-        this.agentStack = [];
-    }
-    getSessionId(msg) {
-        return msg.session_id ?? null;
-    }
-}
-// ─── Utilities ───
-function progressBar(pct, width) {
-    const filled = Math.round((pct / 100) * width);
-    const empty = width - filled;
-    return `${c.green}${'█'.repeat(filled)}${c.gray}${'░'.repeat(empty)}${c.reset}`;
-}
-function formatTokens(n) {
-    if (n < 1000)
-        return String(n);
-    if (n < 1_000_000)
-        return `${(n / 1000).toFixed(1)}K`;
-    return `${(n / 1_000_000).toFixed(2)}M`;
-}

package/dist/scripts/lib/formatter.spec.js

@@ -1,262 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { mkdirSync, rmSync, readFileSync } from 'node:fs';
-import { resolve, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { Formatter } from './formatter.mjs';
-const TEST_DIR = resolve(dirname(fileURLToPath(import.meta.url)), '__fmt_test_tmp__');
-const LOG_FILE = resolve(TEST_DIR, 'test.log');
-beforeEach(() => {
-    mkdirSync(TEST_DIR, { recursive: true });
-    vi.spyOn(console, 'log').mockImplementation(() => { });
-});
-afterEach(() => {
-    vi.restoreAllMocks();
-    rmSync(TEST_DIR, { recursive: true, force: true });
-});
-function readLog() {
-    try {
-        return readFileSync(LOG_FILE, 'utf-8');
-    }
-    catch {
-        return '';
-    }
-}
-describe('Formatter', () => {
-    it('creates instance with log file', () => {
-        const fmt = new Formatter(LOG_FILE);
-        expect(fmt).toBeDefined();
-    });
-    it('banner outputs to console', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.banner();
-        expect(console.log).toHaveBeenCalled();
-    });
-    it('info writes to console and file', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.info('test message');
-        expect(console.log).toHaveBeenCalled();
-        const log = readLog();
-        expect(log).toContain('test message');
-    });
-    it('warn writes with warning indicator', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.warn('warning msg');
-        const log = readLog();
-        expect(log).toContain('warning msg');
-    });
-    it('error writes with error indicator', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.error('error msg');
-        const log = readLog();
-        expect(log).toContain('error msg');
-    });
-    it('success writes with success indicator', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.success('done');
-        const log = readLog();
-        expect(log).toContain('done');
-    });
-    it('iterationStart writes iteration header', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.iterationStart(3, 50);
-        const calls = console.log.mock.calls.map((c) => c[0]);
-        const joined = calls.join('\n');
-        expect(joined).toContain('3');
-        expect(joined).toContain('50');
-    });
-    it('iterationEnd writes summary', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.iterationStart(1, 10);
-        fmt.iterationEnd();
-        const calls = console.log.mock.calls.map((c) => c[0]);
-        const joined = calls.join('\n');
-        expect(joined).toContain('tools');
-        expect(joined).toContain('tokens');
-    });
-});
-describe('Formatter.handleMessage', () => {
-    it('handles assistant text messages', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.handleMessage({
-            type: 'assistant',
-            message: { content: [{ type: 'text', text: 'Hello from Claude' }] },
-        });
-        const log = readLog();
-        expect(log).toContain('Hello from Claude');
-    });
-    it('handles tool_use Bash', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.handleMessage({
-            type: 'assistant',
-            message: { content: [{ type: 'tool_use', name: 'Bash', input: { command: 'ls -la' } }] },
-        });
-        const log = readLog();
-        expect(log).toContain('Bash');
-        expect(log).toContain('ls -la');
-    });
-    it('handles tool_use Read', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.handleMessage({
-            type: 'assistant',
-            message: { content: [{ type: 'tool_use', name: 'Read', input: { file_path: '/project/src/index.ts' } }] },
-        });
-        const log = readLog();
-        expect(log).toContain('Read');
-        expect(log).toContain('index.ts');
-    });
-    it('handles tool_use Write', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.handleMessage({
-            type: 'assistant',
-            message: { content: [{ type: 'tool_use', name: 'Write', input: { file_path: '/project/new-file.ts' } }] },
-        });
-        const log = readLog();
-        expect(log).toContain('Write');
-        expect(log).toContain('new-file.ts');
-    });
-    it('handles tool_use Edit', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.handleMessage({
-            type: 'assistant',
-            message: { content: [{ type: 'tool_use', name: 'Edit', input: { file_path: '/project/file.ts' } }] },
-        });
-        const log = readLog();
-        expect(log).toContain('Edit');
-    });
-    it('handles tool_use Glob', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.handleMessage({
-            type: 'assistant',
-            message: { content: [{ type: 'tool_use', name: 'Glob', input: { pattern: '**/*.ts' } }] },
-        });
-        const log = readLog();
-        expect(log).toContain('Glob');
-        expect(log).toContain('**/*.ts');
-    });
-    it('handles tool_use Grep', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.handleMessage({
-            type: 'assistant',
-            message: { content: [{ type: 'tool_use', name: 'Grep', input: { pattern: 'TODO', path: 'src/' } }] },
-        });
-        const log = readLog();
-        expect(log).toContain('Grep');
-        expect(log).toContain('TODO');
-    });
-    it('handles Agent delegation', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.handleMessage({
-            type: 'assistant',
-            message: { content: [{ type: 'tool_use', name: 'Agent', input: { subagent_type: 'backend-ts-architect', description: 'Plan API design' } }] },
-        });
-        const log = readLog();
-        expect(log).toContain('backend-ts-architect');
-        expect(log).toContain('Plan API design');
-    });
-    it('handles tool results (short)', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.handleMessage({
-            type: 'user',
-            message: { content: [{ type: 'tool_result', content: 'file1.ts\nfile2.ts', is_error: false }] },
-        });
-        const log = readLog();
-        expect(log).toContain('file1.ts');
-    });
-    it('handles tool results (long → line count)', () => {
-        const fmt = new Formatter(LOG_FILE);
-        const longOutput = Array.from({ length: 50 }, (_, i) => `line ${i}`).join('\n');
-        fmt.handleMessage({
-            type: 'user',
-            message: { content: [{ type: 'tool_result', content: longOutput, is_error: false }] },
-        });
-        const log = readLog();
-        expect(log).toContain('50 lines');
-    });
-    it('handles tool error results', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.handleMessage({
-            type: 'user',
-            message: { content: [{ type: 'tool_result', content: 'Permission denied', is_error: true }] },
-        });
-        const log = readLog();
-        expect(log).toContain('Permission denied');
-    });
-    it('handles system task_progress', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.handleMessage({
-            type: 'system',
-            subtype: 'task_progress',
-            description: 'Reading package.json',
-        });
-        const log = readLog();
-        expect(log).toContain('Reading package.json');
-    });
-    it('handles result message', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.handleMessage({
-            type: 'result',
-            session_id: 'abc-123',
-        });
-        const log = readLog();
-        expect(log).toContain('SESSION: abc-123');
-    });
-    it('getSessionId extracts session_id', () => {
-        const fmt = new Formatter(LOG_FILE);
-        expect(fmt.getSessionId({ session_id: 'test-id' })).toBe('test-id');
-        expect(fmt.getSessionId({})).toBeNull();
-    });
-    it('ignores unknown message types silently', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.handleMessage({ type: 'stream_event', data: 'something' });
-        const log = readLog();
-        expect(log).toBe('');
-    });
-    it('handles multiple content blocks in one message', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.handleMessage({
-            type: 'assistant',
-            message: {
-                content: [
-                    { type: 'text', text: 'Planning the implementation' },
-                    { type: 'tool_use', name: 'Read', input: { file_path: '/project/src/main.ts' } },
-                    { type: 'tool_use', name: 'Bash', input: { command: 'npm test' } },
-                ],
-            },
-        });
-        const log = readLog();
-        expect(log).toContain('Planning the implementation');
-        expect(log).toContain('Read');
-        expect(log).toContain('Bash');
-        expect(log).toContain('npm test');
-    });
-    it('tracks tokens from usage', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.iterationStart(1, 10);
-        fmt.handleMessage({
-            type: 'assistant',
-            message: {
-                content: [{ type: 'text', text: 'hi' }],
-                usage: { input_tokens: 1000, output_tokens: 500 },
-            },
-        });
-        fmt.iterationEnd();
-        const calls = console.log.mock.calls.map((c) => c[0]);
-        const summary = calls.join('\n');
-        expect(summary).toContain('1.5K');
-    });
-    it('increments tool call counter', () => {
-        const fmt = new Formatter(LOG_FILE);
-        fmt.iterationStart(1, 10);
-        fmt.handleMessage({
-            type: 'assistant',
-            message: { content: [
-                    { type: 'tool_use', name: 'Read', input: { file_path: 'a.ts' } },
-                    { type: 'tool_use', name: 'Read', input: { file_path: 'b.ts' } },
-                ] },
-        });
-        fmt.iterationEnd();
-        const calls = console.log.mock.calls.map((c) => c[0]);
-        const summary = calls.join('\n');
-        expect(summary).toContain('2 tools');
-    });
-});

package/dist/scripts/lib/state.mjs

@@ -1,44 +0,0 @@
-// ─── Checkpoint state: crash recovery via .claude/autonomous-state.json ───
-import { readFileSync, writeFileSync, renameSync, unlinkSync } from 'node:fs';
-import { resolve } from 'node:path';
-const STATE_FILE = '.claude/autonomous-state.json';
-export function emptyStats() {
-    return { startTime: Date.now(), iterations: 0, tasksCompleted: [] };
-}
-export function emptyCheckpoint() {
-    return {
-        iteration: 0,
-        lastSessionId: null,
-        lastTaskSeen: null,
-        completionVerified: false,
-        stats: emptyStats(),
-    };
-}
-export function readCheckpoint(projectDir) {
-    const path = resolve(projectDir, STATE_FILE);
-    try {
-        const raw = readFileSync(path, 'utf-8');
-        const parsed = JSON.parse(raw);
-        if (typeof parsed.iteration !== 'number')
-            return null;
-        const defaults = emptyCheckpoint();
-        return { ...defaults, ...parsed, stats: { ...defaults.stats, ...parsed.stats } };
-    }
-    catch {
-        return null;
-    }
-}
-export function writeCheckpoint(projectDir, state) {
-    const path = resolve(projectDir, STATE_FILE);
-    const tmp = path + '.tmp';
-    try {
-        writeFileSync(tmp, JSON.stringify(state, null, 2) + '\n', 'utf-8');
-        renameSync(tmp, path);
-    }
-    catch {
-        try {
-            unlinkSync(tmp);
-        }
-        catch { /* */ }
-    }
-}

package/dist/scripts/lib/state.spec.js

@@ -1,59 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdirSync, rmSync, writeFileSync, existsSync } from 'node:fs';
-import { resolve, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { emptyCheckpoint, emptyStats, readCheckpoint, writeCheckpoint } from './state.mjs';
-const TEST_DIR = resolve(dirname(fileURLToPath(import.meta.url)), '__test_tmp__');
-beforeEach(() => {
-    mkdirSync(resolve(TEST_DIR, '.claude'), { recursive: true });
-});
-afterEach(() => {
-    rmSync(TEST_DIR, { recursive: true, force: true });
-});
-describe('emptyStats', () => {
-    it('creates stats with zero values', () => {
-        const stats = emptyStats();
-        expect(stats.iterations).toBe(0);
-        expect(stats.tasksCompleted).toEqual([]);
-    });
-});
-describe('emptyCheckpoint', () => {
-    it('creates checkpoint with zero values', () => {
-        const cp = emptyCheckpoint();
-        expect(cp.iteration).toBe(0);
-        expect(cp.lastSessionId).toBeNull();
-    });
-});
-describe('writeCheckpoint + readCheckpoint', () => {
-    it('round-trips checkpoint data', () => {
-        const cp = emptyCheckpoint();
-        cp.iteration = 5;
-        cp.lastTaskSeen = '#42';
-        writeCheckpoint(TEST_DIR, cp);
-        const read = readCheckpoint(TEST_DIR);
-        expect(read).not.toBeNull();
-        expect(read.iteration).toBe(5);
-        expect(read.lastTaskSeen).toBe('#42');
-    });
-    it('uses atomic write (tmp + rename)', () => {
-        writeCheckpoint(TEST_DIR, emptyCheckpoint());
-        expect(existsSync(resolve(TEST_DIR, '.claude/autonomous-state.json.tmp'))).toBe(false);
-        expect(existsSync(resolve(TEST_DIR, '.claude/autonomous-state.json'))).toBe(true);
-    });
-    it('returns null for missing file', () => {
-        expect(readCheckpoint(TEST_DIR)).toBeNull();
-    });
-    it('returns null for corrupted file', () => {
-        writeFileSync(resolve(TEST_DIR, '.claude/autonomous-state.json'), '{corrupt!!!');
-        expect(readCheckpoint(TEST_DIR)).toBeNull();
-    });
-    it('merges with defaults for forward compatibility', () => {
-        const path = resolve(TEST_DIR, '.claude/autonomous-state.json');
-        writeFileSync(path, JSON.stringify({ iteration: 3, lastSessionId: 'abc', stats: { iterations: 3, tasksCompleted: ['#1'] } }));
-        const read = readCheckpoint(TEST_DIR);
-        expect(read).not.toBeNull();
-        expect(read.iteration).toBe(3);
-        expect(read.completionVerified).toBe(false); // default
-        expect(read.stats.tasksCompleted).toEqual(['#1']);
-    });
-});

package/dist/template/.claude/docker/.dockerignore

@@ -1,8 +0,0 @@
-node_modules
-.git
-dist
-tmp
-.angular
-.nx
-.npmrc
-.docker-compose.auth.yml