@zhijiewang/openharness 2.4.0 → 2.8.0

package/dist/components/InitWizard.js

@@ -86,12 +86,71 @@ export default function InitWizard({ onDone }) {
     const [testStatus, setTestStatus] = useState("testing");
     const [testError, setTestError] = useState("");
     const [permIdx, setPermIdx] = useState(0);
-    const [hatchGotchi, setHatchGotchi] = useState(false);
+    const [_hatchGotchi, setHatchGotchi] = useState(false);
     const [showSetup, setShowSetup] = useState(false);
     const [suggestedMcp, setSuggestedMcp] = useState([]);
     const [selectedMcp, setSelectedMcp] = useState(new Set());
     const [mcpIdx, setMcpIdx] = useState(0);
     const provider = PROVIDERS[providerIdx];
+    // ── Connection test ──
+    const runTest = useCallback(async (prov, key, url) => {
+        setTestStatus("testing");
+        try {
+            const { createProviderInstance } = await import("../providers/index.js");
+            const p = createProviderInstance(prov.key, {
+                name: prov.key,
+                apiKey: key || process.env[`${prov.key.toUpperCase()}_API_KEY`],
+                baseUrl: url || prov.defaultBaseUrl,
+                defaultModel: prov.defaultModel,
+            });
+            const fetched = "fetchModels" in p && typeof p.fetchModels === "function"
+                ? await p.fetchModels()
+                : p.listModels();
+            const modelNames = fetched.map((m) => m.id);
+            setAvailableModels(modelNames.length > 0 ? modelNames : [prov.defaultModel]);
+            setTestStatus("ok");
+            setTimeout(() => setStep("model"), 600);
+        }
+        catch (err) {
+            setTestStatus("fail");
+            setTestError(err instanceof Error ? err.message : String(err));
+            setAvailableModels([prov.defaultModel]);
+            setTimeout(() => setStep("model"), 800);
+        }
+    }, []);
+    // ── Write final config ──
+    const writeFinal = useCallback(() => {
+        const selectedModel = availableModels.length > 0 ? (availableModels[modelIdx] ?? model) : model;
+        // Build MCP server configs from selected registry entries
+        let mcpServers;
+        if (selectedMcp.size > 0) {
+            try {
+                const { MCP_REGISTRY } = require("../mcp/registry.js");
+                mcpServers = [...selectedMcp]
+                    .map((name) => MCP_REGISTRY.find((e) => e.name === name))
+                    .filter(Boolean)
+                    .map((e) => ({
+                    name: e.name,
+                    command: "npx",
+                    args: ["-y", e.package, ...(e.args ?? [])],
+                    ...(e.envVars?.length ? { env: Object.fromEntries(e.envVars.map((v) => [v, `YOUR_${v}`])) } : {}),
+                }));
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        writeOhConfig({
+            provider: provider.key,
+            model: selectedModel || provider.defaultModel,
+            permissionMode: PERMISSION_MODES[permIdx].key,
+            ...(apiKey ? { apiKey } : {}),
+            ...(baseUrl ? { baseUrl } : {}),
+            ...(mcpServers?.length ? { mcpServers } : {}),
+        });
+        setStep("done");
+        setTimeout(() => onDone?.(), 1500);
+    }, [provider, model, availableModels, modelIdx, permIdx, apiKey, baseUrl, selectedMcp, onDone]);
     // ── Keyboard navigation ──
     useInput(useCallback((input, key) => {
         if (step === "provider") {
@@ -175,66 +234,7 @@ export default function InitWizard({ onDone }) {
             if (input === "n" || input === "N")
                 writeFinal();
         }
-    }, [step, providerIdx, provider, modelIdx, availableModels, model]));
-    // ── Connection test ──
-    const runTest = async (prov, key, url) => {
-        setTestStatus("testing");
-        try {
-            const { createProviderInstance } = await import("../providers/index.js");
-            const p = createProviderInstance(prov.key, {
-                name: prov.key,
-                apiKey: key || process.env[`${prov.key.toUpperCase()}_API_KEY`],
-                baseUrl: url || prov.defaultBaseUrl,
-                defaultModel: prov.defaultModel,
-            });
-            const fetched = "fetchModels" in p && typeof p.fetchModels === "function"
-                ? await p.fetchModels()
-                : p.listModels();
-            const modelNames = fetched.map((m) => m.id);
-            setAvailableModels(modelNames.length > 0 ? modelNames : [prov.defaultModel]);
-            setTestStatus("ok");
-            setTimeout(() => setStep("model"), 600);
-        }
-        catch (err) {
-            setTestStatus("fail");
-            setTestError(err instanceof Error ? err.message : String(err));
-            setAvailableModels([prov.defaultModel]);
-            setTimeout(() => setStep("model"), 800);
-        }
-    };
-    // ── Write final config ──
-    const writeFinal = useCallback(() => {
-        const selectedModel = availableModels.length > 0 ? (availableModels[modelIdx] ?? model) : model;
-        // Build MCP server configs from selected registry entries
-        let mcpServers;
-        if (selectedMcp.size > 0) {
-            try {
-                const { MCP_REGISTRY } = require("../mcp/registry.js");
-                mcpServers = [...selectedMcp]
-                    .map((name) => MCP_REGISTRY.find((e) => e.name === name))
-                    .filter(Boolean)
-                    .map((e) => ({
-                    name: e.name,
-                    command: "npx",
-                    args: ["-y", e.package, ...(e.args ?? [])],
-                    ...(e.envVars?.length ? { env: Object.fromEntries(e.envVars.map((v) => [v, `YOUR_${v}`])) } : {}),
-                }));
-            }
-            catch {
-                /* ignore */
-            }
-        }
-        writeOhConfig({
-            provider: provider.key,
-            model: selectedModel || provider.defaultModel,
-            permissionMode: PERMISSION_MODES[permIdx].key,
-            ...(apiKey ? { apiKey } : {}),
-            ...(baseUrl ? { baseUrl } : {}),
-            ...(mcpServers?.length ? { mcpServers } : {}),
-        });
-        setStep("done");
-        setTimeout(() => onDone?.(), 1500);
-    }, [provider, model, availableModels, modelIdx, permIdx, apiKey, baseUrl, selectedMcp]);
+    }, [step, provider, modelIdx, availableModels, model, suggestedMcp, mcpIdx, runTest, writeFinal]));
     // ── Render ──
     if (showSetup) {
         return (_jsx(CybergotchiSetup, { onComplete: () => {

package/dist/harness/config.d.ts

@@ -75,6 +75,8 @@ export type OhConfig = {
         apiKey?: string;
         baseUrl?: string;
     }>;
+    /** Auto-commit after each file-modifying tool execution */
+    gitCommitPerTool?: boolean;
     /** Effort level for LLM reasoning depth */
     effortLevel?: "low" | "medium" | "high" | "max";
     /** Opt-in telemetry (default: off) */

package/dist/harness/hooks.js

@@ -117,13 +117,16 @@ async function runHttpHook(url, event, ctx, timeoutMs = 10_000) {
         return false;
     }
 }
-/** Run a prompt hook. Uses LLM to make a yes/no decision. */
+/**
+ * Run a prompt hook. Uses LLM to make a yes/no decision.
+ *
+ * Currently a stub — prompt hooks always allow because the hook system
+ * runs outside the query loop and has no access to a Provider instance.
+ * Full implementation requires passing a Provider via HookContext so the
+ * hook can call provider.complete() with the prompt text.
+ */
 async function runPromptHook(_promptText, _ctx) {
-    // Prompt hooks require a provider — skip if not available
-    // This is a lightweight check; full LLM call would need provider injection
-    // For now, prompt hooks evaluate the prompt text as a simple template
-    // TODO: inject provider for full LLM-based prompt hooks
-    return true; // Default allow if no LLM available
+    return true;
 }
 // ── Hook Execution ──
 /** Execute a single hook definition. Returns true if allowed. */

package/dist/harness/memory.js

@@ -283,7 +283,34 @@ export function consolidateMemories() {
     // Refresh MEMORY.md index after pruning
     updateMemoryIndex(PROJECT_MEMORY_DIR);
     updateMemoryIndex(GLOBAL_MEMORY_DIR);
-    return { total: all.length, pruned: prunedCount, decayed: decayedCount };
+    // Skill decay: prune auto-extracted skills unused for 60 days
+    let prunedSkills = 0;
+    try {
+        const skillsAutoDir = join(".oh", "skills", "auto");
+        if (existsSync(skillsAutoDir)) {
+            const SKILL_DECAY_MS = 60 * 24 * 60 * 60 * 1000; // 60 days
+            for (const file of readdirSync(skillsAutoDir).filter((f) => f.endsWith(".md"))) {
+                try {
+                    const raw = readFileSync(join(skillsAutoDir, file), "utf-8");
+                    const usedMatch = raw.match(/^timesUsed:\s*(\d+)$/m);
+                    const extractedMatch = raw.match(/^extractedAt:\s*(\d+)$/m);
+                    const timesUsed = usedMatch ? parseInt(usedMatch[1], 10) : 0;
+                    const extractedAt = extractedMatch ? parseInt(extractedMatch[1], 10) : Date.now();
+                    if (timesUsed < 2 && Date.now() - extractedAt > SKILL_DECAY_MS) {
+                        unlinkSync(join(skillsAutoDir, file));
+                        prunedSkills++;
+                    }
+                }
+                catch {
+                    /* skip unreadable skill files */
+                }
+            }
+        }
+    }
+    catch {
+        /* skill pruning is optional */
+    }
+    return { total: all.length, pruned: prunedCount + prunedSkills, decayed: decayedCount };
 }
 // ── User Profile ──
 const USER_PROFILE_FILE = "USER.md";

package/dist/harness/plugins.d.ts

@@ -19,6 +19,8 @@ export type SkillMetadata = {
     content: string;
     filePath: string;
     source: "project" | "global" | "plugin";
+    /** When false, skill is hidden from system prompt until explicitly invoked */
+    invokeModel: boolean;
 };
 export type PluginManifest = {
     name: string;

package/dist/harness/plugins.js

@@ -10,9 +10,9 @@
  * 2. ~/.oh/skills/ (global)
  * 3. node_modules packages with "openharness-plugin" keyword
  */
-import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
-import { basename, join } from "node:path";
+import { join, relative } from "node:path";
 const PROJECT_SKILLS_DIR = join(".oh", "skills");
 const GLOBAL_SKILLS_DIR = join(homedir(), ".oh", "skills");
 /** Parse YAML frontmatter from a skill markdown file */
@@ -34,24 +34,54 @@ function parseSkillFrontmatter(content) {
     const toolsMatch = frontmatter.match(/^tools:\s*\[(.+)\]$/m);
     if (toolsMatch)
         result.tools = toolsMatch[1].split(",").map((t) => t.trim());
+    // Also parse allowedTools (used by built-in skills) and merge with tools
+    const allowedToolsMatch = frontmatter.match(/^allowedTools:\s*\[(.+)\]$/m);
+    if (allowedToolsMatch) {
+        const allowed = allowedToolsMatch[1].split(",").map((t) => t.trim());
+        result.tools = result.tools ? [...new Set([...result.tools, ...allowed])] : allowed;
+    }
     const argsMatch = frontmatter.match(/^args:\s*\[(.+)\]$/m);
     if (argsMatch)
         result.args = argsMatch[1].split(",").map((a) => a.trim());
+    // invokeModel: false OR disable-model-invocation: true → hidden from system prompt
+    if (frontmatter.match(/^invokeModel:\s*false$/m) || frontmatter.match(/^disable-model-invocation:\s*true$/m)) {
+        result.invokeModel = false;
+    }
     return result;
 }
-/** Load skills from a directory */
-function loadSkillsFromDir(dir, source) {
+/** Recursively collect all .md files from a directory tree */
+function walkMdFiles(dir) {
     if (!existsSync(dir))
         return [];
-    return readdirSync(dir)
-        .filter((f) => f.endsWith(".md"))
-        .map((f) => {
-        const filePath = join(dir, f);
+    const results = [];
+    for (const entry of readdirSync(dir)) {
+        const full = join(dir, entry);
+        try {
+            if (statSync(full).isDirectory()) {
+                results.push(...walkMdFiles(full));
+            }
+            else if (entry.endsWith(".md")) {
+                results.push(full);
+            }
+        }
+        catch {
+            /* skip unreadable */
+        }
+    }
+    return results;
+}
+/** Load skills from a directory (recursively walks subdirectories) */
+function loadSkillsFromDir(dir, source) {
+    const files = walkMdFiles(dir);
+    return files
+        .map((filePath) => {
         try {
             const content = readFileSync(filePath, "utf-8");
             const meta = parseSkillFrontmatter(content);
+            // Derive name from relative path if not in frontmatter
+            const relName = relative(dir, filePath).replace(/\.md$/, "").replace(/\\/g, "/");
             return {
-                name: meta.name || basename(f, ".md"),
+                name: meta.name || relName,
                 description: meta.description || "",
                 trigger: meta.trigger,
                 tools: meta.tools,
@@ -59,6 +89,7 @@ function loadSkillsFromDir(dir, source) {
                 content,
                 filePath,
                 source,
+                invokeModel: meta.invokeModel ?? true,
             };
         }
         catch {
@@ -172,9 +203,11 @@ export function discoverPlugins() {
 }
 /** Build a prompt listing available skills for the LLM */
 export function skillsToPrompt(skills) {
-    if (skills.length === 0)
+    // Only include skills with invokeModel !== false (hidden skills excluded from prompt)
+    const visible = skills.filter((s) => s.invokeModel !== false);
+    if (visible.length === 0)
         return "";
-    const lines = skills.map((s) => `- ${s.name}: ${s.description}${s.trigger ? ` (auto-trigger: "${s.trigger}")` : ""}`);
+    const lines = visible.map((s) => `- ${s.name}: ${s.description}${s.trigger ? ` (auto-trigger: "${s.trigger}")` : ""}`);
     return `# Available Skills\nUse the Skill tool to invoke these:\n${lines.join("\n")}`;
 }
 //# sourceMappingURL=plugins.js.map

package/dist/harness/session-db.js

@@ -158,7 +158,9 @@ export function closeGlobalSessionDb() {
         try {
             _singletonDb.close();
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
         _singletonDb = null;
     }
 }

package/dist/harness/skill-registry.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Skills Registry — search and install community skills from a remote registry.
+ */
+export type RegistrySkill = {
+    name: string;
+    description: string;
+    author: string;
+    version: string;
+    source: string;
+    tags: string[];
+};
+export type Registry = {
+    skills: RegistrySkill[];
+};
+/** Fetch the registry from remote URL */
+export declare function fetchRegistry(url?: string): Promise<Registry>;
+/** Search registry by query (matches name, description, tags) */
+export declare function searchRegistry(registry: Registry, query: string): RegistrySkill[];
+/** Install a skill from the registry to ~/.oh/skills/ */
+export declare function installSkill(skill: RegistrySkill): Promise<string>;
+//# sourceMappingURL=skill-registry.d.ts.map

package/dist/harness/skill-registry.js

@@ -0,0 +1,35 @@
+/**
+ * Skills Registry — search and install community skills from a remote registry.
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const DEFAULT_REGISTRY_URL = "https://raw.githubusercontent.com/zhijiewong/openharness/main/data/registry.json";
+const GLOBAL_SKILLS_DIR = join(homedir(), ".oh", "skills");
+/** Fetch the registry from remote URL */
+export async function fetchRegistry(url = DEFAULT_REGISTRY_URL) {
+    const response = await fetch(url);
+    if (!response.ok)
+        throw new Error(`Failed to fetch registry: ${response.status}`);
+    return (await response.json());
+}
+/** Search registry by query (matches name, description, tags) */
+export function searchRegistry(registry, query) {
+    const q = query.toLowerCase();
+    return registry.skills.filter((s) => s.name.toLowerCase().includes(q) ||
+        s.description.toLowerCase().includes(q) ||
+        s.tags.some((t) => t.toLowerCase().includes(q)));
+}
+/** Install a skill from the registry to ~/.oh/skills/ */
+export async function installSkill(skill) {
+    const response = await fetch(skill.source);
+    if (!response.ok)
+        throw new Error(`Failed to download skill: ${response.status}`);
+    const content = await response.text();
+    mkdirSync(GLOBAL_SKILLS_DIR, { recursive: true });
+    const slug = skill.name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+    const filePath = join(GLOBAL_SKILLS_DIR, `${slug}.md`);
+    writeFileSync(filePath, content);
+    return filePath;
+}
+//# sourceMappingURL=skill-registry.js.map

package/dist/lsp/client.js

@@ -11,6 +11,7 @@ export class LspClient {
     buffer = "";
     contentLength = -1;
     diagnostics = new Map();
+    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: set via Object.assign in static factory
     ready = false;
     constructor(proc) {
         this.proc = proc;
@@ -38,7 +39,7 @@ export class LspClient {
                     this.buffer = this.buffer.slice(headerEnd + 4);
                     continue;
                 }
-                this.contentLength = parseInt(match[1]);
+                this.contentLength = parseInt(match[1], 10);
                 this.buffer = this.buffer.slice(headerEnd + 4);
             }
             if (this.buffer.length < this.contentLength)

package/dist/main.js

@@ -17,10 +17,10 @@ import { Command, Option } from "commander";
 import { render } from "ink";
 import { readOhConfig } from "./harness/config.js";
 import { emitHook } from "./harness/hooks.js";
-import { detectProject, projectContextToPrompt } from "./harness/onboarding.js";
-import { createRulesFile, loadRules, loadRulesAsPrompt } from "./harness/rules.js";
 import { loadActiveMemories, memoriesToPrompt, userProfileToPrompt } from "./harness/memory.js";
+import { detectProject, projectContextToPrompt } from "./harness/onboarding.js";
 import { discoverSkills, skillsToPrompt } from "./harness/plugins.js";
+import { createRulesFile, loadRules, loadRulesAsPrompt } from "./harness/rules.js";
 import { listSessions } from "./harness/session.js";
 import { connectedMcpServers, disconnectMcpClients, getMcpInstructions, loadMcpTools } from "./mcp/loader.js";
 import { getAllTools } from "./tools.js";
@@ -735,6 +735,14 @@ program
     const server = new McpServer(tools, context);
     server.start();
 });
+// ── mcp-server (alias for serve, standard MCP server mode) ──
+program
+    .command("mcp-server")
+    .description("Start as MCP server (stdio JSON-RPC) — alias for serve")
+    .action(async () => {
+    const { startMcpServer } = await import("./mcp/server-mode.js");
+    await startMcpServer();
+});
 // ── schedule ──
 program
     .command("schedule")

package/dist/mcp/client.js

@@ -6,6 +6,7 @@ export class McpClient {
     proc;
     nextId = 1;
     pending = new Map();
+    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: set via Object.assign in static factory
     ready = false;
     dead = false;
     cfg;
@@ -139,7 +140,7 @@ export class McpClient {
             const id = this.nextId++;
             const req = { jsonrpc: "2.0", id, method, params };
             this.pending.set(id, { resolve, reject });
-            this.proc.stdin.write(JSON.stringify(req) + "\n");
+            this.proc.stdin.write(`${JSON.stringify(req)}\n`);
         });
     }
     disconnect() {

package/dist/mcp/server-mode.d.ts

@@ -0,0 +1,10 @@
+/**
+ * MCP Server Mode — expose openHarness tools as an MCP server over stdio.
+ * Run: oh mcp-server
+ *
+ * Thin entry-point that wires getAllTools() into the McpServer class.
+ * Each message is a JSON-RPC 2.0 object on a single newline-delimited line.
+ * stdin → requests, stdout → responses, stderr → logs.
+ */
+export declare function startMcpServer(): Promise<void>;
+//# sourceMappingURL=server-mode.d.ts.map

package/dist/mcp/server-mode.js

@@ -0,0 +1,17 @@
+/**
+ * MCP Server Mode — expose openHarness tools as an MCP server over stdio.
+ * Run: oh mcp-server
+ *
+ * Thin entry-point that wires getAllTools() into the McpServer class.
+ * Each message is a JSON-RPC 2.0 object on a single newline-delimited line.
+ * stdin → requests, stdout → responses, stderr → logs.
+ */
+import { getAllTools } from "../tools.js";
+import { McpServer } from "./server.js";
+export async function startMcpServer() {
+    const tools = getAllTools();
+    const context = { workingDir: process.cwd() };
+    const server = new McpServer(tools, context);
+    server.start();
+}
+//# sourceMappingURL=server-mode.js.map

package/dist/providers/anthropic.js

@@ -87,15 +87,18 @@ export class AnthropicProvider {
         // Prompt caching: send system prompt as content blocks with cache_control.
         // Anthropic caches matching prefixes — 90% cost reduction on repeat turns.
         const systemBlocks = [{ type: "text", text: systemPrompt, cache_control: { type: "ephemeral" } }];
+        // Scale max_tokens and thinking budget based on model
+        const isOpus = m.includes("opus");
+        const maxTokens = isOpus ? 16384 : 8192;
+        const thinkingBudget = isOpus ? 32000 : 10000;
         const body = {
             model: m,
-            max_tokens: 8192,
+            max_tokens: maxTokens,
             system: systemBlocks,
             messages: this.convertMessages(messages),
             stream: true,
+            thinking: { type: "enabled", budget_tokens: thinkingBudget },
         };
-        // Enable extended thinking for Claude models
-        body.thinking = { type: "enabled", budget_tokens: 10000 };
         const anthropicTools = this.convertTools(tools);
         if (anthropicTools) {
             // Mark last tool definition as cacheable (cache covers all tools before it)
@@ -131,7 +134,6 @@ export class AnthropicProvider {
         let currentToolId = "";
         let currentToolName = "";
         let currentToolArgs = "";
-        let _inThinkingBlock = false;
         while (true) {
             const { done, value } = await reader.read();
             if (done)
@@ -169,9 +171,7 @@ export class AnthropicProvider {
                                 callId: block.id,
                             };
                         }
-                        if (block?.type === "thinking") {
-                            _inThinkingBlock = true;
-                        }
+                        // thinking blocks are handled via thinking_delta in content_block_delta
                         break;
                     }
                     case "content_block_delta": {
@@ -188,7 +188,6 @@ export class AnthropicProvider {
                         break;
                     }
                     case "content_block_stop": {
-                        _inThinkingBlock = false;
                         if (currentToolId) {
                             let parsedArgs = {};
                             if (currentToolArgs) {

package/dist/providers/fallback.js

@@ -34,9 +34,9 @@ export function createFallbackProvider(primary, fallbacks) {
             for (let i = 0; i < providers.length; i++) {
                 const p = providers[i];
                 try {
-                    let hasYielded = false;
+                    let _hasYielded = false;
                     for await (const event of p.provider.stream(messages, systemPrompt, tools, p.model)) {
-                        hasYielded = true;
+                        _hasYielded = true;
                         yield event;
                     }
                     _activeFallback = i === 0 ? null : p.provider.name;
@@ -48,7 +48,6 @@ export function createFallbackProvider(primary, fallbacks) {
                         throw err;
                     // Pre-stream failure on primary: try next provider
                     _activeFallback = null;
-                    continue;
                 }
             }
             _activeFallback = null;

package/dist/providers/openai.js

@@ -75,8 +75,9 @@ export class OpenAIProvider {
         if (tools?.length)
             body.tools = tools;
         // Enable reasoning for o-series models
-        if (m.startsWith("o1") || m.startsWith("o3")) {
-            body.reasoning_effort = "medium";
+        const isReasoning = m.startsWith("o1") || m.startsWith("o3") || m.startsWith("o4");
+        if (isReasoning) {
+            body.reasoning_effort = m.includes("mini") ? "medium" : "high";
         }
         let res;
         try {

package/dist/query/index.js

@@ -29,6 +29,7 @@ export async function* query(userMessage, config, existingMessages = []) {
         systemPrompt: config.systemPrompt,
         permissionMode: config.permissionMode,
         askUserQuestion: config.askUserQuestion,
+        gitCommitPerTool: config.gitCommitPerTool,
     };
     const estimateTokens = makeTokenEstimator(config.provider);
     const contextManager = new ContextManager(undefined, config.model);
@@ -56,14 +57,18 @@ export async function* query(userMessage, config, existingMessages = []) {
             fullSystemPrompt += `\n\n# Suggested Skills\nThese skills match your request. Use Skill tool to load them:\n${hints}`;
         }
     }
-    catch { /* skills optional */ }
+    catch {
+        /* skills optional */
+    }
     // Track memory version for live injection
     let lastMemoryVer = 0;
     try {
         const { memoryVersion } = await import("../harness/memory.js");
         lastMemoryVer = memoryVersion();
     }
-    catch { /* ignore */ }
+    catch {
+        /* ignore */
+    }
     const state = {
         messages: [...existingMessages, createUserMessage(userMessage)],
         turn: 0,
@@ -85,20 +90,37 @@ export async function* query(userMessage, config, existingMessages = []) {
             return;
         }
         // Context window management
+        // ── Context window management with circuit breaker ──
         const contextWindow = getContextWindow(config.model);
         const estimatedTokens = estimateMessagesTokens(state.messages, estimateTokens);
-        if (estimatedTokens > contextWindow * 0.8) {
+        const MAX_COMPRESSION_FAILURES = 3;
+        if (estimatedTokens > contextWindow * 0.8 && (state.compressionFailures ?? 0) < MAX_COMPRESSION_FAILURES) {
+            const tokensBefore = estimatedTokens;
+            let strategy = "basic";
             state.messages = compressMessages(state.messages, Math.floor(contextWindow * 0.6));
             const afterBasic = estimateMessagesTokens(state.messages, estimateTokens);
             if (afterBasic > contextWindow * 0.7 && state.messages.length > 4) {
                 try {
                     state.messages = await summarizeConversation(config.provider, state.messages, config.model, Math.floor(contextWindow * 0.5));
-                    yield { type: "error", message: "Context compressed with LLM summarization." };
+                    strategy = "llm-summarization";
+                    state.compressionFailures = 0; // Reset on success
                 }
                 catch {
-                    /* continue with basic compression */
+                    state.compressionFailures = (state.compressionFailures ?? 0) + 1;
+                    strategy = "basic-only (llm failed)";
                 }
             }
+            const tokensAfter = estimateMessagesTokens(state.messages, estimateTokens);
+            yield {
+                type: "error",
+                message: `Context compressed (${strategy}): ${tokensBefore} → ${tokensAfter} tokens. Re-read any files you need.`,
+            };
+        }
+        else if (estimatedTokens > contextWindow * 0.8) {
+            yield {
+                type: "error",
+                message: "Context compression disabled (3 consecutive failures). Consider starting a new session.",
+            };
         }
         // ── Dynamic prompt: refresh memories if changed, inject warnings ──
         try {
@@ -116,7 +138,9 @@ export async function* query(userMessage, config, existingMessages = []) {
                 lastMemoryVer = currentVer;
             }
         }
-        catch { /* memory refresh optional */ }
+        catch {
+            /* memory refresh optional */
+        }
         let turnPrompt = fullSystemPrompt;
         if (config.maxCost && config.maxCost > 0) {
             const pct = state.totalCost / config.maxCost;