@bybrawe/opencode-loop 0.5.26 → 0.5.28

package/scripts/host-loop-canary.mjs

@@ -0,0 +1,357 @@
+import assert from "node:assert/strict"
+import { existsSync } from "node:fs"
+import { createServer } from "node:http"
+import net from "node:net"
+import { spawn } from "node:child_process"
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { fileURLToPath, pathToFileURL } from "node:url"
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+const isWindows = process.platform === "win32"
+const LOOP_OBJECTIVE = "real host loop canary"
+
+function resolveOpenCodeBinary() {
+  if (!isWindows) return path.join(repoRoot, "node_modules", ".bin", "opencode")
+  const candidates = [
+    path.join(repoRoot, "node_modules", "opencode-windows-x64", "bin", "opencode.exe"),
+    path.join(repoRoot, "node_modules", "opencode-windows-x64-baseline", "bin", "opencode.exe"),
+    path.join(repoRoot, "node_modules", "opencode-windows-arm64", "bin", "opencode.exe"),
+  ]
+  const found = candidates.find((candidate) => existsSync(candidate))
+  if (!found) throw new Error(`OpenCode native Windows binary was not installed. Checked: ${candidates.join(", ")}`)
+  return found
+}
+
+const opencodeBin = resolveOpenCodeBinary()
+
+function appendLog(current, chunk, limit = 80_000) {
+  return (current + String(chunk)).slice(-limit)
+}
+
+async function seedConfigDependencies(dir) {
+  await mkdir(path.join(dir, "node_modules"), { recursive: true })
+  const dependencies = { "@opencode-ai/plugin": "*" }
+  await writeFile(path.join(dir, "package.json"), `${JSON.stringify({ private: true, dependencies }, null, 2)}\n`)
+  await writeFile(
+    path.join(dir, "package-lock.json"),
+    `${JSON.stringify({
+      name: "opencode-loop-host-canary-config",
+      lockfileVersion: 3,
+      requires: true,
+      packages: { "": { dependencies } },
+    }, null, 2)}\n`,
+  )
+  await writeFile(path.join(dir, ".gitignore"), "node_modules\npackage.json\npackage-lock.json\nbun.lock\n.gitignore\n")
+}
+
+async function reservePort() {
+  return await new Promise((resolve, reject) => {
+    const server = net.createServer()
+    server.once("error", reject)
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address()
+      if (!address || typeof address === "string") return reject(new Error("failed to reserve TCP port"))
+      server.close((error) => error ? reject(error) : resolve(address.port))
+    })
+  })
+}
+
+async function waitForTcp(port, child, logs, timeoutMs = 30_000) {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    if (child.exitCode !== null) throw new Error(`OpenCode server exited before ready.\n${logs()}`)
+    const connected = await new Promise((resolve) => {
+      const socket = net.createConnection({ host: "127.0.0.1", port })
+      socket.once("connect", () => { socket.destroy(); resolve(true) })
+      socket.once("error", () => resolve(false))
+      socket.setTimeout(500, () => { socket.destroy(); resolve(false) })
+    })
+    if (connected) return
+    await new Promise((resolve) => setTimeout(resolve, 100))
+  }
+  throw new Error(`timed out waiting for OpenCode server on ${port}\n${logs()}`)
+}
+
+async function stopProcess(child, timeoutMs = 2_000) {
+  if (!child || child.exitCode !== null) return
+  child.kill()
+  await new Promise((resolve) => {
+    if (child.exitCode !== null) return resolve()
+    const timer = setTimeout(resolve, timeoutMs)
+    child.once("close", () => { clearTimeout(timer); resolve() })
+  })
+}
+
+function spawnOpenCode(args, options = {}) {
+  return spawn(opencodeBin, args, { ...options, windowsHide: true })
+}
+
+async function runOpenCode(args, { cwd, env, timeoutMs = 60_000 }) {
+  return await new Promise((resolve, reject) => {
+    const child = spawnOpenCode(args, { cwd, env })
+    let stdout = ""
+    let stderr = ""
+    let settled = false
+    child.stdout?.on("data", (chunk) => { stdout = appendLog(stdout, chunk) })
+    child.stderr?.on("data", (chunk) => { stderr = appendLog(stderr, chunk) })
+    const finish = (fn, value) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      fn(value)
+    }
+    const timer = setTimeout(() => {
+      void stopProcess(child)
+      finish(reject, new Error(`OpenCode command timed out: ${args.join(" ")}\nstdout:\n${stdout}\nstderr:\n${stderr}`))
+    }, timeoutMs)
+    child.once("error", (error) => finish(reject, error))
+    child.once("close", (code) => {
+      if (code !== 0) return finish(reject, new Error(`OpenCode command exited ${code}: ${args.join(" ")}\nstdout:\n${stdout}\nstderr:\n${stderr}`))
+      finish(resolve, { stdout, stderr })
+    })
+  })
+}
+
+function contentText(content) {
+  if (typeof content === "string") return content
+  if (!Array.isArray(content)) return ""
+  return content.map((part) => typeof part?.text === "string" ? part.text : typeof part?.content === "string" ? part.content : "").join("\n")
+}
+
+function allMessageText(body) {
+  return (body.messages ?? []).map((message) => contentText(message?.content)).join("\n")
+}
+
+function streamHeaders(res) {
+  res.writeHead(200, {
+    "content-type": "text/event-stream; charset=utf-8",
+    "cache-control": "no-cache",
+    connection: "keep-alive",
+  })
+}
+
+function writeSse(res, value) {
+  res.write(`data: ${JSON.stringify(value)}\n\n`)
+}
+
+function streamText(res, content, sequence) {
+  const id = `chatcmpl-loop-${sequence}`
+  const created = Math.floor(Date.now() / 1000)
+  streamHeaders(res)
+  writeSse(res, {
+    id,
+    object: "chat.completion.chunk",
+    created,
+    model: "canary",
+    choices: [{ index: 0, delta: { role: "assistant", content }, finish_reason: null }],
+  })
+  writeSse(res, {
+    id,
+    object: "chat.completion.chunk",
+    created,
+    model: "canary",
+    choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+    usage: { prompt_tokens: 30, completion_tokens: 4, total_tokens: 34 },
+  })
+  res.end("data: [DONE]\n\n")
+}
+
+function startProvider() {
+  const stats = { chatRequests: 0, loopRequests: 0, paths: [] }
+  const server = createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1")
+    stats.paths.push(`${req.method} ${url.pathname}`)
+    if (req.method === "GET" && url.pathname.endsWith("/models")) {
+      res.writeHead(200, { "content-type": "application/json" })
+      res.end(JSON.stringify({ object: "list", data: [{ id: "canary", object: "model", owned_by: "canary" }] }))
+      return
+    }
+    if (req.method !== "POST" || !url.pathname.endsWith("/chat/completions")) {
+      res.writeHead(404, { "content-type": "application/json" })
+      res.end(JSON.stringify({ error: { message: `unexpected endpoint: ${req.method} ${url.pathname}` } }))
+      return
+    }
+
+    let raw = ""
+    for await (const chunk of req) raw += String(chunk)
+    const body = raw ? JSON.parse(raw) : {}
+    stats.chatRequests += 1
+    const text = allMessageText(body)
+    if (text.includes("AUTONOMOUS OPENCODE LOOP ITERATION") && text.includes(LOOP_OBJECTIVE)) {
+      stats.loopRequests += 1
+      streamText(res, `LOOP_TURN_${stats.loopRequests}`, stats.chatRequests)
+      return
+    }
+    streamText(res, "OK", stats.chatRequests)
+  })
+
+  return {
+    stats,
+    async listen() {
+      await new Promise((resolve, reject) => {
+        server.once("error", reject)
+        server.listen(0, "127.0.0.1", resolve)
+      })
+      const address = server.address()
+      if (!address || typeof address === "string") throw new Error("failed to start deterministic loop provider")
+      return address.port
+    },
+    async close() {
+      await new Promise((resolve) => server.close(() => resolve()))
+    },
+  }
+}
+
+async function waitFor(predicate, description, diagnostics, timeoutMs = 45_000) {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    if (await predicate()) return
+    await new Promise((resolve) => setTimeout(resolve, 50))
+  }
+  throw new Error(`timed out waiting for ${description}\n${diagnostics()}`)
+}
+
+function isFetchTimeout(error) {
+  return error?.name === "TimeoutError" || /aborted due to timeout/i.test(String(error?.message ?? error))
+}
+
+async function bootstrapSessions(api, diagnostics) {
+  try {
+    return await api("/session", { method: "GET", signal: AbortSignal.timeout(30_000) })
+  } catch (error) {
+    if (!isFetchTimeout(error)) throw error
+    console.error(`OpenCode session API was not ready after 30s; retrying once.\n${diagnostics()}`)
+    return await api("/session", { method: "GET", signal: AbortSignal.timeout(45_000) })
+  }
+}
+
+async function main() {
+  const workspace = await mkdtemp(path.join(os.tmpdir(), "opencode-loop-host-canary-"))
+  const home = path.join(workspace, ".home")
+  const projectConfig = path.join(workspace, ".opencode")
+  const globalConfig = path.join(home, ".config", "opencode")
+  const pluginDir = path.join(projectConfig, "plugins")
+  const commandDir = path.join(projectConfig, "commands")
+  const agentDir = path.join(projectConfig, "agents")
+  const provider = startProvider()
+  const providerPort = await provider.listen()
+  let server
+  let serverLog = ""
+  let commandError = null
+
+  await mkdir(pluginDir, { recursive: true })
+  await mkdir(commandDir, { recursive: true })
+  await mkdir(agentDir, { recursive: true })
+  await seedConfigDependencies(projectConfig)
+  await seedConfigDependencies(globalConfig)
+  const pluginEntry = pathToFileURL(path.join(repoRoot, "src", "index.js")).href
+  await writeFile(path.join(pluginDir, "opencode-loop.js"), `export { default as OpenCodeLoopPlugin } from ${JSON.stringify(pluginEntry)}\n`)
+  await writeFile(path.join(commandDir, "loop.md"), `---\ndescription: Start a host canary loop\nagent: opencode-loop-local\n---\n\nOpenCode Loop local command handled. Reply exactly: OK.\n`)
+  await writeFile(path.join(agentDir, "opencode-loop-local.md"), `---\ndescription: Local Loop command acknowledgement\nmode: primary\npermission:\n  "*": deny\n---\n\nReply exactly: OK\n`)
+  await writeFile(path.join(workspace, "opencode.json"), `${JSON.stringify({
+    $schema: "https://opencode.ai/config.json",
+    model: "canary/canary",
+    small_model: "canary/canary",
+    provider: {
+      canary: {
+        npm: "@ai-sdk/openai-compatible",
+        name: "Deterministic Loop Canary",
+        options: { baseURL: `http://127.0.0.1:${providerPort}/v1`, apiKey: "canary-key" },
+        models: { canary: { name: "Deterministic Loop Canary", limit: { context: 100000, output: 4096 } } },
+      },
+    },
+  }, null, 2)}\n`)
+
+  const env = {
+    ...process.env,
+    HOME: home,
+    USERPROFILE: home,
+    XDG_CONFIG_HOME: path.join(home, ".config"),
+    XDG_DATA_HOME: path.join(home, ".local", "share"),
+    XDG_CACHE_HOME: path.join(home, ".cache"),
+    OPENCODE_DISABLE_AUTOUPDATE: "true",
+    OPENCODE_DB: ":memory:",
+    OPENCODE_DISABLE_LSP_DOWNLOAD: "true",
+    CI: "true",
+  }
+
+  try {
+    await runOpenCode(["debug", "config"], { cwd: workspace, env, timeoutMs: 60_000 })
+    const port = await reservePort()
+    server = spawnOpenCode(["serve", "--hostname", "127.0.0.1", "--port", String(port)], { cwd: workspace, env })
+    server.stdout?.on("data", (chunk) => { serverLog = appendLog(serverLog, chunk) })
+    server.stderr?.on("data", (chunk) => { serverLog = appendLog(serverLog, chunk) })
+    await waitForTcp(port, server, () => serverLog)
+
+    const baseURL = `http://127.0.0.1:${port}`
+    const directoryQuery = `directory=${encodeURIComponent(workspace)}`
+    const api = async (pathname, init = {}) => {
+      const separator = pathname.includes("?") ? "&" : "?"
+      const response = await fetch(`${baseURL}${pathname}${separator}${directoryQuery}`, {
+        ...init,
+        headers: { "content-type": "application/json", ...(init.headers ?? {}) },
+        signal: init.signal ?? AbortSignal.timeout(30_000),
+      })
+      const text = await response.text()
+      if (!response.ok) throw new Error(`HTTP ${response.status}: ${text}`)
+      if (!text) return null
+      try { return JSON.parse(text) } catch { return text }
+    }
+
+    const sessionsBefore = await bootstrapSessions(api, () => `server log:\n${serverLog}`)
+    assert.ok(Array.isArray(sessionsBefore?.data ?? sessionsBefore), "GET /session bootstrap did not return an array")
+    const createdPayload = await api("/session", { method: "POST", body: JSON.stringify({ title: "opencode-loop host canary" }) })
+    const session = createdPayload?.data ?? createdPayload
+    const sessionID = String(session?.id ?? "")
+    assert.ok(sessionID, `OpenCode did not create a session: ${JSON.stringify(createdPayload)}`)
+
+    const command = api(`/session/${encodeURIComponent(sessionID)}/command`, {
+      method: "POST",
+      body: JSON.stringify({ agent: "build", model: "canary/canary", command: "loop", arguments: `0s --max-runs 3 ${LOOP_OBJECTIVE}` }),
+      signal: AbortSignal.timeout(90_000),
+    }).catch((error) => {
+      commandError = error
+      return null
+    })
+
+    const stateFile = path.join(workspace, ".opencode", "opencode-loop", `${sessionID}.json`)
+    const diagnostics = async () => {
+      let state = "missing"
+      try { state = await readFile(stateFile, "utf8") } catch {}
+      return `provider=${JSON.stringify(provider.stats)}\ncommandError=${String(commandError ?? "none")}\nstate=${state}\nserver log:\n${serverLog}`
+    }
+
+    await waitFor(() => provider.stats.loopRequests >= 3, "three real autonomous Loop turns", () => `provider=${JSON.stringify(provider.stats)}\nserver log:\n${serverLog}`)
+    await new Promise((resolve) => setTimeout(resolve, 1_500))
+    assert.equal(provider.stats.loopRequests, 3, `Loop must stop at --max-runs 3; got extra real-host turn(s)\n${await diagnostics()}`)
+    assert.equal(server.exitCode, null, `OpenCode server exited during canary\n${await diagnostics()}`)
+
+    let persisted = null
+    try { persisted = JSON.parse(await readFile(stateFile, "utf8")) } catch {}
+    if (persisted?.jobs?.length) {
+      const loop = persisted.jobs.find((item) => item.name === "default" || item.action === LOOP_OBJECTIVE)
+      if (loop) assert.ok((loop.runCount || 0) >= 3, `persisted Loop run count was lower than provider turn count: ${JSON.stringify(loop)}`)
+    }
+
+    console.log(JSON.stringify({
+      ok: true,
+      platform: process.platform,
+      sessionID,
+      loopRequests: provider.stats.loopRequests,
+      chatRequests: provider.stats.chatRequests,
+      commandError: commandError ? String(commandError) : null,
+    }, null, 2))
+    void command
+  } finally {
+    await stopProcess(server)
+    await provider.close().catch(() => undefined)
+    await rm(workspace, { recursive: true, force: true }).catch(() => undefined)
+  }
+}
+
+main().catch((error) => {
+  console.error(error?.stack || error)
+  process.exitCode = 1
+})

package/scripts/loopd-test.mjs

@@ -32,16 +32,7 @@ function runCli(cliArgs, env = {}) {
 async function makeFakeCommand(name) {
   const script = path.join(temporaryRoot, `${name}.mjs`)
   const log = path.join(temporaryRoot, `${name}.jsonl`)
-  await fs.writeFile(script, `
-import fs from "node:fs"
-const log = process.env.FAKE_COMMAND_LOG
-let previous = []
-try { previous = fs.readFileSync(log, "utf8").trim().split(/\\r?\\n/).filter(Boolean) } catch {}
-fs.appendFileSync(log, JSON.stringify({ args: process.argv.slice(2), cwd: process.cwd() }) + "\\n")
-const codes = String(process.env.FAKE_EXIT_CODES || "0").split(",").map((value) => Number(value.trim()))
-const code = codes[Math.min(previous.length, codes.length - 1)]
-process.exit(Number.isInteger(code) ? code : 0)
-`, "utf8")
+  await fs.writeFile(script, "\nimport fs from \"node:fs\"\nconst log = process.env.FAKE_COMMAND_LOG\nconst argv = process.argv.slice(2)\nlet previous = []\ntry { previous = fs.readFileSync(log, \"utf8\").trim().split(/\\r?\\n/).filter(Boolean).map((line) => JSON.parse(line)) } catch {}\nfs.appendFileSync(log, JSON.stringify({ args: argv, cwd: process.cwd() }) + \"\\n\")\nif (argv[0] === \"session\" && argv[1] === \"list\") {\n  console.log(process.env.FAKE_SESSION_LIST_JSON || \"[]\")\n  process.exit(0)\n}\nconst sleepMs = Number(process.env.FAKE_SLEEP_MS || 0)\nif (sleepMs > 0) await new Promise((resolve) => setTimeout(resolve, sleepMs))\nconst previousRuns = previous.filter((entry) => entry?.args?.[0] === \"run\").length\nconst codes = String(process.env.FAKE_EXIT_CODES || \"0\").split(\",\").map((value) => Number(value.trim()))\nconst code = codes[Math.min(previousRuns, codes.length - 1)]\nprocess.exit(Number.isInteger(code) ? code : 0)\n", "utf8")
 
   if (process.platform === "win32") {
     const command = path.join(temporaryRoot, `${name}.cmd`)
@@ -83,14 +74,16 @@ try {
   })
   assert.equal(result.code, 0, result.stderr)
   let calls = await readLog(fakeOpenCode.log)
-  assert.equal(calls.length, 1)
-  assert.equal(path.resolve(calls[0].cwd), path.resolve(project))
-  assert.deepEqual(calls[0].args, [
-    "run", "--continue",
+  let runCalls = calls.filter((item) => item.args[0] === "run")
+  assert.equal(runCalls.length, 1)
+  assert.equal(path.resolve(runCalls[0].cwd), path.resolve(project))
+  assert.deepEqual(runCalls[0].args, [
+    "run", "--title", runCalls[0].args[2],
     "--model", "opencode/nemotron-3-ultra-free",
     "--agent", "build",
     inlinePrompt,
   ], "loopd must preserve model, agent, quotes, and shell metacharacters as literal arguments")
+  assert.match(runCalls[0].args[2], /^OpenCode Loop daemon /)
 
   const promptFile = path.join(project, "goal prompt.md")
   await fs.writeFile(promptFile, "\uFEFFPrompt loaded from a BOM file.", "utf8")
@@ -105,7 +98,39 @@ try {
   })
   assert.equal(result.code, 0, result.stderr)
   calls = await readLog(fakeOpenCode.log)
-  assert.equal(calls.at(-1).args.at(-1), "Prompt loaded from a BOM file.")
+  runCalls = calls.filter((item) => item.args[0] === "run")
+  assert.equal(runCalls.at(-1).args.at(-1), "Prompt loaded from a BOM file.")
+
+  const pinnedLog = path.join(temporaryRoot, "pinned.jsonl")
+  result = await runCli([
+    "--project", project,
+    "--every", "0s",
+    "--max-runs", "2",
+    "--prompt", "pinned session work",
+  ], {
+    OPENCODE_BIN: fakeOpenCode.command,
+    FAKE_COMMAND_LOG: pinnedLog,
+    FAKE_SESSION_LIST_JSON: JSON.stringify([{ id: "ses_pinned", title: "Pinned" }]),
+  })
+  assert.equal(result.code, 0, result.stderr)
+  const pinnedRuns = (await readLog(pinnedLog)).filter((item) => item.args[0] === "run")
+  assert.equal(pinnedRuns.length, 2)
+  assert.ok(pinnedRuns.every((item) => item.args[1] === "--session" && item.args[2] === "ses_pinned"), "every daemon iteration must stay pinned to the same session")
+
+  const timeoutLog = path.join(temporaryRoot, "timeout.jsonl")
+  result = await runCli([
+    "--project", project,
+    "--every", "0s",
+    "--max-runs", "1",
+    "--timeout", "50ms",
+    "--prompt", "hang",
+  ], {
+    OPENCODE_BIN: fakeOpenCode.command,
+    FAKE_COMMAND_LOG: timeoutLog,
+    FAKE_SLEEP_MS: "5000",
+  })
+  assert.equal(result.code, 124, "a timed-out daemon run must return exit code 124")
+  assert.match(result.stdout, /timed out after 50ms/)
 
   const failureLog = path.join(temporaryRoot, "failure.jsonl")
   result = await runCli([
@@ -169,6 +194,7 @@ try {
     assert.equal(taskConfig.prompt, "scheduled task prompt")
     assert.equal(taskConfig.model, "opencode/nemotron-3-ultra-free")
     assert.equal(taskConfig.agent, "build")
+    assert.equal(taskConfig.timeout, "30m")
     assert.equal(taskConfig.opencodeBin, fakeOpenCode.command)
 
     const taskRunLog = path.join(temporaryRoot, "task-run.jsonl")
@@ -176,9 +202,10 @@ try {
       FAKE_COMMAND_LOG: taskRunLog,
     })
     assert.equal(result.code, 0, result.stderr)
-    const taskRunCall = (await readLog(taskRunLog))[0]
-    assert.deepEqual(taskRunCall.args, [
-      "run", "--continue",
+    const taskRunCalls = (await readLog(taskRunLog)).filter((item) => item.args[0] === "run")
+    assert.equal(taskRunCalls.length, 1)
+    assert.deepEqual(taskRunCalls[0].args, [
+      "run", "--title", taskRunCalls[0].args[2],
       "--model", "opencode/nemotron-3-ultra-free",
       "--agent", "build",
       "scheduled task prompt",

package/scripts/loopd.mjs

@@ -61,13 +61,46 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms))
 }
 
-function spawnOnce(command, commandArgs, cwd) {
+function terminateChild(child) {
+  if (!child || child.exitCode !== null) return
+  try {
+    if (process.platform === "win32" && child.pid) {
+      spawnSync("taskkill", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true })
+      return
+    }
+    if (child.pid) process.kill(-child.pid, "SIGTERM")
+    else child.kill("SIGTERM")
+    const force = setTimeout(() => {
+      try {
+        if (child.exitCode !== null) return
+        if (child.pid) process.kill(-child.pid, "SIGKILL")
+        else child.kill("SIGKILL")
+      } catch {}
+    }, 1_000)
+    force.unref?.()
+  } catch {
+    try { child.kill("SIGTERM") } catch {}
+  }
+}
+
+function spawnOnce(command, commandArgs, cwd, options = {}) {
   return new Promise((resolve) => {
     let settled = false
+    let timedOut = false
+    const capture = options.capture === true
+    const stdout = []
+    const stderr = []
+    let timer
     const done = (result) => {
       if (settled) return
       settled = true
-      resolve(result)
+      if (timer) clearTimeout(timer)
+      resolve({
+        ...result,
+        timedOut,
+        stdout: capture ? Buffer.concat(stdout).toString("utf8") : "",
+        stderr: capture ? Buffer.concat(stderr).toString("utf8") : "",
+      })
     }
 
     let child
@@ -75,17 +108,27 @@ function spawnOnce(command, commandArgs, cwd) {
       child = spawn(command, commandArgs, {
         cwd,
         shell: false,
-        stdio: "inherit",
+        stdio: capture ? ["ignore", "pipe", "pipe"] : "inherit",
         env: process.env,
         windowsHide: true,
+        detached: process.platform !== "win32",
       })
     } catch (error) {
       done({ code: -1, error })
       return
     }
 
+    child.stdout?.on("data", (chunk) => stdout.push(Buffer.from(chunk)))
+    child.stderr?.on("data", (chunk) => stderr.push(Buffer.from(chunk)))
+    if (Number(options.timeoutMs) > 0) {
+      timer = setTimeout(() => {
+        timedOut = true
+        terminateChild(child)
+      }, Number(options.timeoutMs))
+      timer.unref?.()
+    }
     child.on("error", (error) => done({ code: -1, error }))
-    child.on("exit", (code, signal) => done({ code: code ?? (signal ? 1 : 0), signal }))
+    child.on("exit", (code, signal) => done({ code: timedOut ? 124 : (code ?? (signal ? 1 : 0)), signal }))
   })
 }
 
@@ -98,15 +141,25 @@ function stripBom(text) {
   return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text
 }
 
-async function run(command, commandArgs, cwd) {
-  const direct = await spawnOnce(command, commandArgs, cwd)
-  if (direct.code !== -1 || process.platform !== "win32" || !["ENOENT", "EINVAL"].includes(direct.error?.code)) return direct.code
+async function run(command, commandArgs, cwd, options = {}) {
+  const direct = await spawnOnce(command, commandArgs, cwd, options)
+  if (direct.code !== -1 || process.platform !== "win32" || !["ENOENT", "EINVAL"].includes(direct.error?.code)) return direct
 
-  const fallback = await spawnOnce("cmd.exe", ["/d", "/s", "/c", command, ...commandArgs], cwd)
+  const fallback = await spawnOnce("cmd.exe", ["/d", "/s", "/c", command, ...commandArgs], cwd, options)
   if (fallback.code === -1) {
     console.error(`[opencode-loopd] failed to start ${command}: ${fallback.error?.message || direct.error?.message || "unknown error"}`)
   }
-  return fallback.code
+  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
 }
 
 function runSync(command, commandArgs) {
@@ -145,50 +198,63 @@ async function daemon(options = {}) {
   const every = options.every ?? arg("--every", "0s")
   const delay = parseMs(every)
   const maxRuns = parseMaxRuns(options.maxRuns ?? arg("--max-runs", "0"))
+  const timeoutText = options.timeout ?? arg("--timeout", "30m")
+  const timeoutMs = parseMs(timeoutText)
   const sleepFirst = options.sleepFirst ?? has("--sleep-first")
   const prompt = readPrompt(project, options)
   const model = options.model ?? arg("--model")
   const agent = options.agent ?? arg("--agent")
   const opencodeBin = options.opencodeBin || OPENCODE_BIN
+  const explicitSessionID = options.session ?? arg("--session")
+  let sessionID = explicitSessionID || await resolveLatestSessionID(opencodeBin, project)
+  const sessionTitle = `OpenCode Loop daemon ${process.pid}-${Date.now()}`
 
   console.log("OpenCode Loop daemon")
   console.log(`project: ${project}`)
   console.log(`every: ${every}`)
   console.log(`maxRuns: ${maxRuns || "unlimited"}`)
+  console.log(`timeout: ${timeoutText}`)
+  if (sessionID) console.log(`session: ${sessionID} (pinned)`)
 
   let count = 0
 
-  if (sleepFirst && delay > 0) {
-    await sleep(delay)
-  }
+  if (sleepFirst && delay > 0) await sleep(delay)
 
   while (true) {
     count += 1
-
     console.log("")
     console.log(`[opencode-loopd] run #${count} ${new Date().toISOString()}`)
 
-    const runArgs = ["run", "--continue"]
+    const runArgs = ["run"]
+    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 code = await run(opencodeBin, runArgs, project)
 
-    if (code !== 0) {
-      console.log(`[opencode-loopd] opencode exited with code ${code}`)
-      if (delay === 0) {
-        await sleep(FAILED_RUN_RETRY_MS)
+    const result = await run(opencodeBin, runArgs, project, { timeoutMs })
+    const code = result.timedOut ? 124 : result.code
+    const moreRunsRemain = maxRuns === 0 || count < maxRuns
+
+    if (!sessionID && code === 0 && moreRunsRemain) {
+      sessionID = await resolveLatestSessionID(opencodeBin, project, sessionTitle)
+      if (!sessionID) {
+        console.error("[opencode-loopd] could not resolve the newly created session; refusing to continue unpinned")
+        return 1
       }
+      console.log(`[opencode-loopd] pinned session ${sessionID}`)
     }
 
+    if (result.timedOut) console.log(`[opencode-loopd] opencode run timed out after ${timeoutText}`)
+    else if (code !== 0) console.log(`[opencode-loopd] opencode exited with code ${code}`)
+    if (code !== 0 && delay === 0 && moreRunsRemain) await sleep(FAILED_RUN_RETRY_MS)
+
     if (maxRuns > 0 && count >= maxRuns) {
       console.log("[opencode-loopd] max runs reached")
       return Number.isInteger(code) && code > 0 ? code : code < 0 ? 1 : 0
     }
 
-    if (delay > 0) {
-      await sleep(delay)
-    }
+    if (delay > 0) await sleep(delay)
   }
 }
 
@@ -227,6 +293,7 @@ function installTask() {
   const promptArg = arg("--prompt")
   const model = arg("--model")
   const agent = arg("--agent")
+  const timeout = arg("--timeout", "30m")
   const node = process.execPath
   const script = fileURLToPath(import.meta.url)
   const artifacts = taskArtifacts(name)
@@ -239,6 +306,7 @@ function installTask() {
     prompt: promptArg || undefined,
     model: model || undefined,
     agent: agent || undefined,
+    timeout,
     opencodeBin: OPENCODE_BIN,
   }
   fs.writeFileSync(artifacts.config, JSON.stringify(taskConfig, null, 2) + "\n", "utf8")
@@ -296,6 +364,8 @@ Options:
   --prompt-file <file>   Read prompt from file relative to the project
   --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)
   --max-runs <n>         Stop after n runs
   --sleep-first          Wait before first run
 `)