@bybrawe/opencode-loop 0.5.37 → 0.6.0

package/scripts/loopd.mjs

@@ -5,11 +5,13 @@ import { spawn, spawnSync } from "node:child_process"
 import { createHash } from "node:crypto"
 import { homedir } from "node:os"
 import { fileURLToPath } from "node:url"
+import { selectOpenCodeHost, projectSessions } from "./opencode-host.mjs"
+import { checkGoalPulse, parsePulseDurationMs } from "./pulse-check.mjs"
 
 const args = process.argv.slice(2)
 const configuredRetryMs = Number(process.env.OPENCODE_LOOPD_FAILED_RUN_RETRY_MS)
 const FAILED_RUN_RETRY_MS = Number.isFinite(configuredRetryMs) && configuredRetryMs >= 0 ? configuredRetryMs : 5_000
-const OPENCODE_BIN = process.env.OPENCODE_BIN || "opencode"
+const OPENCODE_BIN = process.env.OPENCODE_BIN || process.env.OPENCODE_BINARY || process.env.OPENCODE2_BINARY
 const SCHTASKS_BIN = process.env.SCHTASKS_BIN || "schtasks"
 const TASK_ROOT = process.env.OPENCODE_LOOPD_TASK_DIR || path.join(process.env.LOCALAPPDATA || path.join(homedir(), "AppData", "Local"), "opencode-loop", "tasks")
 
@@ -51,6 +53,14 @@ function parseMaxRuns(value) {
   return parsed
 }
 
+function parseMaxChecks(value) {
+  const text = String(value ?? "0").trim()
+  if (!/^\d+$/.test(text)) throw new Error(`Invalid --max-checks value: ${value}`)
+  const parsed = Number(text)
+  if (!Number.isSafeInteger(parsed)) throw new Error(`Invalid --max-checks value: ${value}`)
+  return parsed
+}
+
 function validateProject(project) {
   let stat
   try { stat = fs.statSync(project) } catch { throw new Error(`Project directory does not exist: ${project}`) }
@@ -108,8 +118,8 @@ function spawnOnce(command, commandArgs, cwd, options = {}) {
       child = spawn(command, commandArgs, {
         cwd,
         shell: false,
-        stdio: capture ? ["ignore", "pipe", "pipe"] : "inherit",
-        env: process.env,
+        stdio: capture ? ["ignore", "pipe", "pipe"] : options.closeStdin ? ["ignore", "inherit", "inherit"] : "inherit",
+        env: options.env || process.env,
         windowsHide: true,
         detached: process.platform !== "win32",
       })
@@ -128,7 +138,7 @@ function spawnOnce(command, commandArgs, cwd, options = {}) {
       timer.unref?.()
     }
     child.on("error", (error) => done({ code: -1, error }))
-    child.on("exit", (code, signal) => done({ code: timedOut ? 124 : (code ?? (signal ? 1 : 0)), signal }))
+    child.on("close", (code, signal) => done({ code: timedOut ? 124 : (code ?? (signal ? 1 : 0)), signal }))
   })
 }
 
@@ -152,14 +162,52 @@ async function run(command, commandArgs, cwd, options = {}) {
   return fallback
 }
 
-async function resolveLatestSessionID(opencodeBin, project, preferredTitle) {
-  const result = await run(opencodeBin, ["session", "list", "--format", "json", "-n", "20"], project, { capture: true, timeoutMs: 15_000 })
-  if (result.code !== 0 || result.timedOut) return undefined
-  let parsed
-  try { parsed = JSON.parse(result.stdout || "[]") } catch { return undefined }
-  const sessions = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.data) ? parsed.data : []
-  const match = preferredTitle ? sessions.find((item) => item?.title === preferredTitle) : sessions[0]
-  return typeof match?.id === "string" && match.id ? match.id : undefined
+async function selectHost(project, options = {}) {
+  const legacyV1 = options.legacyV1 ?? has("--legacy-v1")
+  if (legacyV1 && has("--native-v2")) throw new Error("Use either --native-v2 or --legacy-v1, not both")
+  const server = options.server ?? arg("--server")
+  if (server) {
+    if (legacyV1) throw new Error("--server is a native OpenCode 2 option")
+    if (!["http:", "https:"].includes(new URL(server).protocol)) throw new Error("--server must be an HTTP(S) URL")
+  }
+  const host = await selectOpenCodeHost({
+    binary: options.opencodeBin || OPENCODE_BIN,
+    legacyV1,
+    probe: (binary) => run(binary, ["--version"], project, { capture: true, timeoutMs: 5_000 }),
+  })
+  return { ...host, server, legacyV1 }
+}
+
+async function listSessions(host, project, limit) {
+  const argv = ["session", "list", "--format", "json", "-n", String(limit)]
+  if (host.server) argv.push("--server", host.server)
+  const result = await run(host.binary, argv, project, {
+    capture: true, timeoutMs: 15_000,
+    ...(host.major === 2 ? { env: { ...process.env, PWD: project } } : {}),
+  })
+  if (result.code !== 0 || result.timedOut) throw new Error("OpenCode session list failed; refusing to guess a session")
+  return projectSessions(result.stdout, project, host.major === 2)
+}
+
+async function resolveLatestSessionID(host, project, preferredTitle) {
+  const sessions = await listSessions(host, project, 100)
+  const match = preferredTitle ? sessions.find((item) => item.title === preferredTitle) : sessions[0]
+  return match?.id
+}
+
+async function resolveSessionActivity(host, project) {
+  if (!host) return {}
+  let sessions
+  try { sessions = await listSessions(host, project, 100) } catch (error) {
+    console.warn(`[opencode-loopd] session telemetry unavailable: ${error.message}`)
+    return {}
+  }
+  const activity = {}
+  for (const session of sessions) {
+    const updated = Number(session.updated ?? session.time?.updated)
+    if (Number.isFinite(updated) && updated >= 0) activity[session.id] = updated
+  }
+  return activity
 }
 
 function runSync(command, commandArgs) {
@@ -204,12 +252,13 @@ async function daemon(options = {}) {
   const prompt = readPrompt(project, options)
   const model = options.model ?? arg("--model")
   const agent = options.agent ?? arg("--agent")
-  const opencodeBin = options.opencodeBin || OPENCODE_BIN
+  const host = await selectHost(project, options)
   const explicitSessionID = options.session ?? arg("--session")
-  let sessionID = explicitSessionID || await resolveLatestSessionID(opencodeBin, project)
+  let sessionID = explicitSessionID || await resolveLatestSessionID(host, project)
   const sessionTitle = `OpenCode Loop daemon ${process.pid}-${Date.now()}`
 
   console.log("OpenCode Loop daemon")
+  console.log(`host: ${host.version}`)
   console.log(`project: ${project}`)
   console.log(`every: ${every}`)
   console.log(`maxRuns: ${maxRuns || "unlimited"}`)
@@ -226,18 +275,32 @@ async function daemon(options = {}) {
     console.log(`[opencode-loopd] run #${count} ${new Date().toISOString()}`)
 
     const runArgs = ["run"]
+    if (host.server) runArgs.push("--server", host.server)
     if (sessionID) runArgs.push("--session", sessionID)
     else runArgs.push("--title", sessionTitle)
     if (model) runArgs.push("--model", model)
     if (agent) runArgs.push("--agent", agent)
-    runArgs.push(prompt)
-
-    const result = await run(opencodeBin, runArgs, project, { timeoutMs })
+    runArgs.push("--", prompt)
+
+    // V2 reads PWD before cwd and reads stdin even with an argv prompt.
+    // Keep native runs project-bound and non-interactive without changing V1.
+    const result = await run(host.binary, runArgs, project, {
+      timeoutMs, closeStdin: host.major === 2,
+      ...(host.major === 2 ? { env: { ...process.env, PWD: project } } : {}),
+    })
     const code = result.timedOut ? 124 : result.code
     const moreRunsRemain = maxRuns === 0 || count < maxRuns
 
+    // V2 run is a client of a persistent native server. A failed/timed-out
+    // client is not proof that its admitted execution stopped. Replaying here
+    // could queue a duplicate turn while the original still runs.
+    if (host.major === 2 && code !== 0) {
+      console.error(`[opencode-loopd] native CLI ended with code ${code}; the server execution may still be active. Automatic replay stopped. Inspect the session before restarting.`)
+      return Number.isInteger(code) && code > 0 ? code : 1
+    }
+
     if (!sessionID && code === 0 && moreRunsRemain) {
-      sessionID = await resolveLatestSessionID(opencodeBin, project, sessionTitle)
+      sessionID = await resolveLatestSessionID(host, project, sessionTitle)
       if (!sessionID) {
         console.error("[opencode-loopd] could not resolve the newly created session; refusing to continue unpinned")
         return 1
@@ -258,6 +321,47 @@ async function daemon(options = {}) {
   }
 }
 
+async function pulseCheck(options = {}) {
+  const project = path.resolve(options.project ?? arg("--project", process.cwd()))
+  validateProject(project)
+  const staleAfterText = options.staleAfter ?? arg("--stale-after", "30m")
+  const staleAfterMs = parsePulseDurationMs(staleAfterText)
+  const every = options.every ?? arg("--every", "0s")
+  const delay = parseMs(every)
+  const maxChecks = parseMaxChecks(options.maxChecks ?? arg("--max-checks", "0"))
+  const target = options.target ?? arg("--goal")
+  let host
+  try { host = await selectHost(project, options) } catch (error) {
+    console.warn(`[opencode-loopd] ${error.message} Pulse-check will use persisted Goal timestamps only.`)
+  }
+
+  console.log("OpenCode Goal pulse-check")
+  console.log(`project: ${project}`)
+  console.log(`stale-after: ${staleAfterText}`)
+  console.log(`every: ${delay > 0 ? every : "one-shot"}`)
+  if (target) console.log(`goal: ${target}`)
+
+  let checks = 0
+  while (true) {
+    checks += 1
+    const sessionActivity = await resolveSessionActivity(host, project)
+    const result = await checkGoalPulse(project, {
+      staleAfterMs,
+      ...(target ? { target } : {}),
+      sessionActivity,
+    })
+
+    for (const alert of result.alerts) console.log(alert.message)
+    if (checks === 1) console.log(`state: ${result.stateFile}`)
+    if (target && checks === 1 && result.checked === 0) {
+      console.log(`[opencode-loopd] no dedicated Goal matched target=${target}`)
+    }
+
+    if (delay <= 0 || (maxChecks > 0 && checks >= maxChecks)) return 0
+    await sleep(delay)
+  }
+}
+
 function taskArtifacts(name) {
   const id = createHash("sha256").update(String(name || "OpenCodeLoop")).digest("hex").slice(0, 16)
   return {
@@ -279,7 +383,7 @@ async function taskRun() {
   return await daemon(config)
 }
 
-function installTask() {
+async function installTask() {
   if (process.platform !== "win32") {
     throw new Error("install-task is currently implemented for Windows Task Scheduler only. Use daemon mode on macOS/Linux.")
   }
@@ -294,6 +398,8 @@ function installTask() {
   const model = arg("--model")
   const agent = arg("--agent")
   const timeout = arg("--timeout", "30m")
+  parseMs(timeout)
+  const host = await selectHost(project)
   const node = process.execPath
   const script = fileURLToPath(import.meta.url)
   const artifacts = taskArtifacts(name)
@@ -307,7 +413,10 @@ function installTask() {
     model: model || undefined,
     agent: agent || undefined,
     timeout,
-    opencodeBin: OPENCODE_BIN,
+    opencodeBin: host.binary,
+    legacyV1: host.legacyV1,
+    server: host.server || undefined,
+    session: arg("--session") || undefined,
   }
   fs.writeFileSync(artifacts.config, JSON.stringify(taskConfig, null, 2) + "\n", "utf8")
   const launcherCommand = [quoteWindowsArg(node), quoteWindowsArg(script), "task-run", "--config", quoteWindowsArg(artifacts.config)].join(" ")
@@ -354,6 +463,8 @@ OpenCode Loop daemon
 Usage:
   opencode-loopd --project . --every 5m --prompt-file loop-prompt.md
   opencode-loopd --project . --every 0s --prompt "continue from progress.md"
+  opencode-loopd pulse-check --project . --stale-after 30m
+  opencode-loopd pulse-check --project . --stale-after 30m --every 1m
   opencode-loopd install-task --project . --every 10m --prompt-file loop-prompt.md --name OpenCodeLoop
   opencode-loopd uninstall-task --name OpenCodeLoop
 
@@ -365,9 +476,23 @@ Options:
   --model <provider/id>  OpenCode model used for each run
   --agent <name>         OpenCode agent used for each run
   --session <id>         Pin an existing OpenCode session (auto-pinned otherwise)
-  --timeout <duration>   Max time per OpenCode run (default: 30m, 0s disables)
+  --server <url>         Native V2 server used for both session lookup and runs
+  --legacy-v1            Explicitly select the legacy V1 CLI (default: native V2)
+  --timeout <duration>   Max time per CLI client run (default: 30m, 0s disables)
   --max-runs <n>         Stop after n runs
   --sleep-first          Wait before first run
+
+Host selection: OPENCODE_BIN (or OPENCODE_BINARY), otherwise opencode then
+opencode2, requiring a 2.x version. V1 is never selected without --legacy-v1.
+Native failures/timeouts stop the daemon without replay: the server execution
+may still be running after its CLI client exits. Inspect it before restarting.
+No automatic permission approval is added. Pulse-check never dispatches work.
+
+Pulse-check options:
+  --stale-after <duration>  Alert when an active dedicated Goal has not changed (default: 30m)
+  --goal <id|session>       Watch one Goal by Goal ID or session ID (default: all dedicated Goals)
+  --every <duration>        Repeat checks at this cadence; 0s is one-shot (default: 0s)
+  --max-checks <n>          Stop a repeating pulse-check after n checks
 `)
 }
 
@@ -375,20 +500,23 @@ const command = args[0]
 
 try {
   let exitCode = 0
-  if (command === "daemon" || command === "loopd") {
+  if (has("--help") || has("-h") || command === "help") {
+    help()
+  } else if (command === "daemon" || command === "loopd") {
     args.shift()
     exitCode = await daemon()
+  } else if (command === "pulse-check") {
+    args.shift()
+    exitCode = await pulseCheck()
   } else if (command === "install-task") {
     args.shift()
-    exitCode = installTask()
+    exitCode = await installTask()
   } else if (command === "uninstall-task") {
     args.shift()
     exitCode = uninstallTask()
   } else if (command === "task-run") {
     args.shift()
     exitCode = await taskRun()
-  } else if (has("--help") || has("-h") || command === "help") {
-    help()
   } else {
     exitCode = await daemon()
   }

package/scripts/native-cli-host-canary.mjs

@@ -0,0 +1,118 @@
+import assert from "node:assert/strict"
+import { spawn, execFileSync } from "node:child_process"
+import { createServer } from "node:http"
+import net from "node:net"
+import { randomBytes } from "node:crypto"
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+const binary = process.env.OPENCODE2_BINARY || "opencode2"
+const workspace = await mkdtemp(path.join(os.tmpdir(), "native-loop-cli-host-"))
+const home = path.join(workspace, ".home")
+const password = randomBytes(24).toString("hex")
+const redact = (value) => String(value).replaceAll(password, "[redacted]").replace(/server password[^\r\n]*/gi, "server password [redacted]")
+const prompt = "NATIVE_CLI_CANARY: reply OK, do not use tools"
+let turns = 0
+let server, serverLog = ""
+const provider = createServer(async (request, response) => {
+  try {
+    if (request.method !== "POST" || !request.url?.endsWith("/chat/completions")) {
+      response.writeHead(404); response.end(); return
+    }
+    let raw = ""
+    for await (const chunk of request) raw += chunk
+    const body = JSON.parse(raw)
+    const last = (body.messages || []).filter((message) => message.role === "user").at(-1)
+    const text = typeof last?.content === "string" ? last.content : (last?.content || []).map((part) => part.text || "").join("\n")
+    if (text.includes(prompt)) turns++
+    const base = { id: `cli-canary-${Date.now()}`, object: "chat.completion.chunk", created: Math.floor(Date.now() / 1000), model: "canary" }
+    response.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache" })
+    response.write(`data: ${JSON.stringify({ ...base, choices: [{ index: 0, delta: { role: "assistant", content: "OK" }, finish_reason: null }] })}\n\n`)
+    response.write(`data: ${JSON.stringify({ ...base, choices: [{ index: 0, delta: {}, finish_reason: "stop" }], usage: { prompt_tokens: 20, completion_tokens: 2, total_tokens: 22 } })}\n\n`)
+    response.end("data: [DONE]\n\n")
+  } catch (error) { response.writeHead(500); response.end(String(error)) }
+})
+function run(command, args, env, timeout = 90_000) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { cwd: workspace, env, windowsHide: true })
+    let stdout = "", stderr = ""
+    const timer = setTimeout(() => { child.kill("SIGKILL"); reject(new Error(redact(`CLI deadline: ${args[0]}\n${stdout}\n${stderr}\n${serverLog}`))) }, timeout)
+    child.stdout.on("data", (data) => { stdout = (stdout + data).slice(-40_000) })
+    child.stderr.on("data", (data) => { stderr = (stderr + data).slice(-40_000) })
+    child.once("error", (error) => { clearTimeout(timer); reject(error) })
+    child.once("close", (code) => { clearTimeout(timer); resolve({ code, stdout: redact(stdout), stderr: redact(stderr) }) })
+  })
+}
+async function stop(child) {
+  if (!child || child.exitCode !== null) return
+  await new Promise((resolve) => {
+    const timer = setTimeout(() => { child.kill("SIGKILL"); resolve() }, 3_000)
+    child.once("close", () => { clearTimeout(timer); resolve() })
+    child.kill("SIGTERM")
+  })
+}
+try {
+  await mkdir(path.join(home, ".config/opencode"), { recursive: true })
+  await new Promise((resolve) => provider.listen(0, "127.0.0.1", resolve))
+  const providerPort = provider.address().port
+  await writeFile(path.join(workspace, "opencode.json"), JSON.stringify({
+    model: "canary/canary",
+    providers: { canary: {
+      name: "Local CLI compatibility canary", package: "@opencode-ai/ai/providers/openai-compatible",
+      settings: { baseURL: `http://127.0.0.1:${providerPort}/v1` },
+      models: { canary: { name: "Canary", capabilities: { tools: true, input: ["text"], output: ["text"] }, limit: { context: 100000, output: 4096 } } },
+    } },
+  }))
+  execFileSync("git", ["init", "--quiet"], { cwd: workspace })
+  const env = {
+    ...process.env, HOME: home, USERPROFILE: home, OPENCODE_CONFIG_DIR: path.join(home, ".config/opencode"),
+    XDG_CONFIG_HOME: path.join(home, ".config"), XDG_DATA_HOME: path.join(home, ".local/share"),
+    XDG_STATE_HOME: path.join(home, ".local/state"), XDG_CACHE_HOME: path.join(home, ".cache"),
+    // Both the CLI and the manually started V2 server consume this value.
+    // Empty legacy credentials do not disable auth: the server generates a password.
+    OPENCODE_PASSWORD: password, OPENCODE_SERVER_USERNAME: "opencode", OPENCODE_SERVER_PASSWORD: password,
+    OPENCODE_DISABLE_AUTOUPDATE: "true",
+    OPENCODE_DISABLE_LSP_DOWNLOAD: "true", OPENCODE_BIN: binary, CI: "true",
+  }
+  const version = await run(binary, ["--version"], env, 10_000)
+  assert.equal(version.code, 0, version.stderr)
+  assert.equal(version.stdout.trim(), "opencode v2.0.18", "this canary proves the exact pinned CLI")
+  const reservation = net.createServer()
+  await new Promise((resolve) => reservation.listen(0, "127.0.0.1", resolve))
+  const port = reservation.address().port
+  await new Promise((resolve) => reservation.close(resolve))
+  const url = `http://127.0.0.1:${port}`
+  server = spawn(binary, ["serve", "--hostname", "127.0.0.1", "--port", String(port)], { cwd: workspace, env })
+  server.on("error", (error) => { serverLog += error.message })
+  server.stdout.on("data", (data) => { serverLog = (serverLog + data).slice(-40_000) })
+  server.stderr.on("data", (data) => { serverLog = (serverLog + data).slice(-40_000) })
+  const deadline = Date.now() + 30_000
+  let ready = false
+  while (!ready && Date.now() < deadline && server.exitCode === null) {
+    ready = await new Promise((resolve) => {
+      const socket = net.createConnection({ host: "127.0.0.1", port })
+      socket.once("connect", () => { socket.destroy(); resolve(true) })
+      socket.once("error", () => { socket.destroy(); resolve(false) })
+    })
+    if (!ready) await new Promise((resolve) => setTimeout(resolve, 100))
+  }
+  assert.ok(ready, redact(serverLog))
+  const result = await run(process.execPath, [path.join(root, "scripts/loopd.mjs"), "--project", workspace, "--server", url, "--max-runs", "2", "--timeout", "60s", "--model", "canary/canary", "--prompt", prompt], env, 150_000)
+  assert.equal(result.code, 0, redact(`${result.stdout}\n${result.stderr}\n${serverLog}`))
+  assert.match(result.stdout, /pinned session/)
+  assert.equal(turns, 2, redact(`expected exactly two daemon turns\n${result.stdout}\n${serverLog}`))
+  const listed = await run(binary, ["session", "list", "--format", "json", "-n", "100", "--server", url], env)
+  assert.equal(listed.code, 0, listed.stderr)
+  const sessions = JSON.parse(listed.stdout)
+  assert.equal(sessions.length, 1, "both daemon iterations must use the one created native session")
+  assert.ok(sessions[0].title.startsWith("OpenCode Loop daemon "))
+  console.log(JSON.stringify({ host: version.stdout.trim(), turns, sessions: sessions.length, sessionID: sessions[0].id, result: "native CLI daemon PASS" }))
+} finally {
+  await stop(server)
+  provider.closeAllConnections()
+  await new Promise((resolve) => provider.close(resolve))
+  await rm(workspace, { recursive: true, force: true })
+}

package/scripts/native-cli-io-test.mjs

@@ -0,0 +1,66 @@
+import test from "node:test"
+import assert from "node:assert/strict"
+import { spawn } from "node:child_process"
+import { mkdtemp, mkdir, writeFile, readFile, rm } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+async function scenario(mode) {
+  const temp = await mkdtemp(path.join(os.tmpdir(), "native-cli-io-"))
+  const project = path.join(temp, "project with spaces")
+  await mkdir(project)
+  const script = path.join(temp, "host.cjs")
+  const log = path.join(temp, "calls.jsonl")
+  await writeFile(script, `const fs = require('node:fs');
+const args = process.argv.slice(2);
+fs.appendFileSync(process.env.IO_LOG, JSON.stringify({args, cwd:process.cwd(), pwd:process.env.PWD})+'\\n');
+if(args[0]==='--version'){console.log(process.env.IO_MODE==='legacy'?'1.18.15':'opencode v2.0.18');process.exit(0)}
+if(args[0]==='session'){console.log(JSON.stringify([{id:'ses_io',directory:process.cwd()}]));process.exit(0)}
+if(process.env.IO_MODE==='pwd'){process.exit(process.env.PWD===process.cwd()?0:23)}
+let input='';process.stdin.setEncoding('utf8');process.stdin.on('data',chunk=>input+=chunk);
+process.stdin.on('end',()=>{console.log('INPUT='+input);process.exit(input===(process.env.IO_MODE==='legacy'?'legacy-input':'')?0:24)});
+process.stdin.resume();
+`)
+  const binary = path.join(temp, process.platform === "win32" ? "host.cmd" : "host")
+  await writeFile(binary, process.platform === "win32"
+    ? `@echo off\r\n"${process.execPath}" "${script}" %*\r\nexit /b %errorlevel%\r\n`
+    : `#!/bin/sh\nexec "${process.execPath}" "${script}" "$@"\n`, { mode: 0o755 })
+  let child, timer
+  try {
+    const result = await new Promise((resolve, reject) => {
+      child = spawn(process.execPath, [path.join(root, "scripts/loopd.mjs"), "--project", project, "--max-runs", "1", "--timeout", "3s", "--prompt", "argument-only prompt", ...(mode === "legacy" ? ["--legacy-v1"] : [])], {
+        cwd: root, windowsHide: true,
+        env: { ...process.env, OPENCODE_BIN: binary, PWD: root, IO_MODE: mode, IO_LOG: log },
+      })
+      let stdout = "", stderr = ""
+      timer = setTimeout(() => { child.kill(); reject(new Error(`daemon deadline\n${stdout}\n${stderr}`)) }, 20_000)
+      child.stdout.on("data", data => { stdout += data })
+      child.stderr.on("data", data => { stderr += data })
+      child.stdin.on("error", error => { if (error.code !== "EPIPE") reject(error) })
+      child.once("error", reject)
+      child.once("close", code => resolve({ code, stdout, stderr }))
+      if (mode === "legacy") child.stdin.end("legacy-input")
+      else child.stdin.write("must-not-become-a-prompt") // Deliberately leave the parent's pipe open.
+    })
+    assert.equal(result.code, 0, `${mode}: ${result.stdout}\n${result.stderr}`)
+    const calls = (await readFile(log, "utf8")).trim().split(/\r?\n/).map(JSON.parse)
+    if (mode === "pwd") {
+      for (const call of calls.filter(call => ["session", "run"].includes(call.args[0]))) {
+        assert.equal(call.pwd, project, "native lookup and run must use the selected project, not the caller's PWD")
+        assert.equal(call.cwd, project)
+      }
+    }
+    if (mode === "stdin") assert.match(result.stdout, /INPUT=\r?\n/)
+    if (mode === "legacy") assert.match(result.stdout, /INPUT=legacy-input/)
+  } finally {
+    clearTimeout(timer)
+    if (child && child.exitCode === null) child.kill()
+    await rm(temp, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 })
+  }
+}
+
+test("native CLI binds PWD to --project for lookup and run", () => scenario("pwd"))
+test("native CLI receives EOF even while the daemon stdin stays open", () => scenario("stdin"))
+test("explicit V1 retains inherited stdin", () => scenario("legacy"))

package/scripts/native-cli-test.mjs

@@ -0,0 +1,130 @@
+import assert from "node:assert/strict"
+import { spawn } from "node:child_process"
+import { mkdtemp, mkdir, readFile, writeFile, rm } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+const temp = await mkdtemp(path.join(os.tmpdir(), "loop-native-cli-"))
+const project = path.join(temp, "project with spaces")
+await mkdir(project)
+const log = path.join(temp, "calls.jsonl")
+const script = path.join(temp, "host.cjs")
+await writeFile(script, `const fs = require('node:fs');
+const args = process.argv.slice(2);
+fs.appendFileSync(process.env.NATIVE_CLI_LOG, JSON.stringify({ args, cwd: process.cwd() }) + '\\n');
+if (args[0] === '--version') { console.log(process.env.NATIVE_CLI_VERSION || 'opencode v2.0.18'); process.exit(0); }
+if (args[0] !== '--version' && process.env.NATIVE_CLI_EXPECT_PASSWORD && process.env.OPENCODE_PASSWORD !== process.env.NATIVE_CLI_EXPECT_PASSWORD) {
+  console.error('test host rejected missing native password'); process.exit(19);
+}
+if (args[0] === 'session') {
+  if (process.env.NATIVE_CLI_BAD_LIST) { console.log('invalid-json'); process.exit(0); }
+  console.log(JSON.stringify([
+    { id: 'ses_foreign', directory: process.cwd() + '-other', title: 'Other worktree' },
+    { id: 'ses_local', directory: process.cwd(), title: 'Local session', updated: Date.now() }
+  ])); process.exit(0);
+}
+if (process.env.NATIVE_CLI_SLEEP) setTimeout(() => process.exit(0), 10000);
+else process.exit(Number(process.env.NATIVE_CLI_EXIT || 0));
+`)
+const command = path.join(temp, process.platform === "win32" ? "host.cmd" : "host")
+await writeFile(command, process.platform === "win32"
+  ? `@echo off\r\n"${process.execPath}" "${script}" %*\r\nexit /b %errorlevel%\r\n`
+  : `#!/bin/sh\nexec "${process.execPath}" "${script}" "$@"\n`, { mode: 0o755 })
+async function run(args = [], env = {}) {
+  await rm(log, { force: true })
+  return await new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [path.join(root, "scripts/loopd.mjs"), ...args], {
+      cwd: root, windowsHide: true,
+      env: { ...process.env, OPENCODE_BIN: command, OPENCODE_BINARY: "", NATIVE_CLI_LOG: log, OPENCODE_LOOPD_FAILED_RUN_RETRY_MS: "0", ...env },
+    })
+    let stdout = "", stderr = ""
+    const deadline = setTimeout(() => { child.kill(); reject(new Error(`CLI test hung: ${args.join(' ')}\n${stdout}\n${stderr}`)) }, 20_000)
+    child.stdout.on("data", (data) => { stdout += data })
+    child.stderr.on("data", (data) => { stderr += data })
+    child.once("error", (error) => { clearTimeout(deadline); reject(error) })
+    child.once("close", (code) => { clearTimeout(deadline); resolve({ code, stdout, stderr }) })
+  })
+}
+const calls = async () => (await readFile(log, "utf8").catch(() => "")).trim().split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line))
+const base = ["--project", project, "--max-runs", "2", "--prompt", "native task"]
+let cases = 0
+try {
+  let result = await run(base, { NATIVE_CLI_VERSION: "1.18.15" })
+  assert.notEqual(result.code, 0, "native daemon must reject V1 instead of silently dispatching there")
+  assert.equal((await calls()).filter((call) => call.args[0] === "run").length, 0)
+  cases++
+
+  result = await run([...base, "--server", "http://127.0.0.1:12345"])
+  assert.equal(result.code, 0, result.stderr)
+  const observed = await calls()
+  assert.equal(observed.filter((call) => call.args[0] === "--version").length, 1, "select the host once, not once per iteration")
+  const runs = observed.filter((call) => call.args[0] === "run")
+  assert.equal(runs.length, 2)
+  for (const call of runs) {
+    assert.equal(call.args[call.args.indexOf("--session") + 1], "ses_local", "never adopt another worktree's newest session")
+    assert.equal(call.args[call.args.indexOf("--server") + 1], "http://127.0.0.1:12345")
+    assert.deepEqual(call.args.slice(-2), ["--", "native task"])
+  }
+  assert.ok(observed.filter((call) => call.args[0] === "session").every((call) => call.args.includes("--server")))
+  cases++
+
+  result = await run(base, { NATIVE_CLI_EXIT: "7" })
+  assert.equal(result.code, 7, result.stderr)
+  assert.equal((await calls()).filter((call) => call.args[0] === "run").length, 1, "V2 dispatch errors are not replay-safe")
+  cases++
+
+  result = await run([...base, "--timeout", "200ms"], { NATIVE_CLI_SLEEP: "1" })
+  assert.equal(result.code, 124, result.stderr)
+  assert.equal((await calls()).filter((call) => call.args[0] === "run").length, 1, "killing a CLI client does not prove its native server execution ended")
+  cases++
+
+  result = await run(base, { NATIVE_CLI_BAD_LIST: "1" })
+  assert.notEqual(result.code, 0)
+  assert.equal((await calls()).filter((call) => call.args[0] === "run").length, 0, "invalid session output cannot be mistaken for an empty list")
+  cases++
+
+  for (const subcommand of ["daemon", "pulse-check", "install-task", "task-run"]) {
+    result = await run([subcommand, "--help"])
+    assert.equal(result.code, 0, result.stderr)
+    assert.match(result.stdout, /--legacy-v1/)
+    assert.deepEqual(await calls(), [], "help must not probe or start a host")
+  }
+  cases++
+
+  result = await run([...base, "--legacy-v1"], { NATIVE_CLI_VERSION: "1.18.15" })
+  assert.equal(result.code, 0, result.stderr)
+  assert.equal((await calls()).filter((call) => call.args[0] === "run").length, 2)
+  cases++
+
+  result = await run(["--project", project, "--max-runs", "1", "--prompt", "--server not-a-flag"])
+  assert.equal(result.code, 0, result.stderr)
+  assert.deepEqual((await calls()).find((call) => call.args[0] === "run").args.slice(-2), ["--", "--server not-a-flag"])
+  cases++
+
+  result = await run([...base, "--server", "http://127.0.0.1:12345"], {
+    OPENCODE_PASSWORD: "isolated-cli-test-password",
+    NATIVE_CLI_EXPECT_PASSWORD: "isolated-cli-test-password",
+  })
+  assert.equal(result.code, 0, result.stderr)
+  assert.equal((await calls()).filter((call) => call.args[0] === "run").length, 2)
+  assert.doesNotMatch(result.stdout + result.stderr + JSON.stringify(await calls()), /isolated-cli-test-password/, "native auth must stay in the environment, not argv or logs")
+  cases++
+
+  const { selectOpenCodeHost, projectSessions } = await import("./opencode-host.mjs")
+  const probed = []
+  const probe = async (binary) => { probed.push(binary); return { code: 0, stdout: binary === "opencode2" ? "opencode v2.0.18\n" : "1.18.15\n" } }
+  assert.equal((await selectOpenCodeHost({ probe })).binary, "opencode2")
+  assert.deepEqual(probed, ["opencode", "opencode2"])
+  assert.equal((await selectOpenCodeHost({ probe: async () => ({ code: 0, stdout: "opencode v2.0.18" }) })).binary, "opencode", "prefer the current canonical binary when both names work")
+  const fallback = await selectOpenCodeHost({ probe: async (binary) => binary === "opencode2" ? { code: -1 } : { code: 0, stdout: "opencode v2.0.18" } })
+  assert.equal(fallback.binary, "opencode")
+  await assert.rejects(selectOpenCodeHost({ binary: "custom", probe: async () => ({ code: 0, stdout: "warning 2.0.18" }) }), /OpenCode 2/)
+  await assert.rejects(selectOpenCodeHost({ probe: async () => ({ code: 0, stdout: "1.18.15" }) }), /legacy-v1/)
+  assert.equal((await selectOpenCodeHost({ legacyV1: true, probe })).major, 1)
+  assert.deepEqual(projectSessions(JSON.stringify([{ id: "a", location: { directory: project } }, { id: "b", directory: temp }]), project, true).map((item) => item.id), ["a"])
+  assert.throws(() => projectSessions("{}", project, true), /session list/)
+  cases++
+  console.log(`Native CLI: ${cases} scenarios passed`)
+} finally { await rm(temp, { recursive: true, force: true }) }

package/scripts/native-coexistence-test.mjs

@@ -0,0 +1,38 @@
+import assert from "node:assert/strict"
+import { createHash } from "node:crypto"
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises"
+import path from "node:path"
+import os from "node:os"
+import { nativeGoalReservesSession } from "../src/source/opencode2/native-companion.js"
+import { createNativeLoopRuntime } from "../src/source/opencode2/native-runtime.js"
+
+const directory = await mkdtemp(path.join(os.tmpdir(), "native-coexist-"))
+const sessionID = "native-shared-session"
+const root = path.join(directory, ".opencode", "goals")
+const file = path.join(root, `${createHash("sha256").update(sessionID).digest("hex").slice(0, 32)}.json`)
+const scope = { directory, sessionID }
+let prompts = 0
+const runtime = createNativeLoopRuntime({ directory, prompt: async (request) => { prompts++; return { id: request.id } } })
+try {
+  assert.equal(await nativeGoalReservesSession(directory, sessionID), false)
+  await mkdir(root, { recursive: true })
+  for (const status of ["active", "paused", "waiting_user", "handoff_pending", "handed_off", "budget_limited"]) {
+    await writeFile(file, JSON.stringify({ schemaVersion: 1, id: "shared-goal", sessionID, status }))
+    assert.equal(await nativeGoalReservesSession(directory, sessionID), true, status)
+  }
+  await runtime.onEvent({ ...scope, kind: "command", action: "executed", name: "loop", arguments: "0s do work --max-runs 1" })
+  await runtime.wake(scope)
+  assert.equal(prompts, 0, "Loop must not take over a reserved Goal session")
+  await writeFile(file, "invalid json")
+  await runtime.wake(scope)
+  assert.equal(prompts, 0, "corrupt Goal storage must fail closed")
+  await writeFile(file, JSON.stringify({ schemaVersion: 1, id: "shared-goal", sessionID, status: "completed" }))
+  assert.equal(await nativeGoalReservesSession(directory, sessionID), false)
+  await runtime.wake(scope)
+  assert.equal(prompts, 1, "completed Goal can release continuation to an explicitly configured Loop")
+  assert.equal(await nativeGoalReservesSession(directory, "another-session"), false)
+  console.log("Native Goal/Loop ownership tests passed")
+} finally {
+  await runtime.dispose()
+  await rm(directory, { recursive: true, force: true, maxRetries: 8, retryDelay: 50 })
+}