oh-my-opencode 4.9.0 → 4.9.2

package/.agents/skills/opencode-qa/SKILL.md

@@ -54,6 +54,7 @@ sandbox, free port, server start/stop, and an EXIT-trap cleanup). It requires
 | Export a whole session as JSON | D | `scripts/export-roundtrip.sh <ses_id>` | `references/db-investigation.md` |
 | Check the HTTP server / an endpoint | B | `scripts/server-smoke.sh` | `references/server-api.md` |
 | Prove a hook / action / event fired | B | `scripts/sse-hook-probe.sh` | `references/events-hooks.md` |
+| Prove serve-topology wake runner-split (reproduced/fixed) | B | `scripts/serve-wake-split-probe.sh --expect reproduced\|fixed --evidence-dir DIR` (self-test: `--self-test`; fake LLM: `scripts/lib/fake-openai-server.mjs`) | `references/events-hooks.md` |
 | Smoke-test the TUI | C | `scripts/tui-smoke.sh` | `references/tui-tmux.md` |
 | Write/run a test in the opencode source | - | (bun test) | `references/testing-harness.md` |
 | Drive opencode from a Bun/TS script | - | (SDK) | `references/sdk.md` |

package/.agents/skills/opencode-qa/scripts/lib/fake-openai-branches.mjs

@@ -0,0 +1,39 @@
+export const branchCounts = {
+  title: 0,
+  "parent-tool-call": 0,
+  "parent-hold": 0,
+  child: 0,
+  wake: 0,
+  default: 0,
+}
+
+export const latches = {
+  parentToolCallIssued: false,
+  parentHoldIssued: false,
+}
+
+export function hasToolResult(inputStr) {
+  return (
+    inputStr.includes('"type":"function_call_output"') ||
+    inputStr.includes('"type": "function_call_output"') ||
+    inputStr.includes('"type":"tool_result"') ||
+    inputStr.includes('"type": "tool_result"') ||
+    inputStr.includes('"role":"tool"') ||
+    inputStr.includes('"role": "tool"')
+  )
+}
+
+export function selectBranch(inputStr) {
+  const isTitle = inputStr.includes("Generate a title")
+  const isSplitProbe = inputStr.includes("Run the split probe")
+  const isChild = inputStr.includes("SPLIT_CHILD_TASK")
+  const isWake = inputStr.includes("[BACKGROUND TASK")
+  const hasResult = hasToolResult(inputStr)
+
+  if (isTitle) return "title"
+  if (isChild && !isSplitProbe) return "child"
+  if (isWake) return "wake"
+  if (isSplitProbe && !hasResult && !latches.parentToolCallIssued) return "parent-tool-call"
+  if (isSplitProbe && (hasResult || latches.parentToolCallIssued) && !latches.parentHoldIssued) return "parent-hold"
+  return "default"
+}

package/.agents/skills/opencode-qa/scripts/lib/fake-openai-events.mjs

@@ -0,0 +1,106 @@
+import fs from "node:fs"
+
+export function completedUsage() {
+  return {
+    input_tokens: 10,
+    output_tokens: 5,
+    input_tokens_details: { cached_tokens: 0 },
+    output_tokens_details: { reasoning_tokens: 0 },
+  }
+}
+
+export function sendSse(res, events) {
+  res.writeHead(200, {
+    "content-type": "text/event-stream; charset=utf-8",
+    "cache-control": "no-cache",
+    connection: "keep-alive",
+  })
+  for (const event of events) {
+    res.write(`data: ${JSON.stringify(event)}\n\n`)
+  }
+  res.write("data: [DONE]\n\n")
+  res.end()
+}
+
+export function textEvents(callCount, text) {
+  const id = `resp_${callCount}`
+  const item = `msg_${callCount}`
+  return [
+    {
+      type: "response.created",
+      response: { id, created_at: Math.floor(Date.now() / 1000), model: "gpt-fake" },
+    },
+    {
+      type: "response.output_item.added",
+      output_index: 0,
+      item: { type: "message", id: item },
+    },
+    {
+      type: "response.output_text.delta",
+      item_id: item,
+      output_index: 0,
+      delta: text,
+    },
+    {
+      type: "response.output_item.done",
+      output_index: 0,
+      item: { type: "message", id: item },
+    },
+    {
+      type: "response.completed",
+      response: { usage: completedUsage() },
+    },
+  ]
+}
+
+export function toolCallEvents(callCount, name, callId, argsObj) {
+  const id = `resp_${callCount}`
+  const fcId = `fc_${callCount}`
+  const argsStr = JSON.stringify(argsObj)
+  return [
+    {
+      type: "response.created",
+      response: { id, created_at: Math.floor(Date.now() / 1000), model: "gpt-fake" },
+    },
+    {
+      type: "response.output_item.added",
+      output_index: 0,
+      item: {
+        type: "function_call",
+        id: fcId,
+        call_id: callId,
+        name,
+        arguments: "",
+      },
+    },
+    {
+      type: "response.function_call_arguments.delta",
+      item_id: fcId,
+      output_index: 0,
+      delta: argsStr,
+    },
+    {
+      type: "response.output_item.done",
+      output_index: 0,
+      item: {
+        type: "function_call",
+        id: fcId,
+        call_id: callId,
+        name,
+        arguments: argsStr,
+        status: "completed",
+      },
+    },
+    {
+      type: "response.completed",
+      response: { usage: completedUsage() },
+    },
+  ]
+}
+
+export function appendLog(logFile, line) {
+  try {
+    fs.appendFileSync(logFile, line)
+  } catch {
+  }
+}

package/.agents/skills/opencode-qa/scripts/lib/fake-openai-server.mjs

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+import http from "node:http"
+import fs from "node:fs"
+import path from "node:path"
+import os from "node:os"
+import { sendSse, textEvents, toolCallEvents, appendLog } from "./fake-openai-events.mjs"
+import { branchCounts, latches, selectBranch } from "./fake-openai-branches.mjs"
+
+const requestedPort = Number(process.env.FAKE_OPENAI_PORT ?? 0)
+const logFile = process.env.FAKE_LLM_LOG ?? path.join(os.tmpdir(), "fake-llm.log")
+
+let callCount = 0
+
+function logBranch(branch, extra = {}) {
+  const now = new Date().toISOString()
+  const line = `[${now}] branch=${branch} call=${callCount}${Object.keys(extra).length ? " " + JSON.stringify(extra) : ""}\n`
+  appendLog(logFile, line)
+  process.stdout.write(line)
+}
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = []
+    req.on("data", (chunk) => chunks.push(chunk))
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")))
+    req.on("error", reject)
+  })
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+const server = http.createServer(async (req, res) => {
+  if (req.method === "GET" && req.url === "/health") {
+    res.writeHead(200, { "content-type": "text/plain" }).end("ok")
+    return
+  }
+
+  if (req.method !== "POST" || !req.url?.includes("/responses")) {
+    res.writeHead(404, { "content-type": "application/json" }).end(JSON.stringify({ error: "not found" }))
+    return
+  }
+
+  callCount++
+  const raw = await readBody(req)
+  let body
+  try { body = JSON.parse(raw) } catch { body = {} }
+
+  const inputStr = JSON.stringify(body.input ?? body.messages ?? body)
+  const branch = selectBranch(inputStr)
+  branchCounts[branch] = (branchCounts[branch] ?? 0) + 1
+  logBranch(branch)
+
+  if (branch === "title") {
+    sendSse(res, textEvents(callCount, "wake split probe session"))
+    return
+  }
+
+  if (branch === "child") {
+    sendSse(res, textEvents(callCount, "DONE"))
+    return
+  }
+
+  if (branch === "wake") {
+    await sleep(3000)
+    sendSse(res, textEvents(callCount, `WAKE_ACK ${callCount}`))
+    return
+  }
+
+  if (branch === "parent-tool-call") {
+    latches.parentToolCallIssued = true
+    sendSse(res, toolCallEvents(callCount, "task", `call_agent_${callCount}`, {
+      description: "split probe child",
+      prompt: "SPLIT_CHILD_TASK: reply exactly DONE",
+      subagent_type: "explore",
+      run_in_background: true,
+      load_skills: [],
+    }))
+    return
+  }
+
+  if (branch === "parent-hold") {
+    latches.parentHoldIssued = true
+    sendSse(res, toolCallEvents(callCount, "bash", `call_bash_${callCount}`, {
+      command: "i=0; while [ $i -lt 8 ]; do i=$((i+1)); sleep 1; done",
+      description: "hold turn",
+    }))
+    return
+  }
+
+  if (inputStr.includes("say exactly: TUI_NOREG_OK")) {
+    sendSse(res, textEvents(callCount, "TUI_NOREG_OK"))
+    return
+  }
+  sendSse(res, textEvents(callCount, `fake response ${callCount}`))
+})
+
+function logFinalCounts() {
+  const summary = Object.entries(branchCounts).map(([k, v]) => `${k}=${v}`).join(" ")
+  const line = `[${new Date().toISOString()}] FINAL_COUNTS ${summary}\n`
+  appendLog(logFile, line)
+  process.stdout.write(line)
+}
+
+server.listen(requestedPort, "127.0.0.1", () => {
+  const addr = server.address()
+  const port = typeof addr === "object" && addr !== null ? addr.port : requestedPort
+  try {
+    fs.mkdirSync(path.dirname(logFile), { recursive: true })
+    appendLog(logFile, `[${new Date().toISOString()}] START port=${port}\n`)
+  } catch {}
+  process.stdout.write(`fake-openai listening on ${port}\n`)
+})
+
+process.on("SIGTERM", () => { logFinalCounts(); server.close(() => process.exit(0)) })
+process.on("SIGINT", () => { logFinalCounts(); server.close(() => process.exit(0)) })