@bojackduy/opencode-loopd 1.10.1 → 1.10.3

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,16 @@ 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 = [];
+  }
   return result;
 }
 async function writeAtomic(target, contents) {
@@ -480,18 +490,373 @@ 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 = 8, 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/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 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()
+      }];
+      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()
+      }];
+    }
+    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"
+    };
+  }
+  await appendEvent(directory, ledgerEvent({
+    goalID: input.goalID,
+    commandID: input.commandID,
+    type: "command.await-requested"
+  })).catch(() => {});
+  return { ok: true, message: `Goal "${goal.name}" now awaits "${command.title}" (fires once on exit).` };
+}
+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_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 +965,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 +1229,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 +1270,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 +1281,103 @@ 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": {
+        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 {
+              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 +1392,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 +1417,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 +1462,7 @@ var HANDLED_EVENT_TYPES = new Set([
   "session.status",
   "session.error",
   "session.compacted",
+  "session.execution.succeeded",
   "message.updated",
   "message.part.updated"
 ]);
@@ -1100,6 +1567,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 +1609,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 +1697,7 @@ function createLoopEngine(options) {
         if (newlyStamped) {
           await appendEvent(directory, {
             version: 1,
-            eventID: randomUUID2(),
+            eventID: randomUUID3(),
             goalID,
             type: "idle.confirm-failed",
             reason: failureReason,
@@ -1260,7 +1742,7 @@ function createLoopEngine(options) {
     if (completedRunID) {
       await appendEvent(directory, {
         version: 1,
-        eventID: randomUUID2(),
+        eventID: randomUUID3(),
         goalID,
         type: "run.completed",
         runID: completedRunID,
@@ -1325,7 +1807,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 +1831,7 @@ function createLoopEngine(options) {
       });
       await appendEvent(directory, {
         version: 1,
-        eventID: randomUUID2(),
+        eventID: randomUUID3(),
         goalID,
         type: "goal.status_changed",
         from: "active",
@@ -1451,7 +1933,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 +1946,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 +1974,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 +2044,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 +2102,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 +2278,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 +2312,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 +2352,7 @@ function createLoopEngine(options) {
             });
             await appendEvent(directory, {
               version: 1,
-              eventID: randomUUID2(),
+              eventID: randomUUID3(),
               goalID: goal.id,
               type: "run.stuck",
               runID: runtime.activeRunID,
@@ -1893,12 +2375,14 @@ 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
+import { randomUUID as randomUUID4 } from "crypto";
 function parseModelRef(value) {
   if (value === undefined)
     return;
@@ -1916,6 +2400,12 @@ function parseModelRef(value) {
   }
   return { providerID, modelID };
 }
+function newPromptMessageID() {
+  return `msg_${randomUUID4()}`;
+}
+function isV2PromptMessageID(messageID) {
+  return messageID.startsWith("msg_");
+}
 var recentParentNotifies = new Map;
 function shouldDedupParentNotify(ownerSessionID, message) {
   const key = `${ownerSessionID}:${message.slice(0, 200)}`;
@@ -1962,8 +2452,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;
@@ -2131,6 +2620,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 +2630,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 {
@@ -2370,6 +2862,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 +2895,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 +2941,7 @@ function createGoalService(host) {
     });
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID3(),
+      eventID: randomUUID5(),
       goalID,
       type: "run.failed",
       runID,
@@ -2448,7 +2953,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}`,
@@ -2482,7 +2987,7 @@ function createGoalService(host) {
     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 +3026,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 +3067,7 @@ function createGoalService(host) {
       });
       await appendEvent(directory, {
         version: 1,
-        eventID: randomUUID3(),
+        eventID: randomUUID5(),
         goalID: id,
         type: "goal.blocked",
         reason: detail,
@@ -2571,7 +3076,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) => {
@@ -2583,8 +3088,8 @@ function createGoalService(host) {
       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 +3099,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 +3111,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 +3123,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 +3224,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 +3242,7 @@ function createGoalService(host) {
       return;
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID3(),
+      eventID: randomUUID5(),
       goalID,
       type: "run.started",
       runID: freshRuntime.activeRunID,
@@ -2819,8 +3328,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 +3343,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 +3363,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 +3385,7 @@ function createGoalService(host) {
     }
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID3(),
+      eventID: randomUUID5(),
       goalID,
       type: "goal.status_changed",
       from: "paused",
@@ -2889,7 +3401,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 +3437,7 @@ function createGoalService(host) {
     }
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID3(),
+      eventID: randomUUID5(),
       goalID,
       type: "goal.status_changed",
       from: "blocked",
@@ -2952,11 +3464,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(),
@@ -3164,7 +3677,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;
@@ -3252,7 +3765,7 @@ function createScheduleWorker(options) {
         continue;
       await appendEvent(directory, {
         version: 1,
-        eventID: randomUUID4(),
+        eventID: randomUUID6(),
         goalID: goal.id,
         type: "schedule.tick",
         scheduleRunCount: count,
@@ -3277,71 +3790,1526 @@ function createScheduleWorker(options) {
   return { start, stop, isRunning, tick };
 }
 
-// src/server/goal-tools.ts
-init_state_repository();
-import { randomUUID as randomUUID5 } from "crypto";
-import { tool } from "@opencode-ai/plugin/tool";
-// src/domain/verification.ts
-var MAX_RECENT_ATTEMPTS = 10;
-function appendVerificationAttempt(recent, attempt) {
-  const next = [...recent, attempt];
-  if (next.length > MAX_RECENT_ATTEMPTS) {
-    return next.slice(next.length - MAX_RECENT_ATTEMPTS);
+// 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 {}
   }
-  return next;
 }
-
-// src/server/goal-tools.ts
-import { exec as execChild } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(execChild);
-function goalTools(dir, goalService, hostSessionID, defaults = {}, host) {
+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 {
-    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.",
-      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."),
-        agent: tool.schema.string().optional().describe(`Agent to run the worker as (e.g. "researcher", "smart-agent"). Optional \u2014 inherits the calling session's agent if omitted, else plugin defaultAgent.`),
-        model: tool.schema.string().optional().describe(`Model to run the worker as, as "providerID/modelID" (e.g. "openai/gpt-5.6-sol", "ollama/qwen3.8:27b"). Optional \u2014 inherits the calling session's live model if omitted, else plugin defaultModel.`),
-        costBudget: tool.schema.number().optional().describe("Max provider cost in dollars before the engine stops the goal as budget_limited (e.g. 0.5). Optional \u2014 unlimited if omitted."),
-        checks: tool.schema.array(tool.schema.string()).optional().describe('Shell commands that must pass for completion to be accepted. E.g. ["npm test"].'),
-        checkCwd: tool.schema.string().optional().describe("Directory where completion checks run. Workspace-writing goals default to the project root."),
-        workspaceWrite: tool.schema.boolean().optional().describe("Whether this goal edits the shared project workspace. Defaults to true; explicitly set false for artifact-only/read-only work."),
-        progressFile: tool.schema.string().optional().describe("Markdown file the worker reads/writes as its transaction state."),
-        maxTurns: tool.schema.number().optional().describe("Max turns before auto-block."),
-        maxNoProgress: tool.schema.number().optional().describe("Block after N turns without progress."),
-        maxFailures: tool.schema.number().optional().describe("Block after N consecutive failures."),
-        compactEvery: tool.schema.number().optional().describe("Compact the worker session every N turns."),
-        timeoutMs: tool.schema.number().optional().describe("Per-turn timeout in ms."),
-        scheduleEveryMs: tool.schema.number().optional().describe("Interval in ms to auto-requeue the same goal after each completion. Minimum 1000. Enables repetitive dialogue reduction."),
-        scheduleMaxRuns: tool.schema.number().optional().describe("Maximum total runs including the initial run. Undefined = unlimited. Requires scheduleEveryMs.")
-      },
-      execute: async (args, context) => {
-        const sessionID = context?.sessionID || hostSessionID;
-        if (!sessionID || sessionID === "main") {
-          return {
-            title: "Goal not created",
-            output: JSON.stringify({
-              ok: false,
-              message: "A valid owner session is required. Run /goal from an active OpenCode session."
-            })
-          };
-        }
-        const config = {
-          maxTurns: 50
+    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)
         };
-        if (args.agent)
-          config.agent = args.agent;
-        if (args.model)
-          config.model = args.model;
-        if (args.checks)
-          config.checks = args.checks;
-        if (args.checkCwd)
-          config.checkCwd = args.checkCwd;
-        if (args.workspaceWrite !== undefined)
-          config.workspaceWrite = args.workspaceWrite;
-        if (args.progressFile)
+        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 randomUUID7 } from "crypto";
+import { promises as fs3 } from "fs";
+import path3 from "path";
+
+// src/domain/command-session.ts
+function createCommandSession(input) {
+  const now = new Date().toISOString();
+  return {
+    id: input.id,
+    title: input.title,
+    command: input.command,
+    args: input.args ?? [],
+    cwd: input.cwd,
+    ownerSessionID: input.ownerSessionID,
+    goalID: input.goalID,
+    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;
+
+// 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();
+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;
+  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 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;
+      }
+    }
+    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;
+      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 {}
+  }
+  async function persistExit(directory, id, info) {
+    rememberDir(id, directory);
+    live.delete(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;
+      c.exitCode = info.exitCode;
+      if (info.signal && (c.signal === "SIGKILL" || c.signal === "SIGTERM")) {
+        c.status = "terminated";
+      } else {
+        c.status = "exited";
+        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: randomUUID7(),
+      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);
+  }
+  function owned(cmd, ownerSessionID) {
+    return !!cmd && cmd.ownerSessionID === ownerSessionID;
+  }
+  return {
+    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 id = randomUUID7();
+      const cwd = input.cwd || directory;
+      const pending = [];
+      let ready = false;
+      const handle = host.spawn({ command, args: input.args ?? [], cwd, cols: input.cols, rows: input.rows }, (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,
+        pid: handle.pid,
+        cols: input.cols,
+        rows: input.rows
+      });
+      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 });
+      rememberDir(id, directory);
+      await appendEvent(directory, {
+        version: 1,
+        eventID: randomUUID7(),
+        ...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 this.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 this.get(directory, id, ownerSessionID);
+      if (!session)
+        return;
+      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 this.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 this.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 this.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) {
+      rememberDir(id, directory);
+      const session = await this.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 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;
+      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 (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 (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);
+      return { ok: true, message: `Command "${session.title}" ${status}.` };
+    },
+    async remove(directory, id, ownerSessionID) {
+      rememberDir(id, directory);
+      const session = await this.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).` };
+      }
+      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 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);
+            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.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);
+          }
+          continue;
+        }
+        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.lastError = "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);
+      }
+      return { markedMissing };
+    },
+    async dispose(directory) {
+      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 this.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);
+      }));
+    }
+  };
+}
+
+// src/application/command-event-broker.ts
+import { randomUUID as randomUUID8 } 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 = randomUUID8();
+      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 randomUUID9, 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 = randomUUID9();
+  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);
+  }
+  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;
+        });
+        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);
+          }
+        }
+      });
+      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 {
+        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 });
+    }
+  };
+}
+
+// src/server/goal-tools.ts
+init_state_repository();
+import { randomUUID as randomUUID10 } from "crypto";
+import { tool } from "@opencode-ai/plugin/tool";
+// src/domain/verification.ts
+var MAX_RECENT_ATTEMPTS = 10;
+function appendVerificationAttempt(recent, attempt) {
+  const next = [...recent, attempt];
+  if (next.length > MAX_RECENT_ATTEMPTS) {
+    return next.slice(next.length - MAX_RECENT_ATTEMPTS);
+  }
+  return next;
+}
+
+// src/server/goal-tools.ts
+import { exec as execChild } from "child_process";
+import { promisify } from "util";
+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.",
+      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."),
+        agent: tool.schema.string().optional().describe(`Agent to run the worker as (e.g. "researcher", "smart-agent"). Optional \u2014 inherits the calling session's agent if omitted, else plugin defaultAgent.`),
+        model: tool.schema.string().optional().describe(`Model to run the worker as, as "providerID/modelID" (e.g. "openai/gpt-5.6-sol", "ollama/qwen3.8:27b"). Optional \u2014 inherits the calling session's live model if omitted, else plugin defaultModel.`),
+        costBudget: tool.schema.number().optional().describe("Max provider cost in dollars before the engine stops the goal as budget_limited (e.g. 0.5). Optional \u2014 unlimited if omitted."),
+        checks: tool.schema.array(tool.schema.string()).optional().describe('Shell commands that must pass for completion to be accepted. E.g. ["npm test"].'),
+        checkCwd: tool.schema.string().optional().describe("Directory where completion checks run. Workspace-writing goals default to the project root."),
+        workspaceWrite: tool.schema.boolean().optional().describe("Whether this goal edits the shared project workspace. Defaults to true; explicitly set false for artifact-only/read-only work."),
+        progressFile: tool.schema.string().optional().describe("Markdown file the worker reads/writes as its transaction state."),
+        maxTurns: tool.schema.number().optional().describe("Max turns before auto-block."),
+        maxNoProgress: tool.schema.number().optional().describe("Block after N turns without progress."),
+        maxFailures: tool.schema.number().optional().describe("Block after N consecutive failures."),
+        compactEvery: tool.schema.number().optional().describe("Compact the worker session every N turns."),
+        timeoutMs: tool.schema.number().optional().describe("Per-turn timeout in ms."),
+        scheduleEveryMs: tool.schema.number().optional().describe("Interval in ms to auto-requeue the same goal after each completion. Minimum 1000. Enables repetitive dialogue reduction."),
+        scheduleMaxRuns: tool.schema.number().optional().describe("Maximum total runs including the initial run. Undefined = unlimited. Requires scheduleEveryMs.")
+      },
+      execute: async (args, context) => {
+        const sessionID = context?.sessionID || hostSessionID;
+        if (!sessionID || sessionID === "main") {
+          return {
+            title: "Goal not created",
+            output: JSON.stringify({
+              ok: false,
+              message: "A valid owner session is required. Run /goal from an active OpenCode session."
+            })
+          };
+        }
+        const config = {
+          maxTurns: 50
+        };
+        if (args.agent)
+          config.agent = args.agent;
+        if (args.model)
+          config.model = args.model;
+        if (args.checks)
+          config.checks = args.checks;
+        if (args.checkCwd)
+          config.checkCwd = args.checkCwd;
+        if (args.workspaceWrite !== undefined)
+          config.workspaceWrite = args.workspaceWrite;
+        if (args.progressFile)
           config.progressFile = args.progressFile;
         if (args.maxTurns !== undefined)
           config.maxTurns = args.maxTurns;
@@ -3430,12 +5398,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 +5472,7 @@ function goalTools(dir, goalService, hostSessionID, defaults = {}, host) {
         await writeState(dir, state);
         const event = {
           version: 1,
-          eventID: randomUUID5(),
+          eventID: randomUUID10(),
           goalID: goal.id,
           type: "goal.progress",
           summary: args.summary,
@@ -3561,7 +5537,7 @@ Exit code: ${f.exitCode}${stdoutSnippet}${stderrSnippet}`;
 Working directory: ${cwd}
 
 ${failureDetails}`;
-              attemptID = randomUUID5();
+              attemptID = randomUUID10();
               const verificationAttempt = {
                 id: attemptID,
                 sequence: runtime.evaluatorRejectionCount,
@@ -3606,7 +5582,7 @@ ${failureDetails.slice(0, 500)}`,
             if (attemptID) {
               await appendEvent(dir, {
                 version: 1,
-                eventID: randomUUID5(),
+                eventID: randomUUID10(),
                 goalID: goal.id,
                 type: "goal.completion_rejected",
                 attemptID,
@@ -3624,7 +5600,7 @@ ${failureDetails.slice(0, 500)}`,
             if (blocked && rejectedGoal?.blocker) {
               await appendEvent(dir, {
                 version: 1,
-                eventID: randomUUID5(),
+                eventID: randomUUID10(),
                 goalID: goal.id,
                 type: "goal.blocked",
                 reason: rejectedGoal.blocker.reason,
@@ -3684,7 +5660,7 @@ ${failureDetails.slice(0, 500)}`,
             }
             runtime.updatedAt = new Date().toISOString();
           }
-          const attemptID = randomUUID5();
+          const attemptID = randomUUID10();
           const cwd = goal.config.checkCwd || goal.config.artifactDir || dir;
           const checks = (goal.config.checks || []).map((cmd) => ({
             command: cmd,
@@ -3708,7 +5684,7 @@ ${failureDetails.slice(0, 500)}`,
         await writeState(dir, state);
         const event = {
           version: 1,
-          eventID: randomUUID5(),
+          eventID: randomUUID10(),
           goalID: goal.id,
           type: "goal.completed",
           summary: args.summary,
@@ -3768,7 +5744,7 @@ ${failureDetails.slice(0, 500)}`,
         await writeState(dir, state);
         const event = {
           version: 1,
-          eventID: randomUUID5(),
+          eventID: randomUUID10(),
           goalID: goal.id,
           type: "goal.blocked",
           reason: args.reason,
@@ -3948,7 +5924,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 +6006,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 +6037,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";
@@ -4516,19 +6507,264 @@ 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,
+    outputBytes: c.outputBytes,
+    truncated: c.truncated,
+    goalID: c.goalID,
+    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 command session (arbitrary shell command) in the background. Returns an ID for write/read/interrupt/terminate/remove. Independent from goals: linking a goalID is display-only and never couples lifecycles.",
+      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)."),
+        cols: tool3.schema.number().optional().describe(`Requested terminal width (${sizeNote}).`),
+        rows: tool3.schema.number().optional().describe(`Requested terminal height (${sizeNote}).`)
+      },
+      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 }
+          });
+          const session = await commandService.start(directory, {
+            title: args.title,
+            command: args.command,
+            args: args.args ?? [],
+            cwd: args.cwd,
+            ownerSessionID: owner,
+            goalID: args.goal_id,
+            cols: args.cols,
+            rows: args.rows
+          });
+          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.",
+      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: "Get a command session's metadata plus a bounded output snapshot. Closing a view detaches; it never terminates.",
+      args: {
+        command_id: tool3.schema.string().describe("Command session ID."),
+        offset_bytes: tool3.schema.number().optional().describe("Byte offset into the output log (paging)."),
+        limit_bytes: tool3.schema.number().optional().describe("Max bytes to return (default 64KB, cap 256KB).")
+      },
+      execute: async (args, context) => {
+        const owner = ownerID(context);
+        if (!owner)
+          return denied();
+        const result = await commandService.read(directory, args.command_id, owner, {
+          offsetBytes: args.offset_bytes,
+          limitBytes: args.limit_bytes
+        });
+        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
+          }, null, 2)
+        };
+      }
+    }),
+    loopd_command_write: tool3({
+      description: "Send raw input (stdin bytes) to a running command session.",
+      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.",
+      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.terminate(directory, args.command_id, owner);
+        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_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. Explicit opt-in only \u2014 a merely linked command never wakes its goal. Exactly-once: the await is consumed on fire, output chunks never fire, 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.")
+      },
+      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
+        });
+        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.3";
+
+// 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)
+        }));
+      }
+    }
+  });
+  const commandStream = createCommandStreamServer(directory, commandService, commandBroker);
   const worker = createControlWorker({
     directory,
     goalService,
+    commandService,
     pollIntervalMs: 1000,
     defaults
   });
@@ -4552,13 +6788,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 +6819,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 +6897,11 @@ function createServerHooks(directory, host, defaults) {
       }
     },
     dispose: async () => {
+      await commandStream.stop().catch(() => {});
       engine.stop();
       await worker.stop();
       scheduleWorker.stop();
+      await commandService.dispose(directory);
     }
   };
 }
@@ -4668,6 +6919,7 @@ 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 hooks = createServerHooks(directory, host, parsePluginDefaults(context.options));
@@ -4729,6 +6981,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 +7027,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 +7055,6 @@ var plugin_default = {
   setup: v2.setup
 };
 export {
-  plugin_default as default
+  plugin_default as default,
+  normalizeV2Event
 };