@zhijiewang/openharness 2.1.0 → 2.3.1

package/dist/services/MetaHarness.js

@@ -18,10 +18,10 @@
  * - Compression strategy
  * - Permission rules
  */
-import { readOhConfig, writeOhConfig, invalidateConfigCache } from '../harness/config.js';
-import { copyFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { execSync } from 'node:child_process';
+import { execSync } from "node:child_process";
+import { copyFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { invalidateConfigCache, readOhConfig, writeOhConfig } from "../harness/config.js";
 // ── Benchmark Runner ──
 /**
  * Run a benchmark command and extract a score.
@@ -31,9 +31,9 @@ export async function runBenchmark(command) {
     const start = Date.now();
     try {
         const output = execSync(command, {
-            encoding: 'utf-8',
+            encoding: "utf-8",
             timeout: 300_000, // 5 minute max
-            stdio: ['pipe', 'pipe', 'pipe'],
+            stdio: ["pipe", "pipe", "pipe"],
         });
         // Parse test results to extract score
         const score = extractScore(output);
@@ -44,7 +44,7 @@ export async function runBenchmark(command) {
         };
     }
     catch (err) {
-        const output = String(err.stdout ?? err.stderr ?? err.message ?? '');
+        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
@@ -60,8 +60,8 @@ function extractScore(output) {
     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 passed = parseInt(passMatch[1], 10);
+        const failed = failMatch ? parseInt(failMatch[1], 10) : 0;
         const total = passed + failed;
         return total > 0 ? passed / total : 0;
     }
@@ -69,13 +69,13 @@ function extractScore(output) {
     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 passed = parseInt(tapPass[1], 10);
+        const failed = tapFail ? parseInt(tapFail[1], 10) : 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;
+    return output.includes("error") || output.includes("FAIL") ? 0.3 : 0.8;
 }
 // ── Meta-Harness ──
 export class MetaHarness {
@@ -94,8 +94,8 @@ export class MetaHarness {
         const totalStart = Date.now();
         const changes = [];
         // Backup current config
-        const configPath = join('.oh', 'config.yaml');
-        const backupPath = join('.oh', 'config.yaml.backup');
+        const configPath = join(".oh", "config.yaml");
+        const backupPath = join(".oh", "config.yaml.backup");
         if (existsSync(configPath)) {
             copyFileSync(configPath, backupPath);
         }
@@ -134,8 +134,8 @@ export class MetaHarness {
         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')}`
-            : '';
+            ? `\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}
 
@@ -150,14 +150,14 @@ Suggest ONE specific configuration change that might improve the benchmark score
 
 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 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',
+                description: parsed.description ?? "unknown change",
+                field: parsed.field ?? "unknown",
                 oldValue: undefined,
                 newValue: parsed.newValue,
             };
@@ -172,17 +172,19 @@ Respond with JSON: {"description": "what to change", "field": "config.path", "ne
         const config = readOhConfig() ?? {};
         try {
             // Simple top-level field update (nested paths would need lodash.set)
-            const field = change.field.replace(/^config\./, '');
+            const field = change.field.replace(/^config\./, "");
             config[field] = change.newValue;
             writeOhConfig(config);
         }
-        catch { /* revert will handle failures */ }
+        catch {
+            /* revert will handle failures */
+        }
     }
-    revertChange(change) {
+    revertChange(_change) {
         invalidateConfigCache();
         // Revert by re-reading the backup config
-        const backupPath = join('.oh', 'config.yaml.backup');
-        const configPath = join('.oh', 'config.yaml');
+        const backupPath = join(".oh", "config.yaml.backup");
+        const configPath = join(".oh", "config.yaml");
         if (existsSync(backupPath)) {
             copyFileSync(backupPath, configPath);
             invalidateConfigCache();
@@ -193,24 +195,24 @@ Respond with JSON: {"description": "what to change", "field": "config.path", "ne
 export function formatOptimizationResult(result) {
     const lines = [];
     const improvement = result.finalScore - result.initialScore;
-    const pct = result.initialScore > 0 ? (improvement / result.initialScore * 100).toFixed(1) : '0';
+    const pct = result.initialScore > 0 ? ((improvement / result.initialScore) * 100).toFixed(1) : "0";
     lines.push(`Meta-Harness Optimization Complete`);
-    lines.push(`${'─'.repeat(40)}`);
+    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(`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:');
+        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.');
+        lines.push("");
+        lines.push("No improvements found in this run.");
     }
-    return lines.join('\n');
+    return lines.join("\n");
 }
 //# sourceMappingURL=MetaHarness.js.map

package/dist/services/PipelineExecutor.d.ts

@@ -9,7 +9,7 @@
  *
  * Reuses the dependency resolution pattern from AgentDispatcher.
  */
-import type { Tools, ToolContext } from '../Tool.js';
+import type { ToolContext, Tools } from "../Tool.js";
 export type PipelineStep = {
     id: string;
     tool: string;

package/dist/services/PipelineExecutor.js

@@ -9,7 +9,7 @@
  *
  * Reuses the dependency resolution pattern from AgentDispatcher.
  */
-import { findToolByName } from '../Tool.js';
+import { findToolByName } from "../Tool.js";
 // ── Executor ──
 export class PipelineExecutor {
     tools;
@@ -24,30 +24,30 @@ export class PipelineExecutor {
      */
     async execute(steps) {
         // Validate step IDs are unique
-        const ids = new Set(steps.map(s => s.id));
+        const ids = new Set(steps.map((s) => s.id));
         if (ids.size !== steps.length) {
-            return [{ stepId: 'pipeline', output: 'Error: duplicate step IDs', isError: true, durationMs: 0 }];
+            return [{ stepId: "pipeline", output: "Error: duplicate step IDs", isError: true, durationMs: 0 }];
         }
         const internal = new Map();
         for (const step of steps) {
-            internal.set(step.id, { ...step, status: 'pending' });
+            internal.set(step.id, { ...step, status: "pending" });
         }
         const results = [];
         // Process steps in dependency order
         while (true) {
-            const ready = [...internal.values()].filter(s => s.status === 'pending' && this.isReady(s, internal));
-            const running = [...internal.values()].filter(s => s.status === 'running');
+            const ready = [...internal.values()].filter((s) => s.status === "pending" && this.isReady(s, internal));
+            const running = [...internal.values()].filter((s) => s.status === "running");
             if (ready.length === 0 && running.length === 0)
                 break;
             // Execute ready steps (sequentially for safety — tools may have side effects)
             for (const step of ready) {
-                step.status = 'running';
+                step.status = "running";
                 // Check if any blocker failed — skip this step
                 if (this.hasFailedBlocker(step, internal)) {
-                    step.status = 'skipped';
+                    step.status = "skipped";
                     const result = {
                         stepId: step.id,
-                        output: 'Skipped: dependency failed',
+                        output: "Skipped: dependency failed",
                         isError: true,
                         durationMs: 0,
                     };
@@ -57,7 +57,7 @@ export class PipelineExecutor {
                 }
                 const result = await this.executeStep(step, internal);
                 step.result = result;
-                step.status = result.isError ? 'failed' : 'completed';
+                step.status = result.isError ? "failed" : "completed";
                 results.push(result);
             }
         }
@@ -66,17 +66,17 @@ export class PipelineExecutor {
     isReady(step, all) {
         if (!step.dependsOn || step.dependsOn.length === 0)
             return true;
-        return step.dependsOn.every(id => {
+        return step.dependsOn.every((id) => {
             const dep = all.get(id);
-            return dep && (dep.status === 'completed' || dep.status === 'failed' || dep.status === 'skipped');
+            return dep && (dep.status === "completed" || dep.status === "failed" || dep.status === "skipped");
         });
     }
     hasFailedBlocker(step, all) {
         if (!step.dependsOn)
             return false;
-        return step.dependsOn.some(id => {
+        return step.dependsOn.some((id) => {
             const dep = all.get(id);
-            return dep && (dep.status === 'failed' || dep.status === 'skipped');
+            return dep && (dep.status === "failed" || dep.status === "skipped");
         });
     }
     async executeStep(step, all) {
@@ -128,7 +128,7 @@ export class PipelineExecutor {
      */
     resolveArgs(args, all) {
         const resolve = (value) => {
-            if (typeof value === 'string' && value.startsWith('$')) {
+            if (typeof value === "string" && value.startsWith("$")) {
                 const refId = value.slice(1);
                 const refStep = all.get(refId);
                 if (refStep?.result && !refStep.result.isError) {
@@ -138,7 +138,7 @@ export class PipelineExecutor {
             }
             if (Array.isArray(value))
                 return value.map(resolve);
-            if (value && typeof value === 'object') {
+            if (value && typeof value === "object") {
                 const resolved = {};
                 for (const [k, v] of Object.entries(value)) {
                     resolved[k] = resolve(v);
@@ -157,23 +157,21 @@ export function formatPipelineResults(results) {
     const lines = [];
     let totalMs = 0;
     for (const r of results) {
-        const status = r.isError ? '✗' : '✓';
-        const duration = r.durationMs > 0 ? ` (${r.durationMs}ms)` : '';
+        const status = r.isError ? "✗" : "✓";
+        const duration = r.durationMs > 0 ? ` (${r.durationMs}ms)` : "";
         lines.push(`${status} Step "${r.stepId}"${duration}`);
         // Show truncated output
-        const output = r.output.length > 200
-            ? r.output.slice(0, 200) + '...'
-            : r.output;
+        const output = r.output.length > 200 ? `${r.output.slice(0, 200)}...` : r.output;
         if (output) {
-            for (const line of output.split('\n').slice(0, 5)) {
+            for (const line of output.split("\n").slice(0, 5)) {
                 lines.push(`  ${line}`);
             }
         }
-        lines.push('');
+        lines.push("");
         totalMs += r.durationMs;
     }
-    const passed = results.filter(r => !r.isError).length;
+    const passed = results.filter((r) => !r.isError).length;
     lines.push(`Pipeline: ${passed}/${results.length} steps passed (${totalMs}ms total)`);
-    return lines.join('\n');
+    return lines.join("\n");
 }
 //# sourceMappingURL=PipelineExecutor.js.map

package/dist/services/SkillExtractor.d.ts

@@ -0,0 +1,43 @@
+/**
+ * SkillExtractor — auto-creates skill files from session message history.
+ *
+ * After a session completes, if enough tool usage was observed, we ask the LLM
+ * to identify reusable patterns and persist them as skill markdown files under
+ * .oh/skills/auto/.
+ */
+import type { Provider } from "../providers/base.js";
+import type { Message } from "../types/message.js";
+export type SkillCandidate = {
+    name: string;
+    description: string;
+    trigger: string;
+    procedure: string;
+    pitfalls: string;
+    verification: string;
+};
+/**
+ * Returns true if the message history has enough tool usage to warrant
+ * extracting skills (5 or more total tool calls).
+ */
+export declare function shouldExtract(messages: Message[]): boolean;
+/**
+ * Ask the LLM to identify reusable patterns in the conversation and return
+ * them as an array of SkillCandidates.
+ */
+export declare function extractSkills(provider: Provider, messages: Message[], model?: string): Promise<SkillCandidate[]>;
+/**
+ * Persist a skill candidate to .oh/skills/auto/<slug>.md.
+ * If a file already exists, increments the version in the frontmatter.
+ */
+export declare function persistSkill(candidate: SkillCandidate, sessionId: string): string;
+/**
+ * Orchestrate the full extraction pipeline:
+ * 1. Check if extraction is warranted
+ * 2. Ask LLM to extract skill candidates
+ * 3. Deduplicate against existing skills
+ * 4. Persist each new/updated candidate
+ *
+ * Returns the list of file paths written.
+ */
+export declare function runExtraction(provider: Provider, messages: Message[], sessionId: string, model?: string): Promise<string[]>;
+//# sourceMappingURL=SkillExtractor.d.ts.map

package/dist/services/SkillExtractor.js

@@ -0,0 +1,163 @@
+/**
+ * SkillExtractor — auto-creates skill files from session message history.
+ *
+ * After a session completes, if enough tool usage was observed, we ask the LLM
+ * to identify reusable patterns and persist them as skill markdown files under
+ * .oh/skills/auto/.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { discoverSkills, findSimilarSkill } from "../harness/plugins.js";
+import { createUserMessage } from "../types/message.js";
+// ── Helpers ──
+/** Count total tool calls across all messages */
+function countToolCalls(messages) {
+    return messages.reduce((sum, m) => sum + (m.toolCalls?.length ?? 0), 0);
+}
+/** Convert a skill name to a slug suitable for a filename */
+function toSlug(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+// ── Public API ──
+/**
+ * Returns true if the message history has enough tool usage to warrant
+ * extracting skills (5 or more total tool calls).
+ */
+export function shouldExtract(messages) {
+    return countToolCalls(messages) >= 5;
+}
+/**
+ * Ask the LLM to identify reusable patterns in the conversation and return
+ * them as an array of SkillCandidates.
+ */
+export async function extractSkills(provider, messages, model) {
+    const systemPrompt = `You are a skill extraction assistant. Analyze the conversation and identify reusable patterns or procedures that could be turned into skills for future sessions.
+
+Return a JSON array of skill candidates. Each candidate must have these fields:
+- name: short kebab-case identifier (e.g. "run-tests")
+- description: one-line description of what the skill does
+- trigger: a short phrase that would trigger this skill (e.g. "run the tests")
+- procedure: step-by-step instructions as a markdown string
+- pitfalls: common mistakes to avoid as a markdown string
+- verification: how to verify the skill succeeded as a markdown string
+
+Return ONLY the JSON array, no other text. If no reusable patterns exist, return [].`;
+    const prompt = createUserMessage("Analyze this conversation and extract reusable skill patterns as a JSON array.");
+    const response = await provider.complete([...messages, prompt], systemPrompt, undefined, model);
+    try {
+        // Extract JSON from response — handle code fences if present
+        const text = response.content.trim();
+        const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/) ?? null;
+        const jsonText = jsonMatch ? jsonMatch[1].trim() : text;
+        const parsed = JSON.parse(jsonText);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((item) => typeof item === "object" &&
+            item !== null &&
+            typeof item.name === "string" &&
+            typeof item.description === "string");
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Persist a skill candidate to .oh/skills/auto/<slug>.md.
+ * If a file already exists, increments the version in the frontmatter.
+ */
+export function persistSkill(candidate, sessionId) {
+    const autoDir = join(".oh", "skills", "auto");
+    mkdirSync(autoDir, { recursive: true });
+    const slug = toSlug(candidate.name);
+    const filePath = join(autoDir, `${slug}.md`);
+    // Determine version
+    let version = 1;
+    if (existsSync(filePath)) {
+        try {
+            const existing = readFileSync(filePath, "utf-8");
+            const versionMatch = existing.match(/^version:\s*(\d+)$/m);
+            if (versionMatch) {
+                version = parseInt(versionMatch[1], 10) + 1;
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    const now = new Date().toISOString();
+    const content = `---
+name: ${candidate.name}
+description: ${candidate.description}
+trigger: ${candidate.trigger}
+source: auto
+extractedFrom: ${sessionId}
+extractedAt: ${now}
+version: ${version}
+---
+
+## Procedure
+
+${candidate.procedure}
+
+## Pitfalls
+
+${candidate.pitfalls}
+
+## Verification
+
+${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
+ * 2. Ask LLM to extract skill candidates
+ * 3. Deduplicate against existing skills
+ * 4. Persist each new/updated candidate
+ *
+ * Returns the list of file paths written.
+ */
+export async function runExtraction(provider, messages, sessionId, model) {
+    if (!shouldExtract(messages))
+        return [];
+    const candidates = await extractSkills(provider, messages, model);
+    if (candidates.length === 0)
+        return [];
+    const existingSkills = discoverSkills().map((s) => ({ name: s.name, description: s.description }));
+    const written = [];
+    for (const candidate of candidates) {
+        const similar = findSimilarSkill(candidate.name, candidate.description, existingSkills);
+        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);
+    }
+    return written;
+}
+//# sourceMappingURL=SkillExtractor.js.map

package/dist/services/StreamingToolExecutor.d.ts

@@ -2,9 +2,9 @@
  * Tool execution during LLM streaming — concurrent tool execution
  * with permission checks and queue management.
  */
+import type { ToolContext, ToolResult, Tools } from "../Tool.js";
 import type { ToolCall } from "../types/message.js";
-import type { ToolResult, ToolContext, Tools } from "../Tool.js";
-import type { PermissionMode, AskUserFn } from "../types/permissions.js";
+import type { AskUserFn, PermissionMode } from "../types/permissions.js";
 export declare class StreamingToolExecutor {
     private tools;
     private context;

package/dist/services/StreamingToolExecutor.js

@@ -90,14 +90,16 @@ export class StreamingToolExecutor {
             ...this.context,
             callId,
             abortSignal: this.abortSignal,
-            onOutputChunk: (id, chunk) => { this.outputChunks.push({ callId: id, chunk }); },
+            onOutputChunk: (id, chunk) => {
+                this.outputChunks.push({ callId: id, chunk });
+            },
         };
         try {
             tracked.result = await tool.call(parsed.data, callContext);
             // Verification loop: auto-run lint/typecheck after file-modifying tools
-            if (tracked.result && !tracked.result.isError && ['Edit', 'Write', 'MultiEdit'].includes(tool.name)) {
+            if (tracked.result && !tracked.result.isError && ["Edit", "Write", "MultiEdit"].includes(tool.name)) {
                 try {
-                    const { runVerificationForFiles, getVerificationConfig, extractFilePaths } = await import('../harness/verification.js');
+                    const { runVerificationForFiles, getVerificationConfig, extractFilePaths } = await import("../harness/verification.js");
                     const vConfig = getVerificationConfig();
                     if (vConfig?.enabled) {
                         const filePaths = extractFilePaths(tool.name, tracked.toolCall.arguments);
@@ -106,13 +108,13 @@ export class StreamingToolExecutor {
                             if (vResult.ran) {
                                 if (!vResult.passed) {
                                     tracked.result = {
-                                        output: tracked.result.output + `\n\n[Verification FAILED]\n${vResult.summary}`,
-                                        isError: vConfig.mode === 'block',
+                                        output: `${tracked.result.output}\n\n[Verification FAILED]\n${vResult.summary}`,
+                                        isError: vConfig.mode === "block",
                                     };
                                 }
                                 else {
                                     tracked.result = {
-                                        output: tracked.result.output + '\n\n[Verification passed]',
+                                        output: `${tracked.result.output}\n\n[Verification passed]`,
                                         isError: false,
                                     };
                                 }
@@ -120,7 +122,9 @@ export class StreamingToolExecutor {
                         }
                     }
                 }
-                catch { /* verification should never break tool execution */ }
+                catch {
+                    /* verification should never break tool execution */
+                }
             }
         }
         catch (err) {

package/dist/services/a2a.d.ts

@@ -45,7 +45,7 @@ export type AgentCapability = {
 };
 export type AgentEndpoint = {
     /** Transport type */
-    type: 'http' | 'ipc' | 'stdio';
+    type: "http" | "ipc" | "stdio";
     /** Address (URL for http, socket path for ipc, pid for stdio) */
     address: string;
     /** Port for HTTP transport */
@@ -59,32 +59,32 @@ export type A2AMessage = {
     /** Target agent ID or capability name */
     to: string;
     /** Message type */
-    type: 'task' | 'result' | 'status' | 'cancel' | 'discover';
+    type: "task" | "result" | "status" | "cancel" | "discover";
     /** Payload */
     payload: A2APayload;
     /** Timestamp */
     timestamp: number;
 };
 export type A2APayload = {
-    kind: 'task';
+    kind: "task";
     capability: string;
     input: unknown;
     timeout?: number;
 } | {
-    kind: 'result';
+    kind: "result";
     taskId: string;
     output: unknown;
     error?: string;
 } | {
-    kind: 'status';
-    state: 'idle' | 'working' | 'done' | 'error';
+    kind: "status";
+    state: "idle" | "working" | "done" | "error";
     progress?: string;
 } | {
-    kind: 'cancel';
+    kind: "cancel";
     taskId: string;
     reason?: string;
 } | {
-    kind: 'discover';
+    kind: "discover";
     filter?: {
         capability?: string;
         name?: string;