osborn 0.9.149 → 0.9.151

package/dist/claude-llm.js

@@ -14,7 +14,7 @@ import { statusManager } from './status-manager.js';
 import { getResearchSystemPrompt, getDirectModeResearchPrompt } from './prompts.js';
 import { getIndexPath } from './summary-index.js';
 import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { join, dirname } from 'node:path';
+import { join, dirname, resolve, basename } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
 // Directory of this module — used to locate co-located prompt files (e.g., turn-shape reminder).
@@ -183,6 +183,11 @@ export const NAMED_AGENTS = {
             'Gather information the main agent needs to answer the user\'s question or make a decision.',
             'You are a scout — go find things, read them carefully, and report back.',
             '',
+            '## Grounding — check the session index first',
+            'Before researching, locate the session index (search-index.txt — a compact line-per-message log of this mission, under .claude/projects/<slug>/osb/<session>/; if several exist pick the most recently modified) and Grep it for the topic you are about to investigate. Read ONLY the matching slice, never the whole file.',
+            'Purpose: find what has ALREADY been decided, answered, or ruled out so you do not re-research a settled question. If the index already establishes the answer, report that (with the index reference) instead of redoing the work.',
+            'If you cannot find the index, proceed normally — this is an optimization, not a hard dependency.',
+            '',
             '## How to work',
             '1. Understand what information is needed and why.',
             '2. Search broadly first (Glob, Grep, WebSearch), then read deeply (Read specific files).',
@@ -278,6 +283,10 @@ export const NAMED_AGENTS = {
             'Handle ALL file operations — code, config, documentation, scripts, data files.',
             'You are the only agent that writes. The main agent and reasoner produce plans; you execute them.',
             '',
+            '## Grounding — consult the session index (light touch)',
+            'Before editing, locate the session index (search-index.txt under .claude/projects/<slug>/osb/<session>/; newest if several) and Grep it ONLY for: (a) the files/symbols you are about to change, and (b) any recorded DECISIONS or known GOTCHAS relevant to this change. Read only the matching lines — do NOT read the whole index (thousands of lines). This is a lighter dose than the reviewer: a targeted lookup.',
+            'If a decision or gotcha contradicts your task, STOP and report to the main agent before editing. If you find nothing or no index exists, proceed normally.',
+            '',
             '## VERIFY-FIRST workflow (mandatory)',
             '',
             '### Step 1: Verify assumptions',
@@ -317,7 +326,7 @@ export const NAMED_AGENTS = {
             'CI failures, checking compilation errors, verifying that a change did not break anything.',
             'Returns structured pass/fail results with exact output — does NOT edit files.',
         ].join(' '),
-        tools: ['Bash', 'Read', 'Glob', 'Grep'],
+        tools: ['Bash', 'Read', 'Glob', 'Grep', 'Write', 'Edit'],
         model: 'sonnet',
         prompt: [
             'You are Osborn\'s tester agent. Your job is running tests and builds, then reporting results.',
@@ -326,6 +335,11 @@ export const NAMED_AGENTS = {
             'Execute test suites, build commands, and linters. Interpret failures clearly.',
             'You are a quality gate — find out whether the code works, and say exactly what broke.',
             '',
+            '## Grounding — consult shared context before writing or running tests',
+            'Before deciding what to test, locate the session index (search-index.txt under .claude/projects/<slug>/osb/<session>/; newest if several) and Grep it for the changes/work under test. Also check any project docs and known-issues files (e.g. CONVENTIONS.md, docs/, a known-issues or gotchas doc if present) for: (a) KNOWN ISSUES and gotchas already recorded, and (b) what behavior is ALREADY covered by existing tests.',
+            'Purpose: target regression coverage at real GAPS and known-risk areas rather than testing blind or duplicating coverage — and stay IN SYNC with the reviewer, which reads the same sources.',
+            'Read only the relevant slice of the index, never the whole file. If you find nothing or no index/docs exist, proceed normally — this is an optimization, not a hard dependency.',
+            '',
             '## Backward-compatibility / regression mandate (CRITICAL)',
             'Existing test suites MUST still pass — any pre-existing test that breaks is a BLOCKER; report it as such.',
             'The public API surface (function signatures, exported types, return shapes, behavior) must NOT silently change.',
@@ -354,6 +368,16 @@ export const NAMED_AGENTS = {
             '- REGRESSIONS / COMPAT BREAKS: explicit list of any pre-existing tests that now fail or API changes that could break existing callers — tag each as BLOCKER',
             '- What you checked but found to be unrelated',
             '',
+            '## Backward-compatibility testing & building the test library',
+            'GROW THE LIBRARY OVER TIME: where coverage is missing for the behavior being verified,',
+            'CREATE a targeted regression test so the suite accumulates over time. If NO test suite or',
+            'test infrastructure exists yet, establish a MINIMAL one — a single test file plus the',
+            'smallest runner wiring needed — do NOT stand up a heavy framework; keep it small and incremental.',
+            '',
+            'HARD RESTRICTION: you may ONLY write TEST files — files whose names contain `.test.` or `.spec.`,',
+            'or files located under a `__tests__/` or `tests/` directory.',
+            'NEVER write source, config, or other files. The write-gate enforces this and will deny any non-test path.',
+            '',
             '## What NOT to do',
             '- Do NOT edit or write production files — report failures so the writer agent can fix them',
             '- Do NOT run destructive commands (no rm, no git push, no npm publish)',
@@ -382,6 +406,18 @@ export const NAMED_AGENTS = {
             'Turn a vague or large request into a precise, ordered implementation plan the writer can execute',
             'step by step without guessing. You are the bridge between "what" and "how".',
             '',
+            '## Grounding — plan against what already exists',
+            'Before drafting a plan, locate the session index (search-index.txt under .claude/projects/<slug>/osb/<session>/; newest if several) and Grep it for prior DECISIONS, constraints, and known GOTCHAS relevant to the task. Read only the matching slice, never the whole file.',
+            'Purpose: make the plan fit what has already been decided or tried — do not propose an approach the mission already ruled out. If a prior decision conflicts with the obvious plan, surface it in the plan rather than silently contradicting it.',
+            'If you cannot find the index, proceed normally.',
+            '',
+            '## Documentation at delivery milestones',
+            'Plans should account for documentation reconciliation at the point work is DELIVERED — when it ships,',
+            'goes live, or reaches a release milestone. Include a step (or an explicit note in VERIFY) to check',
+            'whether existing documentation still reflects what is changing, and flag it as a task if updates are',
+            'needed. Do NOT schedule doc updates for every incremental step; anchor them to the delivery boundary',
+            'so documentation stays stable between releases and does not silently drift out of sync when the work ships.',
+            '',
             '## How to work',
             '1. Read enough of the codebase to understand the current structure (Glob, Grep, Read).',
             '2. Identify every file that needs to change and why.',
@@ -439,10 +475,18 @@ export const NAMED_AGENTS = {
             '## Maintain documentation',
             'You MAY create and maintain project standards and conventions files. Specifically: adopt an existing',
             'standards doc if one is found, or create one (e.g. CONVENTIONS.md, docs/standards.md) when none exists',
-            'and the review reveals patterns worth recording. Keep documentation current as you review.',
+            'and the review reveals patterns worth recording.',
+            '',
+            'WHEN to reconcile docs: at the moment work is being DELIVERED — when a unit of work ships, goes live,',
+            'or reaches a release milestone. That is the checkpoint to verify whether existing documentation still',
+            'reflects what actually changed and update it if it has drifted. Do NOT update docs on every small',
+            'incremental change; wait for the natural delivery boundary so docs stay stable between releases.',
+            'Between delivery milestones, note discrepancies as findings in your verdict (MINOR or NIT) rather',
+            'than immediately rewriting documentation.',
+            '',
             'RESTRICTION: you may ONLY write files with documentation extensions: .md, .markdown, .mdx, .txt, .rst, .adoc.',
-            'You must NEVER write code, config, or source files (.ts, .js, .json, .env, etc.) — the write gate',
-            'enforces this at the system level and will deny any such attempt.',
+            'You must NEVER write source, config, or executable files — the write gate enforces this at the system',
+            'level and will deny any such attempt.',
             '',
             '## Backward-compatibility mandate',
             'For every change, explicitly verify:',
@@ -453,6 +497,15 @@ export const NAMED_AGENTS = {
             '- Existing callers and consumers of the changed code still work',
             'Tag any violation BLOCKER — silent compat breaks are the hardest bugs to catch after the fact.',
             '',
+            '## Regression test suite — run and correlate',
+            'If a backward-compatibility/regression test suite exists in the project (any test/ or __tests__/',
+            'directory, *.test.* or *.spec.* files, or a test script in package.json), RUN IT as part of your',
+            'review using Bash. Correlate the results into your verdict:',
+            '- A passing suite with no regressions: note it in WHAT IT CHECKED-AND-CLEARED.',
+            '- Any pre-existing test that now fails is a BLOCKER — include it as an ISSUES entry tagged BLOCKER.',
+            'Do not skip this step when a suite exists; a failing regression test is a hard blocker regardless',
+            'of whether the diff looks clean.',
+            '',
             '## How to work',
             '0. **Get the diff first (MANDATORY):** Run `git diff HEAD~1 HEAD --stat` then `git diff HEAD~1 HEAD`.',
             '   Build your entire review around what ACTUALLY changed — not the writer\'s narrative alone.',
@@ -1621,6 +1674,22 @@ class ClaudeLLMStream extends llm.LLMStream {
                                             console.log(`📝 Reviewer doc write allowed: ${reviewerPath}`);
                                             return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'ask' } };
                                         }
+                                        // Tester agent: ONLY test files allowed — fail closed
+                                        if (agentType === 'tester') {
+                                            const testerPath = String(toolInput.file_path || '');
+                                            const STRICT_TEST_FILE = /\.(test|spec)\.[jt]sx?$/;
+                                            const resolvedBase = testerPath ? basename(resolve(testerPath)) : '';
+                                            if (!testerPath || !STRICT_TEST_FILE.test(resolvedBase)) {
+                                                const reason = testerPath
+                                                    ? `Tester write denied: ${testerPath} is not a test file (basename must match .test.ts/tsx/js/jsx or .spec.ts/tsx/js/jsx). Tester may only write test files.`
+                                                    : 'Tester write denied: could not determine target file path. Failing closed.';
+                                                console.log(`🚫 Tester write blocked: ${testerPath || '(no path)'} — not a test file`);
+                                                this.#eventEmitter.emit('tool_blocked', { name: toolName, reason });
+                                                return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny' }, reason };
+                                            }
+                                            console.log(`🧪 Tester test-file write allowed: ${testerPath}`);
+                                            return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'ask' } };
+                                        }
                                         // All other agents (main, researcher, reasoner, etc.): workspace only
                                         const filePath = String(toolInput.file_path || '');
                                         if (filePath && !filePath.includes('/osb/') && !filePath.includes('.osborn/sessions/') && !filePath.includes('.osborn/research/')) {

package/dist/index.js

@@ -9,12 +9,13 @@ initializeLogger({ pretty: true, level: 'info' });
 // Each resumed query() adds listeners to the shared signal; default limit is 10
 import { setMaxListeners } from 'node:events';
 setMaxListeners(50);
-import { createServer } from 'http';
+import { createServer, request as httpRequest } from 'http';
 import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, mkdtempSync, cpSync, rmSync, statSync, utimesSync, createWriteStream } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn } from 'node:child_process';
-import { randomUUID } from 'node:crypto';
+import { randomUUID, randomBytes } from 'node:crypto';
+import { createConnection as netConnect } from 'node:net';
 import { createRequire } from 'node:module';
 // 0.9.71: createRequire for resolving package.json versions inside ESM
 const __sdkVersionRequire = createRequire(import.meta.url);
@@ -258,6 +259,48 @@ let leaveRoomHook = null;
 // as the existing fetch-log/save-log flow so we don't ship Supabase credentials
 // to the Fly machine.
 let bugReportHook = null;
+// Module-scope hook wired by main() once startCodeServer() is defined in its
+// closure. The /editor route in startApiServer() calls this to start the IDE
+// in the background without depending on main()'s closure directly.
+let codeServerStartHook = null;
+// ── IDE reverse-proxy (module scope — shared between startApiServer + main) ──
+// code-server runs on 127.0.0.1:8300; the agent proxies it through its own
+// public HTTP server so no Cloudflare tunnel is needed.
+const IDE_TARGET = 'http://127.0.0.1:8300';
+// Route prefixes that belong to the agent itself. The proxy fall-through checks
+// this list FIRST so it never intercepts an agent API path.
+const AGENT_ROUTE_PREFIXES = [
+    '/health', '/sessions', '/skills', '/agents', '/canvas', '/canvas-token',
+    '/canvas-stream', '/events', '/room-code', '/connect-room', '/leave-room',
+    '/report-bug', '/restart', '/tts', '/webhook', '/sessions/export',
+    '/sessions/import', '/sessions/manifest',
+    '/editor',
+];
+// Set true when code-server is confirmed ready; false when stopped/not running.
+// Proxy returns 404 while this is false.
+let ideProxyEnabled = false;
+// Bumped on every proxied HTTP request and WS upgrade so the idle watcher sees
+// real editor activity rather than code-server log noise.
+let ideLastProxiedActivity = 0;
+// Per-session cookie token minted when code-server becomes ready. The proxy
+// gate checks this token via the osborn_ide cookie — only requests carrying a
+// valid cookie are forwarded, so a forgotten agent route can never be silently
+// swallowed by the IDE proxy. Cleared in stopIde().
+let ideSessionToken = null;
+// Helper: parse the osborn_ide cookie from a request and return true iff it
+// matches the current ideSessionToken (and a token exists).
+function hasValidIdeCookie(req) {
+    if (!ideSessionToken)
+        return false;
+    const cookieHeader = req.headers.cookie || '';
+    for (const part of cookieHeader.split(';')) {
+        const [name, ...rest] = part.trim().split('=');
+        if (name.trim() === 'osborn_ide' && rest.join('=').trim() === ideSessionToken) {
+            return true;
+        }
+    }
+    return false;
+}
 const canvasClients = new Set();
 let latestCanvasShow = null; // last 'show' so a reconnecting canvas resyncs its visual
 function pushCanvas(evt) {
@@ -1430,6 +1473,77 @@ function startApiServer(workingDir, port) {
             }
             return;
         }
+        // ── /editor entry point ──────────────────────────────────────────────────
+        // Explicit door into the IDE. When code-server is ready this route mints the
+        // osborn_ide session cookie and 302s to / (where the proxy then forwards). If
+        // code-server is not yet running, it starts it in the background and returns a
+        // self-refreshing "Starting…" page so the user naturally re-hits /editor every
+        // 3 s until ready.
+        if (url.pathname === '/editor' && req.method === 'GET') {
+            // AUTH GATE (future): validate key / signed session before minting the cookie
+            if (ideProxyEnabled && ideSessionToken) {
+                // code-server is up — set cookie and redirect to root (code-server's asset base)
+                res.writeHead(302, {
+                    'Set-Cookie': `osborn_ide=${ideSessionToken}; Path=/; HttpOnly; SameSite=Lax`,
+                    'Location': '/',
+                });
+                res.end();
+            }
+            else {
+                // Not yet running — kick off start in the background, show "Starting…" page
+                if (codeServerStartHook) {
+                    codeServerStartHook().catch((err) => {
+                        console.error('❌ startCodeServer() from /editor failed:', err);
+                    });
+                }
+                res.writeHead(200, {
+                    'Content-Type': 'text/html; charset=utf-8',
+                    'Cache-Control': 'no-store, must-revalidate',
+                    'Pragma': 'no-cache',
+                });
+                res.end(`<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<meta http-equiv="refresh" content="3;url=/editor">
+<title>Starting editor…</title>
+<style>body{font-family:sans-serif;display:flex;align-items:center;justify-content:center;height:100vh;margin:0;background:#1e1e1e;color:#ccc}</style>
+</head><body><p>Starting your editor…</p></body></html>`);
+            }
+            return;
+        }
+        // ────────────────────────────────────────────────────────────────────────
+        // ── IDE reverse proxy (cookie-gated fall-through) ────────────────────────
+        // Forwards to code-server ONLY when:
+        //   1. ideProxyEnabled is true (code-server is confirmed ready), AND
+        //   2. the request carries a valid osborn_ide session cookie (primary gate), AND
+        //   3. the path is not an agent route (secondary backstop).
+        // A missing/invalid cookie means the request came from somewhere other than
+        // the /editor door — refuse it so a forgotten agent route is never swallowed.
+        if (ideProxyEnabled &&
+            hasValidIdeCookie(req) &&
+            !AGENT_ROUTE_PREFIXES.some(p => url.pathname === p || url.pathname.startsWith(p + '/'))) {
+            ideLastProxiedActivity = Date.now();
+            const targetUrl = new URL(req.url || '/', IDE_TARGET);
+            const options = {
+                hostname: '127.0.0.1',
+                port: 8300,
+                path: targetUrl.pathname + (targetUrl.search || ''),
+                method: req.method,
+                headers: { ...req.headers, host: '127.0.0.1:8300' },
+            };
+            const proxyReq = httpRequest(options, (proxyRes) => {
+                res.writeHead(proxyRes.statusCode || 502, proxyRes.headers);
+                proxyRes.pipe(res);
+            });
+            proxyReq.on('error', () => {
+                if (!res.headersSent) {
+                    res.writeHead(502);
+                    res.end('IDE proxy error');
+                }
+            });
+            req.pipe(proxyReq);
+            return;
+        }
+        // ────────────────────────────────────────────────────────────────────────
         res.writeHead(404, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ error: 'Not found' }));
     });
@@ -1467,11 +1581,53 @@ function startApiServer(workingDir, port) {
     };
     cleanStaleUploadDirs();
     setInterval(cleanStaleUploadDirs, 10 * 60 * 1000);
-    // No WebSocket upgrade routes — meeting audio in/out moved off LiveKit to
-    // a polling architecture (see MeetingTranscriptPoller). The /meeting-audio
-    // and /meeting-audio-in routes were the old WebSocket-audio pipeline; both
-    // are gone. Reject all upgrade attempts.
-    server.on('upgrade', (_req, socket) => {
+    // WebSocket upgrade handler: forward to code-server when the IDE proxy is
+    // active, the request carries a valid osborn_ide session cookie, and the path
+    // is not an agent route. code-server's terminal and editor are websocket-heavy
+    // — this must work for the integrated terminal to connect.
+    // Reject all other upgrades (meeting audio moved to polling in 0.9.xx).
+    server.on('upgrade', (req, socket, head) => {
+        const upgradePath = new URL(req.url || '/', `http://localhost`).pathname;
+        const isAgentRoute = AGENT_ROUTE_PREFIXES.some(p => upgradePath === p || upgradePath.startsWith(p + '/'));
+        if (ideProxyEnabled && hasValidIdeCookie(req) && !isAgentRoute) {
+            ideLastProxiedActivity = Date.now();
+            // Raw TCP tunnel: connect to code-server and splice the socket.
+            // Pause the client socket before initiating the connect so that any
+            // bytes the browser sends before the connect callback fires are buffered
+            // by Node rather than silently dropped — the classic silent-hang shape
+            // for a websocket terminal on a slow connect.
+            socket.pause();
+            const conn = netConnect(8300, '127.0.0.1', () => {
+                // Forward the original HTTP upgrade request headers.
+                const headerLines = [`${req.method} ${req.url} HTTP/1.1`];
+                for (const [k, v] of Object.entries(req.headers)) {
+                    if (k.toLowerCase() === 'host')
+                        continue;
+                    if (Array.isArray(v)) {
+                        for (const vv of v)
+                            headerLines.push(`${k}: ${vv}`);
+                    }
+                    else if (v != null)
+                        headerLines.push(`${k}: ${v}`);
+                }
+                headerLines.push('host: 127.0.0.1:8300');
+                conn.write(headerLines.join('\r\n') + '\r\n\r\n');
+                if (head && head.length)
+                    conn.write(head);
+                conn.pipe(socket);
+                socket.pipe(conn);
+                socket.resume();
+            });
+            conn.on('error', () => { try {
+                socket.destroy();
+            }
+            catch { } });
+            socket.on('error', () => { try {
+                conn.destroy();
+            }
+            catch { } });
+            return;
+        }
         socket.destroy();
     });
     server.on('error', (err) => {
@@ -1990,6 +2146,19 @@ async function main() {
     // the fresh session's latch was never opened by the name).
     const meetingSpeakers = new Set();
     let activeMeetingPoller = null; // Transcript poller bound to that bot
+    // ── IDE (code-server) state ──────────────────────────────────────────────
+    // All fields reset together in stopIde(). Never auto-started; only spawned
+    // by an explicit start_ide data-channel command from the frontend.
+    // Cloudflared is gone — exposure is via the agent's own HTTP server proxy
+    // (ideProxyEnabled at module scope, set/cleared by start_ide/stopIde).
+    let ideCodeServerProc = null;
+    let ideLastActivity = 0; // bumped on code-server stdout/stderr
+    let ideIdleWatcher = null;
+    // In-flight start promise: set for the duration of startCodeServer()'s async
+    // body, cleared in its finally. Concurrent callers (e.g. /editor page refreshes
+    // every 3s) return early instead of killing the process that is still booting.
+    let ideStartInProgress = null;
+    // ────────────────────────────────────────────────────────────────────────
     // LIVE meeting transcript → LLM (buffered webhook finals). See recall.on('transcript').
     const meetingTranscriptBuffer = [];
     let meetingFlushTimer = null;
@@ -2164,6 +2333,206 @@ async function main() {
             }
         }, MEETING_MAX_MS);
     };
+    // ── IDE helpers ─────────────────────────────────────────────────────────
+    // ensureCodeServer() — idempotent: installs code-server if missing.
+    // Cloudflared is no longer downloaded here (exposure via agent's own HTTP proxy).
+    // Emits ide_status:'installing' before any long download so the frontend can
+    // show a spinner. (~36s + ~740MB first run, once per machine lifetime).
+    const ensureCodeServer = async () => {
+        // Resolve code-server binary
+        const which = await new Promise((res) => {
+            const p = spawn('which', ['code-server']);
+            let out = '';
+            p.stdout?.on('data', (d) => { out += d.toString(); });
+            p.on('close', () => res(out.trim()));
+        });
+        if (!which) {
+            await sendToFrontend({ type: 'ide_status', status: 'installing' });
+            console.log('⬇️ Installing code-server via official script...');
+            await new Promise((res, rej) => {
+                const install = spawn('sh', ['-c', 'curl -fsSL https://code-server.dev/install.sh | sh'], {
+                    env: { ...process.env },
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                install.stdout?.on('data', (d) => process.stdout.write(d));
+                install.stderr?.on('data', (d) => process.stderr.write(d));
+                install.on('close', (code) => code === 0 ? res() : rej(new Error(`code-server install exited ${code}`)));
+            });
+        }
+    };
+    // Kill code-server, disable proxy, clear interval, reset IDE state.
+    const stopIde = (reason) => {
+        ideProxyEnabled = false;
+        ideSessionToken = null;
+        ideStartInProgress = null;
+        if (ideIdleWatcher) {
+            clearInterval(ideIdleWatcher);
+            ideIdleWatcher = null;
+        }
+        if (ideCodeServerProc) {
+            try {
+                ideCodeServerProc.kill();
+            }
+            catch { }
+            ideCodeServerProc = null;
+        }
+        ideLastActivity = 0;
+        ideLastProxiedActivity = 0;
+        const msg = { type: 'ide_stopped' };
+        if (reason)
+            msg.reason = reason;
+        sendToFrontend(msg).catch(() => { });
+        console.log(`🛑 IDE stopped${reason ? ` (${reason})` : ''}`);
+    };
+    // Idle watcher: poll every 60s; stop IDE if no proxied HTTP/WS activity
+    // within the threshold. Uses ideLastProxiedActivity (real editor traffic seen
+    // by the agent's proxy) as the primary signal — more reliable than log noise
+    // on code-server's stdout/stderr. Falls back to ideLastActivity (process output)
+    // if no proxied activity has ever been recorded (pre-first-browser-open).
+    const startIdeIdleWatcher = () => {
+        if (ideIdleWatcher) {
+            clearInterval(ideIdleWatcher);
+            ideIdleWatcher = null;
+        }
+        const idleMinutes = Math.max(1, parseInt(process.env.OSBORN_IDE_IDLE_MIN || '10', 10));
+        const idleMs = idleMinutes * 60 * 1000;
+        ideIdleWatcher = setInterval(() => {
+            if (!ideCodeServerProc) {
+                clearInterval(ideIdleWatcher);
+                ideIdleWatcher = null;
+                return;
+            }
+            // Prefer proxied-activity timestamp; fall back to process output timestamp.
+            const lastSeen = ideLastProxiedActivity > 0 ? ideLastProxiedActivity : ideLastActivity;
+            const elapsed = Date.now() - lastSeen;
+            if (elapsed > idleMs) {
+                console.log(`⏱️ IDE idle for ${Math.round(elapsed / 60000)} min — stopping`);
+                stopIde('idle');
+            }
+        }, 60_000);
+    };
+    // ── startCodeServer() ───────────────────────────────────────────────────────
+    // Shared helper called by both the start_ide data-channel handler and the
+    // GET /editor HTTP route. Idempotent: no-op if code-server is already running
+    // and the proxy is enabled. On fresh start it:
+    //   1. ensureCodeServer() — installs if missing
+    //   2. probes --idle-timeout-seconds flag support
+    //   3. spawns code-server on 127.0.0.1:8300 with --auth none, cwd /workspace
+    //   4. polls until ready (up to 20 s)
+    //   5. mints ideSessionToken (the cookie marker) and sets ideProxyEnabled = true
+    const startCodeServer = async () => {
+        // Fast path 1: already fully up — nothing to do.
+        if (ideCodeServerProc && ideProxyEnabled) {
+            console.log('🖥️ IDE already running — reusing existing instance');
+            return;
+        }
+        // Fast path 2: a start is already in progress — join it instead of killing
+        // the process that is still booting (prevents the /editor 3s-refresh self-DoS).
+        if (ideStartInProgress) {
+            console.log('🖥️ IDE start already in progress — awaiting in-flight promise');
+            return ideStartInProgress;
+        }
+        // Fresh start: kill any stale proc (shouldn't normally exist here, but be safe).
+        if (ideCodeServerProc)
+            stopIde();
+        let resolveFn;
+        let rejectFn;
+        ideStartInProgress = new Promise((res, rej) => { resolveFn = res; rejectFn = rej; });
+        try {
+            await ensureCodeServer();
+            // Probe whether this code-server version supports --idle-timeout-seconds
+            // (landed ~Oct 2025; older installs predate it). Only pass the flag if
+            // the binary reports it — an unknown flag prevents code-server from starting.
+            const idleMinutes = Math.max(1, parseInt(process.env.OSBORN_IDE_IDLE_MIN || '10', 10));
+            const idleSeconds = idleMinutes * 60;
+            const supportsIdleFlag = await new Promise((res) => {
+                const h = spawn('sh', ['-c', 'code-server --help 2>&1 | grep -q idle-timeout-seconds && echo yes || echo no'], {
+                    env: { ...process.env }, stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                let out = '';
+                h.stdout?.on('data', (d) => { out += d.toString(); });
+                h.on('close', () => res(out.trim() === 'yes'));
+            });
+            console.log(`🖥️ code-server idle-timeout-seconds flag: ${supportsIdleFlag ? 'supported' : 'absent (using watcher)'}`);
+            // Spawn code-server bound to 127.0.0.1:8300 (never 8741).
+            console.log('🖥️ Spawning code-server on 127.0.0.1:8300...');
+            const csArgs = [
+                '--bind-addr', '127.0.0.1:8300',
+                '--auth', 'none',
+                '/workspace',
+            ];
+            if (supportsIdleFlag) {
+                csArgs.push('--idle-timeout-seconds', String(Math.max(60, idleSeconds)));
+            }
+            const codeServerProc = spawn('code-server', csArgs, {
+                env: { ...process.env },
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            ideCodeServerProc = codeServerProc;
+            ideLastActivity = Date.now();
+            ideLastProxiedActivity = 0;
+            // Bump lastActivity on any output from code-server (fallback idle signal).
+            codeServerProc.stdout?.on('data', () => { ideLastActivity = Date.now(); });
+            codeServerProc.stderr?.on('data', () => { ideLastActivity = Date.now(); });
+            codeServerProc.on('exit', (code) => {
+                console.log(`🖥️ code-server exited (${code})`);
+                if (ideCodeServerProc === codeServerProc)
+                    stopIde();
+            });
+            // Poll until code-server is ready (302 or 200 on the root, up to 20s).
+            // Minor fix: if the process we spawned has been replaced or killed mid-poll,
+            // reject immediately rather than burning the rest of the 20s timeout.
+            await new Promise((res, rej) => {
+                let attempts = 0;
+                const poll = setInterval(() => {
+                    // Early-exit: the proc we spawned is no longer the active one (stopIde
+                    // was called, or a concurrent path replaced it).
+                    if (ideCodeServerProc !== codeServerProc) {
+                        clearInterval(poll);
+                        rej(new Error('code-server process was replaced or stopped mid-poll'));
+                        return;
+                    }
+                    attempts++;
+                    const check = spawn('curl', ['-s', '-o', '/dev/null', '-w', '%{http_code}', 'http://127.0.0.1:8300']);
+                    let out = '';
+                    check.stdout?.on('data', (d) => { out += d.toString(); });
+                    check.on('close', () => {
+                        const httpCode = parseInt(out.trim(), 10);
+                        if (httpCode === 200 || httpCode === 302 || httpCode === 301) {
+                            clearInterval(poll);
+                            res();
+                        }
+                        else if (attempts >= 40) { // 40 * 500ms = 20s
+                            clearInterval(poll);
+                            rej(new Error('code-server did not become ready within 20s'));
+                        }
+                    });
+                }, 500);
+            });
+            console.log('✅ code-server ready on 8300');
+            // Mint the session cookie token and enable the proxy. From this point the
+            // /editor route will 302+Set-Cookie and the fall-through proxy will only
+            // forward requests that carry the valid osborn_ide cookie.
+            ideSessionToken = randomBytes(24).toString('hex');
+            ideProxyEnabled = true;
+            // Start idle watcher only when the native idle flag is absent.
+            if (!supportsIdleFlag) {
+                startIdeIdleWatcher();
+            }
+            resolveFn();
+        }
+        catch (err) {
+            rejectFn(err);
+            throw err;
+        }
+        finally {
+            ideStartInProgress = null;
+        }
+    };
+    // Wire the module-scope hook so startApiServer()'s /editor route can call
+    // startCodeServer() without reaching into main()'s closure directly.
+    codeServerStartHook = startCodeServer;
+    // ────────────────────────────────────────────────────────────────────────
     // Track the active resume session ID across scopes (ParticipantConnected + DataReceived)
     // Updated by resume_session, session_selected, continue_session, switch_session handlers
     let currentResumeSessionId;
@@ -4900,6 +5269,11 @@ async function main() {
             armMeetingLeaveGrace(); // no-op when no meeting, kept for symmetry
             armFastLeaveTimer();
         }
+        // Tear down IDE if one is running — user has disconnected, no point keeping
+        // code-server alive for a departed session.
+        if (ideCodeServerProc) {
+            stopIde();
+        }
         console.log('⏳ Waiting for new user...\n');
     };
     const handleDataReceived = async (payload, participant, kind, topic) => {
@@ -5663,6 +6037,32 @@ async function main() {
                     await sendToFrontend({ type: 'meeting_error', message: err.message });
                 }
             }
+            // ── IDE (code-server) handlers ──────────────────────────────────────
+            else if (data.type === 'start_ide') {
+                try {
+                    await startCodeServer();
+                    // Build the /editor entry-point URL for the frontend to open.
+                    const flyAppHost = process.env.FLY_APP_NAME
+                        ? `${process.env.FLY_APP_NAME}.fly.dev`
+                        : (process.env.OSBORN_PUBLIC_HOST || `localhost:${apiPort}`);
+                    const ideUrl = process.env.FLY_APP_NAME
+                        ? `https://${flyAppHost}/editor`
+                        : `http://${flyAppHost}/editor`;
+                    console.log(`✅ IDE proxy ready: ${ideUrl}`);
+                    await sendToFrontend({ type: 'ide_ready', url: ideUrl });
+                }
+                catch (err) {
+                    console.error('❌ start_ide error:', err);
+                    // Clean up any partial state.
+                    if (ideCodeServerProc)
+                        stopIde();
+                    await sendToFrontend({ type: 'ide_error', error: err.message || String(err) });
+                }
+            }
+            else if (data.type === 'stop_ide') {
+                stopIde();
+            }
+            // ───────────────────────────────────────────────────────────────────
             else if (data.type === 'session_selected') {
                 const sessionId = data.sessionId;
                 console.log(`🚪 Session gate completed: ${sessionId ? `resume ${sessionId}` : 'fresh start'}`);
@@ -5815,6 +6215,45 @@ async function main() {
                     slots: [...focusedEntry, ...bgEntries],
                 });
             }
+            else if (data.type === 'list_processes') {
+                // Read process list from /proc. Each numeric subdir is a PID.
+                // We read /proc/<pid>/comm (process name) and VmRSS from /proc/<pid>/status.
+                // Skips any PID that errors mid-scan (race: process may have exited).
+                try {
+                    const procEntries = readdirSync('/proc');
+                    const processes = [];
+                    for (const entry of procEntries) {
+                        if (!/^\d+$/.test(entry))
+                            continue;
+                        const pid = parseInt(entry, 10);
+                        try {
+                            const comm = readFileSync(`/proc/${entry}/comm`, 'utf8').trim();
+                            const status = readFileSync(`/proc/${entry}/status`, 'utf8');
+                            const vmRssMatch = status.match(/^VmRSS:\s*(\d+)\s*kB/m);
+                            const rssMb = vmRssMatch ? Math.round(parseInt(vmRssMatch[1], 10) / 1024) : 0;
+                            processes.push({ pid, name: comm, rssMb });
+                        }
+                        catch {
+                            // Process exited between readdir and read — skip it
+                        }
+                    }
+                    // Sort by resident memory descending, cap at 40 entries
+                    processes.sort((a, b) => b.rssMb - a.rssMb);
+                    const topProcesses = processes.slice(0, 40);
+                    // Reuse the existing os module memory totals (same source as /health endpoint)
+                    const totalMb = Math.round(totalmem() / 1024 / 1024);
+                    const freeMb = Math.round(freemem() / 1024 / 1024);
+                    const usedMb = totalMb - freeMb;
+                    await sendToFrontend({
+                        type: 'process_list',
+                        processes: topProcesses,
+                        memory: { usedMb, totalMb, freeMb },
+                    });
+                }
+                catch (err) {
+                    console.error('❌ list_processes: failed to read /proc:', err);
+                }
+            }
         }
         catch { }
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osborn",
-  "version": "0.9.149",
+  "version": "0.9.151",
   "description": "Voice AI coding assistant - local agent that connects to Osborn frontend",
   "type": "module",
   "bin": {