@zhijiewang/openharness 2.19.0 → 2.20.0

package/dist/commands/index.d.ts

@@ -26,4 +26,27 @@ export declare function getCommandEntries(): Array<{
     name: string;
     description: string;
 }>;
+/**
+ * Register MCP-server prompts as `/server:prompt` slash commands. Called from
+ * main.tsx after `loadMcpTools()` + `loadMcpPrompts()` so the connections are
+ * warm. Each handler invokes the prompt's `render()` and returns the result
+ * as a `prependToPrompt` so the next user prompt carries it as context.
+ *
+ * Argument syntax: `/server:prompt key=value key2=value2 ...`. Quoted values
+ * (`key="value with spaces"`) are supported. Args declared as `required` on
+ * the prompt template that aren't supplied surface as a usage error.
+ *
+ * Re-registering replaces any prior MCP prompt commands — safe to call again
+ * after `/reload-plugins` triggers a re-discover.
+ */
+import type { McpPromptHandle } from "../mcp/loader.js";
+export declare function registerMcpPromptCommands(prompts: readonly McpPromptHandle[]): void;
+/**
+ * Parse `key=value key2="value with spaces"` style args into a map. Bare
+ * tokens (no `=`) are dropped — MCP prompt arguments are always named.
+ * Exposed for tests.
+ *
+ * @internal
+ */
+export declare function parseMcpPromptArgs(raw: string): Record<string, string>;
 //# sourceMappingURL=index.d.ts.map

package/dist/commands/index.js

@@ -67,4 +67,68 @@ export function getCommandNames() {
 export function getCommandEntries() {
     return [...commands.entries()].map(([name, { description }]) => ({ name, description }));
 }
+let mcpPromptKeys = [];
+export function registerMcpPromptCommands(prompts) {
+    for (const key of mcpPromptKeys)
+        commands.delete(key);
+    mcpPromptKeys = [];
+    for (const handle of prompts) {
+        const key = handle.qualifiedName.toLowerCase();
+        const required = (handle.arguments ?? []).filter((a) => a.required).map((a) => a.name);
+        const optional = (handle.arguments ?? []).filter((a) => !a.required).map((a) => a.name);
+        const usageBits = [...required.map((n) => `${n}=<value>`), ...optional.map((n) => `[${n}=<value>]`)].join(" ");
+        commands.set(key, {
+            description: handle.description,
+            handler: async (args) => {
+                const parsed = parseMcpPromptArgs(args);
+                const missing = required.filter((n) => !(n in parsed));
+                if (missing.length > 0) {
+                    return {
+                        output: `/${handle.qualifiedName}: missing required argument(s): ${missing.join(", ")}\nUsage: /${handle.qualifiedName}${usageBits ? ` ${usageBits}` : ""}`,
+                        handled: true,
+                    };
+                }
+                try {
+                    const rendered = await handle.render(parsed);
+                    if (!rendered.trim()) {
+                        return { output: `/${handle.qualifiedName} returned an empty prompt.`, handled: true };
+                    }
+                    return {
+                        output: `[mcp-prompt] ${handle.qualifiedName}`,
+                        handled: false,
+                        prependToPrompt: rendered,
+                    };
+                }
+                catch (err) {
+                    return {
+                        output: `/${handle.qualifiedName} failed: ${err instanceof Error ? err.message : String(err)}`,
+                        handled: true,
+                    };
+                }
+            },
+        });
+        mcpPromptKeys.push(key);
+    }
+}
+/**
+ * Parse `key=value key2="value with spaces"` style args into a map. Bare
+ * tokens (no `=`) are dropped — MCP prompt arguments are always named.
+ * Exposed for tests.
+ *
+ * @internal
+ */
+export function parseMcpPromptArgs(raw) {
+    const out = {};
+    if (!raw.trim())
+        return out;
+    // Match key=value or key="value with spaces" or key='value'
+    const re = /(\w[\w.-]*)\s*=\s*(?:"([^"]*)"|'([^']*)'|(\S+))/g;
+    let m;
+    while ((m = re.exec(raw)) !== null) {
+        const key = m[1];
+        const value = m[2] ?? m[3] ?? m[4] ?? "";
+        out[key] = value;
+    }
+    return out;
+}
 //# sourceMappingURL=index.js.map

package/dist/commands/info.js

@@ -5,12 +5,15 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { gitBranch, isGitRepo, isInMergeOrRebase } from "../git/index.js";
-import { readOhConfig } from "../harness/config.js";
+import { invalidateConfigCache, readOhConfig } from "../harness/config.js";
 import { estimateMessageTokens } from "../harness/context-warning.js";
 import { getContextWindow } from "../harness/cost.js";
-import { getHooks } from "../harness/hooks.js";
+import { getHooks, invalidateHookCache } from "../harness/hooks.js";
+import { discoverPlugins, discoverSkills } from "../harness/plugins.js";
+import { invalidateSandboxCache } from "../harness/sandbox.js";
+import { invalidateVerificationCache } from "../harness/verification.js";
 import { normalizeMcpConfig } from "../mcp/config-normalize.js";
-import { connectedMcpServers } from "../mcp/loader.js";
+import { connectedMcpServers, disconnectMcpClients, loadMcpTools } from "../mcp/loader.js";
 import { getAuthStatus } from "../mcp/oauth.js";
 import { getRouteSelection } from "../providers/router.js";
 import { formatHooksReport } from "./hooks-report.js";
@@ -721,6 +724,46 @@ export function registerInfoCommands(register, getCommandMap) {
         }
         return { output: lines.join("\n"), handled: true };
     });
+    register("reload-plugins", "Hot-reload plugins, skills, hooks, MCP servers and config without restarting the session.", async () => {
+        // Invalidate every cached source — config, hooks, sandbox, verification.
+        // Skills + plugins aren't cached (each discoverSkills/discoverPlugins call
+        // reads fresh) but we still re-run them for the report so the user sees
+        // a count consistent with the new on-disk state.
+        invalidateConfigCache();
+        invalidateHookCache();
+        invalidateSandboxCache();
+        invalidateVerificationCache();
+        // Tear down + reconnect MCP servers (the live connections aren't
+        // cache-driven; they're long-lived sockets that need an explicit
+        // disconnect/reconnect). Failures don't block the reload — partial
+        // success is more useful than nothing.
+        disconnectMcpClients();
+        let mcpTools = 0;
+        let mcpError = null;
+        try {
+            const tools = await loadMcpTools();
+            mcpTools = tools.length;
+        }
+        catch (err) {
+            mcpError = err instanceof Error ? err.message : String(err);
+        }
+        const skillsCount = discoverSkills().length;
+        const pluginsCount = discoverPlugins().length;
+        const hookEvents = Object.keys(getHooks() ?? {}).length;
+        const mcpServers = connectedMcpServers().length;
+        const lines = [
+            "Hot reload complete:",
+            "  - config + hooks + sandbox + verification: caches invalidated",
+            `  - hook events configured:       ${hookEvents}`,
+            `  - MCP servers connected:        ${mcpServers}${mcpError ? ` (error: ${mcpError})` : ""}`,
+            `  - MCP tools loaded:             ${mcpTools}`,
+            `  - skills discovered:            ${skillsCount}`,
+            `  - plugins discovered:           ${pluginsCount}`,
+            "",
+            "Note: in-flight tool registries (held by the agent loop) refresh on the next prompt.",
+        ];
+        return { output: lines.join("\n"), handled: true };
+    });
     register("benchmark", "Run SWE-bench benchmark suite", (args) => {
         const task = args.trim();
         if (!task) {

package/dist/harness/config.d.ts

@@ -66,6 +66,18 @@ export type HooksConfig = {
     turnStart?: HookDef[];
     /** Fires at the end of each top-level agent turn (after the model either completes or errors). Matches Claude Code's Stop hook. */
     turnStop?: HookDef[];
+    /** Fires after a slash command expands into a model prompt (`prependToPrompt`), between expansion and userPromptSubmit. Useful for audit trails. */
+    userPromptExpansion?: HookDef[];
+    /** Fires after a turn's full set of tool calls have all resolved, before the next model call. Sees the batch as a whole; postToolUse fires per-tool. */
+    postToolBatch?: HookDef[];
+    /** Fires when a tool call is denied (auto-mode policy block, hook-driven deny, headless fail-closed, or user "no"). Symmetric to permissionRequest. */
+    permissionDenied?: HookDef[];
+    /** Fires when a TaskCreate tool call has just persisted a new task. */
+    taskCreated?: HookDef[];
+    /** Fires when a TaskUpdate tool call transitions a task to status "completed". */
+    taskCompleted?: HookDef[];
+    /** Fires once per system-prompt build after CLAUDE.md / global-rules / project RULES.md / user profile have been concatenated. Useful for audit trails. */
+    instructionsLoaded?: HookDef[];
 };
 export type ToolPermissionRule = {
     tool: string;

package/dist/harness/hooks.d.ts

@@ -10,7 +10,7 @@
  * - prompt: LLM yes/no check via provider.complete()
  */
 import type { HookDef, HooksConfig } from "./config.js";
-export type HookEvent = "sessionStart" | "sessionEnd" | "preToolUse" | "postToolUse" | "postToolUseFailure" | "userPromptSubmit" | "permissionRequest" | "fileChanged" | "cwdChanged" | "subagentStart" | "subagentStop" | "preCompact" | "postCompact" | "configChange" | "notification" | "turnStart" | "turnStop";
+export type HookEvent = "sessionStart" | "sessionEnd" | "preToolUse" | "postToolUse" | "postToolUseFailure" | "postToolBatch" | "userPromptSubmit" | "userPromptExpansion" | "permissionRequest" | "permissionDenied" | "fileChanged" | "cwdChanged" | "subagentStart" | "subagentStop" | "preCompact" | "postCompact" | "configChange" | "notification" | "turnStart" | "turnStop" | "taskCreated" | "taskCompleted" | "instructionsLoaded";
 export type HookContext = {
     toolName?: string;
     toolArgs?: string;
@@ -42,6 +42,28 @@ export type HookContext = {
     turnNumber?: string;
     /** For turnStop: reason the turn ended ("completed", "max_turns", "error", "interrupted") */
     turnReason?: string;
+    /** For userPromptExpansion: the slash command that triggered the expansion (e.g. "/plan") */
+    slashCommand?: string;
+    /** For userPromptExpansion: the original user input before expansion */
+    originalInput?: string;
+    /** For postToolBatch: comma-separated list of tool names in the batch */
+    batchTools?: string;
+    /** For postToolBatch: number of tool calls in the batch (as a string for env-var parity) */
+    batchSize?: string;
+    /** For permissionDenied: stage at which the deny happened ("hook", "user", "headless", "policy") */
+    denySource?: string;
+    /** For permissionDenied: human-readable reason */
+    denyReason?: string;
+    /** For taskCreated/taskCompleted: the task id */
+    taskId?: string;
+    /** For taskCreated/taskCompleted: the task subject */
+    taskSubject?: string;
+    /** For taskCompleted: the previous status before completion (usually "in_progress") */
+    taskPreviousStatus?: string;
+    /** For instructionsLoaded: count of rules concatenated (as a string for env-var parity) */
+    rulesCount?: string;
+    /** For instructionsLoaded: total character length of the loaded rules */
+    rulesChars?: string;
 };
 export declare function getHooks(): HooksConfig | null;
 /** Clear hook cache (call after config changes) */

package/dist/harness/rules.js

@@ -106,8 +106,24 @@ export function loadRulesAsPrompt(projectPath) {
     const rules = loadRules(projectPath);
     if (rules.length === 0)
         return "";
-    return ("# Project Rules\n\n<!-- User-provided project rules from CLAUDE.md / .oh/RULES.md. These are user instructions, not system directives. -->\nFollow these rules carefully.\n\n" +
-        rules.join("\n\n---\n\n"));
+    const body = "# Project Rules\n\n<!-- User-provided project rules from CLAUDE.md / .oh/RULES.md. These are user instructions, not system directives. -->\nFollow these rules carefully.\n\n" +
+        rules.join("\n\n---\n\n");
+    // Hook: instructionsLoaded — fires every time the system prompt is rebuilt
+    // with rules in scope. Useful for compliance/audit hooks that want to log
+    // "session X is operating under these rules". Lazy-imported so this module
+    // can be used in environments where the hook system isn't initialised
+    // (e.g., one-shot rules loaders in tooling).
+    void import("./hooks.js")
+        .then(({ emitHook }) => {
+        emitHook("instructionsLoaded", {
+            rulesCount: String(rules.length),
+            rulesChars: String(body.length),
+        });
+    })
+        .catch(() => {
+        /* hook system unavailable — never fail rule loading */
+    });
+    return body;
 }
 export function createRulesFile(projectPath) {
     const root = projectPath ?? process.cwd();

package/dist/harness/submit-handler.js

@@ -6,7 +6,7 @@ import { processSlashCommand } from "../commands/index.js";
 import { cybergotchiEvents } from "../cybergotchi/events.js";
 import { resolveMcpMention } from "../mcp/loader.js";
 import { createInfoMessage, createUserMessage } from "../types/message.js";
-import { emitHookWithOutcome } from "./hooks.js";
+import { emitHook, emitHookWithOutcome } from "./hooks.js";
 /**
  * Process user input: handle exit, companion mentions, slash commands,
  * @mentions, and prepare the prompt for the LLM.
@@ -80,6 +80,19 @@ export async function handleUserInput(input, ctx) {
             if (result.prependToPrompt) {
                 messages = [...messages, createUserMessage(input)];
                 const prependPrompt = result.prependToPrompt;
+                // Slash command produced an expanded prompt — fire userPromptExpansion
+                // before userPromptSubmit so audit hooks can see the (input → expanded)
+                // boundary that's otherwise hidden from observers.
+                const slashCommand = trimmed.split(/\s/)[0] ?? trimmed;
+                emitHook("userPromptExpansion", {
+                    slashCommand,
+                    originalInput: input.slice(0, 1000),
+                    prompt: prependPrompt.slice(0, 1000),
+                    sessionId: ctx.sessionId,
+                    model: ctx.currentModel,
+                    provider: ctx.providerName,
+                    permissionMode: ctx.permissionMode,
+                });
                 const prependOutcome = await emitHookWithOutcome("userPromptSubmit", {
                     prompt: prependPrompt,
                     sessionId: ctx.sessionId,

package/dist/main.js

@@ -23,7 +23,7 @@ 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 { connectedMcpServers, disconnectMcpClients, getMcpInstructions, loadMcpPrompts, loadMcpTools, } from "./mcp/loader.js";
 import { loadOutputStyle } from "./outputStyles/index.js";
 import { getAllTools } from "./tools.js";
 import { validateAgainstJsonSchema } from "./utils/json-schema.js";
@@ -653,6 +653,20 @@ program
     if (mcpNames.length > 0) {
         console.log(`[mcp] Connected: ${mcpNames.join(", ")}`);
     }
+    // Surface MCP-server prompts (`prompts/list`) as `/server:prompt` slash
+    // commands. Errors are swallowed inside loadMcpPrompts — servers that
+    // don't implement the prompts capability return [] without throwing.
+    try {
+        const { registerMcpPromptCommands } = await import("./commands/index.js");
+        const prompts = await loadMcpPrompts();
+        registerMcpPromptCommands(prompts);
+        if (prompts.length > 0) {
+            console.log(`[mcp] Prompts: ${prompts.map((p) => `/${p.qualifiedName}`).join(", ")}`);
+        }
+    }
+    catch {
+        /* prompt registration is best-effort; never block the REPL */
+    }
     const tools = [...getAllTools(), ...mcpTools];
     process.on("exit", () => disconnectMcpClients());
     // Compute working directory and git branch

package/dist/mcp/client.d.ts

@@ -31,6 +31,29 @@ export declare class McpClient {
         description?: string;
     }>>;
     readResource(uri: string): Promise<string>;
+    /**
+     * List the prompts an MCP server exposes. Returns `[]` for servers that
+     * don't implement the `prompts/list` capability — this is a normal case
+     * (most non-prompt-aware MCP servers throw a method-not-found error).
+     *
+     * Each prompt may declare named arguments; surfaced via `arguments`.
+     */
+    listPrompts(): Promise<Array<{
+        name: string;
+        description?: string;
+        arguments?: Array<{
+            name: string;
+            description?: string;
+            required?: boolean;
+        }>;
+    }>>;
+    /**
+     * Get the rendered text of an MCP prompt. Server-side templates are
+     * applied with the supplied arguments. Multiple message turns are
+     * concatenated with double-newline separators — same shape OH uses for
+     * other prepended prompts.
+     */
+    getPrompt(name: string, args?: Record<string, string>): Promise<string>;
     callTool(name: string, args: Record<string, unknown>): Promise<string>;
     disconnect(): void;
 }

package/dist/mcp/client.js

@@ -91,6 +91,43 @@ export class McpClient {
             .map((c) => c.text)
             .join("\n");
     }
+    /**
+     * List the prompts an MCP server exposes. Returns `[]` for servers that
+     * don't implement the `prompts/list` capability — this is a normal case
+     * (most non-prompt-aware MCP servers throw a method-not-found error).
+     *
+     * Each prompt may declare named arguments; surfaced via `arguments`.
+     */
+    async listPrompts() {
+        try {
+            const res = await this.sdk.listPrompts();
+            return (res?.prompts ?? []);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Get the rendered text of an MCP prompt. Server-side templates are
+     * applied with the supplied arguments. Multiple message turns are
+     * concatenated with double-newline separators — same shape OH uses for
+     * other prepended prompts.
+     */
+    async getPrompt(name, args = {}) {
+        const res = await this.sdk.getPrompt({ name, arguments: args });
+        const messages = (res?.messages ?? []);
+        const parts = [];
+        for (const m of messages) {
+            const content = m.content;
+            if (typeof content === "string") {
+                parts.push(content);
+            }
+            else if (content && content.type === "text" && typeof content.text === "string") {
+                parts.push(content.text);
+            }
+        }
+        return parts.join("\n\n");
+    }
     async callTool(name, args) {
         // Retry up to 2 times on transport-closed / timeout errors
         let lastErr = null;

package/dist/mcp/loader.d.ts

@@ -5,6 +5,26 @@ export declare function loadMcpTools(): Promise<Tool[]>;
 export declare function disconnectMcpClients(): void;
 /** Names of connected MCP servers */
 export declare function connectedMcpServers(): string[];
+export type McpPromptHandle = {
+    /** `<server>:<prompt>` qualified name — the slash command is `/<server>:<prompt>`. */
+    qualifiedName: string;
+    description: string;
+    /** List of named arguments the prompt template expects. */
+    arguments?: Array<{
+        name: string;
+        description?: string;
+        required?: boolean;
+    }>;
+    /** Render the prompt with the supplied named arguments. */
+    render(args?: Record<string, string>): Promise<string>;
+};
+/**
+ * Enumerate prompts on every already-connected MCP server. Servers that don't
+ * implement the `prompts/list` capability return an empty list (handled
+ * inside `client.listPrompts`). Call AFTER `loadMcpTools()` so the client
+ * connections are warm.
+ */
+export declare function loadMcpPrompts(): Promise<McpPromptHandle[]>;
 /** Get MCP server instructions to inject into system prompt (sandboxed with origin markers) */
 export declare function getMcpInstructions(): string[];
 /** List all available resources across connected MCP servers */

package/dist/mcp/loader.js

@@ -78,6 +78,33 @@ export function disconnectMcpClients() {
 export function connectedMcpServers() {
     return connectedClients.map((c) => c.name);
 }
+/**
+ * Enumerate prompts on every already-connected MCP server. Servers that don't
+ * implement the `prompts/list` capability return an empty list (handled
+ * inside `client.listPrompts`). Call AFTER `loadMcpTools()` so the client
+ * connections are warm.
+ */
+export async function loadMcpPrompts() {
+    const handles = [];
+    for (const client of connectedClients) {
+        let prompts;
+        try {
+            prompts = await client.listPrompts();
+        }
+        catch {
+            continue; // Defensive — listPrompts already swallows method-not-found
+        }
+        for (const p of prompts) {
+            handles.push({
+                qualifiedName: `${client.name}:${p.name}`,
+                description: p.description ?? `MCP prompt from ${client.name}`,
+                ...(p.arguments ? { arguments: p.arguments } : {}),
+                render: (args = {}) => client.getPrompt(p.name, args),
+            });
+        }
+    }
+    return handles;
+}
 const MAX_MCP_INSTRUCTION_LENGTH = 2000;
 /** Get MCP server instructions to inject into system prompt (sandboxed with origin markers) */
 export function getMcpInstructions() {

package/dist/query/tools.js

@@ -55,12 +55,22 @@ export async function executeSingleTool(toolCall, tools, context, permissionMode
                 permissionMode,
                 permissionAction: "ask",
             });
+            const denyAndEmit = (source, reason, output) => {
+                emitHook("permissionDenied", {
+                    toolName: tool.name,
+                    toolArgs: JSON.stringify(toolCall.arguments).slice(0, 1000),
+                    permissionMode,
+                    denySource: source,
+                    denyReason: reason,
+                });
+                return { output, isError: true };
+            };
             if (hookOutcome.permissionDecision === "allow") {
                 // Hook granted permission — proceed to execution.
             }
             else if (hookOutcome.permissionDecision === "deny" || !hookOutcome.allowed) {
                 const reason = hookOutcome.reason ? `: ${hookOutcome.reason}` : "";
-                return { output: `Permission denied by hook${reason}`, isError: true };
+                return denyAndEmit("hook", hookOutcome.reason ?? "hook denied", `Permission denied by hook${reason}`);
             }
             else if (askUser) {
                 // "ask" or no decision → interactive prompt when available
@@ -68,20 +78,25 @@ export async function executeSingleTool(toolCall, tools, context, permissionMode
                 const description = formatToolArgs(tool.name, toolCall.arguments);
                 const allowed = await askUser(tool.name, description, tool.riskLevel);
                 if (!allowed) {
-                    return { output: "Permission denied by user.", isError: true };
+                    return denyAndEmit("user", "user declined", "Permission denied by user.");
                 }
             }
             else {
                 // Headless mode with no hook decision and no interactive prompt:
                 // fail-closed deny. SDK consumers should configure a permissionRequest
                 // hook (or use canUseTool) to make per-call decisions.
-                return {
-                    output: "Permission denied: needs-approval (no interactive prompt available; configure a permissionRequest hook to gate this tool)",
-                    isError: true,
-                };
+                return denyAndEmit("headless", "no hook decision and no interactive prompt available", "Permission denied: needs-approval (no interactive prompt available; configure a permissionRequest hook to gate this tool)");
             }
         }
         else {
+            // Auto-mode policy block (deny / acceptEdits / etc) — symmetric event.
+            emitHook("permissionDenied", {
+                toolName: tool.name,
+                toolArgs: JSON.stringify(toolCall.arguments).slice(0, 1000),
+                permissionMode,
+                denySource: "policy",
+                denyReason: perm.reason,
+            });
             return { output: `Permission denied: ${perm.reason}`, isError: true };
         }
     }
@@ -200,6 +215,7 @@ export async function* executeToolCalls(toolCalls, tools, context, permissionMod
     const onOutputChunk = (callId, chunk) => {
         outputChunks.push({ type: "tool_output_delta", callId, chunk });
     };
+    const allToolNames = toolCalls.map((tc) => tc.toolName);
     for (const batch of batches) {
         if (batch.concurrent) {
             const results = await Promise.all(batch.calls.map((tc) => executeSingleTool(tc, tools, { ...context, callId: tc.id, onOutputChunk }, permissionMode, askUser)));
@@ -222,5 +238,17 @@ export async function* executeToolCalls(toolCalls, tools, context, permissionMod
             }
         }
     }
+    // Hook: postToolBatch — fires once after the model's full set of tool
+    // calls for this turn have all resolved (across however many serial /
+    // concurrent batches partitionToolCalls produced), before the next model
+    // call. Per-tool postToolUse / postToolUseFailure still fire as before;
+    // this is the batch-level boundary for hooks that want to act once per
+    // turn instead of once per tool.
+    if (toolCalls.length > 0) {
+        emitHook("postToolBatch", {
+            batchSize: String(toolCalls.length),
+            batchTools: allToolNames.slice(0, 50).join(","),
+        });
+    }
 }
 //# sourceMappingURL=tools.js.map

package/dist/tools/TaskCreateTool/index.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { z } from "zod";
+import { emitHook } from "../../harness/hooks.js";
 const inputSchema = z.object({
     subject: z.string(),
     description: z.string(),
@@ -42,6 +43,10 @@ export const TaskCreateTool = {
             };
             tasks.push(newTask);
             await fs.writeFile(filePath, JSON.stringify(tasks, null, 2), "utf-8");
+            emitHook("taskCreated", {
+                taskId: String(newTask.id),
+                taskSubject: newTask.subject.slice(0, 200),
+            });
             return { output: `Task #${newTask.id} created: ${newTask.subject}`, isError: false };
         }
         catch (err) {

package/dist/tools/TaskUpdateTool/index.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { z } from "zod";
+import { emitHook } from "../../harness/hooks.js";
 const inputSchema = z.object({
     taskId: z.number(),
     status: z.enum(["pending", "in_progress", "completed", "cancelled", "deleted"]).optional(),
@@ -32,6 +33,7 @@ export const TaskUpdateTool = {
             if (!task) {
                 return { output: `Error: Task #${input.taskId} not found.`, isError: true };
             }
+            const previousStatus = task.status;
             // Handle deletion
             if (input.status === "deleted") {
                 const idx = tasks.indexOf(task);
@@ -69,6 +71,15 @@ export const TaskUpdateTool = {
                 task.blockedBy = [...new Set([...(task.blockedBy ?? []), ...input.addBlockedBy])];
             }
             await fs.writeFile(filePath, JSON.stringify(tasks, null, 2), "utf-8");
+            // Hook: taskCompleted — fires only on the pending|in_progress → completed
+            // transition. Re-saving an already-completed task is a no-op for the hook.
+            if (input.status === "completed" && previousStatus !== "completed") {
+                emitHook("taskCompleted", {
+                    taskId: String(task.id),
+                    taskSubject: task.subject.slice(0, 200),
+                    taskPreviousStatus: previousStatus,
+                });
+            }
             return { output: `Task #${task.id} updated. Status: ${task.status}`, isError: false };
         }
         catch (err) {

package/package.json

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