@hecer/yoke 1.11.0 → 1.13.0

package/canon/skills/yoke-retrofit/SKILL.md

@@ -1,26 +1,26 @@
----
-name: yoke-retrofit
-description: Use when asked to "retrofit", "yoke this project", or set up the Yoke harness in a project — runs the shared setup wizard and configures the same behavior for Claude, Codex, and Gemini.
----
-
-# Yoke Retrofit
-
-Set up or update Yoke through the shared `yoke setup` contract.
-
-1. Inspect the project and identify the current host (`claude`, `codex`, or `gemini`).
-2. Ask these setup questions one at a time and give a direct recommendation:
-   - target agents (recommend the current host; use `all` for deliberately cross-agent projects),
-   - code-graph tool,
-   - autonomous loop on/off,
-   - default runner (recommend the current host),
-   - decision mode: `auto` or `critical`.
-3. Recommend the code graph based on this project:
-   - **Serena** is LSP-accurate and best for large typed codebases or systematic symbol refactors where a missed reference is costly. It needs a language server per language.
-   - **graphify** is fast and multimodal, and is best for exploration, migration, onboarding, or mixed code and document repositories. Its graph is an index and can become stale.
-4. Apply the answers without a second round of prompts:
-   `yoke setup . --yes --host=<host> --agent=<agents> --code-graph=<choice> --runner=<runner> --decision-policy=<auto|critical> --loop|--no-loop`.
-   A human who runs `yoke setup .` directly receives the same five terminal questions.
-5. Show the generated report and backup paths. Existing files are backed up under `.yoke/backup/`; settings are merged where supported.
-6. If an old generated `CLAUDE.md` or `GEMINI.md` contained project-specific instructions, restore them inside its `<!-- yoke:preserve:start -->` / `<!-- yoke:preserve:end -->` block. Preserve blocks survive every later retrofit.
-
-The generated harness includes the provider-neutral `yoke-workflow` skill. It owns the planning questions, approved-plan handoff, autonomous stories, and critical-decision resume flow.
+---
+name: yoke-retrofit
+description: Use when asked to "retrofit", "yoke this project", or set up the Yoke harness in a project — runs the shared setup wizard and configures the same behavior for the supported Yoke harnesses.
+---
+
+# Yoke Retrofit
+
+Set up or update Yoke through the shared `yoke setup` contract.
+
+1. Inspect the project and identify the current host (`claude`, `codex`, `gemini`, `qwen`, `opencode`, `kilo`, or `pi`).
+2. Ask these setup questions one at a time and give a direct recommendation:
+   - target agents (recommend the current host; use `all` for deliberately cross-agent projects),
+   - code-graph tool,
+   - autonomous loop on/off,
+   - default runner (recommend the current host),
+   - decision mode: `auto` or `critical`.
+3. Recommend the code graph based on this project:
+   - **Serena** is LSP-accurate and best for large typed codebases or systematic symbol refactors where a missed reference is costly. It needs a language server per language.
+   - **graphify** is fast and multimodal, and is best for exploration, migration, onboarding, or mixed code and document repositories. Its graph is an index and can become stale.
+4. Apply the answers without a second round of prompts:
+   `yoke setup . --yes --host=<host> --agent=<agents> --code-graph=<choice> --runner=<runner> --decision-policy=<auto|critical> --loop|--no-loop`.
+   A human who runs `yoke setup .` directly receives the same five terminal questions.
+5. Show the generated report and backup paths. Existing files are backed up under `.yoke/backup/`; settings are merged where supported.
+6. If an old generated `CLAUDE.md` or `GEMINI.md` contained project-specific instructions, restore them inside its `<!-- yoke:preserve:start -->` / `<!-- yoke:preserve:end -->` block. Preserve blocks survive every later retrofit.
+
+The generated harness includes the provider-neutral `yoke-workflow` skill. It owns the planning questions, approved-plan handoff, autonomous stories, and critical-decision resume flow.

package/canon/skills/yoke-workflow/SKILL.md

@@ -1,20 +1,20 @@
----
-name: yoke-workflow
-description: Use when the user asks Yoke to plan and build a feature, run stories autonomously, continue a Yoke loop, or only interrupt for major decisions.
----
-
-# Yoke Workflow
-
-Provide the same interaction contract in Claude, Codex, and Gemini.
-
-1. Read `.yoke/config.yaml`. If it is missing, offer `yoke setup . --host=<current-agent>` and run the setup flow before planning.
-2. Plan before starting the loop. Inspect the project, then ask one focused question at a time only where the answer changes product behavior, scope, architecture, security, data ownership, external cost, or an irreversible choice. Include a recommended answer. Resolve routine implementation details yourself.
-3. Summarize the agreed design in `.yoke/plan.md`, including goals, non-goals, constraints, and decisions. Use the `authoring-prd` skill to turn it into small stories with testable acceptance criteria. Run `yoke prd check .`.
-4. Ask once for approval of the complete plan and story set. Do not begin implementation before that approval.
-5. If `loop.enabled` is true, run the stories without routine follow-up questions using the configured runner. Prefer `yoke loop run . --max=5 --isolate`, report status after each batch, and continue until complete or genuinely blocked.
-6. Respect `loop.decisionPolicy`:
-   - `auto`: choose the most suitable option from the plan, current code, and established conventions. Record the interpretation and continue.
-   - `critical`: routine ambiguity is still resolved automatically. If the loop reports a pending critical decision, run `yoke loop decision .`, present its options and recommendation to the user, ask exactly that question, then run `yoke loop answer . --choice=<id> --rationale="<answer>"`. The answer command records the decision and resumes the same story.
-7. Never ask whether to run tests, review, commit, or continue to the next approved story. Those are part of the approved workflow.
-
-The user's configured commit identity is authoritative. Do not add an AI co-author unless `commit.allowCoAuthors` explicitly permits it.
+---
+name: yoke-workflow
+description: Use when the user asks Yoke to plan and build a feature, run stories autonomously, continue a Yoke loop, or only interrupt for major decisions.
+---
+
+# Yoke Workflow
+
+Provide the same interaction contract in every supported Yoke harness.
+
+1. Read `.yoke/config.yaml`. If it is missing, offer `yoke setup . --host=<current-agent>` and run the setup flow before planning.
+2. Plan before starting the loop. Inspect the project, then ask one focused question at a time only where the answer changes product behavior, scope, architecture, security, data ownership, external cost, or an irreversible choice. Include a recommended answer. Resolve routine implementation details yourself.
+3. Summarize the agreed design in `.yoke/plan.md`, including goals, non-goals, constraints, and decisions. Use the `authoring-prd` skill to turn it into small stories with testable acceptance criteria. Run `yoke prd check .`.
+4. Ask once for approval of the complete plan and story set. Do not begin implementation before that approval.
+5. If `loop.enabled` is true, run the stories without routine follow-up questions using the configured runner. Prefer `yoke loop run . --max=5 --isolate`, report status after each batch, and continue until complete or genuinely blocked.
+6. Respect `loop.decisionPolicy`:
+   - `auto`: choose the most suitable option from the plan, current code, and established conventions. Record the interpretation and continue.
+   - `critical`: routine ambiguity is still resolved automatically. If the loop reports a pending critical decision, run `yoke loop decision .`, present its options and recommendation to the user, ask exactly that question, then run `yoke loop answer . --choice=<id> --rationale="<answer>"`. The answer command records the decision and resumes the same story.
+7. Never ask whether to run tests, review, commit, or continue to the next approved story. Those are part of the approved workflow.
+
+The user's configured commit identity is authoritative. Do not add an AI co-author unless `commit.allowCoAuthors` explicitly permits it.

package/canon/tools/codex-rtk-hook.mjs

@@ -1,36 +1,36 @@
 import { spawnSync } from 'node:child_process'
-import { resolve } from 'node:path'
-import { pathToFileURL } from 'node:url'
-
-function rtkCheck(command) {
-  const result = spawnSync('rtk', ['hook', 'check', command], { encoding: 'utf8', timeout: 3000 })
-  return result.status === 0 ? result.stdout.trim() : ''
-}
-
-export function rewriteHookInput(input, check = rtkCheck) {
-  if (input?.tool_name !== 'Bash' && input?.toolName !== 'Bash') return null
-  const toolInput = input.tool_input ?? input.toolInput
-  const command = toolInput?.command
-  if (typeof command !== 'string' || command.trim() === '') return null
-  const rewritten = check(command)
-  if (!rewritten || rewritten === command) return null
-  return {
-    hookSpecificOutput: {
-      hookEventName: 'PreToolUse',
-      updatedInput: { ...toolInput, command: rewritten },
-    },
-  }
-}
-
-async function main() {
-  let raw = ''
-  for await (const chunk of process.stdin) raw += chunk
-  try {
-    const output = rewriteHookInput(JSON.parse(raw))
-    if (output) process.stdout.write(JSON.stringify(output))
-  } catch {
-    // Compression is an optimization. Malformed input must never block Codex.
-  }
-}
-
-if (process.argv[1] && pathToFileURL(resolve(process.argv[1])).href === import.meta.url) await main()
+import { resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+function rtkCheck(command) {
+  const result = spawnSync('rtk', ['hook', 'check', command], { encoding: 'utf8', timeout: 3000 })
+  return result.status === 0 ? result.stdout.trim() : ''
+}
+
+export function rewriteHookInput(input, check = rtkCheck) {
+  if (input?.tool_name !== 'Bash' && input?.toolName !== 'Bash') return null
+  const toolInput = input.tool_input ?? input.toolInput
+  const command = toolInput?.command
+  if (typeof command !== 'string' || command.trim() === '') return null
+  const rewritten = check(command)
+  if (!rewritten || rewritten === command) return null
+  return {
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      updatedInput: { ...toolInput, command: rewritten },
+    },
+  }
+}
+
+async function main() {
+  let raw = ''
+  for await (const chunk of process.stdin) raw += chunk
+  try {
+    const output = rewriteHookInput(JSON.parse(raw))
+    if (output) process.stdout.write(JSON.stringify(output))
+  } catch {
+    // Compression is an optimization. Malformed input must never block Codex.
+  }
+}
+
+if (process.argv[1] && pathToFileURL(resolve(process.argv[1])).href === import.meta.url) await main()

package/canon/tools/gemini-rtk-hook.mjs

@@ -1,25 +1,25 @@
-#!/usr/bin/env node
-// Pure BeforeTool argument adapter. Never evaluates or executes tool commands.
-import { readFileSync } from 'node:fs'
-
-const record = value => value !== null && typeof value === 'object' && !Array.isArray(value)
-try {
-  const event = JSON.parse(readFileSync(0, 'utf8'))
-  if (!record(event) || typeof event.tool_name !== 'string' ||
-      (event.hook_event_name !== undefined && event.hook_event_name !== 'BeforeTool')) throw new Error('event')
-  let response = {}
-  if (event.tool_name === 'run_shell_command') {
-    if (!record(event.tool_input) || typeof event.tool_input.command !== 'string' || !event.tool_input.command.trim() || event.tool_input.command.includes('\0')) throw new Error('command')
-    const command = event.tool_input.command
-    // Restrict rewriting to simple supported invocations. Leave shell syntax,
-    // quoted executables, assignments and existing RTK wrappers untouched.
-    if (!/[;&|<>`$\r\n()]/u.test(command) && /^\s*(?:git|rg|npm|npx|cargo|pytest|go|docker|kubectl)\s/u.test(command)) {
-      const rewritten = command.trimStart().replace(/^rg\s/u, 'grep ')
-      response = { hookSpecificOutput: { tool_input: { ...event.tool_input, command: `rtk ${rewritten}` } } }
-    }
-  }
-  process.stdout.write(JSON.stringify(response) + '\n')
-} catch {
-  process.stderr.write('Invalid Gemini BeforeTool hook input\n')
-  process.exitCode = 2
-}
+#!/usr/bin/env node
+// Pure BeforeTool argument adapter. Never evaluates or executes tool commands.
+import { readFileSync } from 'node:fs'
+
+const record = value => value !== null && typeof value === 'object' && !Array.isArray(value)
+try {
+  const event = JSON.parse(readFileSync(0, 'utf8'))
+  if (!record(event) || typeof event.tool_name !== 'string' ||
+      (event.hook_event_name !== undefined && event.hook_event_name !== 'BeforeTool')) throw new Error('event')
+  let response = {}
+  if (event.tool_name === 'run_shell_command') {
+    if (!record(event.tool_input) || typeof event.tool_input.command !== 'string' || !event.tool_input.command.trim() || event.tool_input.command.includes('\0')) throw new Error('command')
+    const command = event.tool_input.command
+    // Restrict rewriting to simple supported invocations. Leave shell syntax,
+    // quoted executables, assignments and existing RTK wrappers untouched.
+    if (!/[;&|<>`$\r\n()]/u.test(command) && /^\s*(?:git|rg|npm|npx|cargo|pytest|go|docker|kubectl)\s/u.test(command)) {
+      const rewritten = command.trimStart().replace(/^rg\s/u, 'grep ')
+      response = { hookSpecificOutput: { tool_input: { ...event.tool_input, command: `rtk ${rewritten}` } } }
+    }
+  }
+  process.stdout.write(JSON.stringify(response) + '\n')
+} catch {
+  process.stderr.write('Invalid Gemini BeforeTool hook input\n')
+  process.exitCode = 2
+}

package/canon/tools/graphify.md

@@ -1,3 +1,3 @@
-# Tool: graphify (code-graph)
-
-MIT, multimodal code/doc graph. Wired as an MCP server for all three agents (stdio). Prefer symbol/graph lookups over reading whole files. Caveat: heuristic edges (INFERRED/AMBIGUOUS) and a static index that can go stale — rebuild on significant changes.
+# Tool: graphify (code-graph)
+
+MIT, multimodal code/doc graph. Wired as an MCP server for Claude, Codex, Gemini, Qwen, OpenCode and Kilo (stdio). Pi has no native MCP layer. Prefer symbol/graph lookups over reading whole files. Caveat: heuristic edges (INFERRED/AMBIGUOUS) and a static index that can go stale — rebuild on significant changes.

package/canon/tools/playwright-mcp.md

@@ -1,3 +1,3 @@
-# Tool: Playwright MCP (browser / dogfooding)
-
-Microsoft Playwright MCP, Apache-2.0. Wired as an MCP server for all three agents — the only browser tool with native MCP parity across Claude/Codex/Gemini. Used for QA, dogfooding user flows, screenshots, and deploy verification.
+# Tool: Playwright MCP (browser / dogfooding)
+
+Microsoft Playwright MCP, Apache-2.0. Wired as an MCP server for the harnesses that support native MCP configuration (Claude, Codex, Gemini, Qwen, OpenCode and Kilo). Pi has no native MCP layer, so Pi projects use the portable skills and explicit Yoke gates instead. Used for QA, dogfooding user flows, screenshots, and deploy verification.

package/canon/tools/qwen-rtk-hook.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+// PreToolUse guard requesting a retry through RTK. Never evaluates or executes tool commands.
+import { readFileSync } from 'node:fs'
+
+const record = value => value !== null && typeof value === 'object' && !Array.isArray(value)
+try {
+  const event = JSON.parse(readFileSync(0, 'utf8'))
+  if (!record(event) || typeof event.tool_name !== 'string' ||
+      (event.hook_event_name !== undefined && event.hook_event_name !== 'PreToolUse')) throw new Error('event')
+  let response = {}
+  if (event.tool_name === 'run_shell_command') {
+    if (!record(event.tool_input) || typeof event.tool_input.command !== 'string' || !event.tool_input.command.trim() || event.tool_input.command.includes('\0')) throw new Error('command')
+    const command = event.tool_input.command
+    // Restrict rewriting to simple supported invocations. Leave shell syntax,
+    // quoted executables, assignments and existing RTK wrappers untouched.
+    if (!/[;&|<>`$\r\n()]/u.test(command) && /^\s*(?:git|rg|npm|npx|cargo|pytest|go|docker|kubectl)\s/u.test(command)) {
+      const rewritten = command.trimStart().replace(/^rg\s/u, 'grep ')
+      response = { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: `Retry this command through RTK: rtk ${rewritten}` } }
+    }
+  }
+  process.stdout.write(JSON.stringify(response) + '\n')
+} catch {
+  process.stderr.write('Invalid Qwen PreToolUse hook input\n')
+  process.exitCode = 2
+}

package/canon/tools/rtk.md

@@ -1,7 +1,7 @@
-# Tool: rtk (token compression)
-
-Per-agent wiring (generated by Baustein B):
-
-- **Claude Code:** PreToolUse hook auto-rewrites commands (`git status` → `rtk git status`). On Windows this needs WSL; otherwise fall back to instruction mode (this file injected into CLAUDE.md telling the agent to prefix commands with `rtk`).
-- **Codex CLI:** inject `RTK.md` / AGENTS.md instruction.
-- **Gemini CLI:** no hook system — register rtk as an MCP tool or inject the GEMINI.md instruction.
+# Tool: rtk (token compression)
+
+Per-agent wiring (generated by Baustein B):
+
+- **Claude Code:** PreToolUse hook auto-rewrites commands (`git status` → `rtk git status`). On Windows this needs WSL; otherwise fall back to instruction mode (this file injected into CLAUDE.md telling the agent to prefix commands with `rtk`).
+- **Codex CLI:** inject `RTK.md` / AGENTS.md instruction.
+- **Gemini CLI:** no hook system — register rtk as an MCP tool or inject the GEMINI.md instruction.

package/canon/tools/serena.md

@@ -1,9 +1,9 @@
-# Tool: Serena (code-graph, LSP-accurate)
-
-MIT, MCP-first. The alternative to graphify, selected via `yoke retrofit --code-graph=serena`. Serena uses real language servers (LSP) for symbol-accurate, cross-file retrieval and refactoring (`find_symbol`, `find_referencing_symbols`, rename/move) — no static index that goes stale, so it will not miss a reference.
-
-Wired as an MCP server for all three agents. Best for large, strongly-typed codebases (TypeScript, Python, Go) doing systematic refactoring, where missing a caller is costly.
-
+# Tool: Serena (code-graph, LSP-accurate)
+
+MIT, MCP-first. The alternative to graphify, selected via `yoke retrofit --code-graph=serena`. Serena uses real language servers (LSP) for symbol-accurate, cross-file retrieval and refactoring (`find_symbol`, `find_referencing_symbols`, rename/move) — no static index that goes stale, so it will not miss a reference.
+
+Wired as an MCP server for Claude, Codex, Gemini, Qwen, OpenCode and Kilo. Pi has no native MCP layer. Best for large, strongly-typed codebases (TypeScript, Python, Go) doing systematic refactoring, where missing a caller is costly.
+
 Caveat: needs one language server per language (can be fiddly on Windows for exotic languages) and requires `uv`. The launch command is a best-effort template — adjust to your install, e.g. `uvx --from git+https://github.com/oraios/serena serena-mcp-server`.
 
 Yoke disables Serena's automatic web-dashboard launch in generated MCP configurations. The

package/dist/agents/catalog.js

@@ -0,0 +1,7 @@
+import { AgentSchema } from './contracts.js';
+/** Single source of truth for CLI help, setup prompts, and default resolution. */
+export const SUPPORTED_AGENTS = AgentSchema.options;
+export const AGENT_LIST = SUPPORTED_AGENTS.join(',');
+export function isSupportedAgent(value) {
+    return SUPPORTED_AGENTS.includes(value);
+}

package/dist/agents/contracts.js

@@ -1,9 +1,11 @@
 import { z } from 'zod';
-export const AgentSchema = z.enum(['claude', 'codex', 'gemini', 'qwen']);
+export const AgentSchema = z.enum(['claude', 'codex', 'gemini', 'qwen', 'opencode', 'kilo', 'pi']);
 export const PermissionProfileSchema = z.enum(['safe', 'unsafe', 'read-only']);
 export const ModelSelectionSchema = z.object({
+    provider: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/).optional(),
     model: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/).optional(),
     reasoningEffort: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,31}$/).optional(),
+    variant: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,31}$/).optional(),
     nativeMultiAgent: z.boolean().optional(),
     bare: z.boolean().optional(),
 });

package/dist/agents/host.js

@@ -7,8 +7,12 @@ export function detectHostAgent(env = process.env) {
         return 'claude';
     if (env.GEMINI_CLI)
         return 'gemini';
-    if (env.QWEN_CLI)
+    if (env.QWEN_CODE || env.QWEN_CODE_SESSION_ID || env.QWEN_CLI)
         return 'qwen';
+    if (env.OPENCODE_CLIENT || env.OPENCODE_CONFIG || env.OPENCODE_CONFIG_DIR)
+        return 'opencode';
+    if (env.KILO_CLIENT || env.KILO_CONFIG || env.KILO_CONFIG_DIR)
+        return 'kilo';
     if (env.CODEX_HOME)
         return 'codex';
     if (env.CLAUDE_CONFIG_DIR)

package/dist/agents/process-streams.js

@@ -20,6 +20,9 @@ export function createTelemetryAccumulator(agent) {
     let trailing = '';
     let telemetry = { usageAvailable: false };
     let reportedModels = [];
+    const stepTotals = agent === 'opencode' || agent === 'kilo'
+        ? { input: 0, output: 0, cached: 0, cacheWrite: 0, reasoning: 0, cost: 0, hasInput: false, hasOutput: false, hasCached: false, hasCacheWrite: false, hasReasoning: false, hasCost: false }
+        : undefined;
     const update = (lines) => {
         for (const line of lines) {
             const next = parseProviderTelemetry(agent, [line]);
@@ -31,6 +34,35 @@ export function createTelemetryAccumulator(agent) {
             // never add it to earlier results or to assistant-message snapshots.
             if (next.tokens || next.partialUsage)
                 telemetry = next;
+            if (stepTotals && isStepFinish(line)) {
+                const usage = next.tokens ?? next.partialUsage;
+                if (usage) {
+                    if (usage.inputTokens !== undefined) {
+                        stepTotals.input += usage.inputTokens;
+                        stepTotals.hasInput = true;
+                    }
+                    if (usage.outputTokens !== undefined) {
+                        stepTotals.output += usage.outputTokens;
+                        stepTotals.hasOutput = true;
+                    }
+                    if (usage.cachedInputTokens !== undefined) {
+                        stepTotals.cached += usage.cachedInputTokens;
+                        stepTotals.hasCached = true;
+                    }
+                    if (usage.cacheWriteInputTokens !== undefined) {
+                        stepTotals.cacheWrite += usage.cacheWriteInputTokens;
+                        stepTotals.hasCacheWrite = true;
+                    }
+                    if (usage.reasoningOutputTokens !== undefined) {
+                        stepTotals.reasoning += usage.reasoningOutputTokens;
+                        stepTotals.hasReasoning = true;
+                    }
+                    if (usage.totalCostUsd !== undefined) {
+                        stepTotals.cost += usage.totalCostUsd;
+                        stepTotals.hasCost = true;
+                    }
+                }
+            }
         }
     };
     return {
@@ -43,6 +75,26 @@ export function createTelemetryAccumulator(agent) {
             if (trailing)
                 update([trailing]);
             trailing = '';
+            if (stepTotals && (stepTotals.hasInput || stepTotals.hasOutput)) {
+                const latest = telemetry.tokens;
+                const inputTokens = stepTotals.hasInput ? stepTotals.input : latest?.inputTokens;
+                const outputTokens = stepTotals.hasOutput ? stepTotals.output : latest?.outputTokens;
+                const partialUsage = {
+                    ...(inputTokens !== undefined ? { inputTokens } : {}),
+                    ...(outputTokens !== undefined ? { outputTokens } : {}),
+                    ...(stepTotals.hasCached ? { cachedInputTokens: stepTotals.cached } : latest?.cachedInputTokens !== undefined ? { cachedInputTokens: latest.cachedInputTokens } : {}),
+                    ...(stepTotals.hasCacheWrite ? { cacheWriteInputTokens: stepTotals.cacheWrite } : latest?.cacheWriteInputTokens !== undefined ? { cacheWriteInputTokens: latest.cacheWriteInputTokens } : {}),
+                    ...(stepTotals.hasReasoning ? { reasoningOutputTokens: stepTotals.reasoning } : latest?.reasoningOutputTokens !== undefined ? { reasoningOutputTokens: latest.reasoningOutputTokens } : {}),
+                    ...(stepTotals.hasCost ? { totalCostUsd: stepTotals.cost } : latest?.totalCostUsd !== undefined ? { totalCostUsd: latest.totalCostUsd } : {}),
+                    ...(latest?.model ? { model: latest.model } : {}),
+                };
+                if (inputTokens !== undefined && outputTokens !== undefined) {
+                    telemetry = { usageAvailable: true, tokens: { ...partialUsage, inputTokens, outputTokens } };
+                }
+                else {
+                    telemetry = { usageAvailable: false, partialUsage };
+                }
+            }
             if (telemetry.tokens) {
                 const { model: _model, ...tokens } = telemetry.tokens;
                 return { usageAvailable: telemetry.usageAvailable, tokens: { ...tokens, ...(reportedModels.length === 1 ? { model: reportedModels[0] } : {}) },
@@ -52,3 +104,13 @@ export function createTelemetryAccumulator(agent) {
         },
     };
 }
+function isStepFinish(line) {
+    try {
+        const value = JSON.parse(line);
+        const part = value.part && typeof value.part === 'object' ? value.part : undefined;
+        return value.type === 'step_finish' || part?.type === 'step-finish';
+    }
+    catch {
+        return false;
+    }
+}

package/dist/agents/process.js

@@ -58,7 +58,32 @@ export function startProviderProcess(agent, invocation, options = {}) {
         catch {
             return true;
         }
-        if (startedAt.startsWith('unverified:') || processIncarnation(processPid) !== startedAt)
+        // A slow or unavailable Windows identity query must not strand the exact
+        // child process Yoke just spawned. The live ChildProcess handle proves
+        // ownership more strongly than a late PID lookup. Terminate that exact
+        // handle immediately and ask taskkill asynchronously to catch descendants;
+        // waiting synchronously for taskkill can itself exceed the provider timeout
+        // on a heavily loaded Windows host. If the identity was verified, retain the
+        // PID-reuse guard for cleanup records.
+        if (startedAt.startsWith('unverified:')) {
+            if (child.exitCode !== null || child.signalCode !== null || child.killed)
+                return true;
+            try {
+                const killed = child.kill('SIGKILL');
+                if (killed && process.platform === 'win32') {
+                    try {
+                        const tree = spawn('taskkill', ['/PID', String(processPid), '/T', '/F'], { stdio: 'ignore', windowsHide: true });
+                        tree.unref();
+                    }
+                    catch { /* direct child termination already succeeded */ }
+                }
+                return killed;
+            }
+            catch {
+                return false;
+            }
+        }
+        if (processIncarnation(processPid) !== startedAt)
             return false;
         return killProcessTreeForCleanup(processPid);
     });
@@ -76,6 +101,7 @@ export function startProviderProcess(agent, invocation, options = {}) {
     let completionTimer;
     let recordFailure;
     let terminationConfirmed = false;
+    let forcedTerminationAttempted = false;
     let settled = false;
     let resolveCompletion = () => { };
     const completion = new Promise(resolveCompletionValue => {
@@ -119,14 +145,24 @@ export function startProviderProcess(agent, invocation, options = {}) {
         stderrTruncated: stderr.truncated,
         telemetry: telemetry.finish(),
     });
+    const forceTerminateExactChild = () => {
+        if (child.exitCode !== null || child.signalCode !== null || child.killed)
+            return;
+        try {
+            child.kill('SIGKILL');
+        }
+        catch { /* the tree killer may have won the race */ }
+    };
     const finalize = (exitCode) => {
         if (settled)
             return;
         supervision.flush();
         // Windows can emit close before taskkill's process-tree state is observable.
         // Reconfirm here so successful termination does not leave a stale ownership record.
-        if (termination && pid !== undefined && !terminationConfirmed) {
+        if (termination && pid !== undefined && !terminationConfirmed && !forcedTerminationAttempted) {
             terminationConfirmed = terminateProcessTree(pid, true);
+            if (terminationConfirmed)
+                forceTerminateExactChild();
         }
         const details = evidence();
         if (recordFailure) {
@@ -154,8 +190,12 @@ export function startProviderProcess(agent, invocation, options = {}) {
         if (pid !== undefined)
             terminationConfirmed = terminateProcessTree(pid, false);
         forceTimer = setTimeout(() => {
-            if (pid !== undefined && !settled)
+            if (pid !== undefined && !settled) {
+                forcedTerminationAttempted = true;
                 terminationConfirmed = terminateProcessTree(pid, true);
+                if (terminationConfirmed)
+                    forceTerminateExactChild();
+            }
             // Allow close/pipe draining to confirm termination before the bounded fallback.
             if (!settled)
                 completionTimer = setTimeout(() => {

package/dist/agents/providers.js

@@ -17,12 +17,26 @@ const argsFor = (agent, permissions) => {
         // Automatic review already selects workspace-write and conflicts with --sandbox.
         return ['exec', '--approve-for-me', '--json'];
     }
-    // Qwen CLI is a Gemini fork with similar arguments
+    // Qwen Code uses its own approval modes and native tool exclusions.
     if (agent === 'qwen') {
         if (permissions === 'unsafe')
             return ['--yolo', '--output-format', 'stream-json'];
-        const approval = permissions === 'read-only' ? 'plan' : 'auto_edit';
-        return ['--approval-mode', approval, '--sandbox', '--output-format', 'stream-json'];
+        const approval = permissions === 'read-only' ? 'plan' : 'auto-edit';
+        return ['--approval-mode', approval, '--sandbox', '--output-format', 'stream-json', ...(permissions === 'safe' ? ['--allowed-tools', 'run_shell_command'] : [])];
+    }
+    if (agent === 'opencode' || agent === 'kilo') {
+        const args = ['run', '--format', 'json', '--auto'];
+        if (permissions === 'read-only')
+            args.push('--agent', 'plan');
+        if (permissions === 'unsafe')
+            args.push('--dangerously-skip-permissions');
+        return args;
+    }
+    if (agent === 'pi') {
+        const args = ['--mode', 'json', '--no-session'];
+        if (permissions !== 'unsafe')
+            args.push('--tools', permissions === 'read-only' ? 'read,grep,find,ls' : 'read,bash,edit,write');
+        return args;
     }
     if (permissions === 'unsafe')
         return ['--yolo', '--output-format', 'stream-json'];
@@ -43,6 +57,10 @@ export function buildProviderInvocation(agent, prompt, cwd, permissions = 'safe'
         throw new Error('Qwen does not support the reasoningEffort selection');
     if (agent === 'qwen' && parsedSelection.nativeMultiAgent === true)
         throw new Error('Qwen does not support enabling the nativeMultiAgent selection');
+    if (parsedSelection.provider && !['opencode', 'kilo', 'pi'].includes(agent))
+        throw new Error(`${agent} does not support an explicit provider selection`);
+    if (parsedSelection.variant && !['opencode', 'kilo', 'pi'].includes(agent))
+        throw new Error(`${agent} does not support a model variant selection`);
     const args = argsFor(agent, permissions);
     if (output.schemaFile !== undefined || output.jsonSchema !== undefined) {
         if (agent === 'codex' && output.schemaFile && output.jsonSchema === undefined) {
@@ -56,26 +74,63 @@ export function buildProviderInvocation(agent, prompt, cwd, permissions = 'safe'
                 throw new Error('Inline structured output is unsupported by the Windows provider shell shim');
             args.push('--json-schema', schema);
         }
-        else
+        else if (!['opencode', 'kilo', 'pi'].includes(agent))
             throw new Error(`${agent} structured output schema requires ${agent === 'codex' ? 'schemaFile' : agent === 'claude' ? 'jsonSchema' : 'a supported native schema option (unavailable)'}`);
     }
-    if (parsedSelection.model)
-        args.push('--model', parsedSelection.model);
+    if (parsedSelection.provider && agent === 'pi')
+        args.push('--provider', parsedSelection.provider);
+    if (parsedSelection.model) {
+        const qualified = agent === 'qwen' && parsedSelection.model.includes('::')
+            ? parsedSelection.model.match(/^(openai|anthropic|gemini|vertex-ai|qwen-oauth)::(.+)$/u) : undefined;
+        if (agent === 'qwen' && parsedSelection.model.includes('::') && !qualified)
+            throw Error('Invalid Qwen auth/model selector');
+        if (qualified) {
+            const model = ModelSelectionSchema.shape.model.parse(qualified[2]);
+            args.push('--auth-type', qualified[1], '--model', model);
+        }
+        else {
+            const qualified = parsedSelection.provider && (agent === 'opencode' || agent === 'kilo')
+                ? `${parsedSelection.provider}/${parsedSelection.model}`
+                : parsedSelection.model;
+            args.push('--model', qualified);
+        }
+    }
     if (parsedSelection.reasoningEffort) {
         if (agent === 'claude')
             args.push('--effort', parsedSelection.reasoningEffort);
         else if (agent === 'codex')
             args.push('--config', `model_reasoning_effort=${parsedSelection.reasoningEffort}`);
+        else if (agent === 'opencode' || agent === 'kilo')
+            args.push('--variant', parsedSelection.reasoningEffort);
+        else if (agent === 'pi')
+            args.push('--thinking', parsedSelection.reasoningEffort);
+    }
+    if (parsedSelection.variant) {
+        if (agent === 'opencode' || agent === 'kilo')
+            args.push('--variant', parsedSelection.variant);
+        else if (agent === 'pi') {
+            if (parsedSelection.reasoningEffort && parsedSelection.reasoningEffort !== parsedSelection.variant)
+                throw new Error('Pi reasoningEffort and variant selections must match');
+            if (!parsedSelection.reasoningEffort)
+                args.push('--thinking', parsedSelection.variant);
+        }
     }
     if (agent === 'codex' && parsedSelection.nativeMultiAgent === false)
         args.push('--disable', 'multi_agent');
     if (agent === 'claude' && parsedSelection.nativeMultiAgent === false)
         args.push('--disallowedTools', 'Agent', 'Task', 'TeamCreate', 'SendMessage');
+    if (agent === 'qwen' && parsedSelection.nativeMultiAgent === false) {
+        args.push('--exclude-tools', 'agent', 'task', 'create_sub_session', 'team_create', 'send_message');
+    }
     if (parsedSelection.bare) {
         if (agent === 'codex')
             args.push('--ignore-user-config');
         else if (agent === 'claude')
             args.push('--bare');
+        else if (agent === 'opencode' || agent === 'kilo')
+            args.push('--pure');
+        else if (agent === 'pi')
+            throw new Error('Pi does not support the bare startup selection');
     }
     if (agent === 'gemini' && parsedSelection.nativeMultiAgent === false) {
         return { command: process.execPath, args: [fileURLToPath(new URL('../../hooks/bounded-gemini.mjs', import.meta.url)), ...args], input: prompt, cwd };