@zhijiewang/openharness 1.3.0 → 2.0.0

package/dist/services/MetaHarness.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Meta-Harness — self-optimizing agent harness.
+ *
+ * Inspired by AutoAgent (which hit #1 on SpreadsheetBench by letting
+ * the agent optimize its own harness overnight).
+ *
+ * Flow:
+ * 1. Run benchmark → get baseline score
+ * 2. Ask LLM to suggest a config change
+ * 3. Apply change → re-run benchmark
+ * 4. If score improved, keep; otherwise revert
+ * 5. Repeat for N iterations
+ *
+ * What it optimizes:
+ * - System prompt (trim, rephrase, add instructions)
+ * - Tool selection (which tools are core vs deferred)
+ * - Model router configuration
+ * - Compression strategy
+ * - Permission rules
+ */
+import type { Provider } from '../providers/base.js';
+export type BenchmarkResult = {
+    score: number;
+    details: string;
+    durationMs: number;
+};
+export type OptimizationChange = {
+    description: string;
+    field: string;
+    oldValue: unknown;
+    newValue: unknown;
+    impact: number;
+};
+export type OptimizationResult = {
+    initialScore: number;
+    finalScore: number;
+    iterations: number;
+    changes: OptimizationChange[];
+    totalDurationMs: number;
+};
+/**
+ * Run a benchmark command and extract a score.
+ * Score is derived from test results: pass_rate + speed_bonus.
+ */
+export declare function runBenchmark(command: string): Promise<BenchmarkResult>;
+export declare class MetaHarness {
+    private provider;
+    private benchmarkCommand;
+    private model?;
+    constructor(provider: Provider, benchmarkCommand: string, model?: string | undefined);
+    /**
+     * Run the optimization loop.
+     */
+    optimize(iterations: number): Promise<OptimizationResult>;
+    private suggestChange;
+    private applyChange;
+    private revertChange;
+}
+/** Format optimization results for display */
+export declare function formatOptimizationResult(result: OptimizationResult): string;
+//# sourceMappingURL=MetaHarness.d.ts.map

package/dist/services/MetaHarness.js

@@ -0,0 +1,210 @@
+/**
+ * Meta-Harness — self-optimizing agent harness.
+ *
+ * Inspired by AutoAgent (which hit #1 on SpreadsheetBench by letting
+ * the agent optimize its own harness overnight).
+ *
+ * Flow:
+ * 1. Run benchmark → get baseline score
+ * 2. Ask LLM to suggest a config change
+ * 3. Apply change → re-run benchmark
+ * 4. If score improved, keep; otherwise revert
+ * 5. Repeat for N iterations
+ *
+ * What it optimizes:
+ * - System prompt (trim, rephrase, add instructions)
+ * - Tool selection (which tools are core vs deferred)
+ * - Model router configuration
+ * - Compression strategy
+ * - Permission rules
+ */
+import { readOhConfig, invalidateConfigCache } from '../harness/config.js';
+import { copyFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+// ── Benchmark Runner ──
+/**
+ * Run a benchmark command and extract a score.
+ * Score is derived from test results: pass_rate + speed_bonus.
+ */
+export async function runBenchmark(command) {
+    const start = Date.now();
+    try {
+        const output = execSync(command, {
+            encoding: 'utf-8',
+            timeout: 300_000, // 5 minute max
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        // Parse test results to extract score
+        const score = extractScore(output);
+        return {
+            score,
+            details: output.slice(-500),
+            durationMs: Date.now() - start,
+        };
+    }
+    catch (err) {
+        const output = String(err.stdout ?? err.stderr ?? err.message ?? '');
+        const score = extractScore(output);
+        return {
+            score: score > 0 ? score * 0.5 : 0, // Penalty for non-zero exit
+            details: output.slice(-500),
+            durationMs: Date.now() - start,
+        };
+    }
+}
+/** Extract a 0-1 score from test output */
+function extractScore(output) {
+    // Look for common test result patterns
+    // "X passed, Y failed" → pass_rate
+    const passMatch = output.match(/(\d+)\s+pass/i);
+    const failMatch = output.match(/(\d+)\s+fail/i);
+    if (passMatch) {
+        const passed = parseInt(passMatch[1]);
+        const failed = failMatch ? parseInt(failMatch[1]) : 0;
+        const total = passed + failed;
+        return total > 0 ? passed / total : 0;
+    }
+    // "# pass N" (TAP format)
+    const tapPass = output.match(/# pass\s+(\d+)/);
+    const tapFail = output.match(/# fail\s+(\d+)/);
+    if (tapPass) {
+        const passed = parseInt(tapPass[1]);
+        const failed = tapFail ? parseInt(tapFail[1]) : 0;
+        const total = passed + failed;
+        return total > 0 ? passed / total : 0;
+    }
+    // Exit code 0 = 1.0, non-zero = 0
+    return output.includes('error') || output.includes('FAIL') ? 0.3 : 0.8;
+}
+// ── Meta-Harness ──
+export class MetaHarness {
+    provider;
+    benchmarkCommand;
+    model;
+    constructor(provider, benchmarkCommand, model) {
+        this.provider = provider;
+        this.benchmarkCommand = benchmarkCommand;
+        this.model = model;
+    }
+    /**
+     * Run the optimization loop.
+     */
+    async optimize(iterations) {
+        const totalStart = Date.now();
+        const changes = [];
+        // Backup current config
+        const configPath = join('.oh', 'config.yaml');
+        const backupPath = join('.oh', 'config.yaml.backup');
+        if (existsSync(configPath)) {
+            copyFileSync(configPath, backupPath);
+        }
+        // Get baseline score
+        const baseline = await runBenchmark(this.benchmarkCommand);
+        let bestScore = baseline.score;
+        for (let i = 0; i < iterations; i++) {
+            // Ask LLM to suggest an optimization
+            const suggestion = await this.suggestChange(bestScore, changes);
+            if (!suggestion)
+                continue;
+            // Apply the change
+            this.applyChange(suggestion);
+            // Re-benchmark
+            const result = await runBenchmark(this.benchmarkCommand);
+            if (result.score > bestScore) {
+                // Keep the change
+                const impact = result.score - bestScore;
+                changes.push({ ...suggestion, impact });
+                bestScore = result.score;
+            }
+            else {
+                // Revert
+                this.revertChange(suggestion);
+            }
+        }
+        return {
+            initialScore: baseline.score,
+            finalScore: bestScore,
+            iterations,
+            changes,
+            totalDurationMs: Date.now() - totalStart,
+        };
+    }
+    async suggestChange(currentScore, previousChanges) {
+        const config = readOhConfig();
+        const configStr = JSON.stringify(config, null, 2);
+        const prevChangesStr = previousChanges.length > 0
+            ? `\nPrevious successful changes:\n${previousChanges.map(c => `- ${c.description} (+${c.impact.toFixed(3)})`).join('\n')}`
+            : '';
+        const prompt = `You are optimizing an AI agent harness configuration. Current score: ${currentScore.toFixed(3)}/1.0.
+${prevChangesStr}
+
+Current config:
+${configStr.slice(0, 2000)}
+
+Suggest ONE specific configuration change that might improve the benchmark score. Focus on:
+- System prompt optimization
+- Tool selection (which tools are core)
+- Permission rules that speed up automation
+- Verification configuration
+
+Respond with JSON: {"description": "what to change", "field": "config.path", "newValue": "the new value"}`;
+        try {
+            const response = await this.provider.complete([{ role: 'user', content: prompt, uuid: `meta-${Date.now()}`, timestamp: Date.now() }], 'You are a harness optimization engine. Respond ONLY with valid JSON.', undefined, this.model);
+            const jsonMatch = response.content.match(/\{[\s\S]*\}/);
+            if (!jsonMatch)
+                return null;
+            const parsed = JSON.parse(jsonMatch[0]);
+            return {
+                description: parsed.description ?? 'unknown change',
+                field: parsed.field ?? 'unknown',
+                oldValue: undefined,
+                newValue: parsed.newValue,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    applyChange(change) {
+        invalidateConfigCache();
+        // For now, log the change. Full config mutation would require
+        // a safe config updater that handles nested paths.
+        // This is a placeholder — real implementation would use lodash.set or similar.
+    }
+    revertChange(change) {
+        invalidateConfigCache();
+        // Revert by re-reading the backup config
+        const backupPath = join('.oh', 'config.yaml.backup');
+        const configPath = join('.oh', 'config.yaml');
+        if (existsSync(backupPath)) {
+            copyFileSync(backupPath, configPath);
+            invalidateConfigCache();
+        }
+    }
+}
+/** Format optimization results for display */
+export function formatOptimizationResult(result) {
+    const lines = [];
+    const improvement = result.finalScore - result.initialScore;
+    const pct = result.initialScore > 0 ? (improvement / result.initialScore * 100).toFixed(1) : '0';
+    lines.push(`Meta-Harness Optimization Complete`);
+    lines.push(`${'─'.repeat(40)}`);
+    lines.push(`Initial score: ${result.initialScore.toFixed(3)}`);
+    lines.push(`Final score:   ${result.finalScore.toFixed(3)} (${improvement >= 0 ? '+' : ''}${pct}%)`);
+    lines.push(`Iterations:    ${result.iterations}`);
+    lines.push(`Duration:      ${Math.round(result.totalDurationMs / 1000)}s`);
+    if (result.changes.length > 0) {
+        lines.push('');
+        lines.push('Applied changes:');
+        for (const c of result.changes) {
+            lines.push(`  +${c.impact.toFixed(3)} ${c.description}`);
+        }
+    }
+    else {
+        lines.push('');
+        lines.push('No improvements found in this run.');
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=MetaHarness.js.map

package/dist/tools/AgentTool/index.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { createWorktree, removeWorktree, hasWorktreeChanges, isGitRepo } from "../../git/index.js";
+import { emitHook } from "../../harness/hooks.js";
 const inputSchema = z.object({
     prompt: z.string(),
     description: z.string().optional(),
@@ -80,9 +81,11 @@ export const AgentTool = {
             maxTurns: 20,
             abortSignal: context.abortSignal,
         };
+        const agentId = Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+        emitHook("subagentStart", { agentId, toolName: input.subagent_type ?? 'general' });
         // Background execution: start agent and return immediately
         if (input.run_in_background) {
-            const bgId = Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+            const bgId = agentId;
             const runAgent = async () => {
                 let finalText = "";
                 const originalCwd = process.cwd();
@@ -190,7 +193,15 @@ export const AgentTool = {
                 }
             }
         }
-        return { output: finalText || "(sub-agent completed with no text output)", isError: false };
+        emitHook("subagentStop", { agentId });
+        // Context folding: collapse long sub-agent output to summary
+        let output = finalText || "(sub-agent completed with no text output)";
+        if (output.length > 2000) {
+            const { ContextManager } = await import("../../query/context-manager.js");
+            const cm = new ContextManager();
+            output = cm.foldSubagentResult(agentId, output);
+        }
+        return { output, isError: false };
     },
     prompt() {
         return `Spawn a sub-agent with its own tool-use loop to handle a delegated task autonomously. The sub-agent runs in an isolated git worktree to prevent file conflicts. Parameters:

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

@@ -2,17 +2,17 @@ import { z } from "zod";
 import type { Tool } from "../../Tool.js";
 declare const inputSchema: z.ZodObject<{
     file_path: z.ZodString;
-    action: z.ZodDefault<z.ZodEnum<["diagnostics", "definition", "references"]>>;
+    action: z.ZodDefault<z.ZodEnum<["diagnostics", "definition", "references", "hover"]>>;
     line: z.ZodOptional<z.ZodNumber>;
     character: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    action: "diagnostics" | "definition" | "references";
     file_path: string;
+    action: "diagnostics" | "definition" | "references" | "hover";
     line?: number | undefined;
     character?: number | undefined;
 }, {
     file_path: string;
-    action?: "diagnostics" | "definition" | "references" | undefined;
+    action?: "diagnostics" | "definition" | "references" | "hover" | undefined;
     line?: number | undefined;
     character?: number | undefined;
 }>;

package/dist/tools/DiagnosticsTool/index.js

@@ -2,8 +2,8 @@ import { z } from "zod";
 import { LspClient } from "../../lsp/client.js";
 const inputSchema = z.object({
     file_path: z.string().describe("Absolute path to the file to check"),
-    action: z.enum(["diagnostics", "definition", "references"]).default("diagnostics")
-        .describe("Action: diagnostics (errors/warnings), definition (go-to-def), references (find-refs)"),
+    action: z.enum(["diagnostics", "definition", "references", "hover"]).default("diagnostics")
+        .describe("Action: diagnostics (errors/warnings), definition (go-to-def), references (find-refs), hover (type info)"),
     line: z.number().optional().describe("Line number (0-indexed) for definition/references"),
     character: z.number().optional().describe("Column number (0-indexed) for definition/references"),
 });
@@ -16,6 +16,12 @@ function getLspCommand(filePath) {
     if (filePath.endsWith('.py')) {
         return { command: 'pylsp', args: [] };
     }
+    if (filePath.endsWith('.go')) {
+        return { command: 'gopls', args: ['serve'] };
+    }
+    if (filePath.endsWith('.rs')) {
+        return { command: 'rust-analyzer', args: [] };
+    }
     return null;
 }
 async function getClient(filePath, workingDir) {
@@ -84,6 +90,28 @@ export const DiagnosticsTool = {
                 const lines = refs.map(r => `${r.uri.replace('file://', '')}:${r.range.start.line + 1}:${r.range.start.character}`);
                 return { output: `${refs.length} reference(s):\n${lines.join('\n')}`, isError: false };
             }
+            if (input.action === "hover") {
+                if (input.line === undefined || input.character === undefined) {
+                    return { output: "line and character are required for hover.", isError: true };
+                }
+                await client.openFile(input.file_path);
+                // Hover uses textDocument/hover which returns MarkupContent
+                try {
+                    const result = await client.send('textDocument/hover', {
+                        textDocument: { uri: `file://${input.file_path.replace(/\\/g, '/')}` },
+                        position: { line: input.line, character: input.character },
+                    });
+                    if (!result || !result.contents)
+                        return { output: "No hover information.", isError: false };
+                    const content = typeof result.contents === 'string'
+                        ? result.contents
+                        : result.contents.value ?? JSON.stringify(result.contents);
+                    return { output: content, isError: false };
+                }
+                catch {
+                    return { output: "Hover not supported by this language server.", isError: false };
+                }
+            }
             return { output: `Unknown action: ${input.action}`, isError: true };
         }
         catch (err) {
@@ -94,15 +122,16 @@ export const DiagnosticsTool = {
         }
     },
     prompt() {
-        return `Get code intelligence from the language server. Actions:
+        return `Get code intelligence from the language server. Supports TypeScript, JavaScript, Python, Go, and Rust. Actions:
 - diagnostics: Get errors and warnings for a file
-- definition: Go to definition of a symbol at a given position (requires line, character)
-- references: Find all references to a symbol at a given position (requires line, character)
+- definition: Go to definition of a symbol at a given position
+- references: Find all references to a symbol at a given position
+- hover: Get type information and documentation for a symbol
 Parameters:
 - file_path (string, required): Absolute path to the file
-- action (string): "diagnostics" | "definition" | "references" (default: diagnostics)
-- line (number, optional): 0-indexed line for definition/references
-- character (number, optional): 0-indexed column for definition/references`;
+- action (string): "diagnostics" | "definition" | "references" | "hover" (default: diagnostics)
+- line (number, optional): 0-indexed line for definition/references/hover
+- character (number, optional): 0-indexed column for definition/references/hover`;
     },
 };
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import type { Tool } from "../../Tool.js";
+declare const inputSchema: z.ZodObject<{
+    command: z.ZodString;
+    pattern: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    maxLines: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    command: string;
+    pattern?: string | undefined;
+    timeout?: number | undefined;
+    maxLines?: number | undefined;
+}, {
+    command: string;
+    pattern?: string | undefined;
+    timeout?: number | undefined;
+    maxLines?: number | undefined;
+}>;
+export declare const MonitorTool: Tool<typeof inputSchema>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/MonitorTool/index.js

@@ -0,0 +1,114 @@
+import { z } from "zod";
+import { spawn } from "node:child_process";
+const inputSchema = z.object({
+    command: z.string().describe("Background command to watch"),
+    pattern: z.string().optional().describe("Regex pattern to match output lines"),
+    timeout: z.number().optional().describe("Max watch time in ms (default 60000)"),
+    maxLines: z.number().optional().describe("Max output lines to collect (default 100)"),
+});
+export const MonitorTool = {
+    name: "Monitor",
+    description: "Watch a background process and collect output. Optionally filter by regex pattern.",
+    inputSchema,
+    riskLevel: "medium",
+    isReadOnly() { return true; },
+    isConcurrencySafe() { return true; },
+    async call(input, context) {
+        const timeout = input.timeout ?? 60_000;
+        const maxLines = input.maxLines ?? 100;
+        const pattern = input.pattern ? new RegExp(input.pattern) : null;
+        return new Promise((resolve) => {
+            const lines = [];
+            let settled = false;
+            const proc = spawn(input.command, {
+                shell: true,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                windowsHide: true,
+            });
+            const timer = setTimeout(() => {
+                if (!settled) {
+                    settled = true;
+                    proc.kill();
+                    resolve({
+                        output: lines.length > 0
+                            ? lines.join('\n') + `\n\n[Monitor timed out after ${timeout / 1000}s — ${lines.length} lines collected]`
+                            : `[Monitor timed out after ${timeout / 1000}s — no output]`,
+                        isError: false,
+                    });
+                }
+            }, timeout);
+            const handleLine = (line) => {
+                if (settled)
+                    return;
+                if (pattern && !pattern.test(line))
+                    return;
+                lines.push(line.trimEnd());
+                // Stream output chunk if callback available
+                if (context.onOutputChunk && context.callId) {
+                    context.onOutputChunk(context.callId, line + '\n');
+                }
+                if (lines.length >= maxLines) {
+                    settled = true;
+                    clearTimeout(timer);
+                    proc.kill();
+                    resolve({
+                        output: lines.join('\n') + `\n\n[Collected ${maxLines} lines — stopped]`,
+                        isError: false,
+                    });
+                }
+            };
+            let stdoutBuffer = '';
+            proc.stdout?.on('data', (chunk) => {
+                stdoutBuffer += chunk.toString();
+                const parts = stdoutBuffer.split('\n');
+                stdoutBuffer = parts.pop() ?? '';
+                for (const line of parts)
+                    handleLine(line);
+            });
+            let stderrBuffer = '';
+            proc.stderr?.on('data', (chunk) => {
+                stderrBuffer += chunk.toString();
+                const parts = stderrBuffer.split('\n');
+                stderrBuffer = parts.pop() ?? '';
+                for (const line of parts)
+                    handleLine(line);
+            });
+            proc.on('exit', (code) => {
+                if (!settled) {
+                    settled = true;
+                    clearTimeout(timer);
+                    // Flush remaining buffers
+                    if (stdoutBuffer)
+                        handleLine(stdoutBuffer);
+                    if (stderrBuffer)
+                        handleLine(stderrBuffer);
+                    resolve({
+                        output: lines.length > 0
+                            ? lines.join('\n') + `\n\n[Process exited with code ${code ?? 'unknown'} — ${lines.length} lines]`
+                            : `[Process exited with code ${code ?? 'unknown'} — no output]`,
+                        isError: (code ?? 0) !== 0,
+                    });
+                }
+            });
+            proc.on('error', (err) => {
+                if (!settled) {
+                    settled = true;
+                    clearTimeout(timer);
+                    resolve({
+                        output: `Monitor error: ${err.message}`,
+                        isError: true,
+                    });
+                }
+            });
+        });
+    },
+    prompt() {
+        return `Watch a background process and collect its output. Optionally filter lines by regex pattern.
+Parameters:
+- command (string, required): The command to run and watch
+- pattern (string, optional): Regex to filter output lines
+- timeout (number, optional): Max time in ms (default 60000)
+- maxLines (number, optional): Max lines to collect (default 100)`;
+    },
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import type { Tool } from "../../Tool.js";
+declare const inputSchema: z.ZodObject<{
+    command: z.ZodString;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    command: string;
+    timeout?: number | undefined;
+}, {
+    command: string;
+    timeout?: number | undefined;
+}>;
+export declare const PowerShellTool: Tool<typeof inputSchema>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/PowerShellTool/index.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { execSync } from "node:child_process";
+const inputSchema = z.object({
+    command: z.string().describe("PowerShell command to execute"),
+    timeout: z.number().optional().describe("Timeout in ms (default 120000)"),
+});
+export const PowerShellTool = {
+    name: "PowerShell",
+    description: "Execute PowerShell commands (Windows only). Use for Windows-specific tasks like registry access, COM objects, or .NET calls.",
+    inputSchema,
+    riskLevel: "high",
+    isReadOnly() { return false; },
+    isConcurrencySafe() { return false; },
+    async call(input) {
+        if (process.platform !== 'win32') {
+            return { output: "PowerShell is only available on Windows. Use Bash instead.", isError: true };
+        }
+        const timeout = input.timeout ?? 120_000;
+        try {
+            const output = execSync(`powershell.exe -NoProfile -NonInteractive -Command "${input.command.replace(/"/g, '\\"')}"`, { encoding: 'utf-8', timeout, maxBuffer: 10 * 1024 * 1024, windowsHide: true });
+            return { output: output.trim(), isError: false };
+        }
+        catch (err) {
+            const output = String(err.stdout ?? err.stderr ?? err.message ?? 'PowerShell error');
+            return { output: output.slice(0, 100_000), isError: true };
+        }
+    },
+    prompt() {
+        return "Execute PowerShell commands on Windows. Use for registry, COM, .NET, and Windows-specific operations.";
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/tools.js

@@ -42,6 +42,8 @@ import { KillProcessTool } from "./tools/KillProcessTool/index.js";
 import { RemoteTriggerTool } from "./tools/RemoteTriggerTool/index.js";
 import { MultiEditTool } from "./tools/MultiEditTool/index.js";
 import { PipelineTool } from "./tools/PipelineTool/index.js";
+import { PowerShellTool } from "./tools/PowerShellTool/index.js";
+import { MonitorTool } from "./tools/MonitorTool/index.js";
 /**
  * Returns all registered tools.
  *
@@ -96,6 +98,8 @@ export function getAllTools() {
         KillProcessTool,
         RemoteTriggerTool,
         MultiEditTool,
+        PowerShellTool,
+        MonitorTool,
     ];
     return [
         ...core,

package/dist/types/permissions.js

@@ -7,6 +7,13 @@ const EDIT_SAFE_TOOLS = new Set([
     "FileRead", "FileWrite", "FileEdit", "Glob", "Grep", "LS",
     "ImageRead", "NotebookEdit",
 ]);
+/** Parse a tool specifier like "Bash(npm run *)" into tool name + pattern */
+function parseToolSpecifier(specifier) {
+    const match = specifier.match(/^(\w+)\((.+)\)$/);
+    if (match)
+        return { toolName: match[1], argPattern: match[2] };
+    return { toolName: specifier };
+}
 /** Match a tool name against a pattern (supports trailing * for prefix matching) */
 function matchToolPattern(pattern, toolName) {
     if (pattern.endsWith("*")) {
@@ -14,14 +21,47 @@ function matchToolPattern(pattern, toolName) {
     }
     return pattern === toolName;
 }
+/**
+ * Match an argument pattern against a value using glob-style matching.
+ * Supports: * (any chars), ** (any path segments)
+ */
+function matchArgGlob(pattern, value) {
+    // Convert glob to regex: * → [^/]*, ** → .*, escape other regex chars
+    const regexStr = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&') // escape regex chars (except * and ?)
+        .replace(/\*\*/g, '{{DOUBLESTAR}}')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\{\{DOUBLESTAR\}\}/g, '.*');
+    try {
+        return new RegExp(`^${regexStr}$`).test(value);
+    }
+    catch {
+        return false;
+    }
+}
 /** Find the first matching tool permission rule */
 function findToolRule(rules, toolName, toolInput) {
     if (!rules || rules.length === 0)
         return undefined;
     return rules.find(r => {
-        if (!matchToolPattern(r.tool, toolName))
+        const { toolName: specToolName, argPattern } = parseToolSpecifier(r.tool);
+        // Check tool name match (with prefix * support)
+        if (!matchToolPattern(specToolName, toolName))
             return false;
-        // If rule has a pattern, match against Bash command content only
+        // If rule has an inline argument pattern (e.g., "Bash(npm run *)")
+        if (argPattern && toolInput) {
+            const input = toolInput;
+            // For Bash: match against command string
+            if (toolName === 'Bash' && typeof input.command === 'string') {
+                return matchArgGlob(argPattern, input.command);
+            }
+            // For file tools: match against file_path
+            if (['Edit', 'Write', 'Read'].includes(toolName) && typeof input.file_path === 'string') {
+                return matchArgGlob(argPattern, input.file_path);
+            }
+            return false; // Has pattern but no matching field
+        }
+        // Legacy: separate pattern field (regex) for Bash commands
         if (r.pattern && toolInput && toolName === "Bash") {
             const command = toolInput?.command;
             if (typeof command === "string") {