relay-ide 0.1.0

package/dist/test/analytics.test.js

@@ -0,0 +1,158 @@
+import { test, before, after, afterEach } 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 Database from 'better-sqlite3';
+import { initAnalytics, closeAnalytics, trackEvent, getDbSize, getDbPath, } from '../server/analytics.js';
+let tmpDir;
+before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-remote-cli-analytics-test-'));
+});
+afterEach(() => {
+    closeAnalytics();
+    // Clean up DB files between tests
+    for (const entry of fs.readdirSync(tmpDir)) {
+        fs.unlinkSync(path.join(tmpDir, entry));
+    }
+});
+after(() => {
+    fs.rmSync(tmpDir, { recursive: true });
+});
+test('initAnalytics creates database and schema', () => {
+    initAnalytics(tmpDir);
+    const dbPath = getDbPath(tmpDir);
+    assert.ok(fs.existsSync(dbPath), 'DB file should exist');
+    const db = new Database(dbPath, { readonly: true });
+    const tables = db
+        .prepare("SELECT name FROM sqlite_master WHERE type='table'")
+        .all();
+    assert.ok(tables.some((t) => t.name === 'events'), 'events table should exist');
+    db.close();
+});
+test('trackEvent inserts a row', () => {
+    initAnalytics(tmpDir);
+    trackEvent({
+        category: 'session',
+        action: 'created',
+        target: 'session-123',
+        properties: { workspace: '/proj', agent: 'claude' },
+        session_id: 'session-123',
+        device: 'desktop',
+    });
+    const db = new Database(getDbPath(tmpDir), { readonly: true });
+    const rows = db.prepare('SELECT * FROM events').all();
+    assert.equal(rows.length, 1);
+    assert.equal(rows[0].category, 'session');
+    assert.equal(rows[0].action, 'created');
+    assert.equal(rows[0].target, 'session-123');
+    assert.equal(rows[0].device, 'desktop');
+    const props = JSON.parse(rows[0].properties);
+    assert.equal(props.workspace, '/proj');
+    assert.equal(props.agent, 'claude');
+    db.close();
+});
+test('trackEvent handles optional fields as null', () => {
+    initAnalytics(tmpDir);
+    trackEvent({ category: 'ui', action: 'click' });
+    const db = new Database(getDbPath(tmpDir), { readonly: true });
+    const rows = db.prepare('SELECT * FROM events').all();
+    assert.equal(rows.length, 1);
+    assert.equal(rows[0].target, null);
+    assert.equal(rows[0].properties, null);
+    assert.equal(rows[0].session_id, null);
+    assert.equal(rows[0].device, null);
+    db.close();
+});
+test('trackEvent is no-op before initAnalytics', () => {
+    // Should not throw
+    trackEvent({ category: 'test', action: 'noop' });
+});
+test('getDbSize returns file size after writes', () => {
+    initAnalytics(tmpDir);
+    const sizeBefore = getDbSize(tmpDir);
+    assert.ok(sizeBefore > 0, 'DB file should have non-zero size after init');
+    for (let i = 0; i < 10; i++) {
+        trackEvent({ category: 'bulk', action: 'test', properties: { i } });
+    }
+    const sizeAfter = getDbSize(tmpDir);
+    assert.ok(sizeAfter >= sizeBefore, 'Size should grow after writes');
+});
+test('getDbSize returns 0 for non-existent path', () => {
+    assert.equal(getDbSize('/nonexistent/path'), 0);
+});
+test('initAnalytics is idempotent (schema already exists)', () => {
+    initAnalytics(tmpDir);
+    trackEvent({ category: 'test', action: 'first' });
+    closeAnalytics();
+    // Re-init should not throw or lose data
+    initAnalytics(tmpDir);
+    const db = new Database(getDbPath(tmpDir), { readonly: true });
+    const rows = db.prepare('SELECT * FROM events').all();
+    assert.equal(rows.length, 1);
+    db.close();
+});
+// ── Router endpoint tests ──────────────────────────────────────────────
+// These test the Express Router in isolation (same pattern as fs-browse.test.ts)
+import express from 'express';
+import http from 'node:http';
+import { createAnalyticsRouter } from '../server/analytics.js';
+test('POST /analytics/events batch inserts events', async () => {
+    initAnalytics(tmpDir);
+    const app = express();
+    app.use(express.json());
+    app.use('/analytics', createAnalyticsRouter(tmpDir));
+    const server = http.createServer(app);
+    await new Promise((resolve) => server.listen(0, resolve));
+    const port = server.address().port;
+    const res = await fetch(`http://localhost:${port}/analytics/events`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            events: [
+                { category: 'ui', action: 'click', target: 'test-btn' },
+                { category: 'session', action: 'created' },
+            ],
+        }),
+    });
+    const data = (await res.json());
+    assert.equal(data.ok, true);
+    assert.equal(data.count, 2);
+    const db = new Database(getDbPath(tmpDir), { readonly: true });
+    const rows = db.prepare('SELECT * FROM events').all();
+    assert.equal(rows.length, 2);
+    db.close();
+    server.close();
+});
+test('GET /analytics/size returns bytes', async () => {
+    initAnalytics(tmpDir);
+    const app = express();
+    app.use('/analytics', createAnalyticsRouter(tmpDir));
+    const server = http.createServer(app);
+    await new Promise((resolve) => server.listen(0, resolve));
+    const port = server.address().port;
+    const res = await fetch(`http://localhost:${port}/analytics/size`);
+    const data = (await res.json());
+    assert.ok(data.bytes > 0);
+    server.close();
+});
+test('DELETE /analytics/events clears all events', async () => {
+    initAnalytics(tmpDir);
+    trackEvent({ category: 'test', action: 'to-delete' });
+    const app = express();
+    app.use(express.json());
+    app.use('/analytics', createAnalyticsRouter(tmpDir));
+    const server = http.createServer(app);
+    await new Promise((resolve) => server.listen(0, resolve));
+    const port = server.address().port;
+    const res = await fetch(`http://localhost:${port}/analytics/events`, {
+        method: 'DELETE',
+    });
+    const data = (await res.json());
+    assert.equal(data.ok, true);
+    const db = new Database(getDbPath(tmpDir), { readonly: true });
+    const rows = db.prepare('SELECT * FROM events').all();
+    assert.equal(rows.length, 0);
+    db.close();
+    server.close();
+});

package/dist/test/attention.test.js

@@ -0,0 +1,91 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { computeAttentionScore, sortByAttention, } from '../frontend/src/lib/state/attention.js';
+function makeScoreItem(overrides) {
+    return {
+        id: 'test',
+        kind: 'worktree',
+        path: '/test',
+        repoPath: '/repo',
+        displayName: 'test',
+        branchName: 'main',
+        lastActivity: new Date().toISOString(),
+        lastKnownBackendState: null,
+        sessions: [],
+        ...overrides,
+    };
+}
+describe('computeAttentionScore', () => {
+    it('permission scores highest', () => {
+        const permission = computeAttentionScore(makeScoreItem({ displayState: 'permission' }));
+        const running = computeAttentionScore(makeScoreItem({ displayState: 'running' }));
+        assert.ok(permission > running);
+    });
+    it('needs-answer scores above error', () => {
+        const needsAnswer = computeAttentionScore(makeScoreItem({ displayState: 'needs-answer' }));
+        const error = computeAttentionScore(makeScoreItem({ displayState: 'error' }));
+        assert.ok(needsAnswer > error);
+    });
+    it('error scores above unseen-idle', () => {
+        const error = computeAttentionScore(makeScoreItem({ displayState: 'error' }));
+        const unseen = computeAttentionScore(makeScoreItem({ displayState: 'unseen-idle' }));
+        assert.ok(error > unseen);
+    });
+    it('unseen-idle scores above running', () => {
+        const unseen = computeAttentionScore(makeScoreItem({ displayState: 'unseen-idle' }));
+        const running = computeAttentionScore(makeScoreItem({ displayState: 'running' }));
+        assert.ok(unseen > running);
+    });
+    it('inactive scores lowest', () => {
+        const inactive = computeAttentionScore(makeScoreItem({ displayState: 'inactive' }));
+        const seenIdle = computeAttentionScore(makeScoreItem({ displayState: 'seen-idle' }));
+        assert.ok(inactive < seenIdle);
+    });
+    it('unread bonus stacks with state score', () => {
+        const unread = computeAttentionScore(makeScoreItem({ displayState: 'unseen-idle', isUnread: true }));
+        const read = computeAttentionScore(makeScoreItem({ displayState: 'unseen-idle', isUnread: false }));
+        assert.ok(unread > read);
+    });
+    it('changes-requested PR adds urgency', () => {
+        const withPr = computeAttentionScore(makeScoreItem({
+            displayState: 'running',
+            prStatus: 'changes-requested',
+        }));
+        const withoutPr = computeAttentionScore(makeScoreItem({
+            displayState: 'running',
+        }));
+        assert.ok(withPr > withoutPr);
+        assert.equal(withPr - withoutPr, 200);
+    });
+    it('review-requested PR adds urgency', () => {
+        const withPr = computeAttentionScore(makeScoreItem({
+            displayState: 'running',
+            prStatus: 'review-requested',
+        }));
+        const withoutPr = computeAttentionScore(makeScoreItem({
+            displayState: 'running',
+        }));
+        assert.equal(withPr - withoutPr, 150);
+    });
+    it('recency contributes to score', () => {
+        const recent = computeAttentionScore(makeScoreItem({
+            displayState: 'running',
+            lastActivity: new Date().toISOString(),
+        }));
+        const old = computeAttentionScore(makeScoreItem({
+            displayState: 'running',
+            lastActivity: new Date(Date.now() - 120 * 60_000).toISOString(),
+        }));
+        assert.ok(recent > old);
+    });
+});
+describe('sortByAttention', () => {
+    it('sorts permission above running', () => {
+        const items = [
+            makeScoreItem({ id: 'a', displayState: 'running' }),
+            makeScoreItem({ id: 'b', displayState: 'permission' }),
+        ];
+        const sorted = sortByAttention(items);
+        assert.equal(sorted[0].id, 'b');
+    });
+});

package/dist/test/auth.test.js

@@ -0,0 +1,105 @@
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { hashPin, verifyPin, isLegacyHash, isRateLimited, recordFailedAttempt, generateCookieToken, _resetForTesting, } from '../server/auth.js';
+test('hashPin returns scrypt hash with expected format', async () => {
+    _resetForTesting();
+    const hash = await hashPin('1234');
+    assert.ok(hash.startsWith('scrypt:'), `Expected hash to start with scrypt:, got: ${hash}`);
+    const parts = hash.split(':');
+    assert.strictEqual(parts.length, 3, 'Hash should have 3 colon-separated parts');
+});
+test('verifyPin returns true for correct PIN', async () => {
+    _resetForTesting();
+    const hash = await hashPin('1234');
+    const result = await verifyPin('1234', hash);
+    assert.strictEqual(result, true);
+});
+test('verifyPin returns false for wrong PIN', async () => {
+    _resetForTesting();
+    const hash = await hashPin('1234');
+    const result = await verifyPin('9999', hash);
+    assert.strictEqual(result, false);
+});
+test('rate limiter blocks after 5 failures', () => {
+    _resetForTesting();
+    const ip = '127.0.0.1';
+    for (let i = 0; i < 5; i++) {
+        recordFailedAttempt(ip);
+    }
+    assert.strictEqual(isRateLimited(ip), true);
+});
+test('rate limiter allows under threshold', () => {
+    _resetForTesting();
+    const ip = '127.0.0.1';
+    for (let i = 0; i < 4; i++) {
+        recordFailedAttempt(ip);
+    }
+    assert.strictEqual(isRateLimited(ip), false);
+});
+test('verifyPin returns false for legacy bcrypt hash (requires PIN reset)', async () => {
+    _resetForTesting();
+    const legacyHash = '$2b$10$abcdefghijklmnopqrstuuABCDEFGHIJKLMNOPQRSTUVWXYZ012';
+    const result = await verifyPin('1234', legacyHash);
+    assert.strictEqual(result, false);
+});
+test('verifyPin returns false for malformed scrypt hash (missing parts)', async () => {
+    _resetForTesting();
+    const result = await verifyPin('1234', 'scrypt:saltonly');
+    assert.strictEqual(result, false);
+});
+test('verifyPin returns false for scrypt hash with empty salt', async () => {
+    _resetForTesting();
+    const result = await verifyPin('1234', 'scrypt::deadbeef');
+    assert.strictEqual(result, false);
+});
+test('verifyPin returns false for scrypt hash with wrong key length', async () => {
+    _resetForTesting();
+    // Valid hex but wrong length (should be 64 bytes = 128 hex chars)
+    const result = await verifyPin('1234', 'scrypt:abcd1234:deadbeef');
+    assert.strictEqual(result, false);
+});
+test('verifyPin returns false for completely empty hash', async () => {
+    _resetForTesting();
+    const result = await verifyPin('1234', '');
+    assert.strictEqual(result, false);
+});
+test('verifyPin returns false for garbage input', async () => {
+    _resetForTesting();
+    const result = await verifyPin('1234', 'not-a-valid-hash-at-all');
+    assert.strictEqual(result, false);
+});
+test('hashPin produces unique salts', async () => {
+    _resetForTesting();
+    const hash1 = await hashPin('1234');
+    const hash2 = await hashPin('1234');
+    assert.notStrictEqual(hash1, hash2, 'Two hashes of the same PIN should have different salts');
+    // But both should verify correctly
+    assert.strictEqual(await verifyPin('1234', hash1), true);
+    assert.strictEqual(await verifyPin('1234', hash2), true);
+});
+test('isLegacyHash returns true for bcrypt hashes', () => {
+    assert.strictEqual(isLegacyHash('$2b$10$abcdefghijklmnopqrstuuABCDEFGHIJKLMNOPQRSTUVWXYZ012'), true);
+    assert.strictEqual(isLegacyHash('$2a$10$someotherbcrypthashvalue'), true);
+});
+test('isLegacyHash returns false for scrypt hashes', async () => {
+    const hash = await hashPin('1234');
+    assert.strictEqual(isLegacyHash(hash), false);
+});
+test('isLegacyHash returns false for empty string', () => {
+    assert.strictEqual(isLegacyHash(''), false);
+});
+test('generateCookieToken returns non-empty string', () => {
+    _resetForTesting();
+    const token = generateCookieToken();
+    assert.ok(typeof token === 'string' && token.length > 0);
+});
+test('verifyPin returns false for undefined hash', async () => {
+    _resetForTesting();
+    const result = await verifyPin('1234', undefined);
+    assert.strictEqual(result, false);
+});
+test('verifyPin returns false for null hash', async () => {
+    _resetForTesting();
+    const result = await verifyPin('1234', null);
+    assert.strictEqual(result, false);
+});

package/dist/test/backend-state.test.js

@@ -0,0 +1,47 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { computeBackendState, fireBackendStateIfChanged, onBackendStateChange, } from '../server/sessions.js';
+// Minimal mock session shape for computeBackendState
+function mockState(agentState, idle) {
+    return { agentState, idle };
+}
+describe('computeBackendState', () => {
+    it('maps processing + idle=false to running', () => {
+        assert.equal(computeBackendState(mockState('processing', false)), 'running');
+    });
+    it('maps initializing + idle=false to initializing', () => {
+        assert.equal(computeBackendState(mockState('initializing', false)), 'initializing');
+    });
+    it('maps idle + idle=true to idle', () => {
+        assert.equal(computeBackendState(mockState('idle', true)), 'idle');
+    });
+    it('maps waiting-for-input + idle=true to idle', () => {
+        assert.equal(computeBackendState(mockState('waiting-for-input', true)), 'idle');
+    });
+    it('maps permission-prompt + idle=false to permission', () => {
+        assert.equal(computeBackendState(mockState('permission-prompt', false)), 'permission');
+    });
+    it('maps error + idle=false to error', () => {
+        assert.equal(computeBackendState(mockState('error', false)), 'error');
+    });
+});
+describe('fireBackendStateIfChanged', () => {
+    it('fires callback only once when called twice with the same state', () => {
+        const calls = [];
+        onBackendStateChange((sessionId, state) => {
+            calls.push([sessionId, state]);
+        });
+        // Minimal session mock — only the fields fireBackendStateIfChanged needs
+        const session = {
+            id: 'test-session-dedup',
+            agentState: 'processing',
+            idle: false,
+            _lastEmittedBackendState: undefined,
+        };
+        fireBackendStateIfChanged(session);
+        fireBackendStateIfChanged(session); // same state — should be a no-op
+        const relevant = calls.filter(([id]) => id === 'test-session-dedup');
+        assert.equal(relevant.length, 1, 'callback should fire exactly once for duplicate state');
+        assert.equal(relevant[0][1], 'running');
+    });
+});

package/dist/test/belayer-executor.test.js

@@ -0,0 +1,33 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { buildClaudeArgs, parseVerdictFile } from '../server/belayer/executor.js';
+test('buildClaudeArgs includes -p and --dangerously-skip-permissions', () => {
+    const args = buildClaudeArgs('opus');
+    assert.ok(args.includes('-p'));
+    assert.ok(args.includes('--dangerously-skip-permissions'));
+});
+test('buildClaudeArgs includes --model flag', () => {
+    const args = buildClaudeArgs('sonnet');
+    const modelIdx = args.indexOf('--model');
+    assert.ok(modelIdx >= 0);
+    assert.equal(args[modelIdx + 1], 'sonnet');
+});
+test('parseVerdictFile parses valid verdict JSON', () => {
+    const json = JSON.stringify({
+        goalName: 'Test',
+        pass: true,
+        criteriaResults: [{ criterion: 'Works', met: true }],
+        summary: 'All good',
+        timestamp: '2026-03-05T00:00:00.000Z',
+    });
+    const verdict = parseVerdictFile(json);
+    assert.ok(verdict);
+    assert.equal(verdict.pass, true);
+    assert.equal(verdict.goalName, 'Test');
+});
+test('parseVerdictFile returns null for invalid JSON', () => {
+    assert.equal(parseVerdictFile('not json'), null);
+});
+test('parseVerdictFile returns null for missing required fields', () => {
+    assert.equal(parseVerdictFile(JSON.stringify({ pass: true })), null);
+});

package/dist/test/belayer-intake.test.js

@@ -0,0 +1,44 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { TextSource, resolveTaskSource } from '../server/belayer/intake.js';
+test('TextSource.canHandle returns true for any non-empty string', () => {
+    const source = new TextSource();
+    assert.equal(source.canHandle('hello world'), true);
+    assert.equal(source.canHandle(''), false);
+});
+test('TextSource.name is "text"', () => {
+    const source = new TextSource();
+    assert.equal(source.name, 'text');
+});
+test('TextSource.fetch extracts title from first line', async () => {
+    const source = new TextSource();
+    const spec = await source.fetch('Add expense export feature\nShould export to CSV and PDF');
+    assert.equal(spec.source, 'text');
+    assert.equal(spec.title, 'Add expense export feature');
+    assert.equal(spec.description, 'Should export to CSV and PDF');
+});
+test('TextSource.fetch handles single-line input', async () => {
+    const source = new TextSource();
+    const spec = await source.fetch('Fix the login bug');
+    assert.equal(spec.title, 'Fix the login bug');
+    assert.equal(spec.description, 'Fix the login bug');
+});
+test('TextSource.fetch trims whitespace', async () => {
+    const source = new TextSource();
+    const spec = await source.fetch('  Trim me  \n  Some description  ');
+    assert.equal(spec.title, 'Trim me');
+    assert.equal(spec.description, 'Some description');
+});
+test('TextSource.fetch handles multi-line descriptions', async () => {
+    const source = new TextSource();
+    const spec = await source.fetch('Title\nLine 1\nLine 2\nLine 3');
+    assert.equal(spec.title, 'Title');
+    assert.equal(spec.description, 'Line 1\nLine 2\nLine 3');
+});
+test('resolveTaskSource returns TextSource for plain text', () => {
+    const source = resolveTaskSource('Just some text');
+    assert.equal(source.name, 'text');
+});
+test('resolveTaskSource throws for empty input', () => {
+    assert.throws(() => resolveTaskSource(''), /No task source can handle empty input/);
+});

package/dist/test/belayer-pipeline.test.js

@@ -0,0 +1,113 @@
+import { test, before, after, afterEach } 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 { createPipeline, getPipeline, listPipelines, transitionPipeline, deletePipeline, loadAllPipelines, setPipelinesDir, clearPipelines } from '../server/belayer/pipeline.js';
+import { DEFAULT_PIPELINE_CONFIG } from '../server/belayer/types.js';
+let tmpDir;
+before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'belayer-pipeline-test-'));
+    setPipelinesDir(tmpDir);
+});
+afterEach(() => {
+    // Clean up in-memory and disk state between tests
+    clearPipelines();
+    for (const entry of fs.readdirSync(tmpDir)) {
+        const fullPath = path.join(tmpDir, entry);
+        fs.rmSync(fullPath, { recursive: true, force: true });
+    }
+});
+after(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+const testTask = {
+    source: 'text',
+    title: 'Test Task',
+    description: 'A test task description',
+};
+test('createPipeline creates a pipeline in intake state', () => {
+    const pipeline = createPipeline(testTask, { ...DEFAULT_PIPELINE_CONFIG, targetRepo: '/tmp/repo' });
+    assert.equal(pipeline.state, 'intake');
+    assert.equal(pipeline.task.title, 'Test Task');
+    assert.equal(pipeline.attempts, 0);
+    assert.ok(pipeline.id);
+    assert.ok(pipeline.createdAt);
+});
+test('createPipeline persists to disk', () => {
+    const pipeline = createPipeline(testTask, { ...DEFAULT_PIPELINE_CONFIG, targetRepo: '/tmp/repo' });
+    const filePath = path.join(tmpDir, pipeline.id + '.json');
+    assert.ok(fs.existsSync(filePath));
+    const loaded = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    assert.equal(loaded.id, pipeline.id);
+});
+test('getPipeline returns a stored pipeline', () => {
+    const created = createPipeline(testTask, { ...DEFAULT_PIPELINE_CONFIG, targetRepo: '/tmp/repo' });
+    const fetched = getPipeline(created.id);
+    assert.ok(fetched);
+    assert.equal(fetched.id, created.id);
+    assert.equal(fetched.state, 'intake');
+});
+test('getPipeline returns null for unknown id', () => {
+    assert.equal(getPipeline('nonexistent'), null);
+});
+test('listPipelines returns all pipelines', () => {
+    createPipeline(testTask, { ...DEFAULT_PIPELINE_CONFIG, targetRepo: '/tmp/repo' });
+    createPipeline({ ...testTask, title: 'Second' }, { ...DEFAULT_PIPELINE_CONFIG, targetRepo: '/tmp/repo' });
+    const list = listPipelines();
+    assert.equal(list.length, 2);
+});
+test('transitionPipeline moves to valid next state', () => {
+    const pipeline = createPipeline(testTask, { ...DEFAULT_PIPELINE_CONFIG, targetRepo: '/tmp/repo' });
+    const updated = transitionPipeline(pipeline.id, 'brainstorming');
+    assert.equal(updated.state, 'brainstorming');
+});
+test('transitionPipeline rejects invalid transition', () => {
+    const pipeline = createPipeline(testTask, { ...DEFAULT_PIPELINE_CONFIG, targetRepo: '/tmp/repo' });
+    assert.throws(() => transitionPipeline(pipeline.id, 'executing'), /Invalid transition from intake to executing/);
+});
+test('transitionPipeline persists state change', () => {
+    const pipeline = createPipeline(testTask, { ...DEFAULT_PIPELINE_CONFIG, targetRepo: '/tmp/repo' });
+    transitionPipeline(pipeline.id, 'brainstorming');
+    const filePath = path.join(tmpDir, pipeline.id + '.json');
+    const loaded = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    assert.equal(loaded.state, 'brainstorming');
+});
+test('transitionPipeline updates updatedAt timestamp', () => {
+    const pipeline = createPipeline(testTask, { ...DEFAULT_PIPELINE_CONFIG, targetRepo: '/tmp/repo' });
+    const before = pipeline.updatedAt;
+    // Small delay to ensure timestamp differs
+    const updated = transitionPipeline(pipeline.id, 'brainstorming');
+    assert.ok(updated.updatedAt >= before);
+});
+test('deletePipeline removes pipeline from memory and disk', () => {
+    const pipeline = createPipeline(testTask, { ...DEFAULT_PIPELINE_CONFIG, targetRepo: '/tmp/repo' });
+    deletePipeline(pipeline.id);
+    assert.equal(getPipeline(pipeline.id), null);
+    const filePath = path.join(tmpDir, pipeline.id + '.json');
+    assert.ok(!fs.existsSync(filePath));
+});
+test('loadAllPipelines restores from disk', () => {
+    const p1 = createPipeline(testTask, { ...DEFAULT_PIPELINE_CONFIG, targetRepo: '/tmp/repo' });
+    const p2 = createPipeline({ ...testTask, title: 'Other' }, { ...DEFAULT_PIPELINE_CONFIG, targetRepo: '/tmp/repo' });
+    // Clear in-memory state
+    deletePipeline(p1.id);
+    deletePipeline(p2.id);
+    // Write files back manually to simulate server restart
+    fs.writeFileSync(path.join(tmpDir, 'fake-id.json'), JSON.stringify({ ...p1, id: 'fake-id' }));
+    loadAllPipelines();
+    const loaded = getPipeline('fake-id');
+    assert.ok(loaded);
+    assert.equal(loaded.task.title, 'Test Task');
+});
+test('transitionPipeline to retry increments attempts', () => {
+    const pipeline = createPipeline(testTask, { ...DEFAULT_PIPELINE_CONFIG, targetRepo: '/tmp/repo' });
+    transitionPipeline(pipeline.id, 'brainstorming');
+    transitionPipeline(pipeline.id, 'prd_review');
+    transitionPipeline(pipeline.id, 'planning');
+    transitionPipeline(pipeline.id, 'plan_review');
+    transitionPipeline(pipeline.id, 'executing');
+    transitionPipeline(pipeline.id, 'reviewing');
+    const retried = transitionPipeline(pipeline.id, 'retry');
+    assert.equal(retried.attempts, 1);
+});

package/dist/test/belayer-pr-lifecycle.test.js

@@ -0,0 +1,26 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { buildPrTitle, buildPrBody } from '../server/belayer/pr-lifecycle.js';
+const testTask = {
+    source: 'text',
+    title: 'Add CSV export',
+    description: 'Users should be able to export data as CSV files',
+};
+test('buildPrTitle returns formatted title', () => {
+    const title = buildPrTitle(testTask);
+    assert.equal(title, 'feat: Add CSV export');
+});
+test('buildPrBody includes task description', () => {
+    const body = buildPrBody(testTask, '# PRD content', 1);
+    assert.ok(body.includes('Add CSV export'));
+    assert.ok(body.includes('export data as CSV files'));
+});
+test('buildPrBody includes attempt count', () => {
+    const body = buildPrBody(testTask, '# PRD', 2);
+    assert.ok(body.includes('2'));
+});
+test('buildPrBody includes PRD content in collapsible section', () => {
+    const body = buildPrBody(testTask, '# My PRD', 1);
+    assert.ok(body.includes('<details>'));
+    assert.ok(body.includes('# My PRD'));
+});