@zhijiewang/openharness 2.3.0 → 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/main.js

@@ -19,6 +19,8 @@ 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 { discoverSkills, skillsToPrompt } from "./harness/plugins.js";
 import { listSessions } from "./harness/session.js";
 import { connectedMcpServers, disconnectMcpClients, getMcpInstructions, loadMcpTools } from "./mcp/loader.js";
 import { getAllTools } from "./tools.js";
@@ -78,6 +80,20 @@ function buildSystemPrompt(model) {
     const rulesPrompt = loadRulesAsPrompt();
     if (rulesPrompt)
         parts.push(rulesPrompt);
+    // User profile (highest priority personal context)
+    const userProfile = userProfileToPrompt();
+    if (userProfile)
+        parts.push(userProfile);
+    // Remembered context from past sessions
+    const memories = loadActiveMemories();
+    const memoriesPrompt = memoriesToPrompt(memories);
+    if (memoriesPrompt)
+        parts.push(memoriesPrompt);
+    // Available skills (Level 0 — names + descriptions only)
+    const skills = discoverSkills();
+    const skillsPrompt = skillsToPrompt(skills);
+    if (skillsPrompt)
+        parts.push(skillsPrompt);
     // MCP server instructions (sandboxed — treat as untrusted)
     const mcpInstructions = getMcpInstructions();
     if (mcpInstructions.length > 0) {

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

@@ -21,7 +21,7 @@ const DEFAULT_MAX_TURNS = 50;
 export async function* query(userMessage, config, existingMessages = []) {
     const maxTurns = config.maxTurns ?? DEFAULT_MAX_TURNS;
     const toolContext = {
-        workingDir: process.cwd(),
+        workingDir: config.workingDir ?? process.cwd(),
         abortSignal: config.abortSignal,
         provider: config.provider,
         model: config.model,
@@ -44,9 +44,26 @@ export async function* query(userMessage, config, existingMessages = []) {
             toolPrompts += `\n\n[${deferredCount} additional tools available — use ToolSearch to discover them]`;
         }
     }
-    const fullSystemPrompt = toolPrompts
+    let fullSystemPrompt = toolPrompts
         ? `${config.systemPrompt}\n\n# Available Tools\n\n${toolPrompts}`
         : config.systemPrompt;
+    // Auto-trigger skills matching user message
+    try {
+        const { findTriggeredSkills } = await import("../harness/plugins.js");
+        const triggered = findTriggeredSkills(userMessage);
+        if (triggered.length > 0) {
+            const hints = triggered.map((s) => `- **${s.name}**: ${s.description}`).join("\n");
+            fullSystemPrompt += `\n\n# Suggested Skills\nThese skills match your request. Use Skill tool to load them:\n${hints}`;
+        }
+    }
+    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,
@@ -83,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/dist/query/types.d.ts

@@ -16,6 +16,8 @@ export type QueryConfig = {
     maxCost?: number;
     model?: string;
     abortSignal?: AbortSignal;
+    /** Working directory for tool execution (defaults to process.cwd()) */
+    workingDir?: string;
 };
 export type TransitionReason = "next_turn" | "retry_network" | "retry_prompt_too_long" | "retry_max_output_tokens";
 export type QueryLoopState = {

package/dist/repl.js

@@ -674,17 +674,28 @@ export async function startREPL(config) {
                 if (extracted.length > 0) {
                     console.log(`[learn] Extracted ${extracted.length} skill(s) from this session.`);
                 }
-                // User profile update
+                // User profile update with LLM consolidation
                 if (messages.length >= 6) {
                     const detected = await detectMemories(config.provider, messages, currentModel);
                     const profileUpdates = detected.filter((d) => d.type === "user");
                     if (profileUpdates.length > 0) {
                         const currentProfile = loadUserProfile();
                         const newObservations = profileUpdates.map((d) => d.content).join("\n");
-                        const merged = currentProfile
-                            ? `${currentProfile}\n\n## Recent Observations\n${newObservations}`
-                            : newObservations;
-                        updateUserProfile(merged);
+                        if (currentProfile) {
+                            // 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);
+                                updateUserProfile(consolidated.content);
+                            }
+                            catch {
+                                // Fallback to simple append if LLM fails
+                                updateUserProfile(`${currentProfile}\n\n${newObservations}`);
+                            }
+                        }
+                        else {
+                            updateUserProfile(newObservations);
+                        }
                     }
                 }
             }

package/dist/services/SkillExtractor.js

@@ -113,6 +113,23 @@ ${candidate.verification}
     writeFileSync(filePath, content, "utf-8");
     return filePath;
 }
+/** Quick LLM quality check — is this skill worth keeping? */
+async function isSkillWorthy(provider, candidate, model) {
+    try {
+        const prompt = `Is this extracted skill worth saving for future reuse? Answer YES or NO (one word only).
+
+Name: ${candidate.name}
+Description: ${candidate.description}
+Procedure: ${candidate.procedure}
+
+Criteria: Is it reusable (not a one-off)? Is the procedure clear and complete? Would it save time in future sessions?`;
+        const response = await provider.complete([createUserMessage(prompt)], "Answer YES or NO only.", undefined, model);
+        return response.content.trim().toUpperCase().startsWith("YES");
+    }
+    catch {
+        return true; // On error, allow the skill through
+    }
+}
 /**
  * Orchestrate the full extraction pipeline:
  * 1. Check if extraction is warranted
@@ -132,9 +149,12 @@ export async function runExtraction(provider, messages, sessionId, model) {
     const written = [];
     for (const candidate of candidates) {
         const similar = findSimilarSkill(candidate.name, candidate.description, existingSkills);
-        // Skip if a very similar skill already exists (avoid duplicates)
         if (similar)
             continue;
+        // Quality gate: quick LLM check before persisting
+        const worthy = await isSkillWorthy(provider, candidate, model);
+        if (!worthy)
+            continue;
         const filePath = persistSkill(candidate, sessionId);
         written.push(filePath);
     }

package/dist/tools/AgentTool/index.js

@@ -87,6 +87,7 @@ export const AgentTool = {
             model: agentModel,
             maxTurns: 20,
             abortSignal: context.abortSignal,
+            workingDir: agentWorkingDir,
         };
         const agentId = Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
         emitHook("subagentStart", { agentId, toolName: input.subagent_type ?? "general" });
@@ -97,30 +98,13 @@ export const AgentTool = {
             bus.registerBackgroundAgent(bgId, input.subagent_type ?? "general");
             const runAgent = async () => {
                 let finalText = "";
-                const originalCwd = process.cwd();
                 try {
-                    if (worktreePath) {
-                        try {
-                            process.chdir(agentWorkingDir);
-                        }
-                        catch {
-                            /* ignore */
-                        }
-                    }
                     for await (const event of query(input.prompt, config)) {
                         if (event.type === "text_delta")
                             finalText += event.content;
                     }
                 }
                 finally {
-                    if (worktreePath) {
-                        try {
-                            process.chdir(originalCwd);
-                        }
-                        catch {
-                            /* ignore */
-                        }
-                    }
                     // Clean up worktree only if no changes were made
                     if (worktreePath) {
                         const hasChanges = hasWorktreeChanges(worktreePath);
@@ -152,16 +136,6 @@ export const AgentTool = {
         const outputChunks = [];
         let finalText = "";
         try {
-            // Override process.cwd for the sub-agent by setting workingDir in tool context
-            const originalCwd = process.cwd();
-            if (worktreePath) {
-                try {
-                    process.chdir(agentWorkingDir);
-                }
-                catch {
-                    /* ignore */
-                }
-            }
             try {
                 for await (const event of query(input.prompt, config)) {
                     if (event.type === "text_delta") {
@@ -184,15 +158,7 @@ export const AgentTool = {
                 }
             }
             finally {
-                // Restore original working directory
-                if (worktreePath) {
-                    try {
-                        process.chdir(originalCwd);
-                    }
-                    catch {
-                        /* ignore */
-                    }
-                }
+                /* workingDir passed via config — no process.chdir cleanup needed */
             }
         }
         catch (err) {

package/dist/tools/CronTool/index.d.ts

@@ -7,13 +7,13 @@ declare const createSchema: z.ZodObject<{
     prompt: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     action: "create";
-    prompt: string;
     name: string;
+    prompt: string;
     schedule: string;
 }, {
     action: "create";
-    prompt: string;
     name: string;
+    prompt: string;
     schedule: string;
 }>;
 declare const deleteSchema: z.ZodObject<{

package/dist/tools/MemoryTool/index.d.ts

@@ -12,18 +12,18 @@ declare const inputSchema: z.ZodObject<{
     action: "search" | "list" | "save";
     content?: string | undefined;
     type?: "user" | "convention" | "preference" | "project" | "debugging" | "feedback" | "reference" | undefined;
-    query?: string | undefined;
-    description?: string | undefined;
-    name?: string | undefined;
     global?: boolean | undefined;
+    name?: string | undefined;
+    description?: string | undefined;
+    query?: string | undefined;
 }, {
     action: "search" | "list" | "save";
     content?: string | undefined;
     type?: "user" | "convention" | "preference" | "project" | "debugging" | "feedback" | "reference" | undefined;
-    query?: string | undefined;
-    description?: string | undefined;
-    name?: string | undefined;
     global?: boolean | undefined;
+    name?: string | undefined;
+    description?: string | undefined;
+    query?: string | undefined;
 }>;
 export declare const MemoryTool: Tool<typeof inputSchema>;
 export {};

package/dist/tools/PipelineTool/index.d.ts

@@ -8,29 +8,29 @@ declare const inputSchema: z.ZodObject<{
         dependsOn: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strip", z.ZodTypeAny, {
         tool: string;
-        id: string;
         args: Record<string, unknown>;
+        id: string;
         dependsOn?: string[] | undefined;
     }, {
         tool: string;
-        id: string;
         args: Record<string, unknown>;
+        id: string;
         dependsOn?: string[] | undefined;
     }>, "many">;
     description: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     steps: {
         tool: string;
-        id: string;
         args: Record<string, unknown>;
+        id: string;
         dependsOn?: string[] | undefined;
     }[];
     description?: string | undefined;
 }, {
     steps: {
         tool: string;
-        id: string;
         args: Record<string, unknown>;
+        id: string;
         dependsOn?: string[] | undefined;
     }[];
     description?: string | undefined;

package/dist/tools/TaskUpdateTool/index.d.ts

@@ -13,8 +13,8 @@ declare const inputSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     taskId: number;
     status?: "completed" | "pending" | "cancelled" | "in_progress" | "deleted" | undefined;
-    metadata?: Record<string, unknown> | undefined;
     description?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
     subject?: string | undefined;
     activeForm?: string | undefined;
     owner?: string | undefined;
@@ -23,8 +23,8 @@ declare const inputSchema: z.ZodObject<{
 }, {
     taskId: number;
     status?: "completed" | "pending" | "cancelled" | "in_progress" | "deleted" | undefined;
-    metadata?: Record<string, unknown> | undefined;
     description?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
     subject?: string | undefined;
     activeForm?: string | undefined;
     owner?: string | undefined;

package/package.json

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