@zhijiewang/openharness 2.3.1 → 2.5.0

package/README.md

@@ -21,7 +21,7 @@ AI coding agent in your terminal. Works with any LLM -- free local models or clo
   <img src="assets/openharness_v0.11.1_4.gif" alt="OpenHarness demo" width="800" />
 </p>
 
-[![npm version](https://img.shields.io/npm/v/@zhijiewang/openharness)](https://www.npmjs.com/package/@zhijiewang/openharness) [![npm downloads](https://img.shields.io/npm/dm/@zhijiewang/openharness)](https://www.npmjs.com/package/@zhijiewang/openharness) [![license](https://img.shields.io/npm/l/@zhijiewang/openharness)](LICENSE) ![tests](https://img.shields.io/badge/tests-769-brightgreen) ![tools](https://img.shields.io/badge/tools-37-blue) ![Node.js 18+](https://img.shields.io/badge/node-18%2B-green) ![TypeScript](https://img.shields.io/badge/typescript-strict-blue) [![GitHub stars](https://img.shields.io/github/stars/zhijiewong/openharness)](https://github.com/zhijiewong/openharness) [![GitHub issues](https://img.shields.io/github/issues-raw/zhijiewong/openharness)](https://github.com/zhijiewong/openharness/issues) [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen)](https://github.com/zhijiewong/openharness/pulls)
+[![npm version](https://img.shields.io/npm/v/@zhijiewang/openharness)](https://www.npmjs.com/package/@zhijiewang/openharness) [![npm downloads](https://img.shields.io/npm/dm/@zhijiewang/openharness)](https://www.npmjs.com/package/@zhijiewang/openharness) [![license](https://img.shields.io/npm/l/@zhijiewang/openharness)](LICENSE) ![tests](https://img.shields.io/badge/tests-784-brightgreen) ![tools](https://img.shields.io/badge/tools-41-blue) ![Node.js 18+](https://img.shields.io/badge/node-18%2B-green) ![TypeScript](https://img.shields.io/badge/typescript-strict-blue) [![GitHub stars](https://img.shields.io/github/stars/zhijiewong/openharness)](https://github.com/zhijiewong/openharness) [![GitHub issues](https://img.shields.io/github/issues-raw/zhijiewong/openharness)](https://github.com/zhijiewong/openharness/issues) [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen)](https://github.com/zhijiewong/openharness/pulls)
 
 ---
 
@@ -84,7 +84,7 @@ Most AI coding agents are locked to one provider or cost $20+/month. OpenHarness
 |---|---|---|---|---|
 | Any LLM | Yes (Ollama, OpenAI, Anthropic, OpenRouter, any OpenAI-compatible) | Anthropic only | Yes | Yes |
 | Free local models | Ollama native | No | Yes | Yes |
-| Tools | 37 with permission gates | 43+ | File-focused | 20+ |
+| Tools | 41 with permission gates | 43+ | File-focused | 20+ |
 | Permission modes | 7 (ask, trust, deny, acceptEdits, plan, auto, bypass) | 7 | Basic | Basic |
 | Git integration | Auto-commit + /undo + /rewind checkpoints | Yes | Deep git | Basic |
 | Slash commands | 42+ built-in | 80+ | Some | Some |

package/dist/Tool.d.ts

@@ -23,6 +23,8 @@ export type ToolContext = {
     permissionMode?: PermissionMode;
     /** Ask the user a question; resolves with their answer string */
     askUserQuestion?: (question: string, options?: string[]) => Promise<string>;
+    /** Auto-commit after file-modifying tools */
+    gitCommitPerTool?: boolean;
 };
 export type Tool<Input extends z.ZodType = z.ZodType> = {
     readonly name: string;

package/dist/commands/index.js

@@ -993,6 +993,117 @@ register("rebuild-sessions", "Rebuild session search index", () => {
     });
     return { output: "Rebuilding session search index...", handled: true };
 });
+// ── Skill Management ──
+register("skill-create", "Create a new skill file", (args) => {
+    const name = args.trim();
+    if (!name)
+        return { output: "Usage: /skill-create <name>", handled: true };
+    if (name.includes("..") || name.includes("/") || name.includes("\\")) {
+        return { output: "Error: Invalid skill name.", handled: true };
+    }
+    const dir = join(process.cwd(), ".oh", "skills");
+    mkdirSync(dir, { recursive: true });
+    const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+    const filePath = join(dir, `${slug}.md`);
+    if (existsSync(filePath)) {
+        return { output: `Skill "${slug}" already exists at ${filePath}`, handled: true };
+    }
+    const template = `---
+name: ${slug}
+description: TODO — describe what this skill does
+trigger: ${slug}
+---
+
+# ${name}
+
+## When to Use
+Describe when this skill should be triggered.
+
+## Procedure
+1. Step one
+2. Step two
+3. Step three
+
+## Pitfalls
+- Common mistakes to avoid
+
+## Verification
+How to confirm the skill worked correctly.
+`;
+    writeFileSync(filePath, template);
+    return { output: `Created skill: ${filePath}\nEdit the file to customize it.`, handled: true };
+});
+register("skill-delete", "Delete a skill file", (args) => {
+    const name = args.trim();
+    if (!name)
+        return { output: "Usage: /skill-delete <name>", handled: true };
+    const { findSkill } = require("../harness/plugins.js");
+    const skill = findSkill(name);
+    if (!skill)
+        return { output: `Skill "${name}" not found.`, handled: true };
+    try {
+        const { unlinkSync } = require("node:fs");
+        unlinkSync(skill.filePath);
+        return { output: `Deleted skill: ${skill.filePath}`, handled: true };
+    }
+    catch (err) {
+        return { output: `Error deleting skill: ${err.message}`, handled: true };
+    }
+});
+register("skill-edit", "Show skill file path for editing", (args) => {
+    const name = args.trim();
+    if (!name)
+        return { output: "Usage: /skill-edit <name>", handled: true };
+    const { findSkill } = require("../harness/plugins.js");
+    const skill = findSkill(name);
+    if (!skill)
+        return { output: `Skill "${name}" not found.`, handled: true };
+    return { output: `Skill file: ${skill.filePath}\nEdit this file to update the skill.`, handled: true };
+});
+register("skill-search", "Search the skills registry", (args) => {
+    const query = args.trim();
+    if (!query)
+        return { output: "Usage: /skill-search <query>", handled: true };
+    // Async search — fire and return message
+    import("../harness/skill-registry.js").then(async ({ fetchRegistry, searchRegistry }) => {
+        try {
+            const registry = await fetchRegistry();
+            const results = searchRegistry(registry, query);
+            if (results.length === 0) {
+                console.log(`No skills found matching "${query}".`);
+            }
+            else {
+                const lines = results.map((s) => `  ${s.name.padEnd(20)} ${s.description} [${s.tags.join(", ")}]`);
+                console.log(`Found ${results.length} skill(s):\n${lines.join("\n")}\n\nInstall: /skill-install <name>`);
+            }
+        }
+        catch (err) {
+            console.log(`Registry search failed: ${err.message}`);
+        }
+    });
+    return { output: "Searching skills registry...", handled: true };
+});
+register("skill-install", "Install a skill from the registry", (args) => {
+    const name = args.trim();
+    if (!name)
+        return { output: "Usage: /skill-install <name>", handled: true };
+    import("../harness/skill-registry.js").then(async ({ fetchRegistry, installSkill }) => {
+        try {
+            const registry = await fetchRegistry();
+            const skill = registry.skills.find((s) => s.name.toLowerCase() === name.toLowerCase());
+            if (!skill) {
+                console.log(`Skill "${name}" not found in registry. Try /skill-search first.`);
+                return;
+            }
+            const path = await installSkill(skill);
+            console.log(`Installed skill "${skill.name}" to ${path}`);
+        }
+        catch (err) {
+            console.log(`Installation failed: ${err.message}`);
+        }
+    });
+    return { output: `Installing skill "${name}"...`, handled: true };
+});
 // ── Command Parser ──
 /**
  * Check if input is a slash command. If so, execute it.

package/dist/components/InitWizard.js

@@ -86,7 +86,7 @@ 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());
@@ -175,7 +175,9 @@ export default function InitWizard({ onDone }) {
             if (input === "n" || input === "N")
                 writeFinal();
         }
-    }, [step, providerIdx, provider, modelIdx, availableModels, model]));
+    }, 
+    // biome-ignore lint/correctness/useExhaustiveDependencies: runTest/writeFinal declared below, providerIdx intentionally omitted
+    [step, providerIdx, provider, modelIdx, availableModels, model, suggestedMcp, mcpIdx]));
     // ── Connection test ──
     const runTest = async (prov, key, url) => {
         setTestStatus("testing");
@@ -234,7 +236,7 @@ export default function InitWizard({ onDone }) {
         });
         setStep("done");
         setTimeout(() => onDone?.(), 1500);
-    }, [provider, model, availableModels, modelIdx, permIdx, apiKey, baseUrl, selectedMcp]);
+    }, [provider, model, availableModels, modelIdx, permIdx, apiKey, baseUrl, selectedMcp, onDone]);
     // ── Render ──
     if (showSetup) {
         return (_jsx(CybergotchiSetup, { onComplete: () => {

package/dist/harness/config.d.ts

@@ -68,6 +68,15 @@ export type OhConfig = {
         balanced?: string;
         powerful?: string;
     };
+    /** Fallback providers — tried in order when primary fails */
+    fallbackProviders?: Array<{
+        provider: string;
+        model?: string;
+        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/memory.d.ts

@@ -9,6 +9,7 @@
  */
 import type { Provider } from "../providers/base.js";
 import type { Message } from "../types/message.js";
+export declare function memoryVersion(): number;
 /**
  * Memory types — supports both legacy and Claude Code-compatible names.
  * Legacy: convention, preference, project, debugging
@@ -28,7 +29,7 @@ export type MemoryEntry = {
 };
 /** Load all memories from project and global dirs */
 export declare function loadMemories(): MemoryEntry[];
-/** Build a system prompt section from loaded memories */
+/** Build a system prompt section from loaded memories (capped at MEMORY_PROMPT_MAX_CHARS) */
 export declare function memoriesToPrompt(memories: MemoryEntry[]): string;
 /** Save a memory entry to the project memory directory */
 export declare function saveMemory(name: string, type: MemoryType, description: string, content: string, global?: boolean): string;

package/dist/harness/memory.js

@@ -13,6 +13,11 @@ import { join, resolve, sep } from "node:path";
 import { createUserMessage } from "../types/message.js";
 const PROJECT_MEMORY_DIR = join(".oh", "memory");
 const GLOBAL_MEMORY_DIR = join(homedir(), ".oh", "memory");
+// Version counter — incremented on every save, used by query loop for live injection
+let _memoryVersion = 0;
+export function memoryVersion() {
+    return _memoryVersion;
+}
 /** Load all memories from project and global dirs */
 export function loadMemories() {
     const entries = [];
@@ -60,12 +65,19 @@ function parseMemory(raw, filePath) {
         accessCount: accessCountMatch ? parseInt(accessCountMatch[1], 10) : 0,
     };
 }
-/** Build a system prompt section from loaded memories */
+/** Build a system prompt section from loaded memories (capped at MEMORY_PROMPT_MAX_CHARS) */
 export function memoriesToPrompt(memories) {
     if (memories.length === 0)
         return "";
-    const lines = memories.map((m) => `- **${m.name}** (${m.type}): ${m.content.slice(0, 200)}`);
-    return `# Remembered Context\n${lines.join("\n")}`;
+    const header = "# Remembered Context\n";
+    let result = header;
+    for (const m of memories) {
+        const line = `- **${m.name}** (${m.type}): ${m.content.slice(0, 200)}\n`;
+        if (result.length + line.length > MEMORY_PROMPT_MAX_CHARS)
+            break;
+        result += line;
+    }
+    return result.trimEnd();
 }
 /** Save a memory entry to the project memory directory */
 export function saveMemory(name, type, description, content, global = false) {
@@ -90,6 +102,7 @@ accessCount: 0
 ${content}
 `;
     writeFileSync(filePath, md);
+    _memoryVersion++;
     updateMemoryIndex(dir);
     return filePath;
 }
@@ -270,11 +283,39 @@ 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";
-const USER_PROFILE_MAX_CHARS = 2000;
+const USER_PROFILE_MAX_CHARS = 1375; // Matches Hermes USER.md limit
+const MEMORY_PROMPT_MAX_CHARS = 2200; // Matches Hermes MEMORY.md limit
 /** Load the user profile from .oh/memory/USER.md */
 export function loadUserProfile() {
     const filePath = join(PROJECT_MEMORY_DIR, USER_PROFILE_FILE);
@@ -307,6 +348,7 @@ updatedAt: ${Date.now()}
 ${truncated}
 `;
     writeFileSync(join(PROJECT_MEMORY_DIR, USER_PROFILE_FILE), md);
+    _memoryVersion++;
 }
 /** Format user profile for system prompt injection */
 export function userProfileToPrompt() {

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/fallback.d.ts

@@ -0,0 +1,27 @@
+/**
+ * FallbackProvider — wraps a primary provider with fallback chain.
+ *
+ * When the primary provider fails (rate limit, 5xx, network), transparently
+ * tries the next provider in the chain. Matches Hermes Agent pattern.
+ *
+ * Design notes:
+ * - Streaming fallback only activates if primary fails BEFORE yielding events.
+ *   Once events are streaming, partial output can't be un-sent, so we don't
+ *   catch mid-stream errors (they propagate to the caller for retry).
+ * - 401/403 are NOT retriable (they're permanent auth failures). Different
+ *   providers have different keys, so this is handled at the config level.
+ */
+import type { Provider } from "./base.js";
+export type FallbackConfig = {
+    provider: Provider;
+    model?: string;
+};
+/**
+ * Create a provider that falls back to alternatives on failure.
+ * The primary provider is tried first. If it fails with a retriable error
+ * BEFORE streaming begins, each fallback is tried in order.
+ */
+export declare function createFallbackProvider(primary: Provider, fallbacks: FallbackConfig[]): Provider & {
+    readonly activeFallback: string | null;
+};
+//# sourceMappingURL=fallback.d.ts.map

package/dist/providers/fallback.js

@@ -0,0 +1,114 @@
+/**
+ * FallbackProvider — wraps a primary provider with fallback chain.
+ *
+ * When the primary provider fails (rate limit, 5xx, network), transparently
+ * tries the next provider in the chain. Matches Hermes Agent pattern.
+ *
+ * Design notes:
+ * - Streaming fallback only activates if primary fails BEFORE yielding events.
+ *   Once events are streaming, partial output can't be un-sent, so we don't
+ *   catch mid-stream errors (they propagate to the caller for retry).
+ * - 401/403 are NOT retriable (they're permanent auth failures). Different
+ *   providers have different keys, so this is handled at the config level.
+ */
+/**
+ * Create a provider that falls back to alternatives on failure.
+ * The primary provider is tried first. If it fails with a retriable error
+ * BEFORE streaming begins, each fallback is tried in order.
+ */
+export function createFallbackProvider(primary, fallbacks) {
+    let _activeFallback = null;
+    const obj = {
+        name: primary.name,
+        get activeFallback() {
+            return _activeFallback;
+        },
+        async *stream(messages, systemPrompt, tools, model) {
+            // Collect first event to detect early failure vs mid-stream failure.
+            // If the provider fails before ANY event, try fallback.
+            // If it fails mid-stream, propagate the error (partial output already sent).
+            const providers = [
+                { provider: primary, model },
+                ...fallbacks.map((fb) => ({ provider: fb.provider, model: fb.model ?? model })),
+            ];
+            for (let i = 0; i < providers.length; i++) {
+                const p = providers[i];
+                try {
+                    let _hasYielded = false;
+                    for await (const event of p.provider.stream(messages, systemPrompt, tools, p.model)) {
+                        _hasYielded = true;
+                        yield event;
+                    }
+                    _activeFallback = i === 0 ? null : p.provider.name;
+                    return;
+                }
+                catch (err) {
+                    // Mid-stream failure: can't un-send events, propagate error
+                    if (i > 0 || !isRetriableError(err))
+                        throw err;
+                    // Pre-stream failure on primary: try next provider
+                    _activeFallback = null;
+                }
+            }
+            _activeFallback = null;
+            throw new Error("All providers failed (primary + fallbacks)");
+        },
+        async complete(messages, systemPrompt, tools, model) {
+            // complete() is atomic — safe to retry with any provider
+            const providers = [
+                { provider: primary, model },
+                ...fallbacks.map((fb) => ({ provider: fb.provider, model: fb.model ?? model })),
+            ];
+            for (let i = 0; i < providers.length; i++) {
+                const p = providers[i];
+                try {
+                    const result = await p.provider.complete(messages, systemPrompt, tools, p.model);
+                    _activeFallback = i === 0 ? null : p.provider.name;
+                    return result;
+                }
+                catch (err) {
+                    if (!isRetriableError(err))
+                        throw err;
+                }
+            }
+            _activeFallback = null;
+            throw new Error("All providers failed (primary + fallbacks)");
+        },
+        listModels() {
+            return primary.listModels();
+        },
+        async healthCheck() {
+            if (await primary.healthCheck())
+                return true;
+            for (const fb of fallbacks) {
+                if (await fb.provider.healthCheck())
+                    return true;
+            }
+            return false;
+        },
+        estimateTokens: primary.estimateTokens?.bind(primary),
+        getModelInfo: primary.getModelInfo?.bind(primary),
+    };
+    return obj;
+}
+/** Check if an error is worth retrying with a different provider */
+function isRetriableError(err) {
+    if (!(err instanceof Error))
+        return false;
+    const msg = err.message.toLowerCase();
+    return (msg.includes("rate limit") ||
+        msg.includes("429") ||
+        msg.includes("too many requests") ||
+        msg.includes("overloaded") ||
+        msg.includes("503") ||
+        msg.includes("529") ||
+        msg.includes("service unavailable") ||
+        msg.includes("econnrefused") ||
+        msg.includes("network") ||
+        msg.includes("timeout")
+    // Note: 401/403 are NOT retriable — they're permanent auth failures.
+    // Different providers use different API keys, so auth issues don't
+    // benefit from fallback. The user should fix their API key.
+    );
+}
+//# sourceMappingURL=fallback.js.map

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,7 +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 */
+    }
     const state = {
         messages: [...existingMessages, createUserMessage(userMessage)],
         turn: 0,
@@ -78,20 +90,69 @@ 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 {
+            const { memoryVersion, loadActiveMemories, memoriesToPrompt } = await import("../harness/memory.js");
+            const currentVer = memoryVersion();
+            if (currentVer > lastMemoryVer) {
+                const fresh = memoriesToPrompt(loadActiveMemories());
+                // Replace or append memory section in fullSystemPrompt
+                if (fullSystemPrompt.includes("# Remembered Context")) {
+                    fullSystemPrompt = fullSystemPrompt.replace(/# Remembered Context[\s\S]*?(?=\n# |$)/, fresh);
+                }
+                else if (fresh) {
+                    fullSystemPrompt += `\n\n${fresh}`;
+                }
+                lastMemoryVer = currentVer;
+            }
+        }
+        catch {
+            /* memory refresh optional */
+        }
+        let turnPrompt = fullSystemPrompt;
+        if (config.maxCost && config.maxCost > 0) {
+            const pct = state.totalCost / config.maxCost;
+            if (pct >= 0.9) {
+                turnPrompt += `\n\n⚠️ BUDGET CRITICAL: Only $${(config.maxCost - state.totalCost).toFixed(4)} remaining. Provide final response NOW.`;
+            }
+            else if (pct >= 0.7) {
+                turnPrompt += `\n\n⚠️ BUDGET WARNING: ${Math.round((1 - pct) * 100)}% budget remaining. Start consolidating.`;
+            }
+        }
+        if (state.turn >= maxTurns * 0.9 && maxTurns > 1) {
+            turnPrompt += `\n\n⚠️ TURN LIMIT: ${maxTurns - state.turn} turn(s) remaining. Wrap up.`;
         }
         // ── LLM call with streaming ──
         let assistantContent = "";
@@ -99,7 +160,7 @@ export async function* query(userMessage, config, existingMessages = []) {
         let streamError = null;
         const streamingExecutor = new StreamingToolExecutor(config.tools, toolContext, config.permissionMode, config.askUser, config.abortSignal);
         try {
-            for await (const event of config.provider.stream(state.messages, fullSystemPrompt, apiTools, config.model)) {
+            for await (const event of config.provider.stream(state.messages, turnPrompt, apiTools, config.model)) {
                 if (config.abortSignal?.aborted)
                     break;
                 switch (event.type) {

package/dist/query/tools.js

@@ -120,6 +120,17 @@ export async function executeSingleTool(toolCall, tools, context, permissionMode
                 /* verification should never break tool execution */
             }
         }
+        // Auto-commit per tool (if enabled and file was modified)
+        if (!result.isError && context.gitCommitPerTool && !tool.isReadOnly(parsed.data)) {
+            try {
+                const { autoCommitAIEdits } = await import("../git/index.js");
+                const filePaths = getAffectedFiles(tool.name, parsed.data);
+                autoCommitAIEdits(tool.name, filePaths);
+            }
+            catch {
+                /* auto-commit is optional */
+            }
+        }
         // Strip ANSI and cap output, then append verification suffix
         let output = result.output.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "") + verificationSuffix;
         if (output.length > MAX_TOOL_RESULT_CHARS) {

package/dist/query/types.d.ts

@@ -18,6 +18,8 @@ export type QueryConfig = {
     abortSignal?: AbortSignal;
     /** Working directory for tool execution (defaults to process.cwd()) */
     workingDir?: string;
+    /** Auto-commit after each file-modifying tool */
+    gitCommitPerTool?: boolean;
 };
 export type TransitionReason = "next_turn" | "retry_network" | "retry_prompt_too_long" | "retry_max_output_tokens";
 export type QueryLoopState = {
@@ -29,5 +31,7 @@ export type QueryLoopState = {
     consecutiveErrors: number;
     transition?: TransitionReason;
     promptTooLongRetries?: number;
+    /** Track consecutive compression failures for circuit breaker */
+    compressionFailures?: number;
 };
 //# sourceMappingURL=types.d.ts.map

package/dist/repl.js

@@ -685,7 +685,9 @@ export async function startREPL(config) {
                             // LLM-assisted merge: consolidate instead of blind append
                             const { createUserMessage: makeMsg } = await import("./types/message.js");
                             try {
-                                const consolidated = await config.provider.complete([makeMsg(`Merge this user profile with new observations into a single cohesive profile. Keep the most important and recent information. Remove duplicates. Stay under 2000 characters. Return ONLY the merged profile text.\n\nCurrent profile:\n${currentProfile}\n\nNew observations:\n${newObservations}`)], "You are a profile curator. Return ONLY the merged profile, no commentary.", undefined, currentModel);
+                                const consolidated = await config.provider.complete([
+                                    makeMsg(`Merge this user profile with new observations into a single cohesive profile. Keep the most important and recent information. Remove duplicates. Stay under 2000 characters. Return ONLY the merged profile text.\n\nCurrent profile:\n${currentProfile}\n\nNew observations:\n${newObservations}`),
+                                ], "You are a profile curator. Return ONLY the merged profile, no commentary.", undefined, currentModel);
                                 updateUserProfile(consolidated.content);
                             }
                             catch {

package/dist/services/SkillExtractor.js

@@ -96,6 +96,8 @@ source: auto
 extractedFrom: ${sessionId}
 extractedAt: ${now}
 version: ${version}
+timesUsed: 0
+lastUsed: 0
 ---
 
 ## Procedure

package/dist/tools/SkillTool/index.js

@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs";
+import { readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { z } from "zod";
 import { discoverSkills, findSkill } from "../../harness/plugins.js";
@@ -24,7 +24,7 @@ export const SkillTool = {
             return { output: "Error: Invalid skill name.", isError: true };
         }
         // Early path traversal check for Level 2
-        if (input.path && input.path.includes("..")) {
+        if (input.path?.includes("..")) {
             return { output: "Error: Path traversal not allowed.", isError: true };
         }
         // List skills if "list" or "ls"
@@ -62,6 +62,30 @@ export const SkillTool = {
                 return { output: `File not found: ${input.path} (looked in ${skillDir}/)`, isError: true };
             }
         }
+        // Track usage (fire-and-forget, don't block skill invocation)
+        try {
+            let raw = readFileSync(skill.filePath, "utf-8");
+            const now = Date.now();
+            const usedMatch = raw.match(/^timesUsed:\s*(\d+)$/m);
+            const count = usedMatch ? parseInt(usedMatch[1], 10) + 1 : 1;
+            if (usedMatch) {
+                raw = raw.replace(/^timesUsed:\s*\d+$/m, `timesUsed: ${count}`);
+            }
+            else {
+                const first = raw.indexOf("---");
+                const closing = raw.indexOf("---", first + 3);
+                if (closing > 0) {
+                    raw = `${raw.slice(0, closing)}timesUsed: ${count}\nlastUsed: ${now}\n${raw.slice(closing)}`;
+                }
+            }
+            if (raw.match(/^lastUsed:/m)) {
+                raw = raw.replace(/^lastUsed:\s*\d+$/m, `lastUsed: ${now}`);
+            }
+            writeFileSync(skill.filePath, raw);
+        }
+        catch {
+            /* don't block on tracking failure */
+        }
         return { output: skill.content, isError: false };
     },
     prompt() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhijiewang/openharness",
-  "version": "2.3.1",
+  "version": "2.5.0",
   "description": "Open-source terminal coding agent. Works with any LLM.",
   "type": "module",
   "bin": {