gsd-unsupervised 1.0.0

package/dist/state-watcher.js

@@ -0,0 +1,148 @@
+import { EventEmitter } from 'node:events';
+import chokidar from 'chokidar';
+import { readStateFile } from './state-index.js';
+/**
+ * Watches STATE.md for changes, parses content, and emits typed progress events.
+ * Used by the daemon and dashboard for real-time progress visibility.
+ */
+export class StateWatcher extends EventEmitter {
+    stateMdPath;
+    debounceMs;
+    logger;
+    watcher = null;
+    debounceTimer = null;
+    lastSnapshot = null;
+    goalCompleteEmitted = false;
+    constructor(options) {
+        super();
+        const { stateMdPath, debounceMs = 500, logger } = options;
+        this.stateMdPath = stateMdPath;
+        this.debounceMs = debounceMs;
+        this.logger = logger;
+    }
+    start() {
+        if (this.watcher) {
+            return;
+        }
+        this.watcher = chokidar.watch(this.stateMdPath, {
+            persistent: true,
+            ignoreInitial: false,
+        });
+        const onFileEvent = () => {
+            if (this.debounceTimer) {
+                clearTimeout(this.debounceTimer);
+            }
+            this.debounceTimer = setTimeout(() => {
+                this.debounceTimer = null;
+                this.handleChange();
+            }, this.debounceMs);
+        };
+        this.watcher.on('add', onFileEvent);
+        this.watcher.on('change', onFileEvent);
+        this.watcher.on('error', (err) => {
+            this.logger.warn({ err }, 'StateWatcher file error');
+        });
+    }
+    async handleChange() {
+        let snapshot = null;
+        try {
+            snapshot = await readStateFile(this.stateMdPath, this.logger);
+        }
+        catch (err) {
+            this.logger.warn({ err }, 'StateWatcher read failed, keeping last snapshot');
+            return;
+        }
+        if (snapshot === null) {
+            this.logger.debug('STATE.md missing or unparseable');
+            return;
+        }
+        const previous = this.lastSnapshot;
+        if (previous !== null) {
+            const isNoop = previous.phaseNumber === snapshot.phaseNumber &&
+                previous.totalPhases === snapshot.totalPhases &&
+                previous.phaseName === snapshot.phaseName &&
+                previous.planNumber === snapshot.planNumber &&
+                previous.totalPlans === snapshot.totalPlans &&
+                previous.status === snapshot.status &&
+                (previous.progressPercent ?? null) === (snapshot.progressPercent ?? null) &&
+                (previous.gitSha ?? null) === (snapshot.gitSha ?? null);
+            if (isNoop) {
+                this.logger.debug({
+                    phase: snapshot.phaseNumber,
+                    plan: snapshot.planNumber,
+                    status: snapshot.status,
+                }, 'state_noop');
+                return;
+            }
+        }
+        if (previous === null) {
+            this.emit('ready', snapshot);
+            this.logger.info({ path: this.stateMdPath }, 'STATE.md first detected');
+        }
+        this.emit('state_changed', { previous, current: snapshot });
+        this.logger.info({
+            phase: snapshot.phaseNumber,
+            plan: snapshot.planNumber,
+            status: snapshot.status,
+            progressPercent: snapshot.progressPercent,
+        }, 'state_changed');
+        if (previous !== null) {
+            if (snapshot.phaseNumber > previous.phaseNumber) {
+                const phaseName = snapshot.phaseName;
+                this.emit('phase_advanced', {
+                    fromPhase: previous.phaseNumber,
+                    toPhase: snapshot.phaseNumber,
+                    phaseName,
+                });
+                this.logger.info({ fromPhase: previous.phaseNumber, toPhase: snapshot.phaseNumber, phaseName }, 'phase_advanced');
+            }
+            if (snapshot.phaseNumber === previous.phaseNumber &&
+                snapshot.planNumber > previous.planNumber) {
+                this.emit('plan_advanced', {
+                    phaseNumber: snapshot.phaseNumber,
+                    fromPlan: previous.planNumber,
+                    toPlan: snapshot.planNumber,
+                });
+                this.logger.info({
+                    phaseNumber: snapshot.phaseNumber,
+                    fromPlan: previous.planNumber,
+                    toPlan: snapshot.planNumber,
+                }, 'plan_advanced');
+            }
+            const statusComplete = /complete/i.test(snapshot.status);
+            const prevComplete = /complete/i.test(previous.status);
+            if (statusComplete &&
+                (previous.phaseNumber !== snapshot.phaseNumber || !prevComplete)) {
+                this.emit('phase_completed', {
+                    phaseNumber: snapshot.phaseNumber,
+                    phaseName: snapshot.phaseName,
+                });
+                this.logger.info({ phaseNumber: snapshot.phaseNumber, phaseName: snapshot.phaseName }, 'phase_completed');
+            }
+        }
+        if (snapshot.phaseNumber === snapshot.totalPhases &&
+            /complete/i.test(snapshot.status)) {
+            if (!this.goalCompleteEmitted) {
+                this.goalCompleteEmitted = true;
+                const progressPercent = snapshot.progressPercent ?? 100;
+                this.emit('goal_completed', { progressPercent });
+                this.logger.info({ progressPercent }, 'goal_completed');
+            }
+        }
+        this.lastSnapshot = snapshot;
+    }
+    stop() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+        this.removeAllListeners();
+    }
+    getLastSnapshot() {
+        return this.lastSnapshot;
+    }
+}

package/dist/status-server.d.ts

@@ -0,0 +1,112 @@
+/** Schema for .planning/config.json parallelization slice (exposed via /api/config). */
+export interface PlanningConfig {
+    mode?: string;
+    depth?: string;
+    parallelization?: {
+        enabled?: boolean;
+        plan_level?: boolean;
+        task_level?: boolean;
+        skip_checkpoints?: boolean;
+        max_concurrent_agents?: number;
+        min_plans_for_parallel?: number;
+    };
+    gates?: Record<string, boolean>;
+    safety?: Record<string, boolean>;
+}
+export interface StatusPayload {
+    running: boolean;
+    currentGoal?: string;
+    phaseNumber?: number;
+    planNumber?: number;
+    heartbeat?: string;
+}
+/** Dashboard-oriented rich payload for GET /api/status. */
+export interface DashboardStatusPayload {
+    /** Legacy-compatible minimal fields. */
+    running: boolean;
+    currentGoal?: string;
+    phaseNumber?: number;
+    planNumber?: number;
+    heartbeat?: string;
+    /** Current agent session ID (from last session log entry). */
+    currentAgentId?: string | null;
+    /** Current phase/plan from STATE.md. */
+    stateSnapshot?: {
+        phaseNumber: number;
+        totalPhases: number;
+        phaseName: string;
+        planNumber: number;
+        totalPlans: number;
+        status: string;
+        lastActivity: string;
+        progressPercent: number | null;
+    } | null;
+    /** Last N session log entries (rolling window). */
+    sessionLogEntries?: Array<{
+        timestamp: string;
+        goalTitle: string;
+        phase: string;
+        phaseNumber?: number;
+        planNumber?: number;
+        sessionId: string | null;
+        status: string;
+    }>;
+    /** Last N git commits (hash, message, timestamp). */
+    gitFeed?: Array<{
+        hash: string;
+        message: string;
+        timestamp: string;
+    }>;
+    /** Placeholder for token/cost tracking (populated later). */
+    tokens?: {
+        prompt?: number;
+        completion?: number;
+        total?: number;
+    };
+    /** Placeholder for cost tracking (populated later). */
+    cost?: {
+        amount?: number;
+        currency?: string;
+    };
+    /** Current system load information (best-effort). */
+    systemLoad?: import('./resource-governor.js').LoadInfo & {
+        maxCpuFraction?: number;
+        maxMemoryFraction?: number;
+    };
+}
+/** Optional webhook: add goals/todos via API or Twilio inbound. */
+export interface WebhookOptions {
+    goalsPath: string;
+    workspaceRoot: string;
+    /** Callback when a goal is added (persisted to goals.md by route). */
+    onQueueGoal: (goal: import('./goals.js').Goal) => void;
+    /** Titles of goals currently being executed (for dedup on reload). */
+    getRunningTitles: () => string[];
+    /** Create a todo file; returns path. */
+    addTodo: (title: string, area?: string) => Promise<string>;
+}
+export interface StatusServerOptions {
+    stateMdPath: string;
+    sessionLogPath: string;
+    workspaceRoot: string;
+    /** Path to .planning/config.json for GET/POST /api/config (optional). */
+    planningConfigPath?: string;
+    /** Max session log entries in dashboard payload (default 20). */
+    sessionLogLimit?: number;
+    /** Max git commits in feed (default 10). */
+    gitFeedLimit?: number;
+    /** When set, enables POST /api/goals, POST /api/todos, POST /webhook/twilio. */
+    webhook?: WebhookOptions;
+}
+export declare function readPlanningConfig(path: string): Promise<PlanningConfig>;
+/**
+ * Creates an Express-based HTTP server that serves:
+ * - GET /: dashboard HTML (when options are provided) or legacy JSON.
+ * - GET /status: legacy JSON status (same shape as before).
+ * - GET /api/status: rich dashboard JSON (agent, goal, phase/plan, state snapshot, session log window, git feed, token/cost placeholders).
+ * When options are provided, / serves the dashboard and /api/status is enabled; otherwise / and /status return legacy JSON.
+ */
+export declare function createStatusServer(port: number, getStatus: () => StatusPayload, options?: StatusServerOptions): {
+    server: import('node:http').Server;
+    close: () => Promise<void>;
+};

package/dist/status-server.js

@@ -0,0 +1,379 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import express from 'express';
+import { appendPendingGoal } from './goals.js';
+function escapeTwiML(s) {
+    return s
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+import { readStateMd } from './state-parser.js';
+import { readSessionLog } from './session-log.js';
+import { getRecentCommits } from './git.js';
+import { currentLoadInfo } from './resource-governor.js';
+const DEFAULT_PLANNING_CONFIG = {
+    mode: 'interactive',
+    depth: 'standard',
+    parallelization: {
+        enabled: false,
+        plan_level: false,
+        task_level: false,
+        skip_checkpoints: false,
+        max_concurrent_agents: 3,
+        min_plans_for_parallel: 2,
+    },
+};
+export async function readPlanningConfig(path) {
+    if (!existsSync(path))
+        return { ...DEFAULT_PLANNING_CONFIG };
+    try {
+        const raw = await readFile(path, 'utf-8');
+        const data = JSON.parse(raw);
+        return {
+            ...DEFAULT_PLANNING_CONFIG,
+            ...data,
+            parallelization: { ...DEFAULT_PLANNING_CONFIG.parallelization, ...data.parallelization },
+        };
+    }
+    catch {
+        return { ...DEFAULT_PLANNING_CONFIG };
+    }
+}
+async function writePlanningConfig(path, config) {
+    await writeFile(path, JSON.stringify(config, null, 2), 'utf-8');
+}
+/** Returns inline HTML for the dashboard (mobile-first, no build). */
+function getDashboardHtml() {
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>GSD Autopilot</title>
+  <style>
+    :root { --bg: #0f0f12; --card: #1a1a1f; --text: #e4e4e7; --muted: #71717a; --accent: #22c55e; --border: #27272a; }
+    @media (prefers-color-scheme: light) {
+      :root { --bg: #fafafa; --card: #fff; --text: #18181b; --muted: #71717a; --accent: #16a34a; --border: #e4e4e7; }
+    }
+    * { box-sizing: border-box; }
+    body { margin: 0; font-family: system-ui, sans-serif; background: var(--bg); color: var(--text); min-height: 100vh; }
+    .container { max-width: 720px; margin: 0 auto; padding: 1rem; }
+    header { display: flex; flex-wrap: wrap; align-items: center; gap: 0.75rem; margin-bottom: 1.25rem; padding-bottom: 1rem; border-bottom: 1px solid var(--border); }
+    h1 { margin: 0; font-size: 1.25rem; font-weight: 600; }
+    .badge { font-size: 0.75rem; padding: 0.2rem 0.5rem; border-radius: 9999px; background: var(--card); color: var(--muted); }
+    .badge.running { background: rgba(34,197,94,0.2); color: var(--accent); }
+    .card { background: var(--card); border: 1px solid var(--border); border-radius: 8px; padding: 1rem; margin-bottom: 1rem; }
+    .card h2 { margin: 0 0 0.5rem; font-size: 0.875rem; font-weight: 600; color: var(--muted); }
+    .progress-wrap { height: 8px; background: var(--border); border-radius: 4px; overflow: hidden; margin-top: 0.5rem; }
+    .progress-bar { height: 100%; background: var(--accent); border-radius: 4px; transition: width 0.3s ease; }
+    .git-feed { font-size: 0.8125rem; }
+    .git-feed li { list-style: none; padding: 0.35rem 0; border-bottom: 1px solid var(--border); display: flex; flex-direction: column; gap: 0.15rem; }
+    .git-feed li:last-child { border-bottom: 0; }
+    .git-hash { font-family: ui-monospace, monospace; color: var(--muted); font-size: 0.75rem; }
+    .metrics { display: grid; grid-template-columns: repeat(auto-fill, minmax(120px, 1fr)); gap: 0.75rem; }
+    .metrics span { font-size: 0.8125rem; color: var(--muted); }
+    .toggle-wrap { display: flex; align-items: center; gap: 0.5rem; flex-wrap: wrap; }
+    .toggle { position: relative; width: 44px; height: 24px; background: var(--border); border-radius: 9999px; cursor: pointer; border: none; }
+    .toggle.on { background: var(--accent); }
+    .toggle::after { content: ''; position: absolute; top: 2px; left: 2px; width: 20px; height: 20px; background: #fff; border-radius: 50%; transition: transform 0.2s; }
+    .toggle.on::after { transform: translateX(20px); }
+    .toggle-label { font-size: 0.875rem; }
+    .error-msg { font-size: 0.8125rem; color: #ef4444; margin-top: 0.25rem; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <header>
+      <h1>GSD Autopilot</h1>
+      <span class="badge" id="status-badge">—</span>
+      <span class="badge" id="agent-badge">Agent: —</span>
+    </header>
+    <section class="card" id="goal-card">
+      <h2>Current goal</h2>
+      <p id="goal-title" style="margin:0;">—</p>
+      <div class="progress-wrap"><div class="progress-bar" id="progress-bar" style="width:0%"></div></div>
+      <p id="phase-plan" style="margin:0.5rem 0 0;font-size:0.8125rem;color:var(--muted)">—</p>
+    </section>
+    <section class="card">
+      <h2>Recent commits</h2>
+      <ul class="git-feed" id="git-feed"></ul>
+    </section>
+    <section class="card">
+      <h2>Tokens / cost</h2>
+      <div class="metrics" id="metrics"><span>—</span></div>
+    </section>
+    <section class="card" id="config-section">
+      <h2>Execution mode</h2>
+      <div class="toggle-wrap">
+        <button type="button" class="toggle" id="mode-toggle" aria-label="Parallel mode"></button>
+        <span class="toggle-label" id="mode-label">Sequential</span>
+      </div>
+      <p class="error-msg" id="config-error" style="display:none"></p>
+    </section>
+  </div>
+  <script>
+    const API = '/api/status';
+    const CONFIG_API = '/api/config';
+    const REFRESH_MS = 10000;
+
+    function render(data) {
+      document.getElementById('status-badge').textContent = data.running ? 'Running' : 'Stopped';
+      document.getElementById('status-badge').className = 'badge' + (data.running ? ' running' : '');
+      document.getElementById('agent-badge').textContent = 'Agent: ' + (data.currentAgentId || '—');
+      document.getElementById('goal-title').textContent = data.currentGoal || '—';
+      const snap = data.stateSnapshot || null;
+      const pct = snap && snap.progressPercent != null ? snap.progressPercent : 0;
+      document.getElementById('progress-bar').style.width = pct + '%';
+      document.getElementById('phase-plan').textContent = snap
+        ? 'Phase ' + snap.phaseNumber + '/' + snap.totalPhases + ' · Plan ' + snap.planNumber + '/' + snap.totalPlans + ' — ' + snap.status
+        : '—';
+      const feed = document.getElementById('git-feed');
+      feed.innerHTML = (data.gitFeed || []).map(function(c) {
+        return '<li><span class="git-hash">' + c.hash + '</span> ' + escapeHtml(c.message) + ' <span style="color:var(--muted)">' + c.timestamp + '</span></li>';
+      }).join('') || '<li>No commits</li>';
+      const t = data.tokens || {};
+      const cost = data.cost || {};
+      document.getElementById('metrics').innerHTML = ('<span>Tokens: ' + (t.total ?? '—') + '</span><span>Cost: ' + (cost.amount != null ? cost.amount + ' ' + (cost.currency || '') : '—') + '</span>');
+    }
+
+    function escapeHtml(s) {
+      const div = document.createElement('div');
+      div.textContent = s;
+      return div.innerHTML;
+    }
+
+    function renderConfig(parallel) {
+      var t = document.getElementById('mode-toggle');
+      var l = document.getElementById('mode-label');
+      t.classList.toggle('on', !!parallel);
+      l.textContent = parallel ? 'Parallel' : 'Sequential';
+    }
+
+    function fetchStatus() {
+      fetch(API).then(function(r) { return r.json(); }).then(render).catch(function() {});
+    }
+
+    function fetchConfig() {
+      fetch(CONFIG_API).then(function(r) { return r.json(); }).then(function(c) {
+        renderConfig(c.parallelization && c.parallelization.enabled);
+      }).catch(function() {});
+    }
+
+    document.getElementById('mode-toggle').addEventListener('click', function() {
+      var errEl = document.getElementById('config-error');
+      errEl.style.display = 'none';
+      fetch(CONFIG_API).then(function(r) { return r.json(); }).then(function(c) {
+        var next = !(c.parallelization && c.parallelization.enabled);
+        return fetch(CONFIG_API, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ parallelization: Object.assign({}, c.parallelization || {}, { enabled: next }) }) });
+      }).then(function(r) {
+        if (!r.ok) throw new Error(r.statusText);
+        return r.json();
+      }).then(function(c) {
+        renderConfig(c.parallelization && c.parallelization.enabled);
+      }).catch(function(e) {
+        errEl.textContent = 'Update failed: ' + e.message;
+        errEl.style.display = 'block';
+      });
+    });
+
+    fetchStatus();
+    fetchConfig();
+    setInterval(fetchStatus, REFRESH_MS);
+  </script>
+</body>
+</html>`;
+}
+/**
+ * Creates an Express-based HTTP server that serves:
+ * - GET /: dashboard HTML (when options are provided) or legacy JSON.
+ * - GET /status: legacy JSON status (same shape as before).
+ * - GET /api/status: rich dashboard JSON (agent, goal, phase/plan, state snapshot, session log window, git feed, token/cost placeholders).
+ * When options are provided, / serves the dashboard and /api/status is enabled; otherwise / and /status return legacy JSON.
+ */
+export function createStatusServer(port, getStatus, options) {
+    const app = express();
+    const sessionLogLimit = options?.sessionLogLimit ?? 20;
+    const gitFeedLimit = options?.gitFeedLimit ?? 10;
+    const planningConfigPath = options?.planningConfigPath;
+    app.use(express.json());
+    app.use(express.urlencoded({ extended: true }));
+    if (planningConfigPath) {
+        app.get('/api/config', async (_req, res) => {
+            try {
+                const config = await readPlanningConfig(planningConfigPath);
+                res.json(config);
+            }
+            catch (err) {
+                res.status(500).json({ error: String(err) });
+            }
+        });
+        app.post('/api/config', async (req, res) => {
+            try {
+                const body = req.body;
+                if (!body || typeof body !== 'object') {
+                    res.status(400).json({ error: 'Invalid JSON body' });
+                    return;
+                }
+                const current = await readPlanningConfig(planningConfigPath);
+                const nextParallelization = body.parallelization;
+                if (nextParallelization !== undefined) {
+                    if (typeof nextParallelization !== 'object' || nextParallelization === null) {
+                        res.status(400).json({ error: 'parallelization must be an object' });
+                        return;
+                    }
+                    const merged = {
+                        ...current.parallelization,
+                        ...nextParallelization,
+                    };
+                    if (merged.enabled !== undefined && typeof merged.enabled !== 'boolean') {
+                        res.status(400).json({ error: 'parallelization.enabled must be a boolean' });
+                        return;
+                    }
+                    current.parallelization = merged;
+                }
+                await writePlanningConfig(planningConfigPath, current);
+                res.json(current);
+            }
+            catch (err) {
+                res.status(500).json({ error: String(err) });
+            }
+        });
+    }
+    if (options?.webhook) {
+        const wh = options.webhook;
+        app.post('/api/goals', async (req, res) => {
+            try {
+                const title = typeof req.body?.title === 'string' ? req.body.title.trim() : '';
+                if (!title) {
+                    res.status(400).json({ error: 'Missing or invalid title' });
+                    return;
+                }
+                const priority = typeof req.body.priority === 'number' && Number.isFinite(req.body.priority)
+                    ? req.body.priority
+                    : undefined;
+                await appendPendingGoal(wh.goalsPath, title, priority);
+                const goal = {
+                    title,
+                    status: 'pending',
+                    raw: `- [ ] ${title}${priority != null ? ` [priority:${priority}]` : ''}`,
+                    priority,
+                };
+                wh.onQueueGoal(goal);
+                res.json({ ok: true, title });
+            }
+            catch (err) {
+                res.status(500).json({ error: String(err) });
+            }
+        });
+        app.post('/api/todos', async (req, res) => {
+            try {
+                const title = typeof req.body?.title === 'string' ? req.body.title.trim() : '';
+                if (!title) {
+                    res.status(400).json({ error: 'Missing or invalid title' });
+                    return;
+                }
+                const area = typeof req.body.area === 'string' ? req.body.area.trim() || 'general' : 'general';
+                const filePath = await wh.addTodo(title, area);
+                res.json({ ok: true, title, path: filePath });
+            }
+            catch (err) {
+                res.status(500).json({ error: String(err) });
+            }
+        });
+        app.post('/webhook/twilio', async (req, res) => {
+            const body = typeof req.body?.Body === 'string' ? req.body.Body.trim() : '';
+            const lower = body.toLowerCase();
+            let reply = '';
+            try {
+                if (lower.startsWith('add ') || lower.startsWith('goal ')) {
+                    const title = body.slice(body.toLowerCase().indexOf(' ') + 1).trim();
+                    if (title) {
+                        await appendPendingGoal(wh.goalsPath, title);
+                        const goal = {
+                            title,
+                            status: 'pending',
+                            raw: `- [ ] ${title}`,
+                        };
+                        wh.onQueueGoal(goal);
+                        reply = `Added goal: ${title}`;
+                    }
+                    else {
+                        reply = 'Usage: add <goal title> or goal <goal title>';
+                    }
+                }
+                else if (lower.startsWith('todo ')) {
+                    const title = body.slice(5).trim();
+                    if (title) {
+                        await wh.addTodo(title);
+                        reply = `Added todo: ${title}`;
+                    }
+                    else {
+                        reply = 'Usage: todo <task description>';
+                    }
+                }
+                else {
+                    reply =
+                        'Send: add <goal> | goal <goal> | todo <task>. Example: add Complete Phase 4';
+                }
+            }
+            catch (err) {
+                reply = `Error: ${String(err)}`;
+            }
+            res.type('text/xml').send(`<?xml version="1.0" encoding="UTF-8"?><Response><Message>${escapeTwiML(reply)}</Message></Response>`);
+        });
+    }
+    /** Dashboard at GET / when rich options provided; legacy JSON at GET /status. */
+    if (options) {
+        app.get('/', (_req, res) => {
+            res.type('html').send(getDashboardHtml());
+        });
+    }
+    else {
+        app.get('/', (_req, res) => {
+            res.json(getStatus());
+        });
+    }
+    app.get('/status', (_req, res) => {
+        res.json(getStatus());
+    });
+    /** Dashboard API: rich payload. */
+    app.get('/api/status', async (_req, res) => {
+        const legacy = getStatus();
+        const payload = {
+            ...legacy,
+            tokens: {},
+            cost: {},
+            systemLoad: currentLoadInfo(),
+        };
+        if (options) {
+            const [stateSnapshot, sessionLogEntries, gitFeed] = await Promise.all([
+                readStateMd(options.stateMdPath),
+                readSessionLog(options.sessionLogPath).then((entries) => entries.slice(-sessionLogLimit).reverse()),
+                getRecentCommits(options.workspaceRoot, gitFeedLimit),
+            ]);
+            payload.stateSnapshot = stateSnapshot ?? undefined;
+            payload.sessionLogEntries = sessionLogEntries.map((e) => ({
+                timestamp: e.timestamp,
+                goalTitle: e.goalTitle,
+                phase: e.phase,
+                phaseNumber: e.phaseNumber,
+                planNumber: e.planNumber,
+                sessionId: e.sessionId,
+                status: e.status,
+            }));
+            payload.gitFeed = gitFeed;
+            const lastEntry = sessionLogEntries[0];
+            if (lastEntry) {
+                payload.currentAgentId = lastEntry.sessionId;
+            }
+        }
+        res.json(payload);
+    });
+    const server = app.listen(port);
+    const close = () => new Promise((resolve, reject) => {
+        server.close((err) => (err ? reject(err) : resolve()));
+    });
+    return { server, close };
+}

package/dist/status-server.test.d.ts

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