osborn 0.9.236 → 0.9.238

package/dist/claude-llm.js

@@ -120,10 +120,17 @@ function extractSpeedMarker(text) {
 }
 function stripMarkdownForTTS(text) {
     return text
-        // Remove code blocks (``` ... ```)
+        // Remove PAIRED code blocks (``` ... ```)
         .replace(/```[\s\S]*?```/g, ' [code block] ')
+        // Remove an UNCLOSED/partial fence to end-of-string. Assistant text streams as multiple
+        // blocks per turn and each block is stripped in isolation, so a fence that opens in one
+        // block (or is never closed) would otherwise leak raw code + literal backticks to TTS.
+        .replace(/```[\s\S]*$/g, ' [code block] ')
         // Remove inline code (` ... `)
         .replace(/`([^`]+)`/g, '$1')
+        // Sweep any remaining stray backtick runs (unbalanced ticks from split chunks) so they're
+        // never spoken aloud.
+        .replace(/`+/g, ' ')
         // Remove bold (**text** or __text__)
         .replace(/\*\*([^*]+)\*\*/g, '$1')
         .replace(/__([^_]+)__/g, '$1')

package/dist/env-keys.js

@@ -35,6 +35,7 @@ export const AGENT_ENV_KEYS = [
     { key: 'OSBORN_CWD', required: false, explicit: true, description: 'Agent working directory.' },
     { key: 'OSBORN_SYNC_TOKEN', required: false, explicit: true, description: 'Session export/import auth token.' },
     { key: 'OSBORN_FRONTEND_URL', required: false, explicit: true, description: 'Frontend base URL for artifact upload.' },
+    { key: 'OSBORN_HOUSEKEEPING_DRYRUN', required: false, explicit: true, description: 'Set "0" to enable live housekeeping deletion; any other value / unset = dry-run (log only).' },
     { key: 'DEV_DOMAIN', required: false, explicit: true, description: 'Wildcard dev-routing domain.' },
 ];
 /** Keys the agent treats as required — absence should be surfaced at startup. */

package/dist/housekeeping.d.ts

@@ -0,0 +1,16 @@
+export interface HousekeepingResult {
+    subagentsRemoved: string[];
+    corruptSlugsRemoved: string[];
+    scannedSlugs: number;
+}
+/**
+ * Prune stale sub-agent transcripts (>ttl) and empty/corrupt slug dirs.
+ * SAFE BY DESIGN: never deletes a {sessionId}.jsonl, never touches the active session's
+ * subtree, and (unless dryRun=false) deletes nothing at all. Conservative — only removes
+ * sub-agent artifacts older than the TTL and slug dirs that contain NO conversation jsonl.
+ */
+export declare function cleanupHousekeeping(opts: {
+    dryRun: boolean;
+    activeSessionId?: string | null;
+    subagentTtlMs?: number;
+}): HousekeepingResult;

package/dist/housekeeping.js

@@ -0,0 +1,151 @@
+// Housekeeping: prune stale sub-agent transcripts and empty/corrupt slug dirs from the Claude
+// projects tree. Runs on the agent (boot + periodic). Ships DRY-RUN by default so we can eyeball
+// what it WOULD delete in fly logs before enabling real deletion (OSBORN_HOUSEKEEPING_DRYRUN=0).
+//
+// Layout (see session-access.ts for the canonical map):
+//   ~/.claude/projects/{slug}/
+//     ├── {sessionId}.jsonl                 ← main conversation (the source of truth — NEVER deleted here)
+//     ├── {sessionId}/subagents/agent-*.jsonl   ← SDK sub-agent transcripts (TTL target)
+//     ├── agent-*.jsonl                     ← project-level native Task transcripts (TTL target)
+//     └── osb/{sessionId}/session.db        ← recall store, SLUG-LEVEL sibling of the jsonl (NEVER deleted here)
+import { existsSync, readdirSync, statSync, lstatSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { getClaudeProjectsDir } from './config.js';
+const DAY_MS = 24 * 60 * 60 * 1000;
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * Prune stale sub-agent transcripts (>ttl) and empty/corrupt slug dirs.
+ * SAFE BY DESIGN: never deletes a {sessionId}.jsonl, never touches the active session's
+ * subtree, and (unless dryRun=false) deletes nothing at all. Conservative — only removes
+ * sub-agent artifacts older than the TTL and slug dirs that contain NO conversation jsonl.
+ */
+export function cleanupHousekeeping(opts) {
+    const { dryRun, activeSessionId } = opts;
+    const ttl = opts.subagentTtlMs ?? DAY_MS;
+    const now = Date.now();
+    const tag = dryRun ? '🧹[dry-run] WOULD remove' : '🧹 removed';
+    const result = { subagentsRemoved: [], corruptSlugsRemoved: [], scannedSlugs: 0 };
+    let projectsDir;
+    try {
+        projectsDir = getClaudeProjectsDir();
+    }
+    catch {
+        return result;
+    }
+    let slugs;
+    try {
+        slugs = readdirSync(projectsDir);
+    }
+    catch {
+        return result;
+    }
+    const rm = (p) => { if (!dryRun) {
+        try {
+            rmSync(p, { recursive: true, force: true });
+        }
+        catch { }
+    } };
+    for (const slug of slugs) {
+        if (slug.startsWith('.'))
+            continue;
+        const slugPath = join(projectsDir, slug);
+        let slugStat;
+        try {
+            slugStat = lstatSync(slugPath);
+        }
+        catch {
+            continue;
+        }
+        if (slugStat.isSymbolicLink())
+            continue; // never follow or delete symlinked entries
+        // Stray non-directory entry directly under projects/ — garbage. Only if old enough,
+        // to avoid racing a write-in-progress.
+        if (!slugStat.isDirectory()) {
+            if (now - slugStat.mtimeMs > ttl) {
+                console.log(`${tag} stray projects entry: ${slugPath}`);
+                result.corruptSlugsRemoved.push(slugPath);
+                rm(slugPath);
+            }
+            continue;
+        }
+        result.scannedSlugs++;
+        let entries;
+        try {
+            entries = readdirSync(slugPath);
+        }
+        catch {
+            continue;
+        }
+        // Which session ids have a live top-level {sessionId}.jsonl in this slug?
+        const liveSessionIds = new Set();
+        for (const e of entries) {
+            if (e.endsWith('.jsonl')) {
+                const base = e.slice(0, -6);
+                if (UUID_RE.test(base))
+                    liveSessionIds.add(base);
+            }
+        }
+        const slugContainsActive = !!activeSessionId && liveSessionIds.has(activeSessionId);
+        // (a) Sub-agent TTL sweep.
+        for (const e of entries) {
+            const full = join(slugPath, e);
+            // Project-level native SDK Task transcripts. Skip the active project's — a long-running
+            // active session may have legitimately old task transcripts still relevant to it.
+            if (e.startsWith('agent-') && e.endsWith('.jsonl')) {
+                if (slugContainsActive)
+                    continue;
+                try {
+                    if (now - statSync(full).mtimeMs > ttl) {
+                        console.log(`${tag} subagent transcript: ${full}`);
+                        result.subagentsRemoved.push(full);
+                        rm(full);
+                    }
+                }
+                catch { /* ignore per-entry */ }
+                continue;
+            }
+            // Per-session subdir → its subagents/ transcripts. Never the active session's subtree.
+            if (UUID_RE.test(e)) {
+                if (activeSessionId && e === activeSessionId)
+                    continue;
+                const subagentsDir = join(full, 'subagents');
+                if (!existsSync(subagentsDir))
+                    continue;
+                let subFiles = [];
+                try {
+                    subFiles = readdirSync(subagentsDir);
+                }
+                catch {
+                    continue;
+                }
+                for (const sf of subFiles) {
+                    const sfull = join(subagentsDir, sf);
+                    try {
+                        if (now - statSync(sfull).mtimeMs > ttl) {
+                            console.log(`${tag} subagent transcript: ${sfull}`);
+                            result.subagentsRemoved.push(sfull);
+                            rm(sfull);
+                        }
+                    }
+                    catch { /* ignore per-entry */ }
+                }
+            }
+        }
+        // (b) Corrupt/empty slug: ONLY a TRULY EMPTY directory (zero entries) that is stale.
+        // We deliberately do NOT delete a slug that merely lacks a top-level *.jsonl — such a dir
+        // can still hold a slug-level `osb/{sessionId}/session.db` recall store or orphan subdirs,
+        // and a directory's mtime does NOT reflect nested writes, so "no jsonl + stale dir-mtime"
+        // is not a safe delete signal. An empty dir has nothing nested to lose.
+        if (entries.length === 0 && now - slugStat.mtimeMs > ttl) {
+            console.log(`${tag} empty slug dir: ${slugPath}`);
+            result.corruptSlugsRemoved.push(slugPath);
+            rm(slugPath);
+        }
+    }
+    const verb = dryRun ? 'would remove' : 'removed';
+    console.log(`🧹 housekeeping: scanned ${result.scannedSlugs} slug(s); ${verb} ` +
+        `${result.subagentsRemoved.length} stale sub-agent artifact(s), ` +
+        `${result.corruptSlugsRemoved.length} empty/corrupt slug(s)` +
+        (dryRun ? ' (dry-run — set OSBORN_HOUSEKEEPING_DRYRUN=0 to enable deletion)' : ''));
+    return result;
+}

package/dist/index.js

@@ -34,6 +34,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 import { createPatch } from 'diff';
 import { loadConfig, getMcpServers, getEnabledMcpServerNames, getVoiceMode, getDirectConfig, listSessions, listAllClaudeSessions, invalidateSessionListCache, getMostRecentSessionId, sessionExists, getSessionSummary, getConversationHistory, ensureSessionWorkspace, getMcpServerStatusList, buildMcpServersForKeys, listWorkspaceArtifacts } from './config.js';
+import { cleanupHousekeeping } from './housekeeping.js';
 import { createSTT, createTTS } from './voice-io.js';
 import { createClaudeLLM, NAMED_AGENTS, applyTurbo } from './claude-llm.js';
 import { clearPipelineFastBrainSession, prewarmBM25Index } from './pipeline-fastbrain.js';
@@ -2785,6 +2786,28 @@ async function main() {
     // Track the active resume session ID across scopes (ParticipantConnected + DataReceived)
     // Updated by resume_session, session_selected, continue_session, switch_session handlers
     let currentResumeSessionId;
+    // Housekeeping: prune stale sub-agent transcripts (>24h) + empty/corrupt slug dirs. Ships
+    // DRY-RUN by default (OSBORN_HOUSEKEEPING_DRYRUN != '0') so it only LOGS what it would remove
+    // until we flip the env. Reads the active session live so it never touches the in-use subtree.
+    const runHousekeeping = () => {
+        try {
+            const envDryRun = process.env.OSBORN_HOUSEKEEPING_DRYRUN !== '0';
+            const activeSessionId = currentLLM?.sessionId ?? currentResumeSessionId ?? null;
+            // Force dry-run whenever NO session is active (e.g. the boot run): with activeSessionId
+            // null the in-use-session guards are inert, so only LOG then — real deletion waits until
+            // a session is established (the periodic 6h runs), when the guards are meaningful.
+            const dryRun = envDryRun || !activeSessionId;
+            const res = cleanupHousekeeping({ dryRun, activeSessionId });
+            if (!dryRun && (res.subagentsRemoved.length > 0 || res.corruptSlugsRemoved.length > 0)) {
+                invalidateSessionListCache();
+            }
+        }
+        catch (e) {
+            console.warn('🧹 housekeeping failed:', e);
+        }
+    };
+    runHousekeeping();
+    setInterval(runHousekeeping, 6 * 60 * 60 * 1000);
     // Claude auth code submission handler (set during OAuth flow, cleared after)
     let pendingAuthSubmitCode = null;
     // Task deduplication guard - prevents Gemini re-execution loops

package/dist/pipeline-fastbrain.js

@@ -255,6 +255,16 @@ function buildSystemPrompt(chatHistory, researchContext) {
         `Greetings/thanks/confirmations: respond directly, no search.`,
         `Tasks needing live code analysis or new research: respond with [RESEARCH_NEEDED]`,
         ``,
+        `== DECISIONS: DEFER, DON'T ASSERT ==`,
+        `The grounded main agent answers the SAME question in parallel with full context — it owns`,
+        `decisions. For questions asking what was DECIDED / CHOSEN / SCOPED / AGREED / "what were the`,
+        `options" / "what did we settle on" / "remind me what we decided": do NOT state a definitive`,
+        `answer from one keyword hit. A single matched line is often a passing mention, not the`,
+        `decision (e.g. a file that "covers WhatsApp and LinkedIn" is NOT the scoping decision).`,
+        `Only assert a decision if MULTIPLE recent hits corroborate it AND one is clearly the decision`,
+        `itself. Otherwise hedge briefly and defer — e.g. "I think it involved X, but let the main`,
+        `agent confirm the exact decision" — or emit [RESEARCH_NEEDED]. Never contradict-with-confidence.`,
+        ``,
         `== STYLE ==`,
         `1-3 sentences. Grounded in results. Never fabricate.`,
         `If not found after thorough searching: "I didn't find that in the session history."`,

package/package.json

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