@bojackduy/opencode-loopd 1.10.1 → 1.10.4

package/dist/server.js

@@ -130,7 +130,7 @@ import { promises as fs } from "fs";
 import path from "path";
 import os from "os";
 function emptyState() {
-  return { version: CURRENT_VERSION, revision: 0, goals: [], runtimes: [], commandLedger: [] };
+  return { version: CURRENT_VERSION, revision: 0, goals: [], runtimes: [], commandLedger: [], commands: [] };
 }
 function loopDir(directory) {
   return path.join(directory, ".opencode", "loopd");
@@ -316,6 +316,24 @@ function migrate(state) {
       lastScheduleAt: rt.lastScheduleAt ?? undefined
     }));
   }
+  if (result.version < 7) {
+    result.version = 7;
+    if (!Array.isArray(result.commands))
+      result.commands = [];
+  }
+  if (result.version < 8) {
+    result.version = 8;
+    if (!Array.isArray(result.commandAwaits))
+      result.commandAwaits = [];
+  }
+  if (result.version < 9) {
+    result.version = 9;
+    result.goals = result.goals.map((goal) => ({
+      ...goal,
+      workerTopology: goal.workerTopology ?? undefined,
+      nativeParentID: goal.nativeParentID ?? undefined
+    }));
+  }
   return result;
 }
 async function writeAtomic(target, contents) {
@@ -480,18 +498,740 @@ async function peekGoalInbox(directory, goalID) {
     return [];
   }
 }
+function commandLogFile(directory, commandID) {
+  return path.join(loopDir(directory), "commands", `${commandID}.log`);
+}
+async function appendCommandLog(directory, commandID, chunk) {
+  const file = commandLogFile(directory, commandID);
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.appendFile(file, chunk, "utf8");
+}
+async function readCommandLog(directory, commandID, opts) {
+  const file = commandLogFile(directory, commandID);
+  try {
+    const stat = await fs.stat(file);
+    const totalBytes = stat.size;
+    const requestedStart = Math.max(0, opts?.offsetBytes ?? 0);
+    if (requestedStart >= totalBytes)
+      return { text: "", totalBytes, startByte: requestedStart };
+    const fh = await fs.open(file, "r");
+    try {
+      const want = Math.min(opts?.limitBytes ?? 64 * 1024, totalBytes - requestedStart);
+      const buf = Buffer.alloc(want);
+      await fh.read(buf, 0, want, requestedStart);
+      const { text, startByte, endByte } = decodeUtf8Window(buf, requestedStart);
+      return { text, totalBytes, startByte };
+    } finally {
+      await fh.close();
+    }
+  } catch {
+    return { text: "", totalBytes: 0, startByte: 0 };
+  }
+}
+function decodeUtf8Window(buf, windowStart) {
+  let start = 0;
+  while (start < buf.length && (buf[start] & 192) === 128 && start < 4)
+    start++;
+  let end = buf.length;
+  let leadIndex = end;
+  while (leadIndex > start && (buf[leadIndex - 1] & 192) === 128)
+    leadIndex--;
+  if (leadIndex > start) {
+    const lead = buf[leadIndex - 1];
+    let expected = 1;
+    if ((lead & 128) === 0)
+      expected = 1;
+    else if ((lead & 224) === 192)
+      expected = 2;
+    else if ((lead & 240) === 224)
+      expected = 3;
+    else if ((lead & 248) === 240)
+      expected = 4;
+    if (end - (leadIndex - 1) < expected)
+      end = leadIndex - 1;
+  } else if (leadIndex === start && start > 0 && end > start) {
+    end = start;
+  }
+  const slice = buf.subarray(start, end);
+  return { text: slice.toString("utf8"), startByte: windowStart + start, endByte: windowStart + end };
+}
+async function removeCommandLog(directory, commandID) {
+  try {
+    await fs.rm(commandLogFile(directory, commandID), { force: true });
+  } catch {}
+}
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-var CURRENT_VERSION = 6, LOCK_STALE_MS = 1e4;
+var CURRENT_VERSION = 9, LOCK_STALE_MS = 1e4;
 var init_state_repository = () => {};
 
+// src/domain/command-await.ts
+function isTerminalCommandStatus(status) {
+  return TERMINAL_COMMAND_STATUSES.includes(status);
+}
+function tailLastBytes(text, maxBytes = MAX_AWAIT_TAIL_BYTES) {
+  const buf = Buffer.from(text, "utf8");
+  if (buf.length <= maxBytes)
+    return text;
+  return buf.subarray(buf.length - maxBytes).toString("utf8");
+}
+function formatAwaitEvidence(input) {
+  const short = input.commandID.slice(0, 8);
+  const header = `[command "${input.title}" (${input.argv.join(" ") || input.title}) ${input.status}` + ` ${short}... exitCode=${input.exitCode ?? "unknown"} signal=${input.signal ?? "none"}]`;
+  const tail = tailLastBytes(input.tail);
+  return tail ? `${header}
+${tail}` : header;
+}
+var TERMINAL_COMMAND_STATUSES, MAX_AWAIT_TAIL_BYTES;
+var init_command_await = __esm(() => {
+  TERMINAL_COMMAND_STATUSES = [
+    "exited",
+    "terminated",
+    "missing"
+  ];
+  MAX_AWAIT_TAIL_BYTES = 4 * 1024;
+});
+
+// src/domain/command-watch.ts
+function initialWatchState() {
+  return { state: "active", matches: 0, pushes: 0, droppedLines: 0 };
+}
+function compileWatchPattern(kind, pattern, ignoreCase = false) {
+  let compiled;
+  try {
+    compiled = new RegExp(pattern, ignoreCase ? "i" : "");
+  } catch (e) {
+    throw new Error(`Invalid watch ${kind} regex '${pattern}': ${e instanceof Error ? e.message : String(e)}`);
+  }
+  if (DANGEROUS_REGEXES.some((d) => d.test(pattern))) {
+    throw new Error(`Potentially dangerous watch ${kind} regex rejected: '${pattern}'. Please use a safer pattern.`);
+  }
+  return compiled;
+}
+function compileWatchSpec(spec) {
+  const ignoreCase = spec.ignoreCase === true;
+  const untilAction = spec.untilAction ?? "stop";
+  if (untilAction !== "stop" && untilAction !== "keep") {
+    throw new Error(`Invalid watch untilAction '${spec.untilAction}': must be "stop" or "keep".`);
+  }
+  return {
+    ...spec.filter !== undefined ? { filterRe: compileWatchPattern("filter", spec.filter, ignoreCase) } : {},
+    ...spec.until !== undefined ? { untilRe: compileWatchPattern("until", spec.until, ignoreCase) } : {},
+    ignoreCase,
+    untilAction
+  };
+}
+function stripAnsiForWatch(line) {
+  return line.replace(ANSI_PATTERN, "");
+}
+function cleanRawLine(raw) {
+  const stripped = stripAnsiForWatch(raw);
+  if (!stripped.includes("\r"))
+    return stripped;
+  const parts = stripped.split("\r");
+  return parts[parts.length - 1] ?? "";
+}
+function createLineAssembler() {
+  let carry = "";
+  return {
+    push(chunk) {
+      carry += chunk;
+      const parts = carry.replace(/\r\n/g, `
+`).split(`
+`);
+      carry = parts.pop() ?? "";
+      return parts.map(cleanRawLine);
+    },
+    flush() {
+      if (!carry)
+        return [];
+      const line = cleanRawLine(carry);
+      carry = "";
+      return [line];
+    }
+  };
+}
+function testFresh(re, line) {
+  const hit = re.test(line);
+  re.lastIndex = 0;
+  return hit;
+}
+function matchLine(compiled, line) {
+  if (compiled.filterRe && !testFresh(compiled.filterRe, line))
+    return { pass: false, until: false };
+  if (compiled.untilRe && testFresh(compiled.untilRe, line))
+    return { pass: true, until: true };
+  return { pass: true, until: false };
+}
+function byteLen(s) {
+  return Buffer.byteLength(s, "utf8");
+}
+
+class CommandWatcher {
+  compiled;
+  state = initialWatchState();
+  assembler = createLineAssembler();
+  pending = [];
+  pendingBytes = 0;
+  stamps = [];
+  constructor(spec) {
+    this.compiled = compileWatchSpec(spec);
+  }
+  get untilAction() {
+    return this.compiled.untilAction;
+  }
+  get pendingCount() {
+    return this.pending.length;
+  }
+  feedChunk(chunk, now) {
+    const completed = [];
+    const matched = [];
+    let untilLine = null;
+    let floodNow = false;
+    const suspended = this.state.state === "flood-suspended" || this.state.state === "budget-exhausted";
+    const lines = this.assembler.push(chunk);
+    for (const line of lines) {
+      if (line.trim() === "")
+        continue;
+      if (suspended) {
+        this.state.droppedLines++;
+        continue;
+      }
+      completed.push(line);
+      this.stamps.push(now);
+      while (this.stamps.length > 0 && (this.stamps[0] ?? now) < now - 1000)
+        this.stamps.shift();
+      if (this.stamps.length > WATCH_FLOOD_LINES_PER_SEC) {
+        this.state.state = "flood-suspended";
+        this.state.droppedLines++;
+        floodNow = true;
+        continue;
+      }
+      const m = matchLine(this.compiled, line);
+      if (!m.pass)
+        continue;
+      if (m.until && this.state.state === "active") {
+        this.state.state = "until-matched";
+        this.state.matches++;
+        this.buffer(line);
+        untilLine = line;
+        continue;
+      }
+      if (this.state.state === "until-matched" && this.untilAction === "stop") {
+        this.state.droppedLines++;
+        continue;
+      }
+      this.state.matches++;
+      this.buffer(line);
+      matched.push(line);
+    }
+    return { completed, matched, untilLine, floodNow };
+  }
+  finish(now) {
+    const trailing = this.assembler.flush();
+    if (trailing.length === 0)
+      return { completed: [], matched: [], untilLine: null, floodNow: false };
+    return this.feedChunk(trailing[0] + `
+`, now);
+  }
+  buffer(line) {
+    this.pending.push(line);
+    this.pendingBytes += byteLen(line);
+  }
+  takePush() {
+    if (this.pending.length === 0)
+      return null;
+    if (this.state.state === "budget-exhausted") {
+      this.state.droppedLines += this.pending.length;
+      this.pending = [];
+      this.pendingBytes = 0;
+      return null;
+    }
+    if (this.state.pushes >= WATCH_MAX_PUSHES_PER_COMMAND) {
+      this.state.state = "budget-exhausted";
+      this.state.droppedLines += this.pending.length;
+      this.pending = [];
+      this.pendingBytes = 0;
+      return { lines: [], exhaustedNow: true };
+    }
+    const lines = [];
+    let bytes = 0;
+    while (this.pending.length > 0 && lines.length < WATCH_MAX_LINES_PER_PUSH) {
+      const next = this.pending[0];
+      const nextBytes = byteLen(next) + (lines.length > 0 ? 1 : 0);
+      if (bytes + nextBytes > WATCH_MAX_BYTES_PER_PUSH && lines.length > 0)
+        break;
+      this.pending.shift();
+      this.pendingBytes -= byteLen(next);
+      lines.push(next);
+      bytes += nextBytes;
+    }
+    this.state.pushes++;
+    return { lines, exhaustedNow: false };
+  }
+  takeUntilPush() {
+    const lines = [];
+    let bytes = 0;
+    while (this.pending.length > 0 && lines.length < WATCH_MAX_LINES_PER_PUSH) {
+      const next = this.pending.pop();
+      this.pendingBytes -= byteLen(next);
+      const nextBytes = byteLen(next) + (lines.length > 0 ? 1 : 0);
+      if (bytes + nextBytes > WATCH_MAX_BYTES_PER_PUSH && lines.length > 0) {
+        this.pending.push(next);
+        this.pendingBytes += byteLen(next);
+        break;
+      }
+      lines.unshift(next);
+      bytes += nextBytes;
+    }
+    this.state.droppedLines += this.pending.length;
+    this.pending = [];
+    this.pendingBytes = 0;
+    this.state.pushes++;
+    return lines;
+  }
+}
+function formatWatchMessage(title, lines, note) {
+  const header = `[watch "${title}"]`;
+  const tail = note ? [...lines, note].join(`
+`) : lines.join(`
+`);
+  if (!tail)
+    return header;
+  const room = Math.max(0, MAX_WATCH_MESSAGE_BYTES - byteLen(header) - 1);
+  return `${header}
+${tailLastBytes(tail, room)}`;
+}
+function formatWatchFloodMessage(title, dropped) {
+  return `[watch "${title}"] FLOOD: ${WATCH_FLOOD_LINES_PER_SEC}+ lines/sec exceeds the limit. ` + `Watch suspended (${dropped} line(s) dropped so far); the process keeps running.`;
+}
+function formatWatchBudgetMessage(title) {
+  return `[watch "${title}"] BUDGET: push limit (${WATCH_MAX_PUSHES_PER_COMMAND}) reached. ` + `Watch exhausted; further matches are dropped. The process keeps running.`;
+}
+var WATCH_COALESCE_WINDOW_MS = 2000, WATCH_MAX_LINES_PER_PUSH = 20, WATCH_MAX_BYTES_PER_PUSH, WATCH_MAX_PUSHES_PER_COMMAND = 30, WATCH_FLOOD_LINES_PER_SEC = 100, MAX_WATCH_MESSAGE_BYTES, DANGEROUS_REGEXES, ANSI_PATTERN;
+var init_command_watch = __esm(() => {
+  init_command_await();
+  WATCH_MAX_BYTES_PER_PUSH = 4 * 1024;
+  MAX_WATCH_MESSAGE_BYTES = 4 * 1024;
+  DANGEROUS_REGEXES = [
+    /\(\?:.*\)\*.*\(\?:.*\)\*/,
+    /.*\(\.\*\?\)\{2,\}.*/,
+    /.*\(.*\|.*\)\{3,\}.*/,
+    /\([^()]*[+*][^()]*\)[+*]/,
+    /\([^()]*(\.\*.*\.\*|\.\+.*\.\+|\\w\+.*\\s\*|\\s\*.*\\w\+)[^()]*\)/
+  ];
+  ANSI_PATTERN = new RegExp("\x1B\\[[0-9;?]*[ -/]*[@-~]|\x1B\\][^\x07]*(?:\x07|\x1B\\\\)|\x1B[()][0-9A-Z]", "g");
+});
+
+// src/application/command-await.ts
+import { randomUUID } from "crypto";
+function ledgerEvent(base) {
+  return {
+    version: 1,
+    eventID: randomUUID(),
+    timestamp: new Date().toISOString(),
+    revision: 0,
+    ...base
+  };
+}
+async function requestCommandAwait(directory, input) {
+  const snapshot = await readState(directory);
+  const goal = snapshot.goals.find((g) => g.id === input.goalID);
+  if (!goal)
+    return { ok: false, message: "Goal not found." };
+  const command = (snapshot.commands ?? []).find((c) => c.id === input.commandID);
+  if (!command)
+    return { ok: false, message: "Command not found." };
+  if (input.ownerSessionID !== goal.ownerSessionID || input.ownerSessionID !== command.ownerSessionID) {
+    return { ok: false, message: "Owner mismatch: the await requester must own both the goal and the command." };
+  }
+  if (goal.ownerSessionID !== command.ownerSessionID) {
+    return { ok: false, message: "Owner mismatch: goal and command are owned by different sessions." };
+  }
+  const until = input.until !== undefined && input.until !== "" ? input.until : undefined;
+  const ignoreCase = input.ignoreCase === true;
+  if (input.until !== undefined && until === undefined) {
+    return { ok: false, message: "Await 'until' must be a non-empty regex." };
+  }
+  if (until !== undefined) {
+    try {
+      compileWatchPattern("until", until, ignoreCase);
+    } catch (e) {
+      return { ok: false, message: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  const existing = (snapshot.commandAwaits ?? []).some((a) => a.goalID === input.goalID && a.commandID === input.commandID);
+  if (existing) {
+    return { ok: true, message: `Already awaiting "${command.title}" for goal "${goal.name}".` };
+  }
+  if (isTerminalCommandStatus(command.status)) {
+    await mutateState(directory, `cmd.await-request:${input.goalID}:${input.commandID}`, async (s) => {
+      s.commandAwaits = [...s.commandAwaits ?? [], {
+        goalID: input.goalID,
+        commandID: input.commandID,
+        ownerSessionID: input.ownerSessionID,
+        createdAt: new Date().toISOString(),
+        ...until !== undefined ? { until, ignoreCase } : {}
+      }];
+      return s;
+    });
+    const fired = await fireCommandAwaits(directory, input.commandID);
+    const mine = fired.find((f) => f.goalID === input.goalID);
+    return {
+      ok: true,
+      message: `Command "${command.title}" already ${command.status}; wake-up delivered to goal "${goal.name}".`,
+      fired: true,
+      active: mine?.active ?? goal.status === "active"
+    };
+  }
+  let becameTerminal = false;
+  await mutateState(directory, `cmd.await-request:${input.goalID}:${input.commandID}`, async (s) => {
+    const dup = (s.commandAwaits ?? []).some((a) => a.goalID === input.goalID && a.commandID === input.commandID);
+    if (!dup) {
+      s.commandAwaits = [...s.commandAwaits ?? [], {
+        goalID: input.goalID,
+        commandID: input.commandID,
+        ownerSessionID: input.ownerSessionID,
+        createdAt: new Date().toISOString(),
+        ...until !== undefined ? { until, ignoreCase } : {}
+      }];
+    }
+    const current = (s.commands ?? []).find((c) => c.id === input.commandID);
+    if (current && isTerminalCommandStatus(current.status)) {
+      becameTerminal = true;
+    }
+    return s;
+  });
+  if (becameTerminal) {
+    const fired = await fireCommandAwaits(directory, input.commandID);
+    const mine = fired.find((f) => f.goalID === input.goalID);
+    return {
+      ok: true,
+      message: `Command "${command.title}" exited while registering; wake-up delivered to goal "${goal.name}".`,
+      fired: true,
+      active: mine?.active ?? goal.status === "active"
+    };
+  }
+  if (until !== undefined) {
+    const retained = await readRetainedLines(directory, input.commandID);
+    const hit = retained.find((line) => testUntil(until, ignoreCase, line));
+    if (hit !== undefined) {
+      const fired = await fireUntilAwaits(directory, input.commandID, [hit]);
+      const mine = fired.find((f) => f.goalID === input.goalID);
+      if (mine) {
+        return {
+          ok: true,
+          message: `Pattern "${until}" already present in "${command.title}" output; wake-up delivered to goal "${goal.name}".`,
+          fired: true,
+          active: mine.active
+        };
+      }
+      const again = await fireCommandAwaits(directory, input.commandID);
+      const second = again.find((f) => f.goalID === input.goalID);
+      if (second) {
+        return {
+          ok: true,
+          message: `Command "${command.title}" exited while registering; wake-up delivered to goal "${goal.name}".`,
+          fired: true,
+          active: second.active
+        };
+      }
+    }
+  }
+  await appendEvent(directory, ledgerEvent({
+    goalID: input.goalID,
+    commandID: input.commandID,
+    type: "command.await-requested",
+    ...until !== undefined ? { until } : {}
+  })).catch(() => {});
+  return {
+    ok: true,
+    message: until !== undefined ? `Goal "${goal.name}" now awaits pattern "${until}" in "${command.title}" (fires once on first match; the command keeps running).` : `Goal "${goal.name}" now awaits "${command.title}" (fires once on exit).`
+  };
+}
+function testUntil(until, ignoreCase, line) {
+  try {
+    const re = new RegExp(until, ignoreCase ? "i" : "");
+    const hit = re.test(line);
+    re.lastIndex = 0;
+    return hit;
+  } catch {
+    return false;
+  }
+}
+async function readRetainedLines(directory, commandID) {
+  try {
+    const full = await readCommandLog(directory, commandID, {
+      offsetBytes: 0,
+      limitBytes: 512 * 1024
+    });
+    if (!full.text)
+      return [];
+    return full.text.split(`
+`).filter((l) => l.trim() !== "");
+  } catch {
+    return [];
+  }
+}
+async function fireUntilAwaits(directory, commandID, lines) {
+  if (lines.length === 0)
+    return [];
+  let candidates = [];
+  let command;
+  await mutateState(directory, `cmd.await-until-consume:${commandID}`, async (s) => {
+    const outstanding = (s.commandAwaits ?? []).filter((a) => a.commandID === commandID && typeof a.until === "string" && a.until !== "");
+    if (outstanding.length === 0)
+      return s;
+    const current = (s.commands ?? []).find((c) => c.id === commandID);
+    if (!current)
+      return s;
+    command = current;
+    const hits = [];
+    for (const a of outstanding) {
+      const pattern = a.until;
+      if (lines.some((line) => testUntil(pattern, a.ignoreCase === true, line)))
+        hits.push(a);
+    }
+    if (hits.length === 0)
+      return s;
+    const hitKeys = new Set(hits.map((h) => `${h.goalID}:${h.commandID}`));
+    s.commandAwaits = (s.commandAwaits ?? []).filter((a) => !(a.commandID === commandID && hitKeys.has(`${a.goalID}:${a.commandID}`)));
+    candidates = hits;
+    return s;
+  });
+  if (candidates.length === 0 || !command)
+    return [];
+  const cmd = command;
+  const tail = await readBoundedTail(directory, commandID);
+  const fired = [];
+  for (const a of candidates) {
+    const pattern = a.until;
+    const matched = lines.filter((line) => testUntil(pattern, a.ignoreCase === true, line));
+    const fresh = await readState(directory);
+    const goal = fresh.goals.find((g) => g.id === a.goalID);
+    if (!goal) {
+      await appendEvent(directory, ledgerEvent({
+        goalID: a.goalID,
+        commandID,
+        type: "command.await-discarded",
+        reason: "goal gone"
+      })).catch(() => {});
+      continue;
+    }
+    const short = commandID.slice(0, 8);
+    const header = `[command "${cmd.title}" (${[cmd.command, ...cmd.args].join(" ") || cmd.title}) ${cmd.status}` + ` ${short}... watch-until "${pattern}" matched]`;
+    const matchedText = tailLastBytes(matched.slice(0, 20).join(`
+`), MAX_AWAIT_TAIL_BYTES);
+    const evidence = tail ? `${header}
+${matchedText}
+--- tail ---
+${tail}` : `${header}
+${matchedText}`;
+    await appendGoalInbox(directory, a.goalID, "worker", evidence);
+    await appendEvent(directory, ledgerEvent({
+      goalID: a.goalID,
+      commandID,
+      type: "command.await-fired",
+      until: pattern,
+      matchedLines: matched.length,
+      status: cmd.status
+    })).catch(() => {});
+    fired.push({ goalID: a.goalID, commandID, active: goal.status === "active" });
+  }
+  return fired;
+}
+async function readBoundedTail(directory, commandID) {
+  try {
+    const probe = await readCommandLog(directory, commandID, { offsetBytes: 0, limitBytes: 0 });
+    if (probe.totalBytes <= MAX_AWAIT_TAIL_BYTES) {
+      const full = await readCommandLog(directory, commandID, {
+        offsetBytes: 0,
+        limitBytes: MAX_AWAIT_TAIL_BYTES
+      });
+      return full.text;
+    }
+    const tail = await readCommandLog(directory, commandID, {
+      offsetBytes: Math.max(0, probe.totalBytes - MAX_AWAIT_TAIL_BYTES),
+      limitBytes: MAX_AWAIT_TAIL_BYTES
+    });
+    return tail.text;
+  } catch {
+    return "";
+  }
+}
+async function fireCommandAwaits(directory, commandID) {
+  let consumed = [];
+  let command;
+  let commandGone = false;
+  await mutateState(directory, `cmd.await-consume:${commandID}`, async (s) => {
+    const outstanding = (s.commandAwaits ?? []).filter((a) => a.commandID === commandID);
+    if (outstanding.length === 0)
+      return s;
+    const current = (s.commands ?? []).find((c) => c.id === commandID);
+    if (!current) {
+      commandGone = true;
+      consumed = outstanding;
+      s.commandAwaits = (s.commandAwaits ?? []).filter((a) => a.commandID !== commandID);
+      return s;
+    }
+    if (!isTerminalCommandStatus(current.status))
+      return s;
+    command = current;
+    consumed = outstanding;
+    s.commandAwaits = (s.commandAwaits ?? []).filter((a) => a.commandID !== commandID);
+    return s;
+  });
+  if (consumed.length === 0)
+    return [];
+  if (commandGone || !command) {
+    for (const a of consumed) {
+      await appendEvent(directory, ledgerEvent({
+        goalID: a.goalID,
+        commandID,
+        type: "command.await-discarded",
+        reason: "command record gone"
+      })).catch(() => {});
+    }
+    return [];
+  }
+  const tail = await readBoundedTail(directory, commandID);
+  const fired = [];
+  for (const a of consumed) {
+    const fresh = await readState(directory);
+    const goal = fresh.goals.find((g) => g.id === a.goalID);
+    if (!goal) {
+      await appendEvent(directory, ledgerEvent({
+        goalID: a.goalID,
+        commandID,
+        type: "command.await-discarded",
+        reason: "goal gone"
+      })).catch(() => {});
+      continue;
+    }
+    const evidence = formatAwaitEvidence({
+      title: command.title,
+      argv: [command.command, ...command.args],
+      commandID: command.id,
+      status: command.status,
+      exitCode: command.exitCode,
+      signal: command.signal,
+      tail
+    });
+    await appendGoalInbox(directory, a.goalID, "worker", evidence);
+    await appendEvent(directory, ledgerEvent({
+      goalID: a.goalID,
+      commandID,
+      type: "command.await-fired",
+      status: command.status,
+      exitCode: command.exitCode,
+      signal: command.signal
+    })).catch(() => {});
+    fired.push({ goalID: a.goalID, commandID, active: goal.status === "active" });
+  }
+  return fired;
+}
+async function cancelAwaitsForGoal(directory, goalID, reason) {
+  const snapshot = await readState(directory);
+  const doomed = (snapshot.commandAwaits ?? []).filter((a) => a.goalID === goalID);
+  if (doomed.length === 0)
+    return 0;
+  await mutateState(directory, `cmd.await-cancel-goal:${goalID}`, async (s) => {
+    s.commandAwaits = (s.commandAwaits ?? []).filter((a) => a.goalID !== goalID);
+    return s;
+  });
+  await appendEvent(directory, ledgerEvent({
+    goalID,
+    type: "command.await-cancelled",
+    reason,
+    count: doomed.length
+  })).catch(() => {});
+  return doomed.length;
+}
+async function clearAwaitsForCommand(directory, commandID, reason) {
+  const snapshot = await readState(directory);
+  const doomed = (snapshot.commandAwaits ?? []).filter((a) => a.commandID === commandID);
+  if (doomed.length === 0)
+    return 0;
+  await mutateState(directory, `cmd.await-clear-command:${commandID}`, async (s) => {
+    s.commandAwaits = (s.commandAwaits ?? []).filter((a) => a.commandID !== commandID);
+    return s;
+  });
+  for (const a of doomed) {
+    await appendEvent(directory, ledgerEvent({
+      goalID: a.goalID,
+      commandID,
+      type: "command.await-cancelled",
+      reason
+    })).catch(() => {});
+  }
+  return doomed.length;
+}
+async function reconcileCommandAwaits(directory) {
+  const snapshot = await readState(directory);
+  const outstanding = [...snapshot.commandAwaits ?? []];
+  const fired = [];
+  for (const a of outstanding) {
+    const fresh = await readState(directory);
+    const still = (fresh.commandAwaits ?? []).some((x) => x.goalID === a.goalID && x.commandID === a.commandID);
+    if (!still)
+      continue;
+    const command = (fresh.commands ?? []).find((c) => c.id === a.commandID);
+    if (!command) {
+      await mutateState(directory, `cmd.await-reconcile-discard:${a.commandID}`, async (s) => {
+        s.commandAwaits = (s.commandAwaits ?? []).filter((x) => !(x.goalID === a.goalID && x.commandID === a.commandID));
+        return s;
+      });
+      await appendEvent(directory, ledgerEvent({
+        goalID: a.goalID,
+        commandID: a.commandID,
+        type: "command.await-discarded",
+        reason: "command record gone at reconcile"
+      })).catch(() => {});
+      continue;
+    }
+    if (!isTerminalCommandStatus(command.status))
+      continue;
+    const now = await fireCommandAwaits(directory, a.commandID);
+    fired.push(...now.filter((f) => f.goalID === a.goalID));
+  }
+  return fired;
+}
+async function wakeGoalForAwait(directory, continuation, goalID) {
+  const snapshot = await readState(directory);
+  const goal = snapshot.goals.find((g) => g.id === goalID);
+  if (!goal)
+    return { woke: false, message: "Goal gone; wake skipped." };
+  if (goal.status !== "active") {
+    return { woke: false, message: `Goal is ${goal.status}; evidence waits in pendingInbox.` };
+  }
+  await mutateState(directory, `cmd.await-wake:${goalID}`, async (s) => {
+    const rt = s.runtimes.find((r) => r.goalID === goalID);
+    if (!rt)
+      return s;
+    rt.phase = "idle";
+    rt.activeRunID = undefined;
+    rt.idleCandidateAt = undefined;
+    rt.activePromptMessageID = undefined;
+    rt.activeToolCallIDs = [];
+    rt.updatedAt = new Date().toISOString();
+    return s;
+  });
+  await continuation.continueTurn(directory, goalID, { force: true });
+  return { woke: true, message: `Woke goal "${goal.name}" for command exit.` };
+}
+var init_command_await2 = __esm(() => {
+  init_command_await();
+  init_command_watch();
+  init_state_repository();
+});
+
 // src/server/plugin.ts
 import { tool as v1Tool } from "@opencode-ai/plugin/tool";
 
 // src/application/control-worker.ts
 init_state_repository();
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // src/application/goal-policy.ts
 function resolveGoalCreationConfig(input) {
@@ -600,6 +1340,7 @@ function errorReplacer(_key, value) {
 }
 
 // src/application/control-worker.ts
+init_command_await2();
 var MAX_LEDGER_SIZE = 100;
 var RESPONSE_CLEANUP_AGE_MS = 60 * 60 * 1000;
 function createControlWorker(options) {
@@ -863,7 +1604,7 @@ function createControlWorker(options) {
         await writeState(directory, state);
         await appendEvent(directory, {
           version: 1,
-          eventID: randomUUID(),
+          eventID: randomUUID2(),
           goalID: goal.id,
           type: "goal.completed",
           summary: goal.completionEvidence.summary,
@@ -904,7 +1645,7 @@ function createControlWorker(options) {
         await writeState(directory, state);
         await appendEvent(directory, {
           version: 1,
-          eventID: randomUUID(),
+          eventID: randomUUID2(),
           goalID: goal.id,
           type: "goal.blocked",
           reason: goal.blocker.reason,
@@ -915,6 +1656,114 @@ function createControlWorker(options) {
         response = { ...base, message: `goal "${goal.name}" blocked`, stateRevision: state.revision };
         break;
       }
+      case "cmd_await": {
+        const args = request.args ?? {};
+        const ownerSessionID = typeof args.ownerSessionID === "string" ? args.ownerSessionID : "";
+        if (!ownerSessionID || ownerSessionID === "main") {
+          response = { ...base, ok: false, message: "ownerSessionID is required for command operations", errorCode: "no_session" };
+          break;
+        }
+        const goalID = typeof args.goalID === "string" ? args.goalID : "";
+        const commandID = typeof args.commandID === "string" && args.commandID ? String(args.commandID) : String(request.goalID || "");
+        if (!goalID || !commandID) {
+          response = { ...base, ok: false, message: "goalID and commandID are required", errorCode: "bad_request" };
+          break;
+        }
+        const result = await requestCommandAwait(directory, { goalID, commandID, ownerSessionID });
+        if (result.ok && result.fired && result.active) {
+          await wakeGoalForAwait(directory, goalSvc, goalID).catch(() => {});
+        }
+        const state = await readState(directory);
+        response = {
+          ...base,
+          ok: result.ok,
+          message: result.message,
+          stateRevision: state.revision,
+          errorCode: result.ok ? undefined : "await_failed"
+        };
+        break;
+      }
+      case "cmd_start":
+      case "cmd_write":
+      case "cmd_interrupt":
+      case "cmd_terminate":
+      case "cmd_remove":
+      case "cmd_resize":
+      case "cmd_watch": {
+        const cmdSvc = options.commandService;
+        if (!cmdSvc) {
+          response = {
+            requestID: request.requestID,
+            ok: false,
+            message: `command "${request.command}" unavailable (command service not initialized)`,
+            errorCode: "unavailable",
+            completedAt: new Date().toISOString()
+          };
+          break;
+        }
+        const args = request.args ?? {};
+        const ownerSessionID = typeof args.ownerSessionID === "string" ? args.ownerSessionID : "";
+        if (!ownerSessionID || ownerSessionID === "main") {
+          response = { ...base, ok: false, message: "ownerSessionID is required for command operations", errorCode: "no_session" };
+          break;
+        }
+        try {
+          if (request.command === "cmd_start") {
+            const session = await cmdSvc.start(directory, {
+              title: String(args.title || "command"),
+              command: String(args.command || ""),
+              args: Array.isArray(args.cmdArgs) ? args.cmdArgs : [],
+              cwd: typeof args.cwd === "string" ? args.cwd : undefined,
+              ownerSessionID,
+              goalID: typeof args.goalID === "string" ? args.goalID : undefined,
+              cols: typeof args.cols === "number" ? args.cols : undefined,
+              rows: typeof args.rows === "number" ? args.rows : undefined
+            });
+            const state = await readState(directory);
+            response = { ...base, message: `command "${session.title}" started (${session.id.slice(0, 8)}...)`, stateRevision: state.revision };
+          } else {
+            const id = String(args.commandID || request.goalID || "");
+            if (!id) {
+              response = { ...base, ok: false, message: "commandID is required", errorCode: "bad_request" };
+              break;
+            }
+            if (request.command === "cmd_write") {
+              const r = await cmdSvc.write(directory, id, ownerSessionID, String(args.input ?? ""));
+              const state = await readState(directory);
+              response = { ...base, ok: r.ok, message: r.message, stateRevision: state.revision };
+            } else if (request.command === "cmd_interrupt") {
+              const r = await cmdSvc.interrupt(directory, id, ownerSessionID);
+              const state = await readState(directory);
+              response = { ...base, ok: r.ok, message: r.message, stateRevision: state.revision };
+            } else if (request.command === "cmd_terminate") {
+              const r = await cmdSvc.terminate(directory, id, ownerSessionID);
+              const state = await readState(directory);
+              response = { ...base, ok: r.ok, message: r.message, stateRevision: state.revision };
+            } else if (request.command === "cmd_remove") {
+              const r = await cmdSvc.remove(directory, id, ownerSessionID);
+              const state = await readState(directory);
+              response = { ...base, ok: r.ok, message: r.message, stateRevision: state.revision };
+            } else if (request.command === "cmd_watch") {
+              const r = await cmdSvc.watch(directory, id, ownerSessionID, {
+                ...typeof args.watchFilter === "string" ? { filter: args.watchFilter } : {},
+                ...typeof args.watchUntil === "string" ? { until: args.watchUntil } : {},
+                ...typeof args.watchIgnoreCase === "boolean" ? { ignoreCase: args.watchIgnoreCase } : {},
+                ...typeof args.watchUntilAction === "string" ? { untilAction: args.watchUntilAction } : {},
+                ...typeof args.clear === "boolean" ? { clear: args.clear } : {}
+              }).catch((error) => ({ ok: false, message: error instanceof Error ? error.message : String(error) }));
+              const state = await readState(directory);
+              response = { ...base, ok: r.ok, message: r.message, stateRevision: state.revision };
+            } else {
+              const r = await cmdSvc.resize(directory, id, ownerSessionID, Number(args.cols), Number(args.rows));
+              const state = await readState(directory);
+              response = { ...base, ok: r.ok, message: r.message, stateRevision: state.revision };
+            }
+          }
+        } catch (error) {
+          response = { ...base, ok: false, message: error instanceof Error ? error.message : String(error), errorCode: "command_failed" };
+        }
+        break;
+      }
       default: {
         response = {
           requestID: request.requestID,
@@ -929,20 +1778,23 @@ function createControlWorker(options) {
     return response;
   }
   async function recordInLedger(directory, request) {
-    const state = await readState(directory);
-    if (!state.commandLedger)
-      state.commandLedger = [];
-    state.commandLedger.push({
-      requestID: request.requestID,
-      command: request.command,
-      goalID: request.goalID,
-      acceptedAt: request.requestedAt,
-      completedAt: new Date().toISOString()
+    await mutateState(directory, `control.ledger:${request.requestID}`, async (state) => {
+      if (!state.commandLedger)
+        state.commandLedger = [];
+      if (state.commandLedger.some((entry) => entry.requestID === request.requestID))
+        return state;
+      state.commandLedger.push({
+        requestID: request.requestID,
+        command: request.command,
+        goalID: request.goalID,
+        acceptedAt: request.requestedAt,
+        completedAt: new Date().toISOString()
+      });
+      if (state.commandLedger.length > MAX_LEDGER_SIZE) {
+        state.commandLedger = state.commandLedger.slice(-MAX_LEDGER_SIZE);
+      }
+      return state;
     });
-    if (state.commandLedger.length > MAX_LEDGER_SIZE) {
-      state.commandLedger = state.commandLedger.slice(-MAX_LEDGER_SIZE);
-    }
-    await writeState(directory, state);
   }
   return { start, stop: async () => {
     await stop();
@@ -951,7 +1803,7 @@ function createControlWorker(options) {
 
 // src/application/loop-engine.ts
 init_state_repository();
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 
 // src/domain/goal.ts
 var MODEL_TRANSITIONS = {
@@ -996,6 +1848,7 @@ var HANDLED_EVENT_TYPES = new Set([
   "session.status",
   "session.error",
   "session.compacted",
+  "session.execution.succeeded",
   "message.updated",
   "message.part.updated"
 ]);
@@ -1100,6 +1953,8 @@ function createLoopEngine(options) {
       case "message.updated":
       case "message.part.updated":
         return await handleMessageActivity(goal, event);
+      case "session.execution.succeeded":
+        return await handleExecutionSucceeded(goal);
       default:
         return false;
     }
@@ -1140,6 +1995,19 @@ function createLoopEngine(options) {
     });
     return matched;
   }
+  async function handleExecutionSucceeded(goal) {
+    let matched = false;
+    await mutateState(directory, `execution-succeeded:${goal.id}`, async (s) => {
+      const rt = s.runtimes.find((r) => r.goalID === goal.id);
+      if (!rt || rt.phase !== "running" || !rt.activePromptMessageID)
+        return s;
+      Object.assign(rt, recordActivity(rt));
+      rt.activeAssistantCompletedAt = new Date().toISOString();
+      matched = true;
+      return s;
+    });
+    return matched;
+  }
   async function handleSessionIdle(state, goal) {
     const goalID = goal.id;
     if (inflightContinuations.has(goalID))
@@ -1215,7 +2083,7 @@ function createLoopEngine(options) {
         if (newlyStamped) {
           await appendEvent(directory, {
             version: 1,
-            eventID: randomUUID2(),
+            eventID: randomUUID3(),
             goalID,
             type: "idle.confirm-failed",
             reason: failureReason,
@@ -1260,7 +2128,7 @@ function createLoopEngine(options) {
     if (completedRunID) {
       await appendEvent(directory, {
         version: 1,
-        eventID: randomUUID2(),
+        eventID: randomUUID3(),
         goalID,
         type: "run.completed",
         runID: completedRunID,
@@ -1325,7 +2193,7 @@ function createLoopEngine(options) {
       });
       await appendEvent(directory, {
         version: 1,
-        eventID: randomUUID2(),
+        eventID: randomUUID3(),
         goalID,
         type: "goal.blocked",
         reason: limitResult.reason + " (force-finish ignored)",
@@ -1349,7 +2217,7 @@ function createLoopEngine(options) {
       });
       await appendEvent(directory, {
         version: 1,
-        eventID: randomUUID2(),
+        eventID: randomUUID3(),
         goalID,
         type: "goal.status_changed",
         from: "active",
@@ -1451,7 +2319,7 @@ function createLoopEngine(options) {
     });
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID2(),
+      eventID: randomUUID3(),
       goalID: goal.id,
       type: "run.failed",
       runID: runtime.activeRunID || "unknown",
@@ -1464,7 +2332,7 @@ function createLoopEngine(options) {
     if (updatedGoal?.status === "blocked") {
       await appendEvent(directory, {
         version: 1,
-        eventID: randomUUID2(),
+        eventID: randomUUID3(),
         goalID: goal.id,
         type: "goal.blocked",
         reason: `Failed ${runtime.consecutiveFailures + 1} times`,
@@ -1492,7 +2360,7 @@ function createLoopEngine(options) {
     });
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID2(),
+      eventID: randomUUID3(),
       goalID: goal.id,
       type: "compaction.completed",
       timestamp: new Date().toISOString(),
@@ -1562,7 +2430,7 @@ function createLoopEngine(options) {
     });
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID2(),
+      eventID: randomUUID3(),
       goalID: goal.id,
       type: "compaction.started",
       timestamp: new Date().toISOString(),
@@ -1620,7 +2488,7 @@ function createLoopEngine(options) {
       return false;
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID2(),
+      eventID: randomUUID3(),
       goalID: goal.id,
       type: "goal.status_changed",
       from: "active",
@@ -1796,7 +2664,7 @@ function createLoopEngine(options) {
             if (recovered) {
               await appendEvent(directory, {
                 version: 1,
-                eventID: randomUUID2(),
+                eventID: randomUUID3(),
                 goalID: goal.id,
                 type: "run.recovered",
                 runID: stalledRunID ?? "unknown",
@@ -1830,7 +2698,7 @@ function createLoopEngine(options) {
           const stuckSeconds = Math.floor((Date.now() - Date.parse(failedAt)) / 1000);
           await appendEvent(directory, {
             version: 1,
-            eventID: randomUUID2(),
+            eventID: randomUUID3(),
             goalID: goal.id,
             type: "run.stuck",
             runID: runtime.activeRunID ?? "unknown",
@@ -1870,7 +2738,7 @@ function createLoopEngine(options) {
             });
             await appendEvent(directory, {
               version: 1,
-              eventID: randomUUID2(),
+              eventID: randomUUID3(),
               goalID: goal.id,
               type: "run.stuck",
               runID: runtime.activeRunID,
@@ -1893,28 +2761,138 @@ function createLoopEngine(options) {
 }
 
 // src/application/goal-service.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 init_state_repository();
+init_command_await2();
 import * as path2 from "path";
 import { promises as fs2 } from "fs";
 
 // src/server/host-adapter.ts
-function parseModelRef(value) {
-  if (value === undefined)
-    return;
-  const trimmed = value.trim();
-  if (!trimmed)
-    return;
-  const slash = trimmed.indexOf("/");
-  if (slash <= 0 || slash >= trimmed.length - 1) {
-    throw new Error(`Invalid model "${value}". Use "providerID/modelID" (e.g. "openai/gpt-5.6-sol").`);
-  }
-  const providerID = trimmed.slice(0, slash).trim();
-  const modelID = trimmed.slice(slash + 1).trim();
-  if (!providerID || !modelID || /\s/.test(providerID) || /\s/.test(modelID)) {
-    throw new Error(`Invalid model "${value}". Use "providerID/modelID" (e.g. "openai/gpt-5.6-sol").`);
-  }
-  return { providerID, modelID };
+import { randomUUID as randomUUID4 } from "crypto";
+
+// src/v2/native-rpc.ts
+var NATIVE_RPC_ID = "loopd.native";
+var CLAIM_TIMEOUT_MS = 3000;
+var CLAIMED_TIMEOUT_MS = 15000;
+function resolveNativeParentID(child) {
+  return child.fork?.sessionID ?? child.parentID ?? undefined;
+}
+var requestSchema = {
+  type: "object",
+  properties: {
+    requestID: { type: "string" },
+    goalID: { type: "string" },
+    parentSessionID: { type: "string" },
+    title: { type: "string" },
+    agent: { type: "string" },
+    model: {
+      type: "object",
+      properties: {
+        id: { type: "string" },
+        providerID: { type: "string" }
+      },
+      required: ["id", "providerID"],
+      additionalProperties: false
+    },
+    permissions: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          action: { type: "string" },
+          resource: { type: "string" },
+          effect: { type: "string", enum: ["allow", "deny", "ask"] }
+        },
+        required: ["action", "resource", "effect"],
+        additionalProperties: false
+      }
+    },
+    directory: { type: "string" }
+  },
+  required: ["requestID", "goalID", "parentSessionID", "title"],
+  additionalProperties: false
+};
+var claimResultSchema = {
+  type: "object",
+  properties: {
+    requestID: { type: "string" },
+    claimantID: { type: "string" }
+  },
+  required: ["requestID", "claimantID"],
+  additionalProperties: false
+};
+var claimAckSchema = {
+  type: "object",
+  properties: {
+    requestID: { type: "string" },
+    claimantID: { type: "string" },
+    won: { type: "boolean" }
+  },
+  required: ["requestID", "claimantID", "won"],
+  additionalProperties: false
+};
+var createResultSchema = {
+  type: "object",
+  properties: {
+    requestID: { type: "string" },
+    childSessionID: { type: "string" },
+    parentSessionID: { type: "string" },
+    topology: { type: "string", const: "v2-native-child" }
+  },
+  required: ["requestID", "childSessionID", "parentSessionID", "topology"],
+  additionalProperties: false
+};
+var failureSchema = {
+  type: "object",
+  properties: {
+    requestID: { type: "string" },
+    reason: { type: "string" },
+    detail: { type: "string" },
+    preCreation: { type: "boolean" }
+  },
+  required: ["requestID", "reason", "preCreation"],
+  additionalProperties: false
+};
+var emptySchema = {
+  type: "object",
+  properties: {},
+  additionalProperties: false
+};
+var nativeRpcDefinition = {
+  id: NATIVE_RPC_ID,
+  methods: {
+    claimRequest: { input: claimResultSchema, output: claimAckSchema, errors: {} },
+    completeWorkerCreate: { input: createResultSchema, output: emptySchema, errors: {} },
+    failRequest: { input: failureSchema, output: emptySchema, errors: {} }
+  },
+  events: {
+    workerCreateRequested: { schema: requestSchema }
+  }
+};
+
+// src/server/host-adapter.ts
+function parseModelRef(value) {
+  if (value === undefined)
+    return;
+  const trimmed = value.trim();
+  if (!trimmed)
+    return;
+  const slash = trimmed.indexOf("/");
+  if (slash <= 0 || slash >= trimmed.length - 1) {
+    throw new Error(`Invalid model "${value}". Use "providerID/modelID" (e.g. "openai/gpt-5.6-sol").`);
+  }
+  const providerID = trimmed.slice(0, slash).trim();
+  const modelID = trimmed.slice(slash + 1).trim();
+  if (!providerID || !modelID || /\s/.test(providerID) || /\s/.test(modelID)) {
+    throw new Error(`Invalid model "${value}". Use "providerID/modelID" (e.g. "openai/gpt-5.6-sol").`);
+  }
+  return { providerID, modelID };
+}
+function newPromptMessageID() {
+  return `msg_${randomUUID4()}`;
+}
+function isV2PromptMessageID(messageID) {
+  return messageID.startsWith("msg_");
 }
 var recentParentNotifies = new Map;
 function shouldDedupParentNotify(ownerSessionID, message) {
@@ -1962,8 +2940,7 @@ function createRealHost(client, directory) {
         parts: [{ type: "text", text: prompt }]
       };
       if (messageID) {
-        const collapsed = messageID.replace(/^(msg-)+/, "msg-");
-        body.messageID = collapsed.startsWith("msg-") ? collapsed : `msg-${messageID}`;
+        body.messageID = /^msg[-_]/.test(messageID) ? messageID : `msg_${messageID}`;
       }
       if (model)
         body.model = model;
@@ -2107,20 +3084,83 @@ function createRealHost(client, directory) {
     }
   };
 }
-function createV2Host(context, statuses) {
+function toWorkerCreation(result) {
+  return typeof result === "string" ? { sessionID: result } : result;
+}
+function createV2Host(context, statuses, options = {}) {
   const directory = context.location.directory;
   return {
-    async createWorker({ parentID, title, agent, model }) {
+    async createWorker({ parentID, title, agent, model, goalID }) {
+      if (options.native) {
+        let outcome;
+        try {
+          outcome = await options.native.requestWorker({
+            goalID,
+            parentSessionID: parentID,
+            title,
+            agent,
+            model,
+            directory
+          });
+        } catch (error) {
+          await logServerEvent(directory, "worker.create.native-failed", {
+            parentID,
+            title,
+            detail: describeError(error)
+          });
+          throw error;
+        }
+        if (outcome.kind === "native-child") {
+          const childID = outcome.childSessionID;
+          const child = await context.session.get({ sessionID: childID });
+          const actualParent = resolveNativeParentID(child);
+          if (actualParent !== parentID) {
+            const detail = `resolved-parent=${JSON.stringify(actualParent)} expected=${JSON.stringify(parentID)}`;
+            await logServerEvent(directory, "worker.create.parent-mismatch", { parentID, workerSessionID: childID, detail });
+            throw new Error(`loopd native worker creation failed for parent "${parentID}" (parent-mismatch): ${detail}`);
+          }
+          if (agent)
+            await context.session.switchAgent({ sessionID: childID, agent });
+          if (model) {
+            await context.session.switchModel({
+              sessionID: childID,
+              model: { id: model.modelID, providerID: model.providerID }
+            });
+          }
+          const rename = context.session.update;
+          if (rename)
+            await rename({ sessionID: childID, title });
+          statuses.set(childID, "idle");
+          await logServerEvent(directory, "worker.created", {
+            parentID,
+            workerSessionID: childID,
+            title,
+            topology: "v2-native-child",
+            nativeParentID: parentID
+          });
+          return { sessionID: childID, topology: "v2-native-child", nativeParentID: parentID };
+        }
+        await logServerEvent(directory, "worker.create.native-fallback", {
+          parentID,
+          title,
+          reason: outcome.kind === "fallback-safe" ? outcome.reason : "unclaimed"
+        });
+      }
       const session = await context.session.create({
         title,
-        agent,
-        model: model ? { id: model.modelID, providerID: model.providerID } : undefined,
+        ...agent !== undefined ? { agent } : {},
+        ...model !== undefined ? { model: { id: model.modelID, providerID: model.providerID } } : {},
         location: { directory },
         metadata: { "loopd.parentID": parentID }
       });
       statuses.set(session.id, "idle");
-      await logServerEvent(directory, "worker.created", { parentID, workerSessionID: session.id, title });
-      return session.id;
+      await logServerEvent(directory, "worker.created", {
+        parentID,
+        workerSessionID: session.id,
+        title,
+        topology: "v2-root-fallback"
+      });
+      return { sessionID: session.id, topology: "v2-root-fallback" };
     },
     async promptWorker({ sessionID, prompt, messageID, model, agent }) {
       if (agent)
@@ -2131,6 +3171,9 @@ function createV2Host(context, statuses) {
           model: { id: model.modelID, providerID: model.providerID }
         });
       }
+      if (messageID !== undefined && !isV2PromptMessageID(messageID)) {
+        throw new Error(`loopd prompt ID "${messageID}" is invalid for OpenCode v2: must start with "msg_". ` + `Generate IDs with newPromptMessageID() so persisted, delivered, and correlated IDs agree.`);
+      }
       const result = await context.session.prompt({
         sessionID,
         id: messageID,
@@ -2138,7 +3181,7 @@ function createV2Host(context, statuses) {
       });
       statuses.set(sessionID, "busy");
       await logServerEvent(directory, "worker.prompted", { sessionID });
-      return { messageID: result.id };
+      return { messageID: result?.id };
     },
     async readSession(sessionID) {
       try {
@@ -2235,16 +3278,18 @@ async function withTimeout(promise, timeoutMs, operation) {
 function createWorkerManager(host) {
   return {
     async createWorker(goal) {
-      const workerSessionID = await host.createWorker({
+      const created = toWorkerCreation(await host.createWorker({
         parentID: goal.ownerSessionID,
         title: `loopd: ${goal.name}`,
         agent: goal.config.agent,
-        model: parseModelRef(goal.config.model)
-      });
+        model: parseModelRef(goal.config.model),
+        goalID: goal.id
+      }));
       return {
         goalID: goal.id,
-        workerSessionID,
-        startedAt: new Date().toISOString()
+        workerSessionID: created.sessionID,
+        startedAt: new Date().toISOString(),
+        ...created.topology ? { topology: created.topology, nativeParentID: created.nativeParentID } : {}
       };
     },
     async continueWorker(worker, goal, runtime, context) {
@@ -2370,6 +3415,18 @@ function buildContinuationSteering(goal, runtime, context) {
 }
 
 // src/application/goal-service.ts
+class GoalStartError extends Error {
+  goalID;
+  workerSessionID;
+  failedStage;
+  constructor(message, info) {
+    super(message);
+    this.name = "GoalStartError";
+    this.goalID = info.goalID;
+    this.workerSessionID = info.workerSessionID;
+    this.failedStage = info.failedStage;
+  }
+}
 function createGoalService(host) {
   const workers = createWorkerManager(host);
   const sessions = new Map;
@@ -2391,12 +3448,13 @@ function createGoalService(host) {
         goalOperations.delete(goalID);
     }
   }
-  function assertWorkspaceWriteAvailable(state, goal) {
+  function assertWorkspaceWriteAvailable(state, goal, requesterSessionID) {
     if (!goal.config.workspaceWrite)
       return;
     const activeWriter = state.goals.find((item) => item.id !== goal.id && item.status === "active" && item.config.workspaceWrite);
     if (activeWriter) {
-      throw new Error(`Workspace-writing goal "${activeWriter.name}" (${activeWriter.id}) is already active. ` + "Pause, block, complete, or clear it before activating another workspace-writing goal.");
+      const ownedElsewhere = requesterSessionID !== undefined && activeWriter.ownerSessionID !== requesterSessionID;
+      throw new Error(`Workspace-writing goal "${activeWriter.name}" (${activeWriter.id}) is already active` + (ownedElsewhere ? ` (owned by session ${activeWriter.ownerSessionID}, not this session)` : "") + ". Pause, block, complete, or clear it before activating another workspace-writing goal." + (ownedElsewhere ? " Note: list_background_goals shows only this session's goals; clear/pause it from its owning session." : ""));
     }
   }
   async function recordPromptFailure(directory, goalID, error, blockImmediately = false) {
@@ -2436,7 +3494,7 @@ function createGoalService(host) {
     });
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID3(),
+      eventID: randomUUID5(),
       goalID,
       type: "run.failed",
       runID,
@@ -2448,7 +3506,7 @@ function createGoalService(host) {
     if (blocked) {
       await appendEvent(directory, {
         version: 1,
-        eventID: randomUUID3(),
+        eventID: randomUUID5(),
         goalID,
         type: "goal.blocked",
         reason: `Worker prompt delivery failed: ${detail}`,
@@ -2475,14 +3533,19 @@ function createGoalService(host) {
     sessions.set(goal.id, session);
     await mutateState(directory, `goal.set-worker:${goal.id}`, async (s) => {
       const persisted = s.goals.find((item) => item.id === goal.id);
-      if (persisted)
+      if (persisted) {
         persisted.workerSessionID = session.workerSessionID;
+        if (session.topology) {
+          persisted.workerTopology = session.topology;
+          persisted.nativeParentID = session.nativeParentID;
+        }
+      }
       return s;
     });
     return session;
   }
   async function start(directory, input) {
-    const id = randomUUID3();
+    const id = randomUUID5();
     return withGoalOperation(id, () => startUnlocked(directory, input, id));
   }
   async function startUnlocked(directory, input, id) {
@@ -2521,7 +3584,7 @@ function createGoalService(host) {
       goal.config.progressFile = path2.join(artifactDir, "progress.md");
     await ensureGoalArtifactDir(directory, id);
     const state1 = await mutateState(directory, `goal.create:${id}`, async (state) => {
-      assertWorkspaceWriteAvailable(state, goal);
+      assertWorkspaceWriteAvailable(state, goal, goal.ownerSessionID);
       state.goals.push(goal);
       const rt = createRuntimeState(id);
       if (goal.config.schedule) {
@@ -2562,7 +3625,7 @@ function createGoalService(host) {
       });
       await appendEvent(directory, {
         version: 1,
-        eventID: randomUUID3(),
+        eventID: randomUUID5(),
         goalID: id,
         type: "goal.blocked",
         reason: detail,
@@ -2571,7 +3634,7 @@ function createGoalService(host) {
         revision: blockedState.revision
       });
       await logServerEvent(directory, "goal.start.failed", { goalID: id, ownerSessionID: input.ownerSessionID, detail });
-      throw error;
+      throw new GoalStartError(detail, { goalID: id, failedStage: "worker_create" });
     }
     sessions.set(id, worker);
     const state2 = await mutateState(directory, `goal.worker-assign:${id}`, async (state) => {
@@ -2580,11 +3643,17 @@ function createGoalService(host) {
         return state;
       g.workerSessionID = worker.workerSessionID;
       goal.workerSessionID = worker.workerSessionID;
+      if (worker.topology) {
+        g.workerTopology = worker.topology;
+        g.nativeParentID = worker.nativeParentID;
+        goal.workerTopology = worker.topology;
+        goal.nativeParentID = worker.nativeParentID;
+      }
       const rt = state.runtimes.find((item) => item.goalID === id);
       if (rt) {
         Object.assign(rt, acquireLease(rt, g.config.timeoutMs || 300000));
-        rt.activeRunID = randomUUID3();
-        rt.activePromptMessageID = `msg-${randomUUID3()}`;
+        rt.activeRunID = randomUUID5();
+        rt.activePromptMessageID = newPromptMessageID();
         rt.runCount = 1;
         rt.budgetTurnCount = 1;
         rt.lastRunAt = new Date().toISOString();
@@ -2594,7 +3663,7 @@ function createGoalService(host) {
     runtime = state2.runtimes.find((r) => r.goalID === id);
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID3(),
+      eventID: randomUUID5(),
       goalID: id,
       type: "goal.created",
       name: input.name,
@@ -2606,7 +3675,7 @@ function createGoalService(host) {
     if (runtime) {
       await appendEvent(directory, {
         version: 1,
-        eventID: randomUUID3(),
+        eventID: randomUUID5(),
         goalID: id,
         type: "run.started",
         runID: runtime.activeRunID,
@@ -2618,7 +3687,11 @@ function createGoalService(host) {
         await workers.continueWorker(worker, goal, runtime);
       } catch (error) {
         await recordPromptFailure(directory, id, error, true);
-        throw error;
+        throw new GoalStartError(describeError(error), {
+          goalID: id,
+          workerSessionID: worker.workerSessionID,
+          failedStage: "prompt_delivery"
+        });
       }
     }
     return { goal, worker };
@@ -2715,8 +3788,8 @@ function createGoalService(host) {
         return s;
       const timeoutMs = g.config.timeoutMs || 300000;
       Object.assign(rt, acquireLease(rt, timeoutMs));
-      rt.activeRunID = randomUUID3();
-      rt.activePromptMessageID = `msg-${randomUUID3()}`;
+      rt.activeRunID = randomUUID5();
+      rt.activePromptMessageID = newPromptMessageID();
       rt.runCount += 1;
       if (rt.freeRetryPending) {
         rt.freeRetryPending = false;
@@ -2733,7 +3806,7 @@ function createGoalService(host) {
       return;
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID3(),
+      eventID: randomUUID5(),
       goalID,
       type: "run.started",
       runID: freshRuntime.activeRunID,
@@ -2819,8 +3892,10 @@ function createGoalService(host) {
       g.status = "paused";
       g.updatedAt = new Date().toISOString();
       const rt = s.runtimes.find((r) => r.goalID === goalID);
-      if (rt)
+      if (rt) {
         Object.assign(rt, releaseLease(rt));
+        rt.activeRunID = undefined;
+      }
       return s;
     });
     const session = sessions.get(goalID) || (goal.workerSessionID ? {
@@ -2832,9 +3907,10 @@ function createGoalService(host) {
       await workers.abortWorker(session.workerSessionID);
       sessions.delete(goalID);
     }
+    await cancelAwaitsForGoal(directory, goalID, "goal paused").catch(() => {});
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID3(),
+      eventID: randomUUID5(),
       goalID,
       type: "goal.status_changed",
       from: "active",
@@ -2851,7 +3927,7 @@ function createGoalService(host) {
         return state;
       if (!canTransition(goal.status, "active", "user"))
         return state;
-      assertWorkspaceWriteAvailable(state, goal);
+      assertWorkspaceWriteAvailable(state, goal, goal.ownerSessionID);
       goal.status = "active";
       goal.updatedAt = new Date().toISOString();
       resumed = true;
@@ -2873,7 +3949,7 @@ function createGoalService(host) {
     }
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID3(),
+      eventID: randomUUID5(),
       goalID,
       type: "goal.status_changed",
       from: "paused",
@@ -2889,7 +3965,7 @@ function createGoalService(host) {
       const goal = state.goals.find((g) => g.id === goalID);
       if (!goal || goal.status !== "blocked")
         return state;
-      assertWorkspaceWriteAvailable(state, goal);
+      assertWorkspaceWriteAvailable(state, goal, goal.ownerSessionID);
       goal.status = "active";
       goal.updatedAt = new Date().toISOString();
       retried = true;
@@ -2925,7 +4001,7 @@ function createGoalService(host) {
     }
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID3(),
+      eventID: randomUUID5(),
       goalID,
       type: "goal.status_changed",
       from: "blocked",
@@ -2952,11 +4028,12 @@ function createGoalService(host) {
     await mutateState(directory, `goal.clear:${goalID}`, async (s) => {
       s.goals = s.goals.filter((g) => g.id !== goalID);
       s.runtimes = s.runtimes.filter((r) => r.goalID !== goalID);
+      s.commandAwaits = (s.commandAwaits ?? []).filter((a) => a.goalID !== goalID);
       return s;
     });
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID3(),
+      eventID: randomUUID5(),
       goalID,
       type: "goal.cleared",
       timestamp: new Date().toISOString(),
@@ -3009,6 +4086,10 @@ function createGoalService(host) {
           const g = s.goals.find((item) => item.id === goal.id);
           if (g) {
             g.workerSessionID = worker.workerSessionID;
+            if (worker.topology) {
+              g.workerTopology = worker.topology;
+              g.nativeParentID = worker.nativeParentID;
+            }
             g.updatedAt = new Date().toISOString();
           }
           return s;
@@ -3164,7 +4245,7 @@ function createGoalService(host) {
 
 // src/application/schedule-worker.ts
 init_state_repository();
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 function createScheduleWorker(options) {
   const { directory, goalService } = options;
   const intervalMs = options.intervalMs ?? 5000;
@@ -3184,102 +4265,2348 @@ function createScheduleWorker(options) {
       clearInterval(timer);
     timer = undefined;
   }
-  function isRunning() {
-    return running;
+  function isRunning() {
+    return running;
+  }
+  async function tick() {
+    const state = await readState(directory);
+    let resurrected = 0;
+    for (const goal of state.goals) {
+      const schedule = goal.config.schedule;
+      if (!schedule || typeof schedule.everyMs !== "number" || schedule.everyMs < 1000)
+        continue;
+      const runtime = state.runtimes.find((r) => r.goalID === goal.id);
+      if (!runtime)
+        continue;
+      if (goal.status !== "complete")
+        continue;
+      const count = runtime.scheduleRunCount ?? 0;
+      const max = schedule.maxRuns;
+      if (typeof max === "number" && count >= max)
+        continue;
+      const nextAt = runtime.nextRunAt;
+      if (!nextAt)
+        continue;
+      if (Date.now() < Date.parse(nextAt))
+        continue;
+      const activeWriter = state.goals.find((g) => g.id !== goal.id && g.status === "active" && g.config.workspaceWrite);
+      if (goal.config.workspaceWrite && activeWriter) {
+        await logServerEvent(directory, "schedule.skipped-writer-active", {
+          goalID: goal.id,
+          activeWriter: activeWriter.id
+        });
+        continue;
+      }
+      if (runtime.phase === "running" || runtime.phase === "queued" || runtime.phase === "compacting")
+        continue;
+      if (leaseIsValid(runtime))
+        continue;
+      const didResurrect = await mutateState(directory, `schedule.tick:${goal.id}`, async (s) => {
+        const g = s.goals.find((x) => x.id === goal.id);
+        const rt = s.runtimes.find((x) => x.goalID === goal.id);
+        if (!g || !rt)
+          return s;
+        if (g.status !== "complete")
+          return s;
+        const curCount = rt.scheduleRunCount ?? 0;
+        if (typeof max === "number" && curCount >= max)
+          return s;
+        const curNext = rt.nextRunAt;
+        if (!curNext || Date.now() < Date.parse(curNext))
+          return s;
+        g.status = "active";
+        g.updatedAt = new Date().toISOString();
+        g.blocker = undefined;
+        Object.assign(rt, releaseLease(rt));
+        rt.activeRunID = undefined;
+        rt.consecutiveFailures = 0;
+        rt.noProgressCount = 0;
+        rt.progressDuringTurn = false;
+        rt.forceFinishRequested = undefined;
+        rt.lastError = undefined;
+        rt.lastScheduleAt = new Date().toISOString();
+        rt.updatedAt = new Date().toISOString();
+        return s;
+      });
+      const after = didResurrect.goals.find((g) => g.id === goal.id);
+      if (!after || after.status !== "active")
+        continue;
+      await appendEvent(directory, {
+        version: 1,
+        eventID: randomUUID6(),
+        goalID: goal.id,
+        type: "schedule.tick",
+        scheduleRunCount: count,
+        nextRunAt: nextAt,
+        timestamp: new Date().toISOString(),
+        revision: didResurrect.revision
+      });
+      await logServerEvent(directory, "schedule.resurrected", {
+        goalID: goal.id,
+        scheduleRunCount: count,
+        nextRunAt: nextAt
+      });
+      const maxLabel = typeof max === "number" ? `/${max}` : "";
+      await appendGoalInbox(directory, goal.id, "user", `Scheduled tick ${count + 1}${maxLabel} \u2014 re-execute the objective now. Previous completion: ${runtime.scheduleRunCount ?? 0} runs. Ensure artifact checks pass for this tick (e.g., append timestamp to tick.txt).`);
+      try {
+        await goalService.continueTurn(directory, goal.id);
+        resurrected++;
+      } catch {}
+    }
+    return resurrected;
+  }
+  return { start, stop, isRunning, tick };
+}
+
+// src/v2/native-server.ts
+import { randomUUID as randomUUID7 } from "crypto";
+
+// src/v2/native-bridge.ts
+class NativeBridgeError extends Error {
+  code;
+  requestID;
+  constructor(code, requestID, message) {
+    super(message);
+    this.name = "NativeBridgeError";
+    this.code = code;
+    this.requestID = requestID;
+  }
+}
+function createNativeBridge(options = {}) {
+  const claimTimeoutMs = options.claimTimeoutMs ?? CLAIM_TIMEOUT_MS;
+  const claimedTimeoutMs = options.claimedTimeoutMs ?? CLAIMED_TIMEOUT_MS;
+  const pending = new Map;
+  let disposed = false;
+  function settle(requestID, settleFn) {
+    const entry = pending.get(requestID);
+    if (!entry || entry.state === "settled")
+      return false;
+    entry.state = "settled";
+    if (entry.claimTimer)
+      clearTimeout(entry.claimTimer);
+    if (entry.claimedTimer)
+      clearTimeout(entry.claimedTimer);
+    pending.delete(requestID);
+    settleFn(entry);
+    return true;
+  }
+  return {
+    pendingCount: () => pending.size,
+    isDisposed: () => disposed,
+    requestWorker(request, emit) {
+      if (disposed) {
+        return Promise.reject(new NativeBridgeError("disposed", request.requestID, "native bridge is disposed"));
+      }
+      return new Promise((resolve, reject) => {
+        const entry = { state: "awaiting-claim", resolve, reject };
+        pending.set(request.requestID, entry);
+        let emitResult;
+        try {
+          emitResult = emit(request);
+        } catch {
+          settle(request.requestID, (e) => e.resolve({ kind: "unclaimed" }));
+          return;
+        }
+        const afterEmit = () => {
+          const live = pending.get(request.requestID);
+          if (!live || live.state !== "awaiting-claim")
+            return;
+          live.claimTimer = setTimeout(() => {
+            settle(request.requestID, (e) => e.resolve({ kind: "unclaimed" }));
+          }, claimTimeoutMs);
+          if (typeof live.claimTimer?.unref === "function")
+            live.claimTimer.unref();
+        };
+        if (emitResult && typeof emitResult.then === "function") {
+          emitResult.then(afterEmit, () => {
+            settle(request.requestID, (e) => e.resolve({ kind: "unclaimed" }));
+          });
+        } else {
+          afterEmit();
+        }
+      });
+    },
+    handleClaim(claim) {
+      const entry = pending.get(claim.requestID);
+      if (!entry || entry.state !== "awaiting-claim")
+        return { won: false };
+      entry.state = "claimed";
+      entry.claimantID = claim.claimantID;
+      if (entry.claimTimer)
+        clearTimeout(entry.claimTimer);
+      entry.claimedTimer = setTimeout(() => {
+        settle(claim.requestID, (e) => e.reject(new NativeBridgeError("claimed-timeout", claim.requestID, `claimant "${claim.claimantID}" vanished before completing worker creation; failing startup rather than duplicating`)));
+      }, claimedTimeoutMs);
+      if (typeof entry.claimedTimer?.unref === "function")
+        entry.claimedTimer.unref();
+      return { won: true };
+    },
+    handleComplete(result) {
+      return settle(result.requestID, (entry) => entry.resolve({
+        kind: "native-child",
+        childSessionID: result.childSessionID,
+        parentSessionID: result.parentSessionID,
+        topology: "v2-native-child"
+      }));
+    },
+    handleFailure(failure) {
+      if (failure.preCreation) {
+        return settle(failure.requestID, (entry) => entry.resolve({ kind: "fallback-safe", reason: failure.reason, detail: failure.detail }));
+      }
+      return settle(failure.requestID, (entry) => entry.reject(new NativeBridgeError(failure.reason === "parent-mismatch" ? "parent-mismatch" : "fork-failed", failure.requestID, `native worker creation failed post-creation (${failure.reason}): ${failure.detail ?? "no detail"}`)));
+    },
+    dispose() {
+      disposed = true;
+      const ids = [...pending.keys()];
+      for (const id of ids) {
+        settle(id, (entry) => entry.reject(new NativeBridgeError("disposed", id, "native bridge disposed with request pending")));
+      }
+    }
+  };
+}
+
+// src/v2/native-server.ts
+async function setupNativeServer(context) {
+  if (!context || !context.rpc || typeof context.rpc.register !== "function")
+    return;
+  const bridge = createNativeBridge();
+  let registration;
+  try {
+    registration = await context.rpc.register(nativeRpcDefinition, {
+      claimRequest: async (input) => {
+        const { won } = bridge.handleClaim(input);
+        return { requestID: input.requestID, claimantID: input.claimantID, won };
+      },
+      completeWorkerCreate: async (input) => {
+        bridge.handleComplete(input);
+        return {};
+      },
+      failRequest: async (input) => {
+        bridge.handleFailure(input);
+        return {};
+      }
+    });
+  } catch {
+    bridge.dispose();
+    return;
+  }
+  if (!registration || !registration.events || typeof registration.events.emit !== "function") {
+    bridge.dispose();
+    try {
+      await registration?.dispose();
+    } catch {}
+    return;
+  }
+  return {
+    bridge,
+    requestWorker: async (input) => {
+      const request = {
+        requestID: `req_${randomUUID7()}`,
+        goalID: input.goalID ?? "",
+        parentSessionID: input.parentSessionID,
+        title: input.title,
+        ...input.agent ? { agent: input.agent } : {},
+        ...input.model ? { model: { id: input.model.modelID, providerID: input.model.providerID } } : {},
+        directory: input.directory
+      };
+      return bridge.requestWorker(request, (req) => registration.events.emit("workerCreateRequested", req));
+    },
+    dispose: async () => {
+      bridge.dispose();
+      try {
+        await registration.dispose();
+      } catch {}
+    }
+  };
+}
+
+// src/server/command-host.ts
+import { createRequire } from "module";
+var COMMAND_HOST_CAPABILITIES = {
+  spawn: true,
+  write: true,
+  interruptSignal: true,
+  terminate: true,
+  resize: false,
+  terminalEmulation: false
+};
+var PTY_HOST_CAPABILITIES = {
+  spawn: true,
+  write: true,
+  interruptSignal: true,
+  terminate: true,
+  resize: true,
+  terminalEmulation: false
+};
+function createLocalProcessHost() {
+  return {
+    capabilities: COMMAND_HOST_CAPABILITIES,
+    spawn(opts, onOutput, onExit) {
+      const proc = Bun.spawn([opts.command, ...opts.args ?? []], {
+        cwd: opts.cwd,
+        env: { ...process.env, ...opts.env ?? {} },
+        stdin: "pipe",
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      let settled = false;
+      let signal;
+      const exitPromise = (async () => {
+        const pumps = [pumpStream(proc.stdout, onOutput), pumpStream(proc.stderr, onOutput)];
+        const code = await proc.exited;
+        await Promise.allSettled(pumps);
+        settled = true;
+        const info = { exitCode: code ?? 0, signal };
+        onExit(info);
+        return info;
+      })();
+      return {
+        pid: proc.pid,
+        write(data) {
+          try {
+            proc.stdin.write(data);
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        interrupt() {
+          try {
+            signal = "SIGINT";
+            proc.kill("SIGINT");
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        terminate() {
+          try {
+            if (!signal)
+              signal = "SIGTERM";
+            proc.kill("SIGTERM");
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        kill() {
+          try {
+            signal = "SIGKILL";
+            proc.kill("SIGKILL");
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        resize() {
+          return false;
+        },
+        isAlive() {
+          if (settled)
+            return false;
+          try {
+            process.kill(proc.pid, 0);
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        exited() {
+          return exitPromise;
+        }
+      };
+    },
+    livePids() {
+      return new Set;
+    }
+  };
+}
+async function pumpStream(stream, onOutput) {
+  if (!stream)
+    return;
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  try {
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      if (value && value.length > 0)
+        onOutput(decoder.decode(value, { stream: true }));
+    }
+    const rest = decoder.decode();
+    if (rest)
+      onOutput(rest);
+  } catch {} finally {
+    try {
+      reader.releaseLock();
+    } catch {}
+  }
+}
+function loadBunPty() {
+  return createRequire(import.meta.url)("bun-pty");
+}
+function asBunPtyModule(loaded) {
+  const spawn = loaded?.spawn;
+  if (typeof spawn !== "function")
+    throw new Error("bun-pty module has no spawn() export");
+  return { spawn };
+}
+function createPtyHost(load = loadBunPty) {
+  const { spawn } = asBunPtyModule(load());
+  return {
+    capabilities: PTY_HOST_CAPABILITIES,
+    spawn(opts, onOutput, onExit) {
+      const pty = spawn(opts.command, opts.args ?? [], {
+        name: "xterm-256color",
+        cols: opts.cols ?? 80,
+        rows: opts.rows ?? 24,
+        cwd: opts.cwd,
+        env: { ...process.env, ...opts.env ?? {}, TERM: "xterm-256color" }
+      });
+      let settled = false;
+      let killedSignal;
+      let resolveExit;
+      const exitPromise = new Promise((r) => {
+        resolveExit = r;
+      });
+      pty.onData((data) => {
+        onOutput(data);
+      });
+      pty.onExit((event) => {
+        if (settled)
+          return;
+        settled = true;
+        const raw = event?.signal;
+        const info = {
+          exitCode: event?.exitCode ?? 0,
+          signal: typeof raw === "string" ? raw : raw == null ? killedSignal : String(raw)
+        };
+        onExit(info);
+        resolveExit(info);
+      });
+      return {
+        pid: pty.pid,
+        write(data) {
+          if (settled)
+            return false;
+          try {
+            pty.write(data);
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        interrupt() {
+          if (settled)
+            return false;
+          try {
+            pty.write("\x03");
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        terminate() {
+          if (settled)
+            return false;
+          try {
+            killedSignal ??= "SIGTERM";
+            pty.kill();
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        kill() {
+          if (settled)
+            return false;
+          try {
+            killedSignal = "SIGKILL";
+            pty.kill("SIGKILL");
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        resize(cols, rows) {
+          if (!Number.isInteger(cols) || !Number.isInteger(rows) || cols <= 0 || rows <= 0)
+            return false;
+          if (settled)
+            return false;
+          try {
+            pty.resize(cols, rows);
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        isAlive() {
+          if (settled)
+            return false;
+          try {
+            process.kill(pty.pid, 0);
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        exited() {
+          return exitPromise;
+        }
+      };
+    },
+    livePids() {
+      return new Set;
+    }
+  };
+}
+function createCommandHost(opts) {
+  try {
+    return Object.assign(createPtyHost(opts?.load ?? loadBunPty), { backend: "pty" });
+  } catch {
+    return Object.assign(createLocalProcessHost(), { backend: "pipe" });
+  }
+}
+
+// src/application/command-service.ts
+import { randomUUID as randomUUID8 } from "crypto";
+import { promises as fs3 } from "fs";
+import path3 from "path";
+
+// src/domain/command-session.ts
+function normalizeTimeoutSeconds(timeoutSeconds) {
+  if (timeoutSeconds === undefined)
+    return;
+  if (!Number.isInteger(timeoutSeconds) || timeoutSeconds <= 0) {
+    throw new Error("timeoutSeconds must be a positive integer in seconds");
+  }
+  return timeoutSeconds;
+}
+function computeDeadlineAt(from, timeoutSeconds) {
+  return new Date(from.getTime() + timeoutSeconds * 1000).toISOString();
+}
+function createCommandSession(input) {
+  const now = new Date().toISOString();
+  const timeout = normalizeTimeoutSeconds(input.timeoutSeconds);
+  return {
+    id: input.id,
+    title: input.title,
+    command: input.command,
+    args: input.args ?? [],
+    shell: input.shell,
+    endReason: input.endReason,
+    timeoutSeconds: timeout,
+    deadlineAt: input.deadlineAt ?? (timeout !== undefined ? computeDeadlineAt(new Date(now), timeout) : undefined),
+    envKeys: input.envKeys,
+    watchFilter: input.watchFilter,
+    watchUntil: input.watchUntil,
+    watchIgnoreCase: input.watchIgnoreCase,
+    watchUntilAction: input.watchUntilAction,
+    watchState: input.watchState,
+    cwd: input.cwd,
+    ownerSessionID: input.ownerSessionID,
+    goalID: input.goalID,
+    notifyOnExit: input.notifyOnExit,
+    status: "running",
+    pid: input.pid,
+    cols: input.cols,
+    rows: input.rows,
+    outputBytes: 0,
+    streamBytes: 0,
+    truncated: false,
+    createdAt: now,
+    updatedAt: now
+  };
+}
+var MAX_COMMAND_OUTPUT_BYTES = 512 * 1024;
+var MAX_COMMAND_READ_LINES = 500;
+var NOTIFY_LONG_RUNNING_MS = 2 * 60 * 1000;
+function shouldNotifyOwnerOnExit(session) {
+  if (session.endReason === "until")
+    return false;
+  if (session.notifyOnExit === false)
+    return false;
+  if (session.notifyOnExit === true)
+    return true;
+  if (session.endReason === "timeout")
+    return true;
+  if (session.status === "missing")
+    return true;
+  if (session.status === "terminated")
+    return false;
+  if (session.status !== "exited")
+    return false;
+  if (session.exitCode !== undefined && session.exitCode !== 0)
+    return true;
+  const started = Date.parse(session.createdAt);
+  const ended = session.endedAt ? Date.parse(session.endedAt) : Date.now();
+  if (!Number.isFinite(started) || !Number.isFinite(ended))
+    return false;
+  return ended - started >= NOTIFY_LONG_RUNNING_MS;
+}
+
+// src/application/command-service.ts
+init_command_watch();
+init_command_await();
+
+// src/domain/command-events.ts
+var _encoder = new TextEncoder;
+function utf8ByteLength(data) {
+  return _encoder.encode(data).length;
+}
+function expectedNextEnd(startOffset, data) {
+  return startOffset + utf8ByteLength(data);
+}
+var VALID_STATUSES = [
+  "running",
+  "exited",
+  "terminated",
+  "missing"
+];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isNonNegativeInt(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function isCommandSessionLike(value) {
+  if (!isRecord(value))
+    return false;
+  if (typeof value["id"] !== "string" || value["id"].length === 0)
+    return false;
+  if (typeof value["title"] !== "string")
+    return false;
+  if (typeof value["command"] !== "string")
+    return false;
+  if (typeof value["cwd"] !== "string")
+    return false;
+  if (typeof value["ownerSessionID"] !== "string")
+    return false;
+  if (typeof value["status"] !== "string")
+    return false;
+  if (!VALID_STATUSES.includes(value["status"]))
+    return false;
+  if (!isNonNegativeInt(value["outputBytes"]))
+    return false;
+  if (typeof value["truncated"] !== "boolean")
+    return false;
+  if (typeof value["createdAt"] !== "string")
+    return false;
+  if (typeof value["updatedAt"] !== "string")
+    return false;
+  if (value["args"] !== undefined && !Array.isArray(value["args"]))
+    return false;
+  if (value["streamBytes"] !== undefined && !isNonNegativeInt(value["streamBytes"]))
+    return false;
+  return true;
+}
+function checkOffsets(startOffset, endOffset, data) {
+  if (typeof data !== "string")
+    return "data must be a string";
+  if (!isNonNegativeInt(startOffset))
+    return "startOffset must be a non-negative integer";
+  if (!isNonNegativeInt(endOffset))
+    return "endOffset must be a non-negative integer";
+  if (endOffset < startOffset)
+    return "endOffset must be >= startOffset";
+  const expected = expectedNextEnd(startOffset, data);
+  if (endOffset !== expected)
+    return `endOffset mismatch: expected ${expected} (startOffset + UTF-8 byte length ${expected - startOffset}), got ${endOffset}`;
+  return null;
+}
+function validateCommandStreamMessage(value) {
+  try {
+    if (!isRecord(value))
+      return { ok: false, error: "message must be an object" };
+    const type = value["type"];
+    if (typeof type !== "string")
+      return { ok: false, error: "missing type field" };
+    switch (type) {
+      case "subscribe": {
+        if (!isNonEmptyString(value["commandID"]))
+          return { ok: false, error: "subscribe.commandID must be a non-empty string" };
+        if (!isNonEmptyString(value["ownerSessionID"]))
+          return { ok: false, error: "subscribe.ownerSessionID must be a non-empty string" };
+        return {
+          ok: true,
+          message: {
+            type: "subscribe",
+            commandID: value["commandID"],
+            ownerSessionID: value["ownerSessionID"]
+          }
+        };
+      }
+      case "snapshot": {
+        if (!isCommandSessionLike(value["command"]))
+          return { ok: false, error: "snapshot.command must be CommandSession metadata" };
+        const offsetError = checkOffsets(value["startOffset"], value["endOffset"], value["data"]);
+        if (offsetError)
+          return { ok: false, error: `snapshot.${offsetError}` };
+        return {
+          ok: true,
+          message: {
+            type: "snapshot",
+            command: value["command"],
+            data: value["data"],
+            startOffset: value["startOffset"],
+            endOffset: value["endOffset"]
+          }
+        };
+      }
+      case "output": {
+        if (!isNonEmptyString(value["commandID"]))
+          return { ok: false, error: "output.commandID must be a non-empty string" };
+        const offsetError = checkOffsets(value["startOffset"], value["endOffset"], value["data"]);
+        if (offsetError)
+          return { ok: false, error: `output.${offsetError}` };
+        return {
+          ok: true,
+          message: {
+            type: "output",
+            commandID: value["commandID"],
+            data: value["data"],
+            startOffset: value["startOffset"],
+            endOffset: value["endOffset"]
+          }
+        };
+      }
+      case "status": {
+        if (!isCommandSessionLike(value["command"]))
+          return { ok: false, error: "status.command must be CommandSession metadata" };
+        return { ok: true, message: { type: "status", command: value["command"] } };
+      }
+      case "input": {
+        if (!isNonEmptyString(value["commandID"]))
+          return { ok: false, error: "input.commandID must be a non-empty string" };
+        if (typeof value["data"] !== "string")
+          return { ok: false, error: "input.data must be a string" };
+        return {
+          ok: true,
+          message: { type: "input", commandID: value["commandID"], data: value["data"] }
+        };
+      }
+      case "interrupt": {
+        if (!isNonEmptyString(value["commandID"]))
+          return { ok: false, error: "interrupt.commandID must be a non-empty string" };
+        return { ok: true, message: { type: "interrupt", commandID: value["commandID"] } };
+      }
+      case "resync": {
+        if (!isNonEmptyString(value["commandID"]))
+          return { ok: false, error: "resync.commandID must be a non-empty string" };
+        return { ok: true, message: { type: "resync", commandID: value["commandID"] } };
+      }
+      case "unsubscribe": {
+        if (!isNonEmptyString(value["commandID"]))
+          return { ok: false, error: "unsubscribe.commandID must be a non-empty string" };
+        return { ok: true, message: { type: "unsubscribe", commandID: value["commandID"] } };
+      }
+      case "error": {
+        if (!isNonEmptyString(value["code"]))
+          return { ok: false, error: "error.code must be a non-empty string" };
+        if (typeof value["message"] !== "string")
+          return { ok: false, error: "error.message must be a string" };
+        return {
+          ok: true,
+          message: { type: "error", code: value["code"], message: value["message"] }
+        };
+      }
+      default:
+        return { ok: false, error: `unknown message type: ${type}` };
+    }
+  } catch (err) {
+    return { ok: false, error: `validation failed: ${String(err)}` };
+  }
+}
+
+// src/application/command-service.ts
+init_command_await2();
+init_state_repository();
+var ANSI_PATTERN2 = new RegExp("\x1B\\[[0-9;?]*[ -/]*[@-~]|\x1B\\][^\x07]*(?:\x07|\x1B\\\\)|\x1B[()][0-9A-Z]", "g");
+function stripAnsiForMatch(line) {
+  return line.replace(ANSI_PATTERN2, "");
+}
+var DANGEROUS_REGEXES2 = [
+  /\(\?:.*\)\*.*\(\?:.*\)\*/,
+  /.*\(\.\*\?\)\{2,\}.*/,
+  /.*\(.*\|.*\)\{3,\}.*/,
+  /\([^()]*[+*][^()]*\)[+*]/,
+  /\([^()]*(\.\*.*\.\*|\.\+.*\.\+|\\w\+.*\\s\*|\\s\*.*\\w\+)[^()]*\)/
+];
+function validateReadPattern(pattern) {
+  let compiled;
+  try {
+    compiled = new RegExp(pattern);
+  } catch (e) {
+    return { error: `Invalid regex pattern '${pattern}': ${e instanceof Error ? e.message : String(e)}` };
+  }
+  if (DANGEROUS_REGEXES2.some((d) => d.test(pattern))) {
+    return { error: `Potentially dangerous regex pattern rejected: '${pattern}'. Please use a safer pattern.` };
+  }
+  return compiled;
+}
+function shellQuote(word) {
+  if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(word))
+    return word;
+  return `'${word.replace(/'/g, `'\\''`)}'`;
+}
+function shellJoin(command, args) {
+  return [command, ...args].map(shellQuote).join(" ");
+}
+function loopCommandsDir(directory) {
+  return path3.join(directory, ".opencode", "loopd", "commands");
+}
+function createCommandService(host, opts) {
+  const live = new Map;
+  const operations = new Map;
+  const broker = opts?.broker;
+  const commandDirs = new Map;
+  const timeouts = new Map;
+  const timeoutOwners = new Map;
+  const watchers = new Map;
+  const watchTimers = new Map;
+  const awaitAsm = new Map;
+  const watchCoalesceMs = opts?.watchCoalesceMs ?? WATCH_COALESCE_WINDOW_MS;
+  function clearWatchTimer(id) {
+    const t = watchTimers.get(id);
+    if (t) {
+      try {
+        globalThis.clearTimeout(t);
+      } catch {}
+    }
+    watchTimers.delete(id);
+  }
+  function deleteWatch(id) {
+    clearWatchTimer(id);
+    watchers.delete(id);
+    awaitAsm.delete(id);
+  }
+  function scheduleWatchFlush(directory, id) {
+    if (watchTimers.has(id))
+      return;
+    const handle = setTimeout(() => {
+      watchTimers.delete(id);
+      enqueue(id, () => flushWatch(directory, id)).catch(() => {});
+    }, Math.max(0, watchCoalesceMs));
+    try {
+      handle.unref?.();
+    } catch {}
+    watchTimers.set(id, handle);
+  }
+  async function persistWatchState(directory, id, state) {
+    await mutateState(directory, `cmd.watch:${id}`, async (s) => {
+      const c = (s.commands ?? []).find((x) => x.id === id);
+      if (c) {
+        c.watchState = { ...state };
+        c.updatedAt = new Date().toISOString();
+      }
+      return s;
+    });
+  }
+  function watchLedger(directory, commandID, type, extra) {
+    return appendEvent(directory, {
+      version: 1,
+      eventID: randomUUID8(),
+      commandID,
+      type,
+      timestamp: new Date().toISOString(),
+      revision: 0,
+      ...extra
+    }).catch(() => {});
+  }
+  function clearCommandTimeout(id) {
+    const t = timeouts.get(id);
+    if (t) {
+      try {
+        globalThis.clearTimeout(t);
+      } catch {}
+    }
+    timeouts.delete(id);
+    timeoutOwners.delete(id);
+  }
+  function scheduleTimeout(directory, id, ownerSessionID, timeoutSeconds) {
+    clearCommandTimeout(id);
+    const handle = setTimeout(() => {
+      timeouts.delete(id);
+      fireTimeout(directory, id).catch(() => {});
+    }, timeoutSeconds * 1000);
+    try {
+      handle.unref?.();
+    } catch {}
+    timeouts.set(id, handle);
+    timeoutOwners.set(id, { directory, ownerSessionID });
+  }
+  async function fireTimeout(directory, id) {
+    const owner = timeoutOwners.get(id)?.ownerSessionID;
+    timeoutOwners.delete(id);
+    if (!owner)
+      return;
+    const before = await readState(directory).then((s) => (s.commands ?? []).find((x) => x.id === id));
+    if (!before || before.status !== "running")
+      return;
+    await service.terminate(directory, id, owner).catch(() => {});
+    await mutateState(directory, `cmd.timeout:${id}`, async (s) => {
+      const c = (s.commands ?? []).find((x) => x.id === id);
+      if (!c)
+        return s;
+      c.endReason = "timeout";
+      c.lastError = c.lastError ?? `Command timed out after ${c.timeoutSeconds ?? "?"}s (timeoutSeconds deadline reached; terminated via the standard SIGTERM\u2192SIGKILL path).`;
+      if (!c.endedAt) {
+        c.endedAt = new Date().toISOString();
+        c.updatedAt = c.endedAt;
+      } else {
+        c.updatedAt = new Date().toISOString();
+      }
+      return s;
+    }).catch(() => {});
+    try {
+      const fresh = await readState(directory).then((st) => (st.commands ?? []).find((x) => x.id === id));
+      if (fresh)
+        emitBroker(id, { type: "status", command: fresh });
+    } catch {}
+    await fireAwaits(directory, id);
+    await notifyOwnerIfNeeded(directory, id);
+  }
+  function tailText(entry, limitBytes = 64 * 1024) {
+    let want = limitBytes;
+    const parts = [];
+    for (let i = entry.buffers.length - 1;i >= 0 && want > 0; i--) {
+      const chunk = entry.buffers[i];
+      if (!chunk)
+        continue;
+      parts.unshift(chunk.subarray(Math.max(0, chunk.length - want)));
+      want -= chunk.length;
+    }
+    return Buffer.concat(parts).toString("utf8");
+  }
+  function enqueue(id, operation) {
+    const previous = operations.get(id) ?? Promise.resolve();
+    const next = previous.then(operation, operation);
+    operations.set(id, next);
+    next.finally(() => {
+      if (operations.get(id) === next)
+        operations.delete(id);
+    }).catch(() => {});
+    return next;
+  }
+  async function waitForOperations(id) {
+    await operations.get(id)?.catch(() => {});
+  }
+  function emitBroker(commandID, message) {
+    if (!broker)
+      return;
+    try {
+      broker.publish(commandID, message);
+    } catch {}
+  }
+  function rememberDir(id, directory) {
+    commandDirs.set(id, directory);
+  }
+  async function fireAwaits(directory, id) {
+    try {
+      const fired = await fireCommandAwaits(directory, id);
+      if (fired.length === 0)
+        return;
+      await opts?.onAwaitFired?.(directory, fired);
+    } catch {}
+  }
+  async function notifyOwnerIfNeeded(directory, id) {
+    try {
+      let target;
+      await mutateState(directory, `cmd.notify-claim:${id}`, async (s) => {
+        const c = (s.commands ?? []).find((x) => x.id === id);
+        if (!c)
+          return s;
+        if (c.ownerNotifiedAt)
+          return s;
+        if (!isTerminalCommandStatus(c.status))
+          return s;
+        if (!shouldNotifyOwnerOnExit(c))
+          return s;
+        c.ownerNotifiedAt = new Date().toISOString();
+        target = { ...c };
+        return s;
+      });
+      if (!target)
+        return;
+      const tail = await readBoundedTail(directory, id);
+      const message = formatAwaitEvidence({
+        title: target.title,
+        argv: [target.command, ...target.args],
+        commandID: target.id,
+        status: target.status,
+        exitCode: target.exitCode,
+        signal: target.signal,
+        tail
+      });
+      await opts?.onOwnerNotify?.(directory, target.ownerSessionID, message);
+    } catch {}
+  }
+  async function flushWatch(directory, id) {
+    const watcher = watchers.get(id);
+    if (!watcher || watcher.pendingCount === 0)
+      return;
+    let session;
+    try {
+      session = await readState(directory).then((s) => (s.commands ?? []).find((x) => x.id === id));
+    } catch {
+      return;
+    }
+    if (!session || session.status !== "running")
+      return;
+    const push = watcher.takePush();
+    await persistWatchState(directory, id, watcher.state).catch(() => {});
+    if (!push)
+      return;
+    if (push.exhaustedNow) {
+      await watchLedger(directory, id, "command.watch-suspended", { reason: "budget", pushes: watcher.state.pushes });
+      try {
+        await opts?.onWatchNotify?.(directory, session.ownerSessionID, formatWatchBudgetMessage(session.title));
+      } catch {}
+      return;
+    }
+    await watchLedger(directory, id, "command.watch-matched", {
+      lines: push.lines.length,
+      matches: watcher.state.matches,
+      pushes: watcher.state.pushes
+    });
+    try {
+      await opts?.onWatchNotify?.(directory, session.ownerSessionID, formatWatchMessage(session.title, push.lines));
+    } catch {}
+    if (watcher.pendingCount > 0)
+      scheduleWatchFlush(directory, id);
+  }
+  async function handleUntilMatch(directory, id) {
+    const watcher = watchers.get(id);
+    if (!watcher)
+      return;
+    clearWatchTimer(id);
+    let session;
+    try {
+      session = await readState(directory).then((s) => (s.commands ?? []).find((x) => x.id === id));
+    } catch {
+      return;
+    }
+    if (!session)
+      return;
+    const action = watcher.untilAction;
+    const lines = watcher.takeUntilPush();
+    const snapshot = { ...watcher.state };
+    const message = formatWatchMessage(session.title, lines, `-- until "${session.watchUntil ?? ""}" matched (action=${action})`);
+    await mutateState(directory, `cmd.until-claim:${id}`, async (s) => {
+      const c = (s.commands ?? []).find((x) => x.id === id);
+      if (!c)
+        return s;
+      c.watchState = { ...snapshot };
+      if (action === "stop" && !c.ownerNotifiedAt)
+        c.ownerNotifiedAt = new Date().toISOString();
+      c.updatedAt = new Date().toISOString();
+      return s;
+    }).catch(() => {});
+    await watchLedger(directory, id, "command.watch-matched", {
+      until: session.watchUntil ?? "",
+      lines: lines.length,
+      pushes: snapshot.pushes
+    });
+    try {
+      await opts?.onWatchNotify?.(directory, session.ownerSessionID, message);
+    } catch {}
+    if (action !== "stop")
+      return;
+    if (session.status !== "running")
+      return;
+    await watchLedger(directory, id, "command.until-stopped", { until: session.watchUntil ?? "" });
+    await service.terminate(directory, id, session.ownerSessionID).catch(() => {});
+    await mutateState(directory, `cmd.until:${id}`, async (s) => {
+      const c = (s.commands ?? []).find((x) => x.id === id);
+      if (!c)
+        return s;
+      if (c.status === "terminated" && c.endReason !== "timeout") {
+        c.endReason = "until";
+        c.lastError = c.lastError ?? `Watch until pattern "${c.watchUntil ?? ""}" matched; command stopped (untilAction=stop).`;
+        c.updatedAt = new Date().toISOString();
+      }
+      return s;
+    }).catch(() => {});
+    try {
+      const fresh = await readState(directory).then((st) => (st.commands ?? []).find((x) => x.id === id));
+      if (fresh)
+        emitBroker(id, { type: "status", command: fresh });
+    } catch {}
+    await fireAwaits(directory, id);
+  }
+  async function readBrokerSnapshot(commandID, ownerSessionID) {
+    const directory = commandDirs.get(commandID);
+    if (!directory)
+      return;
+    const state = await readState(directory);
+    const session = (state.commands ?? []).find((x) => x.id === commandID && x.ownerSessionID === ownerSessionID);
+    if (!session)
+      return;
+    const log = await readCommandLog(directory, commandID, {
+      offsetBytes: 0,
+      limitBytes: MAX_COMMAND_OUTPUT_BYTES
+    });
+    const data = log.text;
+    const byteLen = utf8ByteLength(data);
+    const lifetime = session.streamBytes ?? 0;
+    const endOffset = lifetime >= byteLen ? lifetime : byteLen;
+    const startOffset = endOffset - byteLen;
+    return { command: session, data, startOffset, endOffset };
+  }
+  if (broker) {
+    broker.setResolver({
+      async getSession(commandID, ownerSessionID) {
+        const directory = commandDirs.get(commandID);
+        if (!directory)
+          return;
+        const s = await readState(directory);
+        const c = (s.commands ?? []).find((x) => x.id === commandID);
+        return c && c.ownerSessionID === ownerSessionID ? c : undefined;
+      },
+      async waitForQuiesce(commandID) {
+        await waitForOperations(commandID);
+      },
+      async readSnapshot(commandID, ownerSessionID) {
+        return readBrokerSnapshot(commandID, ownerSessionID);
+      }
+    });
+  }
+  async function persistOutput(directory, id, chunk) {
+    rememberDir(id, directory);
+    const entry = live.get(id);
+    if (entry) {
+      const bytes = Buffer.from(chunk);
+      entry.buffers.push(bytes);
+      entry.bufferedBytes += bytes.length;
+      while (entry.bufferedBytes > 128 * 1024 && entry.buffers.length > 1) {
+        const dropped = entry.buffers.shift();
+        entry.bufferedBytes -= dropped.length;
+      }
+    }
+    let watcher;
+    let feed;
+    let bareLines = [];
+    try {
+      watcher = watchers.get(id);
+      if (!watcher) {
+        const spec = await readState(directory).then((s) => (s.commands ?? []).find((x) => x.id === id)).catch(() => {
+          return;
+        });
+        if (spec && spec.status === "running" && (spec.watchFilter !== undefined || spec.watchUntil !== undefined)) {
+          try {
+            watcher = new CommandWatcher({
+              ...spec.watchFilter !== undefined ? { filter: spec.watchFilter } : {},
+              ...spec.watchUntil !== undefined ? { until: spec.watchUntil } : {},
+              ...spec.watchIgnoreCase !== undefined ? { ignoreCase: spec.watchIgnoreCase } : {},
+              ...spec.watchUntilAction !== undefined ? { untilAction: spec.watchUntilAction } : {}
+            });
+            watchers.set(id, watcher);
+          } catch {
+            watcher = undefined;
+          }
+        }
+      }
+      if (watcher) {
+        feed = watcher.feedChunk(chunk, Date.now());
+      } else {
+        let asm = awaitAsm.get(id);
+        if (!asm) {
+          asm = createLineAssembler();
+          awaitAsm.set(id, asm);
+        }
+        bareLines = asm.push(chunk).filter((l) => l.trim() !== "");
+      }
+    } catch {
+      watcher = undefined;
+      feed = undefined;
+    }
+    await appendCommandLog(directory, id, chunk);
+    let retainedBytes = 0;
+    let truncated = false;
+    const file = path3.join(loopCommandsDir(directory), `${id}.log`);
+    const stat = await fs3.stat(file);
+    retainedBytes = stat.size;
+    if (stat.size > MAX_COMMAND_OUTPUT_BYTES) {
+      const fh = await fs3.open(file, "r");
+      try {
+        const buf = Buffer.alloc(MAX_COMMAND_OUTPUT_BYTES);
+        await fh.read(buf, 0, buf.length, stat.size - buf.length);
+        await fs3.writeFile(file, buf);
+      } finally {
+        await fh.close();
+      }
+      retainedBytes = MAX_COMMAND_OUTPUT_BYTES;
+      truncated = true;
+    }
+    await mutateState(directory, `cmd.output:${id}`, async (s) => {
+      const c = (s.commands ?? []).find((x) => x.id === id);
+      if (!c)
+        return s;
+      const byteLen = utf8ByteLength(chunk);
+      const startOffset = c.streamBytes ?? 0;
+      const endOffset = startOffset + byteLen;
+      c.streamBytes = endOffset;
+      c.outputBytes = retainedBytes;
+      if (truncated)
+        c.truncated = true;
+      if (watcher)
+        c.watchState = { ...watcher.state };
+      c.updatedAt = new Date().toISOString();
+      return s;
+    });
+    try {
+      const fresh = await readState(directory).then((s) => (s.commands ?? []).find((x) => x.id === id));
+      const endOffset = fresh?.streamBytes ?? 0;
+      const startOffset = endOffset - utf8ByteLength(chunk);
+      if (fresh && startOffset >= 0) {
+        emitBroker(id, {
+          type: "output",
+          commandID: id,
+          data: chunk,
+          startOffset,
+          endOffset
+        });
+      }
+    } catch {}
+    try {
+      if (watcher && feed) {
+        if (feed.floodNow) {
+          await persistWatchState(directory, id, watcher.state).catch(() => {});
+          const dropped = watcher.state.droppedLines;
+          let owner;
+          let title = id;
+          try {
+            const snap = await readState(directory).then((s) => (s.commands ?? []).find((x) => x.id === id));
+            owner = snap?.ownerSessionID;
+            title = snap?.title ?? id;
+          } catch {}
+          await watchLedger(directory, id, "command.watch-suspended", { reason: "flood", dropped });
+          if (owner) {
+            try {
+              await opts?.onWatchNotify?.(directory, owner, formatWatchFloodMessage(title, dropped));
+            } catch {}
+          }
+        }
+        if (watcher.pendingCount > 0)
+          scheduleWatchFlush(directory, id);
+        if (feed.untilLine) {
+          clearWatchTimer(id);
+          enqueue(id, () => handleUntilMatch(directory, id)).catch(() => {});
+        }
+      }
+    } catch {}
+    try {
+      const completed = feed ? feed.completed : bareLines;
+      if (completed.length > 0) {
+        const fired = await fireUntilAwaits(directory, id, completed);
+        if (fired.length > 0) {
+          await opts?.onAwaitFired?.(directory, fired);
+        }
+      }
+    } catch {}
+  }
+  async function persistExit(directory, id, info) {
+    rememberDir(id, directory);
+    live.delete(id);
+    clearCommandTimeout(id);
+    const exitWatcher = watchers.get(id);
+    if (exitWatcher) {
+      try {
+        const handledStop = exitWatcher.state.state === "until-matched" && exitWatcher.untilAction === "stop";
+        exitWatcher.finish(Date.now());
+        let snap;
+        try {
+          snap = await readState(directory).then((s) => (s.commands ?? []).find((x) => x.id === id));
+        } catch {
+          snap = undefined;
+        }
+        if (snap && !handledStop && exitWatcher.pendingCount > 0) {
+          const push = exitWatcher.takePush();
+          await persistWatchState(directory, id, exitWatcher.state).catch(() => {});
+          if (push && !push.exhaustedNow && push.lines.length > 0) {
+            await watchLedger(directory, id, "command.watch-matched", {
+              lines: push.lines.length,
+              atExit: true,
+              pushes: exitWatcher.state.pushes
+            });
+            try {
+              await opts?.onWatchNotify?.(directory, snap.ownerSessionID, formatWatchMessage(snap.title, push.lines));
+            } catch {}
+          } else if (push?.exhaustedNow) {
+            await watchLedger(directory, id, "command.watch-suspended", {
+              reason: "budget",
+              atExit: true,
+              pushes: exitWatcher.state.pushes
+            });
+            try {
+              await opts?.onWatchNotify?.(directory, snap.ownerSessionID, formatWatchBudgetMessage(snap.title));
+            } catch {}
+          }
+        } else {
+          await persistWatchState(directory, id, exitWatcher.state).catch(() => {});
+        }
+      } catch {}
+    }
+    deleteWatch(id);
+    await mutateState(directory, `cmd.exit:${id}`, async (s) => {
+      const c = (s.commands ?? []).find((x) => x.id === id);
+      if (!c || c.status !== "running")
+        return s;
+      if (c.endReason === "timeout") {
+        if (!c.endedAt) {
+          c.endedAt = new Date().toISOString();
+          c.updatedAt = c.endedAt;
+        }
+        return s;
+      }
+      c.exitCode = info.exitCode;
+      if (info.signal && (c.signal === "SIGKILL" || c.signal === "SIGTERM")) {
+        c.status = "terminated";
+        c.endReason = "terminate";
+      } else {
+        c.status = "exited";
+        c.endReason = "exit";
+        if (info.signal)
+          c.signal = info.signal;
+      }
+      c.endedAt = new Date().toISOString();
+      c.updatedAt = c.endedAt;
+      return s;
+    }).catch(() => {});
+    await appendEvent(directory, {
+      version: 1,
+      eventID: randomUUID8(),
+      commandID: id,
+      type: "command.exited",
+      exitCode: info.exitCode,
+      timestamp: new Date().toISOString(),
+      revision: 0
+    }).catch(() => {});
+    try {
+      const fresh = await readState(directory).then((s) => (s.commands ?? []).find((x) => x.id === id));
+      if (fresh)
+        emitBroker(id, { type: "status", command: fresh });
+    } catch {}
+    await fireAwaits(directory, id);
+    await notifyOwnerIfNeeded(directory, id);
+  }
+  function owned(cmd, ownerSessionID) {
+    return !!cmd && cmd.ownerSessionID === ownerSessionID;
+  }
+  const service = {
+    async start(directory, input) {
+      const title = input.title.trim();
+      const command = input.command.trim();
+      if (!title)
+        throw new Error("title is required");
+      if (!command)
+        throw new Error("command is required");
+      if (!input.ownerSessionID || input.ownerSessionID === "main") {
+        throw new Error("A valid owner session is required. Run from an active OpenCode session.");
+      }
+      const timeoutSeconds = normalizeTimeoutSeconds(input.timeoutSeconds);
+      const watchFilter = input.watchFilter !== undefined && input.watchFilter !== "" ? input.watchFilter : undefined;
+      const watchUntil = input.watchUntil !== undefined && input.watchUntil !== "" ? input.watchUntil : undefined;
+      const hasWatch = watchFilter !== undefined || watchUntil !== undefined;
+      let watcher;
+      let watchState;
+      if (hasWatch) {
+        watcher = new CommandWatcher({
+          ...watchFilter !== undefined ? { filter: watchFilter } : {},
+          ...watchUntil !== undefined ? { until: watchUntil } : {},
+          ...input.watchIgnoreCase !== undefined ? { ignoreCase: input.watchIgnoreCase } : {},
+          ...input.watchUntilAction !== undefined ? { untilAction: input.watchUntilAction } : {}
+        });
+        watchState = initialWatchState();
+      }
+      const startedAt = new Date;
+      const id = randomUUID8();
+      const cwd = input.cwd || directory;
+      const useShell = input.shell === true;
+      const spawnOpts = useShell ? { command: "/bin/sh", args: ["-c", shellJoin(command, input.args ?? [])], cwd, cols: input.cols, rows: input.rows, env: input.env } : { command, args: input.args ?? [], cwd, cols: input.cols, rows: input.rows, env: input.env };
+      const pending = [];
+      let ready = false;
+      const handle = host.spawn(spawnOpts, (chunk) => {
+        if (!ready)
+          pending.push({ type: "output", chunk });
+        else
+          enqueue(id, () => persistOutput(directory, id, chunk)).catch(() => {});
+      }, (info) => {
+        if (!ready)
+          pending.push({ type: "exit", info });
+        else
+          enqueue(id, () => persistExit(directory, id, info)).catch(() => {});
+      });
+      const session = createCommandSession({
+        id,
+        title,
+        command,
+        args: input.args ?? [],
+        cwd,
+        ownerSessionID: input.ownerSessionID,
+        goalID: input.goalID,
+        notifyOnExit: input.notifyOnExit,
+        pid: handle.pid,
+        cols: input.cols,
+        rows: input.rows,
+        shell: useShell ? true : undefined,
+        timeoutSeconds,
+        deadlineAt: timeoutSeconds !== undefined ? computeDeadlineAt(startedAt, timeoutSeconds) : undefined,
+        envKeys: input.env ? Object.keys(input.env) : undefined,
+        watchFilter,
+        watchUntil,
+        watchIgnoreCase: input.watchIgnoreCase,
+        watchUntilAction: watcher?.untilAction,
+        watchState
+      });
+      try {
+        await mutateState(directory, `cmd.start:${id}`, async (s) => {
+          s.commands = [...s.commands ?? [], session];
+          return s;
+        });
+      } catch (error) {
+        handle.terminate();
+        const exited = await Promise.race([
+          handle.exited().then(() => true, () => true),
+          new Promise((resolve) => setTimeout(() => resolve(false), 1000))
+        ]);
+        if (!exited && handle.isAlive())
+          handle.kill();
+        throw error;
+      }
+      live.set(id, { handle, buffers: [], bufferedBytes: 0 });
+      if (watcher)
+        watchers.set(id, watcher);
+      if (timeoutSeconds !== undefined)
+        scheduleTimeout(directory, id, input.ownerSessionID, timeoutSeconds);
+      rememberDir(id, directory);
+      await appendEvent(directory, {
+        version: 1,
+        eventID: randomUUID8(),
+        ...input.goalID ? { goalID: input.goalID } : {},
+        commandID: id,
+        type: "command.started",
+        title,
+        timestamp: new Date().toISOString(),
+        revision: 0
+      }).catch(() => {});
+      try {
+        const fresh = await readState(directory).then((s) => (s.commands ?? []).find((x) => x.id === id));
+        if (fresh)
+          emitBroker(id, { type: "status", command: fresh });
+      } catch {}
+      const initialEvents = pending.splice(0);
+      ready = true;
+      const initialOperations = [];
+      for (const event of initialEvents) {
+        initialOperations.push(event.type === "output" ? enqueue(id, () => persistOutput(directory, id, event.chunk)) : enqueue(id, () => persistExit(directory, id, event.info)));
+      }
+      await Promise.all(initialOperations);
+      return await service.get(directory, id, input.ownerSessionID) ?? session;
+    },
+    async list(directory, ownerSessionID) {
+      const s = await readState(directory);
+      for (const c of s.commands ?? [])
+        rememberDir(c.id, directory);
+      return (s.commands ?? []).filter((c) => c.ownerSessionID === ownerSessionID);
+    },
+    async get(directory, id, ownerSessionID) {
+      rememberDir(id, directory);
+      const s = await readState(directory);
+      const c = (s.commands ?? []).find((x) => x.id === id);
+      return owned(c, ownerSessionID) ? c : undefined;
+    },
+    async read(directory, id, ownerSessionID, opts) {
+      await waitForOperations(id);
+      const session = await service.get(directory, id, ownerSessionID);
+      if (!session)
+        return;
+      if (opts?.pattern !== undefined) {
+        const flags = opts.ignoreCase ? "i" : "";
+        const checked = validateReadPattern(opts.pattern);
+        if (typeof checked !== "object" || !(checked instanceof RegExp)) {
+          throw new Error(checked.error);
+        }
+        const regex = new RegExp(opts.pattern, flags);
+        const full = await readCommandLog(directory, id, { offsetBytes: 0, limitBytes: MAX_COMMAND_OUTPUT_BYTES });
+        const lines = full.text.length === 0 ? [] : full.text.split(`
+`);
+        const matches = [];
+        for (const line of lines) {
+          let stripped;
+          try {
+            stripped = stripAnsiForMatch(line);
+          } catch {
+            stripped = line;
+          }
+          let hit = false;
+          try {
+            hit = regex.test(stripped);
+          } catch {
+            throw new Error(`Invalid regex pattern '${opts.pattern}'.`);
+          }
+          regex.lastIndex = 0;
+          if (hit)
+            matches.push(line);
+        }
+        const skip = Math.max(0, opts.offsetBytes ?? 0);
+        const take = Math.min(opts.limitBytes ?? MAX_COMMAND_READ_LINES, MAX_COMMAND_READ_LINES);
+        const page = matches.slice(skip, skip + Math.max(0, take));
+        return {
+          session,
+          text: page.join(`
+`) + (page.length > 0 ? `
+` : ""),
+          totalBytes: matches.length,
+          startByte: skip,
+          live: session.status === "running",
+          pattern: opts.pattern,
+          totalMatches: matches.length
+        };
+      }
+      const entry = live.get(id);
+      const offset = opts?.offsetBytes ?? 0;
+      const limit = Math.min(opts?.limitBytes ?? 64 * 1024, 256 * 1024);
+      if (entry && offset === 0) {
+        const mem = tailText(entry, limit);
+        if (entry.bufferedBytes <= limit) {
+          const file = await readCommandLog(directory, id, { offsetBytes: 0, limitBytes: 0 });
+          const memBytes = Buffer.byteLength(mem);
+          return { session, text: mem, totalBytes: session.outputBytes, startByte: Math.max(0, session.outputBytes - memBytes), live: session.status === "running" };
+        }
+      }
+      const file = await readCommandLog(directory, id, { offsetBytes: offset, limitBytes: limit });
+      return { session, text: file.text, totalBytes: session.outputBytes, startByte: file.startByte, live: session.status === "running" };
+    },
+    async write(directory, id, ownerSessionID, data) {
+      const session = await service.get(directory, id, ownerSessionID);
+      if (!session)
+        return { ok: false, message: "Command not found." };
+      if (session.status !== "running")
+        return { ok: false, message: `Command is ${session.status}; only running commands accept input.` };
+      const entry = live.get(id);
+      const ok = entry ? entry.handle.write(data) : false;
+      if (!ok)
+        return { ok: false, message: "Process input unavailable (no live handle \u2014 host may have restarted; reconcile marks it honestly)." };
+      return { ok: true, message: `Sent ${Buffer.byteLength(data)} byte(s) to "${session.title}".` };
+    },
+    async resize(directory, id, ownerSessionID, cols, rows) {
+      const session = await service.get(directory, id, ownerSessionID);
+      if (!session)
+        return { ok: false, message: "Command not found." };
+      if (!Number.isInteger(cols) || !Number.isInteger(rows) || cols <= 0 || rows <= 0) {
+        return { ok: false, message: `Invalid size ${cols}x${rows}: cols and rows must be positive integers.` };
+      }
+      const entry = live.get(id);
+      let applied = false;
+      if (entry) {
+        try {
+          applied = entry.handle.resize(cols, rows);
+        } catch {
+          applied = false;
+        }
+      }
+      await mutateState(directory, `cmd.resize:${id}`, async (s) => {
+        const c = (s.commands ?? []).find((x) => x.id === id);
+        if (c && c.ownerSessionID === ownerSessionID) {
+          c.cols = cols;
+          c.rows = rows;
+          c.updatedAt = new Date().toISOString();
+        }
+        return s;
+      });
+      if (applied)
+        return { ok: true, message: `Terminal resized to ${cols}x${rows} for "${session.title}".` };
+      return { ok: false, unsupported: true, message: "Resize is not supported by the active pipe host (pipes have no tty winsize; the PTY backend was unavailable). Size stored; output remains a byte stream." };
+    },
+    async interrupt(directory, id, ownerSessionID) {
+      const session = await service.get(directory, id, ownerSessionID);
+      if (!session)
+        return { ok: false, message: "Command not found." };
+      if (session.status !== "running")
+        return { ok: false, message: `Command is ${session.status}; nothing to interrupt.` };
+      const entry = live.get(id);
+      if (!entry)
+        return { ok: false, message: "No live handle (host restarted?). Reconcile will mark it missing; use terminate/remove to clean up." };
+      const delivered = entry.handle.interrupt();
+      if (!delivered)
+        return { ok: false, message: "Failed to deliver SIGINT." };
+      await mutateState(directory, `cmd.interrupt:${id}`, async (s) => {
+        const c = (s.commands ?? []).find((x) => x.id === id);
+        if (c && c.ownerSessionID === ownerSessionID) {
+          c.signal = "SIGINT";
+          c.updatedAt = new Date().toISOString();
+        }
+        return s;
+      });
+      return { ok: true, message: `SIGINT delivered to "${session.title}" (process may continue if it traps the signal).` };
+    },
+    async terminate(directory, id, ownerSessionID, opts) {
+      rememberDir(id, directory);
+      const session = await service.get(directory, id, ownerSessionID);
+      if (!session)
+        return { ok: false, message: "Command not found." };
+      if (session.status !== "running") {
+        if (opts?.remove) {
+          const removed = await service.remove(directory, id, ownerSessionID);
+          return removed.ok ? { ok: true, message: `Command was already ${session.status}; removed.`, removed: true } : { ok: false, message: `Command is ${session.status}; remove failed: ${removed.message}` };
+        }
+        return { ok: false, message: `Command is ${session.status}; nothing to terminate.` };
+      }
+      await mutateState(directory, `cmd.terminate-claim:${id}`, async (s) => {
+        const c = (s.commands ?? []).find((x) => x.id === id);
+        if (c && c.ownerSessionID === ownerSessionID && c.status === "running") {
+          c.signal = "SIGTERM";
+          c.updatedAt = new Date().toISOString();
+        }
+        return s;
+      }).catch(() => {});
+      try {
+        const claimed = await readState(directory).then((st) => (st.commands ?? []).find((x) => x.id === id));
+        if (claimed)
+          emitBroker(id, { type: "status", command: claimed });
+      } catch {}
+      const entry = live.get(id);
+      let status = "terminated";
+      if (entry) {
+        const aliveBefore = entry.handle.isAlive();
+        if (!aliveBefore) {
+          status = "exited";
+        } else {
+          entry.handle.terminate();
+          const exited = await Promise.race([
+            entry.handle.exited().then(() => true),
+            new Promise((r) => setTimeout(() => r(false), 3000))
+          ]);
+          if (!exited && entry.handle.isAlive())
+            entry.handle.kill();
+          try {
+            await entry.handle.exited();
+          } catch {}
+        }
+        live.delete(id);
+      }
+      const exitCode = status === "terminated" ? 143 : undefined;
+      clearCommandTimeout(id);
+      clearWatchTimer(id);
+      await mutateState(directory, `cmd.terminate:${id}`, async (s) => {
+        const c = (s.commands ?? []).find((x) => x.id === id);
+        if (!c || c.ownerSessionID !== ownerSessionID)
+          return s;
+        if (c.status === "running") {
+          c.status = status;
+          if (c.endReason !== "timeout")
+            c.endReason = status === "terminated" ? "terminate" : "exit";
+          if (exitCode !== undefined)
+            c.exitCode = c.exitCode ?? exitCode;
+          c.signal = c.signal ?? "SIGTERM";
+          c.endedAt = new Date().toISOString();
+          c.updatedAt = c.endedAt;
+        } else if (c.status === "terminated" && !c.endedAt) {
+          if (c.endReason !== "timeout" && !c.endReason)
+            c.endReason = "terminate";
+          if (exitCode !== undefined)
+            c.exitCode = c.exitCode ?? exitCode;
+          c.endedAt = new Date().toISOString();
+          c.updatedAt = c.endedAt;
+        }
+        return s;
+      });
+      try {
+        const fresh = await readState(directory).then((st) => (st.commands ?? []).find((x) => x.id === id));
+        if (fresh)
+          emitBroker(id, { type: "status", command: fresh });
+      } catch {}
+      await fireAwaits(directory, id);
+      await notifyOwnerIfNeeded(directory, id);
+      if (opts?.remove) {
+        const removed = await service.remove(directory, id, ownerSessionID);
+        if (removed.ok)
+          return { ok: true, message: `Command "${session.title}" ${status}; removed.`, removed: true };
+        return { ok: true, message: `Command "${session.title}" ${status}; remove failed: ${removed.message}` };
+      }
+      return { ok: true, message: `Command "${session.title}" ${status}.` };
+    },
+    async remove(directory, id, ownerSessionID) {
+      rememberDir(id, directory);
+      const session = await service.get(directory, id, ownerSessionID);
+      if (!session)
+        return { ok: false, message: "Command not found." };
+      if (session.status === "running") {
+        return { ok: false, message: `Command "${session.title}" is still running \u2014 terminate it first (terminate \u2260 remove).` };
+      }
+      deleteWatch(id);
+      const lastKnown = { ...session };
+      await mutateState(directory, `cmd.remove:${id}`, async (s) => {
+        s.commands = (s.commands ?? []).filter((x) => !(x.id === id && x.ownerSessionID === ownerSessionID));
+        return s;
+      });
+      await removeCommandLog(directory, id);
+      emitBroker(id, { type: "status", command: lastKnown });
+      await clearAwaitsForCommand(directory, id, "command removed").catch(() => {});
+      return { ok: true, message: `Command "${session.title}" removed.` };
+    },
+    async watch(directory, id, ownerSessionID, opts) {
+      rememberDir(id, directory);
+      const session = await service.get(directory, id, ownerSessionID);
+      if (!session)
+        return { ok: false, message: "Command not found." };
+      if (session.status !== "running") {
+        return { ok: false, message: `Command is ${session.status}; watch is meaningless after exit.` };
+      }
+      if (opts?.untilAction !== undefined && opts.untilAction !== "stop" && opts.untilAction !== "keep") {
+        throw new Error(`Invalid watch untilAction '${opts.untilAction}': must be "stop" or "keep".`);
+      }
+      if (opts?.clear === true) {
+        deleteWatch(id);
+        await mutateState(directory, `cmd.watch-clear:${id}`, async (s) => {
+          const c = (s.commands ?? []).find((x) => x.id === id);
+          if (c && c.ownerSessionID === ownerSessionID) {
+            delete c.watchFilter;
+            delete c.watchUntil;
+            delete c.watchIgnoreCase;
+            delete c.watchUntilAction;
+            delete c.watchState;
+            c.updatedAt = new Date().toISOString();
+          }
+          return s;
+        });
+        await watchLedger(directory, id, "command.watch-suspended", { reason: "cleared" }).catch(() => {});
+        try {
+          const fresh = await readState(directory).then((st) => (st.commands ?? []).find((x) => x.id === id));
+          if (fresh)
+            emitBroker(id, { type: "status", command: fresh });
+        } catch {}
+        const cleared = await service.get(directory, id, ownerSessionID);
+        return { ok: true, message: `Watch cleared for "${session.title}".`, command: cleared };
+      }
+      const filter = opts?.filter !== undefined && opts.filter !== "" ? opts.filter : undefined;
+      const until = opts?.until !== undefined && opts.until !== "" ? opts.until : undefined;
+      const watcher = new CommandWatcher({
+        ...filter !== undefined ? { filter } : {},
+        ...until !== undefined ? { until } : {},
+        ...opts?.ignoreCase !== undefined ? { ignoreCase: opts.ignoreCase } : {},
+        ...opts?.untilAction !== undefined ? { untilAction: opts.untilAction } : {}
+      });
+      clearWatchTimer(id);
+      watchers.set(id, watcher);
+      awaitAsm.delete(id);
+      const freshState = initialWatchState();
+      await mutateState(directory, `cmd.watch:${id}`, async (s) => {
+        const c = (s.commands ?? []).find((x) => x.id === id);
+        if (c && c.ownerSessionID === ownerSessionID) {
+          if (filter !== undefined)
+            c.watchFilter = filter;
+          else
+            delete c.watchFilter;
+          if (until !== undefined)
+            c.watchUntil = until;
+          else
+            delete c.watchUntil;
+          if (opts?.ignoreCase !== undefined)
+            c.watchIgnoreCase = opts.ignoreCase;
+          else
+            delete c.watchIgnoreCase;
+          c.watchUntilAction = watcher.untilAction;
+          c.watchState = { ...freshState };
+          c.updatedAt = new Date().toISOString();
+        }
+        return s;
+      });
+      try {
+        const fresh = await readState(directory).then((st) => (st.commands ?? []).find((x) => x.id === id));
+        if (fresh)
+          emitBroker(id, { type: "status", command: fresh });
+      } catch {}
+      const updated = await service.get(directory, id, ownerSessionID);
+      const desc = [
+        filter !== undefined ? `filter="${filter}"` : "filter=\u2014",
+        until !== undefined ? `until="${until}"` : "until=\u2014",
+        `action=${watcher.untilAction}`
+      ].join(" ");
+      return { ok: true, message: `Watch set for "${session.title}" (${desc}; counters reset to active).`, command: updated };
+    },
+    async reconcile(directory) {
+      const state = await readState(directory);
+      const cmds = state.commands ?? [];
+      for (const c of cmds)
+        rememberDir(c.id, directory);
+      let markedMissing = 0;
+      for (const c of cmds) {
+        if (c.status !== "running")
+          continue;
+        const entry = live.get(c.id);
+        if (entry) {
+          if (!entry.handle.isAlive()) {
+            live.delete(c.id);
+            clearCommandTimeout(c.id);
+            deleteWatch(c.id);
+            await mutateState(directory, `cmd.reconcile-exit:${c.id}`, async (s) => {
+              const x = (s.commands ?? []).find((y) => y.id === c.id);
+              if (x && x.status === "running") {
+                x.status = "exited";
+                x.endReason = "exit";
+                x.endedAt = new Date().toISOString();
+                x.updatedAt = x.endedAt;
+                x.lastError = x.lastError ?? "Process handle died without an exit event.";
+              }
+              return s;
+            }).catch(() => {});
+            try {
+              const fresh = await readState(directory).then((st) => (st.commands ?? []).find((y) => y.id === c.id));
+              if (fresh)
+                emitBroker(c.id, { type: "status", command: fresh });
+            } catch {}
+            await fireAwaits(directory, c.id);
+            await notifyOwnerIfNeeded(directory, c.id);
+          }
+          continue;
+        }
+        clearCommandTimeout(c.id);
+        deleteWatch(c.id);
+        const deadlinePassed = c.deadlineAt ? Date.parse(c.deadlineAt) <= Date.now() : false;
+        await mutateState(directory, `cmd.reconcile-missing:${c.id}`, async (s) => {
+          const x = (s.commands ?? []).find((y) => y.id === c.id);
+          if (x && x.status === "running") {
+            x.status = "missing";
+            x.endReason = "missing";
+            x.lastError = deadlinePassed ? `Host restarted or handle lost \u2014 no live execution found (timeoutSeconds=${x.timeoutSeconds ?? "?"}s deadline ${x.deadlineAt} already passed; treated as missing, timeout elapsed). Output log retained; remove to clean up.` : "Host restarted or handle lost \u2014 no live execution found. Output log retained; remove to clean up.";
+            x.updatedAt = new Date().toISOString();
+            markedMissing++;
+          }
+          return s;
+        }).catch(() => {});
+        try {
+          const fresh = await readState(directory).then((st) => (st.commands ?? []).find((y) => y.id === c.id));
+          if (fresh && fresh.status === "missing")
+            emitBroker(c.id, { type: "status", command: fresh });
+        } catch {}
+        await fireAwaits(directory, c.id);
+        await notifyOwnerIfNeeded(directory, c.id);
+      }
+      return { markedMissing };
+    },
+    async dispose(directory) {
+      for (const id of [...watchTimers.keys()])
+        clearWatchTimer(id);
+      watchers.clear();
+      awaitAsm.clear();
+      const state = await readState(directory);
+      const owned = new Map((state.commands ?? []).map((command) => [command.id, command.ownerSessionID]));
+      await Promise.all([...live.entries()].map(async ([id, entry]) => {
+        const owner = owned.get(id);
+        if (owner) {
+          await service.terminate(directory, id, owner).catch(() => {});
+          return;
+        }
+        entry.handle.terminate();
+        const exited = await Promise.race([
+          entry.handle.exited().then(() => true, () => true),
+          new Promise((resolve) => setTimeout(() => resolve(false), 1000))
+        ]);
+        if (!exited && entry.handle.isAlive())
+          entry.handle.kill();
+        live.delete(id);
+      }));
+      for (const id of [...timeouts.keys()])
+        clearCommandTimeout(id);
+    }
+  };
+  return service;
+}
+
+// src/application/command-event-broker.ts
+import { randomUUID as randomUUID9 } from "crypto";
+function safeDeliver(sink, msg) {
+  try {
+    sink(msg);
+  } catch {}
+}
+function isCoveredBySnapshot(msg, snapshot) {
+  if (msg.type === "output") {
+    const out = msg;
+    return out.endOffset <= snapshot.endOffset;
+  }
+  if (msg.type === "status") {
+    const st = msg;
+    const bufferedAt = st.command.updatedAt ?? "";
+    const snapshotAt = snapshot.command.updatedAt ?? "";
+    return bufferedAt <= snapshotAt;
+  }
+  return true;
+}
+function createCommandEventBroker(resolver) {
+  let currentResolver = resolver;
+  const subscribers = new Map;
+  function entriesFor(commandID) {
+    let m = subscribers.get(commandID);
+    if (!m) {
+      m = new Map;
+      subscribers.set(commandID, m);
+    }
+    return m;
+  }
+  return {
+    setResolver(next) {
+      currentResolver = next;
+    },
+    async subscribe(commandID, ownerSessionID, sink) {
+      if (!currentResolver)
+        throw new Error("Command event broker has no resolver (service not wired).");
+      if (!commandID)
+        throw new Error("commandID is required.");
+      if (!ownerSessionID)
+        throw new Error("ownerSessionID is required.");
+      if (typeof sink !== "function")
+        throw new Error("sink must be a function.");
+      const sinkID = randomUUID9();
+      const entry = { sinkID, sink, state: "subscribing", buffer: [] };
+      entriesFor(commandID).set(sinkID, entry);
+      try {
+        const session = await currentResolver.getSession(commandID, ownerSessionID);
+        if (!session) {
+          throw new Error("Command not found or not owned by this session (cross-owner subscribe rejected).");
+        }
+        await currentResolver.waitForQuiesce(commandID);
+        const snap = await currentResolver.readSnapshot(commandID, ownerSessionID);
+        if (!snap) {
+          throw new Error("Command snapshot unavailable (removed or unreadable).");
+        }
+        const snapshotMsg = {
+          type: "snapshot",
+          command: snap.command,
+          data: snap.data,
+          startOffset: snap.startOffset,
+          endOffset: snap.endOffset
+        };
+        const validated = validateCommandStreamMessage(snapshotMsg);
+        if (!validated.ok) {
+          throw new Error(`Invalid snapshot: ${validated.error}`);
+        }
+        const stillThere = subscribers.get(commandID)?.get(sinkID);
+        if (!stillThere)
+          throw new Error("Subscription cancelled during handshake.");
+        const buffered = entry.buffer.splice(0);
+        safeDeliver(entry.sink, validated.message);
+        for (const msg of buffered) {
+          if (isCoveredBySnapshot(msg, snapshotMsg))
+            continue;
+          safeDeliver(entry.sink, msg);
+        }
+        const extra = entry.buffer.splice(0);
+        for (const msg of extra) {
+          if (isCoveredBySnapshot(msg, snapshotMsg))
+            continue;
+          safeDeliver(entry.sink, msg);
+        }
+        entry.state = "live";
+        return sinkID;
+      } catch (error) {
+        subscribers.get(commandID)?.delete(sinkID);
+        if (subscribers.get(commandID)?.size === 0)
+          subscribers.delete(commandID);
+        throw error;
+      }
+    },
+    unsubscribe(commandID, sinkID) {
+      const m = subscribers.get(commandID);
+      if (!m)
+        return;
+      m.delete(sinkID);
+      if (m.size === 0)
+        subscribers.delete(commandID);
+    },
+    publish(commandID, message) {
+      let valid;
+      try {
+        const result = validateCommandStreamMessage(message);
+        if (!result.ok)
+          return false;
+        valid = result.message;
+      } catch {
+        return false;
+      }
+      const m = subscribers.get(commandID);
+      if (!m || m.size === 0)
+        return false;
+      let handled = false;
+      for (const entry of m.values()) {
+        if (entry.state === "subscribing") {
+          entry.buffer.push(valid);
+          handled = true;
+          continue;
+        }
+        safeDeliver(entry.sink, valid);
+        handled = true;
+      }
+      return handled;
+    },
+    subscriberCount(commandID) {
+      return subscribers.get(commandID)?.size ?? 0;
+    }
+  };
+}
+
+// src/server/command-stream-server.ts
+import { randomBytes, randomUUID as randomUUID10, timingSafeEqual } from "crypto";
+import { promises as fs4 } from "fs";
+import path4 from "path";
+function streamEndpointPath(directory) {
+  return path4.join(directory, ".opencode", "loopd", "commands", ".stream-endpoint.json");
+}
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error?.code;
+    if (code === "EPERM")
+      return true;
+    return false;
+  }
+}
+function tokensEqual(a, b) {
+  const ab = Buffer.from(a);
+  const bb = Buffer.from(b);
+  if (ab.length !== bb.length)
+    return false;
+  try {
+    return timingSafeEqual(ab, bb);
+  } catch {
+    return false;
+  }
+}
+var MAX_BUFFERED_BYTES = 512 * 1024;
+function createCommandStreamServer(directory, commandService, broker) {
+  const endpointPath = streamEndpointPath(directory);
+  const token = randomBytes(32).toString("hex");
+  const generation = randomUUID10();
+  const startedAt = new Date().toISOString();
+  let server;
+  let serverURL;
+  let started = false;
+  let stopped = false;
+  const sockets = new Set;
+  const subsBySocket = new Map;
+  const handshakeBySocket = new Map;
+  function nextHandshake(ws, commandID) {
+    let m = handshakeBySocket.get(ws);
+    if (!m) {
+      m = new Map;
+      handshakeBySocket.set(ws, m);
+    }
+    const next = (m.get(commandID) ?? 0) + 1;
+    m.set(commandID, next);
+    return next;
+  }
+  function currentHandshake(ws, commandID) {
+    return handshakeBySocket.get(ws)?.get(commandID);
+  }
+  function clearHandshake(ws, commandID, generation) {
+    const m = handshakeBySocket.get(ws);
+    if (m?.get(commandID) === generation)
+      m.delete(commandID);
+    if (m && m.size === 0)
+      handshakeBySocket.delete(ws);
+  }
+  function sendError(ws, code, message) {
+    try {
+      ws.send(JSON.stringify({ type: "error", code, message }));
+    } catch {}
+  }
+  function sendToSocket(ws, payload) {
+    try {
+      const buffered = ws.bufferedAmount ?? 0;
+      if (buffered > MAX_BUFFERED_BYTES) {
+        try {
+          ws.close(1011, "backpressure overflow: resync");
+        } catch {}
+        return false;
+      }
+      ws.send(payload);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  function makeSink(ws) {
+    return (msg) => {
+      if (stopped || !sockets.has(ws))
+        return;
+      sendToSocket(ws, JSON.stringify(msg));
+    };
+  }
+  function subsFor(ws) {
+    let m = subsBySocket.get(ws);
+    if (!m) {
+      m = new Map;
+      subsBySocket.set(ws, m);
+    }
+    return m;
+  }
+  function cleanupSocket(ws) {
+    const subs = subsBySocket.get(ws);
+    if (subs) {
+      for (const [commandID, entry] of subs) {
+        try {
+          broker.unsubscribe(commandID, entry.sinkID);
+        } catch {}
+      }
+      subsBySocket.delete(ws);
+    }
+    handshakeBySocket.delete(ws);
+    sockets.delete(ws);
+  }
+  async function handleSubscribe(ws, commandID, ownerSessionID) {
+    const generation = nextHandshake(ws, commandID);
+    const subs = subsFor(ws);
+    const previous = subs.get(commandID);
+    if (previous) {
+      try {
+        broker.unsubscribe(commandID, previous.sinkID);
+      } catch {}
+      subs.delete(commandID);
+    }
+    const sink = makeSink(ws);
+    let sinkID;
+    try {
+      sinkID = await broker.subscribe(commandID, ownerSessionID, sink);
+    } catch (error) {
+      if (currentHandshake(ws, commandID) !== generation)
+        return;
+      clearHandshake(ws, commandID, generation);
+      sendError(ws, "subscribe-failed", error instanceof Error ? error.message : String(error));
+      return;
+    }
+    if (currentHandshake(ws, commandID) !== generation) {
+      try {
+        broker.unsubscribe(commandID, sinkID);
+      } catch {}
+      return;
+    }
+    clearHandshake(ws, commandID, generation);
+    if (!sockets.has(ws)) {
+      try {
+        broker.unsubscribe(commandID, sinkID);
+      } catch {}
+      return;
+    }
+    subs.set(commandID, { sinkID, ownerSessionID });
+  }
+  async function handleResync(ws, commandID) {
+    const subs = subsFor(ws);
+    const previous = subs.get(commandID);
+    if (!previous) {
+      sendError(ws, "not-subscribed", `No subscription for command ${commandID} on this socket; subscribe first.`);
+      return;
+    }
+    await handleSubscribe(ws, commandID, previous.ownerSessionID);
+  }
+  function handleUnsubscribe(ws, commandID) {
+    if (handshakeBySocket.get(ws)?.has(commandID))
+      nextHandshake(ws, commandID);
+    const subs = subsFor(ws);
+    const previous = subs.get(commandID);
+    if (previous) {
+      try {
+        broker.unsubscribe(commandID, previous.sinkID);
+      } catch {}
+      subs.delete(commandID);
+    }
+  }
+  async function handleInput(ws, commandID, data) {
+    const owner = subsFor(ws).get(commandID)?.ownerSessionID;
+    if (!owner) {
+      sendError(ws, "not-subscribed", `No subscription for command ${commandID} on this socket; subscribe first.`);
+      return;
+    }
+    try {
+      const result = await commandService.write(directory, commandID, owner, data);
+      if (!result.ok)
+        sendError(ws, "input-failed", result.message);
+    } catch (error) {
+      sendError(ws, "input-failed", error instanceof Error ? error.message : String(error));
+    }
+  }
+  async function handleInterrupt(ws, commandID) {
+    const owner = subsFor(ws).get(commandID)?.ownerSessionID;
+    if (!owner) {
+      sendError(ws, "not-subscribed", `No subscription for command ${commandID} on this socket; subscribe first.`);
+      return;
+    }
+    try {
+      const result = await commandService.interrupt(directory, commandID, owner);
+      if (!result.ok)
+        sendError(ws, "interrupt-failed", result.message);
+    } catch (error) {
+      sendError(ws, "interrupt-failed", error instanceof Error ? error.message : String(error));
+    }
+  }
+  async function handleSocketMessage(ws, raw) {
+    let parsed;
+    try {
+      const text = typeof raw === "string" ? raw : Buffer.from(raw).toString("utf8");
+      parsed = JSON.parse(text);
+    } catch {
+      sendError(ws, "invalid-message", "Message must be JSON.");
+      return;
+    }
+    let validated;
+    try {
+      validated = validateCommandStreamMessage(parsed);
+    } catch (error) {
+      sendError(ws, "invalid-message", `Validation failed: ${String(error)}`);
+      return;
+    }
+    if (!validated.ok) {
+      sendError(ws, "invalid-message", validated.error);
+      return;
+    }
+    const msg = validated.message;
+    try {
+      switch (msg.type) {
+        case "subscribe":
+          await handleSubscribe(ws, msg.commandID, msg.ownerSessionID);
+          break;
+        case "resync":
+          await handleResync(ws, msg.commandID);
+          break;
+        case "unsubscribe":
+          handleUnsubscribe(ws, msg.commandID);
+          break;
+        case "input":
+          await handleInput(ws, msg.commandID, msg.data);
+          break;
+        case "interrupt":
+          await handleInterrupt(ws, msg.commandID);
+          break;
+        default:
+          sendError(ws, "invalid-message", `Message type "${msg.type}" is not accepted inbound.`);
+          break;
+      }
+    } catch (error) {
+      sendError(ws, "internal-error", error instanceof Error ? error.message : String(error));
+    }
+  }
+  async function writeEndpointFile(url) {
+    const endpoint = {
+      url,
+      token,
+      pid: process.pid,
+      generation,
+      startedAt
+    };
+    await fs4.mkdir(path4.dirname(endpointPath), { recursive: true });
+    await fs4.writeFile(endpointPath, JSON.stringify(endpoint, null, 2) + `
+`, { mode: 384 });
+    await fs4.chmod(endpointPath, 384);
   }
-  async function tick() {
-    const state = await readState(directory);
-    let resurrected = 0;
-    for (const goal of state.goals) {
-      const schedule = goal.config.schedule;
-      if (!schedule || typeof schedule.everyMs !== "number" || schedule.everyMs < 1000)
-        continue;
-      const runtime = state.runtimes.find((r) => r.goalID === goal.id);
-      if (!runtime)
-        continue;
-      if (goal.status !== "complete")
-        continue;
-      const count = runtime.scheduleRunCount ?? 0;
-      const max = schedule.maxRuns;
-      if (typeof max === "number" && count >= max)
-        continue;
-      const nextAt = runtime.nextRunAt;
-      if (!nextAt)
-        continue;
-      if (Date.now() < Date.parse(nextAt))
-        continue;
-      const activeWriter = state.goals.find((g) => g.id !== goal.id && g.status === "active" && g.config.workspaceWrite);
-      if (goal.config.workspaceWrite && activeWriter) {
-        await logServerEvent(directory, "schedule.skipped-writer-active", {
-          goalID: goal.id,
-          activeWriter: activeWriter.id
+  return {
+    get url() {
+      return serverURL;
+    },
+    token,
+    generation,
+    endpointPath,
+    async start() {
+      if (started)
+        return;
+      started = true;
+      try {
+        const previous = await fs4.readFile(endpointPath, "utf8").then((text) => JSON.parse(text), () => {
+          return;
         });
-        continue;
-      }
-      if (runtime.phase === "running" || runtime.phase === "queued" || runtime.phase === "compacting")
-        continue;
-      if (leaseIsValid(runtime))
-        continue;
-      const didResurrect = await mutateState(directory, `schedule.tick:${goal.id}`, async (s) => {
-        const g = s.goals.find((x) => x.id === goal.id);
-        const rt = s.runtimes.find((x) => x.goalID === goal.id);
-        if (!g || !rt)
-          return s;
-        if (g.status !== "complete")
-          return s;
-        const curCount = rt.scheduleRunCount ?? 0;
-        if (typeof max === "number" && curCount >= max)
-          return s;
-        const curNext = rt.nextRunAt;
-        if (!curNext || Date.now() < Date.parse(curNext))
-          return s;
-        g.status = "active";
-        g.updatedAt = new Date().toISOString();
-        g.blocker = undefined;
-        Object.assign(rt, releaseLease(rt));
-        rt.activeRunID = undefined;
-        rt.consecutiveFailures = 0;
-        rt.noProgressCount = 0;
-        rt.progressDuringTurn = false;
-        rt.forceFinishRequested = undefined;
-        rt.lastError = undefined;
-        rt.lastScheduleAt = new Date().toISOString();
-        rt.updatedAt = new Date().toISOString();
-        return s;
-      });
-      const after = didResurrect.goals.find((g) => g.id === goal.id);
-      if (!after || after.status !== "active")
-        continue;
-      await appendEvent(directory, {
-        version: 1,
-        eventID: randomUUID4(),
-        goalID: goal.id,
-        type: "schedule.tick",
-        scheduleRunCount: count,
-        nextRunAt: nextAt,
-        timestamp: new Date().toISOString(),
-        revision: didResurrect.revision
-      });
-      await logServerEvent(directory, "schedule.resurrected", {
-        goalID: goal.id,
-        scheduleRunCount: count,
-        nextRunAt: nextAt
+        if (previous && typeof previous.pid === "number" && isPidAlive(previous.pid) && previous.pid !== process.pid) {
+          logServerEvent(directory, "command-stream.superseded-live-endpoint", { pid: previous.pid });
+        }
+      } catch {}
+      const srv = Bun.serve({
+        hostname: "127.0.0.1",
+        port: 0,
+        fetch(req, upgrading) {
+          if (stopped)
+            return new Response("Server is stopping.", { status: 503 });
+          let url;
+          try {
+            url = new URL(req.url);
+          } catch {
+            return new Response("Bad request.", { status: 400 });
+          }
+          if (url.pathname !== "/" && url.pathname !== "/stream") {
+            return new Response("Not found.", { status: 404 });
+          }
+          const presented = url.searchParams.get("token") ?? "";
+          if (!presented || !tokensEqual(presented, token)) {
+            return new Response("Forbidden: valid connection token required.", { status: 403 });
+          }
+          const ok = upgrading.upgrade(req, { data: undefined });
+          if (!ok)
+            return new Response("WebSocket upgrade required.", { status: 400 });
+          return;
+        },
+        websocket: {
+          open(ws) {
+            sockets.add(ws);
+          },
+          message(ws, raw) {
+            handleSocketMessage(ws, raw).catch((error) => {
+              try {
+                sendError(ws, "internal-error", describeError(error));
+              } catch {}
+            });
+          },
+          close(ws) {
+            cleanupSocket(ws);
+          }
+        }
       });
-      const maxLabel = typeof max === "number" ? `/${max}` : "";
-      await appendGoalInbox(directory, goal.id, "user", `Scheduled tick ${count + 1}${maxLabel} \u2014 re-execute the objective now. Previous completion: ${runtime.scheduleRunCount ?? 0} runs. Ensure artifact checks pass for this tick (e.g., append timestamp to tick.txt).`);
+      server = srv;
+      const port = srv.port;
+      serverURL = `ws://127.0.0.1:${port}/stream?token=${token}`;
+      await writeEndpointFile(serverURL);
+      logServerEvent(directory, "command-stream.started", { port, generation });
+    },
+    async stop() {
+      stopped = true;
+      for (const ws of [...sockets]) {
+        try {
+          ws.close(1001, "server shutting down");
+        } catch {}
+        cleanupSocket(ws);
+      }
+      sockets.clear();
+      subsBySocket.clear();
+      handshakeBySocket.clear();
       try {
-        await goalService.continueTurn(directory, goal.id);
-        resurrected++;
+        server?.stop(true);
       } catch {}
+      server = undefined;
+      serverURL = undefined;
+      try {
+        const text = await fs4.readFile(endpointPath, "utf8");
+        const current = JSON.parse(text);
+        if (current?.generation === generation) {
+          await fs4.unlink(endpointPath);
+        } else {
+          logServerEvent(directory, "command-stream.keep-endpoint", {
+            reason: "generation mismatch \u2014 another server owns the file"
+          });
+        }
+      } catch {}
+      logServerEvent(directory, "command-stream.stopped", { generation });
     }
-    return resurrected;
-  }
-  return { start, stop, isRunning, tick };
+  };
 }
 
 // src/server/goal-tools.ts
 init_state_repository();
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 import { tool } from "@opencode-ai/plugin/tool";
 // src/domain/verification.ts
 var MAX_RECENT_ATTEMPTS = 10;
@@ -3298,7 +6625,7 @@ var execAsync = promisify(execChild);
 function goalTools(dir, goalService, hostSessionID, defaults = {}, host) {
   return {
     loopd_create_goal: tool({
-      description: "Create a new background loop goal (contract: objective + checks + agent/model + workspaceWrite). " + "The engine spawns a dedicated worker session that does the work autonomously \u2014 it never runs in this chat. " + "Call this after clarifying the contract with the user. " + "Worker identity is free-form: agent is any OpenCode agent name (built-in, ~/.config/opencode/agents/*.md, or opencode.jsonc agent.* \u2014 discover with `opencode agent list`), " + 'model is any "providerID/modelID" (discover with `opencode models [provider]`). When omitted, both inherit the CALLING session\'s live agent/model (read at creation), then plugin defaultAgent/defaultModel. ' + "Host is the acceptance authority: checks must pass for complete_goal (free retry if rejected <3, blocked after 3). " + "Workspace-writing goals are serialized (only one active writer) and require checks.",
+      description: "Create a new background loop GOAL: an autonomous AI worker that loops turn-by-turn on a multi-step objective until deterministic checks pass or it needs you (contract: objective + checks + agent/model + workspaceWrite). " + "The engine spawns a dedicated worker session that does the work autonomously \u2014 it never runs in this chat. " + "Use this for AI reasoning work spanning multiple turns (implement a feature, fix a failing suite, research and write a report) \u2014 NOT for running a single process you just want to start, watch, and type into. " + "For that (dev servers, `npm test --watch`, REPLs, log tails, one-off scripts, interactive shells with a fullscreen terminal UI), use loopd_command_start instead: it is lighter-weight, has no agent/checks/turn loop, and is a raw OS process, not an AI worker. " + "Call this after clarifying the contract with the user. " + "Worker identity is free-form: agent is any OpenCode agent name (built-in, ~/.config/opencode/agents/*.md, or opencode.jsonc agent.* \u2014 discover with `opencode agent list`), " + 'model is any "providerID/modelID" (discover with `opencode models [provider]`). When omitted, both inherit the CALLING session\'s live agent/model (read at creation), then plugin defaultAgent/defaultModel. ' + "Host is the acceptance authority: checks must pass for complete_goal (free retry if rejected <3, blocked after 3). " + "Workspace-writing goals are serialized (only one active writer) and require checks. " + "Monitor with the /loop dashboard's Goals tab (Tab/h to switch there if Commands is focused).",
       args: {
         name: tool.schema.string().describe("Short goal name (used in the dashboard)."),
         objective: tool.schema.string().describe("What the goal should accomplish, in detail."),
@@ -3418,6 +6745,8 @@ function goalTools(dir, goalService, hostSessionID, defaults = {}, host) {
               ok: true,
               goalID: goal.id,
               workerSessionID: worker.workerSessionID,
+              workerTopology: worker.topology,
+              ...worker.nativeParentID ? { nativeParentID: worker.nativeParentID } : {},
               artifactDir: goal.config.artifactDir,
               agent: resolution.config.agent,
               model: resolution.config.model,
@@ -3430,12 +6759,20 @@ function goalTools(dir, goalService, hostSessionID, defaults = {}, host) {
             })
           };
         } catch (error) {
+          const startFailure = error instanceof GoalStartError ? error : undefined;
           return {
             title: "Goal creation failed",
             output: JSON.stringify({
               ok: false,
               name: args.name,
               message: error instanceof Error ? error.message : String(error),
+              ...startFailure ? {
+                goalID: startFailure.goalID,
+                status: "blocked",
+                failedStage: startFailure.failedStage,
+                ...startFailure.workerSessionID ? { workerSessionID: startFailure.workerSessionID } : {},
+                nextAction: `Resume the persisted goal with resume_goal (goal_id "${startFailure.goalID}") after fixing the cause \u2014 do not create another goal for the same task.`
+              } : {},
               diagnostics: SERVER_LOG_FILE
             })
           };
@@ -3496,7 +6833,7 @@ function goalTools(dir, goalService, hostSessionID, defaults = {}, host) {
         await writeState(dir, state);
         const event = {
           version: 1,
-          eventID: randomUUID5(),
+          eventID: randomUUID11(),
           goalID: goal.id,
           type: "goal.progress",
           summary: args.summary,
@@ -3561,7 +6898,7 @@ Exit code: ${f.exitCode}${stdoutSnippet}${stderrSnippet}`;
 Working directory: ${cwd}
 
 ${failureDetails}`;
-              attemptID = randomUUID5();
+              attemptID = randomUUID11();
               const verificationAttempt = {
                 id: attemptID,
                 sequence: runtime.evaluatorRejectionCount,
@@ -3606,7 +6943,7 @@ ${failureDetails.slice(0, 500)}`,
             if (attemptID) {
               await appendEvent(dir, {
                 version: 1,
-                eventID: randomUUID5(),
+                eventID: randomUUID11(),
                 goalID: goal.id,
                 type: "goal.completion_rejected",
                 attemptID,
@@ -3624,7 +6961,7 @@ ${failureDetails.slice(0, 500)}`,
             if (blocked && rejectedGoal?.blocker) {
               await appendEvent(dir, {
                 version: 1,
-                eventID: randomUUID5(),
+                eventID: randomUUID11(),
                 goalID: goal.id,
                 type: "goal.blocked",
                 reason: rejectedGoal.blocker.reason,
@@ -3684,7 +7021,7 @@ ${failureDetails.slice(0, 500)}`,
             }
             runtime.updatedAt = new Date().toISOString();
           }
-          const attemptID = randomUUID5();
+          const attemptID = randomUUID11();
           const cwd = goal.config.checkCwd || goal.config.artifactDir || dir;
           const checks = (goal.config.checks || []).map((cmd) => ({
             command: cmd,
@@ -3708,7 +7045,7 @@ ${failureDetails.slice(0, 500)}`,
         await writeState(dir, state);
         const event = {
           version: 1,
-          eventID: randomUUID5(),
+          eventID: randomUUID11(),
           goalID: goal.id,
           type: "goal.completed",
           summary: args.summary,
@@ -3768,7 +7105,7 @@ ${failureDetails.slice(0, 500)}`,
         await writeState(dir, state);
         const event = {
           version: 1,
-          eventID: randomUUID5(),
+          eventID: randomUUID11(),
           goalID: goal.id,
           type: "goal.blocked",
           reason: args.reason,
@@ -3948,7 +7285,7 @@ function describeGoalState(status, phase) {
 }
 
 // src/server/owner-tools.ts
-import { promises as fs3 } from "fs";
+import { promises as fs5 } from "fs";
 function withTimeout2(promise, ms) {
   return Promise.race([
     promise,
@@ -4030,9 +7367,24 @@ function ownerTools(options) {
         const ownerID = context?.sessionID;
         const goal = args.goal_id ? state.goals.find((g) => g.id === args.goal_id && g.ownerSessionID === ownerID) : state.goals.find((g) => g.ownerSessionID === ownerID && g.status !== "complete");
         if (!goal) {
+          if (!ownerID) {
+            return {
+              title: "No goal found",
+              output: JSON.stringify({ ok: false, message: "No session context available, so goal ownership cannot be matched." })
+            };
+          }
+          const ownedActive = state.goals.filter((g) => g.ownerSessionID === ownerID && g.status !== "complete");
+          const ownedComplete = state.goals.filter((g) => g.ownerSessionID === ownerID && g.status === "complete").length;
+          const othersActive = state.goals.filter((g) => g.ownerSessionID !== ownerID && g.status !== "complete").length;
+          const message = ownedActive.length > 0 ? `No goal matched (tried ${args.goal_id ? `ID ${args.goal_id}` : "first active goal"}). This session owns ${ownedActive.length} active goal(s) \u2014 pass its goal_id explicitly.` : othersActive > 0 ? `No matching active goal for this session. ${othersActive} active goal(s) exist, all owned by other sessions \u2014 inspect from the owning session.` : ownedComplete > 0 ? "No matching active goal for this session. Your goals are all complete." : "No matching active goal for this session. No goals exist yet \u2014 create one with /goal.";
           return {
             title: "No goal found",
-            output: JSON.stringify({ ok: false, message: "No matching active goal for this session." })
+            output: JSON.stringify({
+              ok: false,
+              message,
+              ownedGoals: ownedActive.map((g) => ({ id: g.id, name: g.name, status: g.status })),
+              ownedElsewhereActive: othersActive
+            })
           };
         }
         const runtime = state.runtimes.find((r) => r.goalID === goal.id);
@@ -4046,7 +7398,7 @@ function ownerTools(options) {
             if (!dir)
               return;
             try {
-              const files = await fs3.readdir(dir);
+              const files = await fs5.readdir(dir);
               return files.length ? `${files.length} file(s): ${files.slice(0, 8).join(", ")}` : "no artifacts yet";
             } catch {
               return "no artifacts yet";
@@ -4068,6 +7420,8 @@ function ownerTools(options) {
             stateSummary: describeGoalState(goal.status, runtime?.phase),
             ownerSessionID: goal.ownerSessionID,
             workerSessionID: goal.workerSessionID,
+            workerTopology: goal.workerTopology,
+            ...goal.nativeParentID ? { nativeParentID: goal.nativeParentID } : {},
             config: {
               maxTurns: goal.config.maxTurns,
               maxFailures: goal.config.maxFailures,
@@ -4516,19 +7870,361 @@ function ownerTools(options) {
   };
 }
 
+// src/server/command-tools.ts
+init_command_await2();
+import { tool as tool3 } from "@opencode-ai/plugin/tool";
+function ownerID(context) {
+  const id = context?.sessionID;
+  return typeof id === "string" && id.length > 0 ? id : undefined;
+}
+function denied() {
+  return {
+    title: "No session",
+    output: JSON.stringify({
+      ok: false,
+      message: "No session context available. Arbitrary commands require an owning session and are never auto-allowed.",
+      errorCode: "no_session"
+    })
+  };
+}
+function summarize(c) {
+  return {
+    id: c.id,
+    title: c.title,
+    argv: [c.command, ...c.args],
+    status: c.status,
+    exitCode: c.exitCode,
+    signal: c.signal,
+    endReason: c.endReason,
+    timeoutSeconds: c.timeoutSeconds,
+    deadlineAt: c.deadlineAt,
+    envKeys: c.envKeys,
+    shell: c.shell,
+    watchFilter: c.watchFilter,
+    watchUntil: c.watchUntil,
+    watchIgnoreCase: c.watchIgnoreCase,
+    watchUntilAction: c.watchUntilAction,
+    watchState: c.watchState,
+    outputBytes: c.outputBytes,
+    truncated: c.truncated,
+    goalID: c.goalID,
+    notifyOnExit: c.notifyOnExit,
+    updatedAt: c.updatedAt
+  };
+}
+function commandTools(options) {
+  const { directory, commandService } = options;
+  const capabilities = options.capabilities ?? COMMAND_HOST_CAPABILITIES;
+  const sizeNote = capabilities.resize ? "applied live to the PTY winsize" : "stored; resize is unsupported by the pipe host";
+  return {
+    loopd_command_start: tool3({
+      description: "Start a standalone interactive OS process (arbitrary shell command) in the background \u2014 a dev server, `npm test --watch`, a REPL, a log tail, a build, or a one-off script. This is a raw process, NOT an AI worker: no agent, no checks, no turn loop. For multi-turn autonomous AI work with completion criteria, use loopd_create_goal instead. " + "Returns a command_id for loopd_command_get (read output)/loopd_command_write (send stdin)/loopd_command_interrupt (Ctrl+C)/loopd_command_terminate (kill)/loopd_command_remove (delete). " + "The user can also open it live: /loop or /commands \u2192 Tab/l to the Commands tab \u2192 select it \u2192 `o` opens a fullscreen interactive terminal page (type directly, Ctrl+C interrupts, Ctrl+] detaches without stopping it). " + "Independent from goals: an optional goal_id is display-only metadata and never couples lifecycles \u2014 pausing/clearing a goal never touches the command, and terminating a command never touches the goal. " + "To make a specific goal wake up when this command finishes, call loopd_command_await separately after starting it (linking alone does not wake anything). " + "The OWNER session (you) gets pushed a real message when the command reaches a terminal status \u2014 no polling required to find out: by default (auto) that fires on a non-zero exit, on 'missing' (host restarted mid-run), on 'timeout' (timeout_seconds deadline reached \u2014 always notifies), or once total runtime crosses ~2 minutes (the long-running/monitor case); quick successful commands stay silent. Override with notify_on_exit.",
+      args: {
+        title: tool3.schema.string().describe("Short human label for the session."),
+        command: tool3.schema.string().describe('Executable to spawn (e.g. "bun", "python3").'),
+        args: tool3.schema.array(tool3.schema.string()).optional().describe("Arguments for the command."),
+        cwd: tool3.schema.string().optional().describe("Working directory. Defaults to the project root."),
+        goal_id: tool3.schema.string().optional().describe("Optional goal linkage (display only \u2014 no lifecycle coupling)."),
+        notify_on_exit: tool3.schema.boolean().optional().describe("Owner-exit-notification override. true = always push a message to you when this command finishes. false = never (dashboard/loopd_command_get only). Omit for auto (failure, lost-host, timeout, or long-running success)."),
+        cols: tool3.schema.number().optional().describe(`Requested terminal width (${sizeNote}).`),
+        rows: tool3.schema.number().optional().describe(`Requested terminal height (${sizeNote}).`),
+        env: tool3.schema.record(tool3.schema.string(), tool3.schema.string()).optional().describe("Extra environment variables for the child. Values are passed to the host but never persisted \u2014 only names appear as envKeys in summaries."),
+        timeout_seconds: tool3.schema.number().optional().describe("Per-command timeout in seconds (positive integer). The command is terminated via the standard SIGTERM\u2192SIGKILL path when the deadline passes; endReason becomes 'timeout' and the owner is always notified (auto policy). In-memory only \u2014 never resurrected across restarts."),
+        shell: tool3.schema.boolean().optional().describe("When true, spawn via /bin/sh -c with command+args joined into one shell string (POSIX single-quote escaping). Shell metacharacters are interpreted; prefer argv form for untrusted input."),
+        watch_filter: tool3.schema.string().optional().describe("Watch line filter (regex on ANSI-stripped lines): only matching lines buffer toward a coalesced owner push (one push per ~2s window, \u226420 lines/\u22644KB each, \u226430 pushes per command; 100+ lines/sec suspends with one notice). For never-exiting processes (dev servers, log tails). Adjust later via loopd_command_watch."),
+        watch_until: tool3.schema.string().optional().describe("Watch until pattern (regex on the filter-surviving stream): first match notifies the owner immediately with the matched lines. With watch_until_action=stop (default) the command is terminated with endReason=until (exactly one owner message total); with keep it keeps running (until fires once, filter stream continues)."),
+        watch_ignore_case: tool3.schema.boolean().optional().describe("Case-insensitive watch matching (default false)."),
+        watch_until_action: tool3.schema.string().optional().describe('Until action: "stop" (default) terminates the command on first until-match; "keep" notifies but keeps running (until fires once, filter stream continues).')
+      },
+      execute: async (args, context) => {
+        const owner = ownerID(context);
+        if (!owner)
+          return denied();
+        try {
+          const argv = [args.command, ...args.args ?? []];
+          await context.ask({
+            permission: "bash",
+            patterns: [argv.join(" ")],
+            always: [args.command],
+            metadata: { command: args.command, args: args.args ?? [], cwd: args.cwd ?? directory }
+          });
+          if (args.watch_until_action !== undefined && args.watch_until_action !== "stop" && args.watch_until_action !== "keep") {
+            throw new Error(`Invalid watch_until_action '${args.watch_until_action}': must be "stop" or "keep".`);
+          }
+          const session = await commandService.start(directory, {
+            title: args.title,
+            command: args.command,
+            args: args.args ?? [],
+            cwd: args.cwd,
+            ownerSessionID: owner,
+            goalID: args.goal_id,
+            notifyOnExit: args.notify_on_exit,
+            cols: args.cols,
+            rows: args.rows,
+            env: args.env,
+            timeoutSeconds: args.timeout_seconds,
+            shell: args.shell,
+            watchFilter: args.watch_filter,
+            watchUntil: args.watch_until,
+            watchIgnoreCase: args.watch_ignore_case,
+            watchUntilAction: args.watch_until_action
+          });
+          return {
+            title: "Command started",
+            output: JSON.stringify({ ok: true, command: summarize(session), capabilities }, null, 2)
+          };
+        } catch (error) {
+          return {
+            title: "Command not started",
+            output: JSON.stringify({ ok: false, message: error instanceof Error ? error.message : String(error) })
+          };
+        }
+      }
+    }),
+    loopd_command_list: tool3({
+      description: "List standalone command sessions owned by this session (same set the TUI Commands tab shows for this session). Use before reading/writing to find a command's ID, or to check if a dev server/watcher you started earlier is still running.",
+      args: {},
+      execute: async (_args, context) => {
+        const owner = ownerID(context);
+        if (!owner)
+          return denied();
+        const sessions = await commandService.list(directory, owner);
+        return {
+          title: `${sessions.length} command session(s)`,
+          output: JSON.stringify({ ok: true, commands: sessions.map((c) => summarize(c)), capabilities }, null, 2)
+        };
+      }
+    }),
+    loopd_command_get: tool3({
+      description: "Read a command session's status plus its output so far (bounded snapshot; page with offset_bytes for more). For progress checks on plain one-shot commands, read once or twice as needed \u2014 but for never-exiting processes (dev servers, log tails, watch mode) prefer watch_filter/watch_until at start (or loopd_command_watch on a running command) and loopd_command_await for goal wakes: the owner gets pushed on match/exit with no repeated reads. Never terminates the command; detach/inspect is always read-only. With pattern, only matching lines return (regex on ANSI-stripped text, original lines kept; dangerous nested-quantifier patterns are rejected) and offset_bytes/limit_bytes page over MATCHES (match index + max matched lines, default 500).",
+      args: {
+        command_id: tool3.schema.string().describe("Command session ID."),
+        offset_bytes: tool3.schema.number().optional().describe("Byte offset into the output log (paging). With pattern: number of matching lines to skip."),
+        limit_bytes: tool3.schema.number().optional().describe("Max bytes to return (default 64KB, cap 256KB). With pattern: max matching lines (default 500)."),
+        pattern: tool3.schema.string().optional().describe("Regex to filter lines (matched against ANSI-stripped text; original lines returned). Dangerous nested-quantifier patterns are rejected."),
+        ignore_case: tool3.schema.boolean().optional().describe("Case-insensitive pattern matching (default false).")
+      },
+      execute: async (args, context) => {
+        const owner = ownerID(context);
+        if (!owner)
+          return denied();
+        let result;
+        try {
+          result = await commandService.read(directory, args.command_id, owner, {
+            offsetBytes: args.offset_bytes,
+            limitBytes: args.limit_bytes,
+            pattern: args.pattern,
+            ignoreCase: args.ignore_case
+          });
+        } catch (error) {
+          return { title: "Read failed", output: JSON.stringify({ ok: false, message: error instanceof Error ? error.message : String(error) }) };
+        }
+        if (!result) {
+          return { title: "Not found", output: JSON.stringify({ ok: false, message: "Command not found for this session." }) };
+        }
+        return {
+          title: `Command: ${result.session.title}`,
+          output: JSON.stringify({
+            ok: true,
+            command: summarize(result.session),
+            output: result.text,
+            startByte: result.startByte,
+            totalBytes: result.totalBytes,
+            live: result.live,
+            ...result.pattern !== undefined ? { pattern: result.pattern, totalMatches: result.totalMatches } : {}
+          }, null, 2)
+        };
+      }
+    }),
+    loopd_command_write: tool3({
+      description: "Send raw input (stdin bytes) to a running command session \u2014 e.g. answer a REPL prompt, confirm a y/n, or type a command into an interactive shell you started. Include a trailing newline yourself if the program is line-buffered.",
+      args: {
+        command_id: tool3.schema.string().describe("Command session ID."),
+        input: tool3.schema.string().describe("Raw text to write to stdin (include trailing newline for line-buffered programs).")
+      },
+      execute: async (args, context) => {
+        const owner = ownerID(context);
+        if (!owner)
+          return denied();
+        const result = await commandService.write(directory, args.command_id, owner, args.input);
+        return { title: result.ok ? "Input sent" : "Write failed", output: JSON.stringify({ ...result, command_id: args.command_id }) };
+      }
+    }),
+    loopd_command_interrupt: tool3({
+      description: "Deliver SIGINT (Ctrl+C) to a running command. The process may trap and continue \u2014 that is correct, not a failure. Never kills unconditionally.",
+      args: {
+        command_id: tool3.schema.string().describe("Command session ID.")
+      },
+      execute: async (args, context) => {
+        const owner = ownerID(context);
+        if (!owner)
+          return denied();
+        const result = await commandService.interrupt(directory, args.command_id, owner);
+        return { title: result.ok ? "Interrupted" : "Interrupt failed", output: JSON.stringify({ ...result, command_id: args.command_id }) };
+      }
+    }),
+    loopd_command_terminate: tool3({
+      description: "Terminate a running command (SIGTERM, escalates to SIGKILL). Stopping a command never pauses/blocks any goal. With remove:true, the record+log are deleted in the same call (atomic from the caller's perspective; proceeds to remove even when the command is already terminal).",
+      args: {
+        command_id: tool3.schema.string().describe("Command session ID."),
+        remove: tool3.schema.boolean().optional().describe("Also remove the record+log after terminating (or when already terminal).")
+      },
+      execute: async (args, context) => {
+        const owner = ownerID(context);
+        if (!owner)
+          return denied();
+        const result = await commandService.terminate(directory, args.command_id, owner, { remove: args.remove });
+        return { title: result.ok ? "Terminated" : "Terminate failed", output: JSON.stringify({ ...result, command_id: args.command_id }) };
+      }
+    }),
+    loopd_command_remove: tool3({
+      description: "Remove a finished command session and its output log. Refuses while running (terminate \u2260 remove).",
+      args: {
+        command_id: tool3.schema.string().describe("Command session ID.")
+      },
+      execute: async (args, context) => {
+        const owner = ownerID(context);
+        if (!owner)
+          return denied();
+        const result = await commandService.remove(directory, args.command_id, owner);
+        return { title: result.ok ? "Removed" : "Remove failed", output: JSON.stringify({ ...result, command_id: args.command_id }) };
+      }
+    }),
+    loopd_command_watch: tool3({
+      description: 'Set, replace, or clear a watch on an ALREADY-RUNNING command \u2014 line-level filter/until notifications for never-exiting processes (dev servers, log tails, watch mode). watch_filter buffers only matching lines toward a coalesced owner push (one push per ~2s window, \u226420 lines/\u22644KB each, \u226430 pushes per command); watch_until fires once on the first matching line of the filter-surviving stream with an immediate owner notice. watch_until_action "stop" (default) terminates the command on first until-match (endReason=until); "keep" notifies but keeps running (until fires once, the filter stream continues). Replacing the spec resets counters/state to active. Fail closed: invalid or dangerous regexes are rejected and the previous watch (if any) is left untouched; watching a terminal command returns ok:false (watch is meaningless after exit).',
+      args: {
+        command_id: tool3.schema.string().describe("Command session ID (must be running)."),
+        watch_filter: tool3.schema.string().optional().describe("Watch line filter (regex on ANSI-stripped lines): only matching lines buffer toward a coalesced owner push. Omit (or pair with clear) to remove."),
+        watch_until: tool3.schema.string().optional().describe("Watch until pattern (regex on the filter-surviving stream): first match notifies the owner immediately. With watch_until_action=stop (default) the command is terminated with endReason=until; with keep it keeps running."),
+        watch_ignore_case: tool3.schema.boolean().optional().describe("Case-insensitive watch matching (default false)."),
+        watch_until_action: tool3.schema.string().optional().describe('Until action: "stop" (default) terminates the command on first until-match; "keep" notifies but keeps running (until fires once, filter stream continues).'),
+        clear: tool3.schema.boolean().optional().describe("When true, drop the watch entirely (spec + counters + in-memory watcher) instead of setting one.")
+      },
+      execute: async (args, context) => {
+        const owner = ownerID(context);
+        if (!owner)
+          return denied();
+        try {
+          if (args.watch_until_action !== undefined && args.watch_until_action !== "stop" && args.watch_until_action !== "keep") {
+            throw new Error(`Invalid watch_until_action '${args.watch_until_action}': must be "stop" or "keep".`);
+          }
+          const result = await commandService.watch(directory, args.command_id, owner, {
+            ...args.watch_filter !== undefined ? { filter: args.watch_filter } : {},
+            ...args.watch_until !== undefined ? { until: args.watch_until } : {},
+            ...args.watch_ignore_case !== undefined ? { ignoreCase: args.watch_ignore_case } : {},
+            ...args.watch_until_action !== undefined ? { untilAction: args.watch_until_action } : {},
+            ...args.clear !== undefined ? { clear: args.clear } : {}
+          });
+          if (!result.ok) {
+            return { title: "Watch not set", output: JSON.stringify({ ...result, command_id: args.command_id }) };
+          }
+          return {
+            title: "Watch updated",
+            output: JSON.stringify({ ok: true, message: result.message, command: summarize(result.command), command_id: args.command_id }, null, 2)
+          };
+        } catch (error) {
+          return {
+            title: "Watch not set",
+            output: JSON.stringify({ ok: false, message: error instanceof Error ? error.message : String(error), command_id: args.command_id })
+          };
+        }
+      }
+    }),
+    loopd_command_await: tool3({
+      description: "Opt in to a one-shot wake-up: the given goal wakes when the given command reaches a terminal status (exited/terminated/missing) with the exit code, signal, and last 4KB of output as evidence. With 'until', the goal instead wakes ONCE on the first output line matching the regex (evidence: matched lines + bounded tail) and the command keeps running \u2014 use this to have a GOAL worker block until a never-exiting process prints something (e.g. 'wait until the dev server prints ready') without polling. Explicit opt-in only \u2014 a merely linked command (goal_id passed to loopd_command_start) never wakes its goal on its own; this call is required. Exactly-once: the await is consumed on fire, output chunks never fire exit-awaits, pausing/clearing the goal or removing the command cancels it.",
+      args: {
+        command_id: tool3.schema.string().describe("Command session ID to await."),
+        goal_id: tool3.schema.string().describe("Goal ID to wake on exit. You must own both the goal and the command."),
+        until: tool3.schema.string().optional().describe("Regex to wake on: fires once on the first matching output line (matched lines + bounded tail as evidence) without stopping the command. Dangerous nested-quantifier patterns are rejected."),
+        ignore_case: tool3.schema.boolean().optional().describe("Case-insensitive until matching (default false).")
+      },
+      execute: async (args, context) => {
+        const owner = ownerID(context);
+        if (!owner)
+          return denied();
+        const result = await requestCommandAwait(directory, {
+          goalID: args.goal_id,
+          commandID: args.command_id,
+          ownerSessionID: owner,
+          ...args.until !== undefined ? { until: args.until } : {},
+          ...args.ignore_case !== undefined ? { ignoreCase: args.ignore_case } : {}
+        });
+        if (result.ok && result.fired && result.active && options.goalService) {
+          await wakeGoalForAwait(directory, options.goalService, args.goal_id).catch(() => {});
+        }
+        return {
+          title: result.ok ? "Await registered" : "Await failed",
+          output: JSON.stringify({ ...result, command_id: args.command_id, goal_id: args.goal_id })
+        };
+      }
+    }),
+    loopd_command_resize: tool3({
+      description: capabilities.resize ? "Apply a terminal size to a running command (live PTY winsize; the requested size is also stored)." : "Request a terminal size for a command. Honestly unsupported by the pipe host: size is stored, never applied.",
+      args: {
+        command_id: tool3.schema.string().describe("Command session ID."),
+        cols: tool3.schema.number().describe("Requested width."),
+        rows: tool3.schema.number().describe("Requested height.")
+      },
+      execute: async (args, context) => {
+        const owner = ownerID(context);
+        if (!owner)
+          return denied();
+        const result = await commandService.resize(directory, args.command_id, owner, args.cols, args.rows);
+        return { title: "Resize", output: JSON.stringify({ ...result, command_id: args.command_id }) };
+      }
+    })
+  };
+}
+
 // src/server/plugin.ts
 init_state_repository();
+// package.json
+var version = "1.10.4";
+
+// src/server/plugin.ts
 var PLUGIN_ID = "opencode-loopd.server";
 var server = async ({ client, directory }, pluginOptions) => {
   const defaults = parsePluginDefaults(pluginOptions);
   const host = createRealHost(client, directory);
+  logServerEvent(directory, "plugin.loaded", { pluginID: PLUGIN_ID, host: "v1", version });
   return createServerHooks(directory, host, defaults);
 };
 function createServerHooks(directory, host, defaults) {
   const goalService = createGoalService(host);
+  const commandBroker = createCommandEventBroker();
+  const commandHost = createCommandHost();
+  const commandService = createCommandService(commandHost, {
+    broker: commandBroker,
+    onAwaitFired: async (dir, fired) => {
+      await Promise.resolve().then(() => init_command_await2());
+      for (const f of fired) {
+        if (!f.active)
+          continue;
+        await wakeGoalForAwait(dir, goalService, f.goalID).catch((error) => logServerEvent(dir, "command.await-wake-failed", {
+          goalID: f.goalID,
+          commandID: f.commandID,
+          detail: describeError(error)
+        }));
+      }
+    },
+    onOwnerNotify: async (dir, ownerSessionID, message) => {
+      await host.notifyOwner(ownerSessionID, message).catch((error) => logServerEvent(dir, "command.owner-notify-failed", {
+        ownerSessionID,
+        detail: describeError(error)
+      }));
+    },
+    onWatchNotify: async (dir, ownerSessionID, message) => {
+      await host.notifyOwner(ownerSessionID, message).catch((error) => logServerEvent(dir, "command.watch-notify-failed", {
+        ownerSessionID,
+        detail: describeError(error)
+      }));
+    }
+  });
+  const commandStream = createCommandStreamServer(directory, commandService, commandBroker);
   const worker = createControlWorker({
     directory,
     goalService,
+    commandService,
     pollIntervalMs: 1000,
     defaults
   });
@@ -4552,13 +8248,26 @@ function createServerHooks(directory, host, defaults) {
     engine.start();
     worker.start();
     scheduleWorker.start();
+    commandStream.start().catch((error) => logServerEvent(directory, "command-stream.start-failed", { detail: describeError(error) }));
   }
   function reconcileInBackground() {
     if (reconciliationStarted)
       return;
     reconciliationStarted = true;
     logServerEvent(directory, "reconcile.started");
-    goalService.reconcile(directory).then(() => logServerEvent(directory, "reconcile.completed"), (error) => logServerEvent(directory, "reconcile.failed", { detail: describeError(error) }));
+    goalService.reconcile(directory).then(() => commandService.reconcile(directory), (error) => logServerEvent(directory, "reconcile.failed", { detail: describeError(error) })).then(async () => {
+      await Promise.resolve().then(() => init_command_await2());
+      const fired = await reconcileCommandAwaits(directory);
+      for (const f of fired) {
+        if (!f.active)
+          continue;
+        await wakeGoalForAwait(directory, goalService, f.goalID).catch((error) => logServerEvent(directory, "command.await-wake-failed", {
+          goalID: f.goalID,
+          commandID: f.commandID,
+          detail: describeError(error)
+        }));
+      }
+    }, (error) => logServerEvent(directory, "reconcile.failed", { detail: describeError(error) })).then(() => logServerEvent(directory, "reconcile.completed"), (error) => logServerEvent(directory, "reconcile.failed", { detail: describeError(error) }));
   }
   return {
     event: async ({ event }) => {
@@ -4570,7 +8279,7 @@ function createServerHooks(directory, host, defaults) {
       if (type?.startsWith("session."))
         reconcileInBackground();
     },
-    tool: { ...goalTools(directory, goalService, undefined, defaults, host), ...ownerTools({ directory, host, goalService }) },
+    tool: { ...goalTools(directory, goalService, undefined, defaults, host), ...ownerTools({ directory, host, goalService }), ...commandTools({ directory, commandService, capabilities: commandHost.capabilities, goalService }) },
     "tool.execute.before": async (input, _output) => {
       const activeWorkers = goalService.getActiveWorkers();
       let matchedGoalID;
@@ -4648,9 +8357,11 @@ function createServerHooks(directory, host, defaults) {
       }
     },
     dispose: async () => {
+      await commandStream.stop().catch(() => {});
       engine.stop();
       await worker.stop();
       scheduleWorker.stop();
+      await commandService.dispose(directory);
     }
   };
 }
@@ -4668,10 +8379,19 @@ var v2 = {
   id: PLUGIN_ID,
   async setup(context) {
     const directory = context.location.directory;
+    logServerEvent(directory, "plugin.loaded", { pluginID: PLUGIN_ID, host: "v2", version });
     const statuses = new Map;
-    const host = createV2Host(context, statuses);
+    const native = await setupNativeServer(context);
+    if (native) {
+      logServerEvent(directory, "native-bridge.ready", { pluginID: PLUGIN_ID });
+    } else {
+      logServerEvent(directory, "native-bridge.unsupported", { pluginID: PLUGIN_ID });
+    }
+    const host = createV2Host(context, statuses, native ? { native } : undefined);
     const hooks = createServerHooks(directory, host, parsePluginDefaults(context.options));
     const registrations = [];
+    if (native)
+      registrations.push({ dispose: () => native.dispose() });
     const eventController = new AbortController;
     let eventTask = Promise.resolve();
     let disposed = false;
@@ -4729,6 +8449,7 @@ function toV2Tool(id, definition, directory) {
   return {
     name: id,
     description: definition.description,
+    ...id === "loopd_command_start" ? { permission: "bash" } : {},
     input: v1Tool.schema.object(definition.args),
     async execute(input, context) {
       const result = await definition.execute(input, {
@@ -4774,6 +8495,17 @@ function normalizeV2Event(event) {
     return { type: "session.compacted", properties };
   if (event?.type === "session.execution.failed")
     return { type: "session.error", properties };
+  if (event?.type === "session.execution.succeeded")
+    return { type: "session.execution.succeeded", properties };
+  if (event?.type === "session.inbox.delivered") {
+    return {
+      type: "message.updated",
+      properties: {
+        sessionID: properties.sessionID,
+        info: { role: "user", id: properties.inboxID }
+      }
+    };
+  }
   if (event?.type === "session.message.content.updated") {
     return {
       type: "message.part.updated",
@@ -4791,5 +8523,6 @@ var plugin_default = {
   setup: v2.setup
 };
 export {
-  plugin_default as default
+  plugin_default as default,
+  normalizeV2Event
 };