@zhijiewang/openharness 2.3.1 → 2.4.0

package/dist/commands/index.js

@@ -993,6 +993,73 @@ 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 };
+});
 // ── Command Parser ──
 /**
  * Check if input is a slash command. If so, execute it.

package/dist/harness/config.d.ts

@@ -68,6 +68,13 @@ 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;
+    }>;
     /** 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;
 }
@@ -274,7 +287,8 @@ export function consolidateMemories() {
 }
 // ── 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 +321,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/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,115 @@
+/**
+ * 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;
+                    continue;
+                }
+            }
+            _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

@@ -57,6 +57,13 @@ export async function* query(userMessage, config, existingMessages = []) {
         }
     }
     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,
@@ -93,13 +100,43 @@ export async function* query(userMessage, config, existingMessages = []) {
                 }
             }
         }
+        // ── 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 = "";
         const toolCalls = [];
         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/package.json

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