@bojackduy/opencode-loopd 1.10.3 → 1.10.4

package/dist/server.js

@@ -326,6 +326,14 @@ function migrate(state) {
     if (!Array.isArray(result.commandAwaits))
       result.commandAwaits = [];
   }
+  if (result.version < 9) {
+    result.version = 9;
+    result.goals = result.goals.map((goal) => ({
+      ...goal,
+      workerTopology: goal.workerTopology ?? undefined,
+      nativeParentID: goal.nativeParentID ?? undefined
+    }));
+  }
   return result;
 }
 async function writeAtomic(target, contents) {
@@ -555,7 +563,7 @@ async function removeCommandLog(directory, commandID) {
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-var CURRENT_VERSION = 8, LOCK_STALE_MS = 1e4;
+var CURRENT_VERSION = 9, LOCK_STALE_MS = 1e4;
 var init_state_repository = () => {};
 
 // src/domain/command-await.ts
@@ -585,6 +593,237 @@ var init_command_await = __esm(() => {
   MAX_AWAIT_TAIL_BYTES = 4 * 1024;
 });
 
+// src/domain/command-watch.ts
+function initialWatchState() {
+  return { state: "active", matches: 0, pushes: 0, droppedLines: 0 };
+}
+function compileWatchPattern(kind, pattern, ignoreCase = false) {
+  let compiled;
+  try {
+    compiled = new RegExp(pattern, ignoreCase ? "i" : "");
+  } catch (e) {
+    throw new Error(`Invalid watch ${kind} regex '${pattern}': ${e instanceof Error ? e.message : String(e)}`);
+  }
+  if (DANGEROUS_REGEXES.some((d) => d.test(pattern))) {
+    throw new Error(`Potentially dangerous watch ${kind} regex rejected: '${pattern}'. Please use a safer pattern.`);
+  }
+  return compiled;
+}
+function compileWatchSpec(spec) {
+  const ignoreCase = spec.ignoreCase === true;
+  const untilAction = spec.untilAction ?? "stop";
+  if (untilAction !== "stop" && untilAction !== "keep") {
+    throw new Error(`Invalid watch untilAction '${spec.untilAction}': must be "stop" or "keep".`);
+  }
+  return {
+    ...spec.filter !== undefined ? { filterRe: compileWatchPattern("filter", spec.filter, ignoreCase) } : {},
+    ...spec.until !== undefined ? { untilRe: compileWatchPattern("until", spec.until, ignoreCase) } : {},
+    ignoreCase,
+    untilAction
+  };
+}
+function stripAnsiForWatch(line) {
+  return line.replace(ANSI_PATTERN, "");
+}
+function cleanRawLine(raw) {
+  const stripped = stripAnsiForWatch(raw);
+  if (!stripped.includes("\r"))
+    return stripped;
+  const parts = stripped.split("\r");
+  return parts[parts.length - 1] ?? "";
+}
+function createLineAssembler() {
+  let carry = "";
+  return {
+    push(chunk) {
+      carry += chunk;
+      const parts = carry.replace(/\r\n/g, `
+`).split(`
+`);
+      carry = parts.pop() ?? "";
+      return parts.map(cleanRawLine);
+    },
+    flush() {
+      if (!carry)
+        return [];
+      const line = cleanRawLine(carry);
+      carry = "";
+      return [line];
+    }
+  };
+}
+function testFresh(re, line) {
+  const hit = re.test(line);
+  re.lastIndex = 0;
+  return hit;
+}
+function matchLine(compiled, line) {
+  if (compiled.filterRe && !testFresh(compiled.filterRe, line))
+    return { pass: false, until: false };
+  if (compiled.untilRe && testFresh(compiled.untilRe, line))
+    return { pass: true, until: true };
+  return { pass: true, until: false };
+}
+function byteLen(s) {
+  return Buffer.byteLength(s, "utf8");
+}
+
+class CommandWatcher {
+  compiled;
+  state = initialWatchState();
+  assembler = createLineAssembler();
+  pending = [];
+  pendingBytes = 0;
+  stamps = [];
+  constructor(spec) {
+    this.compiled = compileWatchSpec(spec);
+  }
+  get untilAction() {
+    return this.compiled.untilAction;
+  }
+  get pendingCount() {
+    return this.pending.length;
+  }
+  feedChunk(chunk, now) {
+    const completed = [];
+    const matched = [];
+    let untilLine = null;
+    let floodNow = false;
+    const suspended = this.state.state === "flood-suspended" || this.state.state === "budget-exhausted";
+    const lines = this.assembler.push(chunk);
+    for (const line of lines) {
+      if (line.trim() === "")
+        continue;
+      if (suspended) {
+        this.state.droppedLines++;
+        continue;
+      }
+      completed.push(line);
+      this.stamps.push(now);
+      while (this.stamps.length > 0 && (this.stamps[0] ?? now) < now - 1000)
+        this.stamps.shift();
+      if (this.stamps.length > WATCH_FLOOD_LINES_PER_SEC) {
+        this.state.state = "flood-suspended";
+        this.state.droppedLines++;
+        floodNow = true;
+        continue;
+      }
+      const m = matchLine(this.compiled, line);
+      if (!m.pass)
+        continue;
+      if (m.until && this.state.state === "active") {
+        this.state.state = "until-matched";
+        this.state.matches++;
+        this.buffer(line);
+        untilLine = line;
+        continue;
+      }
+      if (this.state.state === "until-matched" && this.untilAction === "stop") {
+        this.state.droppedLines++;
+        continue;
+      }
+      this.state.matches++;
+      this.buffer(line);
+      matched.push(line);
+    }
+    return { completed, matched, untilLine, floodNow };
+  }
+  finish(now) {
+    const trailing = this.assembler.flush();
+    if (trailing.length === 0)
+      return { completed: [], matched: [], untilLine: null, floodNow: false };
+    return this.feedChunk(trailing[0] + `
+`, now);
+  }
+  buffer(line) {
+    this.pending.push(line);
+    this.pendingBytes += byteLen(line);
+  }
+  takePush() {
+    if (this.pending.length === 0)
+      return null;
+    if (this.state.state === "budget-exhausted") {
+      this.state.droppedLines += this.pending.length;
+      this.pending = [];
+      this.pendingBytes = 0;
+      return null;
+    }
+    if (this.state.pushes >= WATCH_MAX_PUSHES_PER_COMMAND) {
+      this.state.state = "budget-exhausted";
+      this.state.droppedLines += this.pending.length;
+      this.pending = [];
+      this.pendingBytes = 0;
+      return { lines: [], exhaustedNow: true };
+    }
+    const lines = [];
+    let bytes = 0;
+    while (this.pending.length > 0 && lines.length < WATCH_MAX_LINES_PER_PUSH) {
+      const next = this.pending[0];
+      const nextBytes = byteLen(next) + (lines.length > 0 ? 1 : 0);
+      if (bytes + nextBytes > WATCH_MAX_BYTES_PER_PUSH && lines.length > 0)
+        break;
+      this.pending.shift();
+      this.pendingBytes -= byteLen(next);
+      lines.push(next);
+      bytes += nextBytes;
+    }
+    this.state.pushes++;
+    return { lines, exhaustedNow: false };
+  }
+  takeUntilPush() {
+    const lines = [];
+    let bytes = 0;
+    while (this.pending.length > 0 && lines.length < WATCH_MAX_LINES_PER_PUSH) {
+      const next = this.pending.pop();
+      this.pendingBytes -= byteLen(next);
+      const nextBytes = byteLen(next) + (lines.length > 0 ? 1 : 0);
+      if (bytes + nextBytes > WATCH_MAX_BYTES_PER_PUSH && lines.length > 0) {
+        this.pending.push(next);
+        this.pendingBytes += byteLen(next);
+        break;
+      }
+      lines.unshift(next);
+      bytes += nextBytes;
+    }
+    this.state.droppedLines += this.pending.length;
+    this.pending = [];
+    this.pendingBytes = 0;
+    this.state.pushes++;
+    return lines;
+  }
+}
+function formatWatchMessage(title, lines, note) {
+  const header = `[watch "${title}"]`;
+  const tail = note ? [...lines, note].join(`
+`) : lines.join(`
+`);
+  if (!tail)
+    return header;
+  const room = Math.max(0, MAX_WATCH_MESSAGE_BYTES - byteLen(header) - 1);
+  return `${header}
+${tailLastBytes(tail, room)}`;
+}
+function formatWatchFloodMessage(title, dropped) {
+  return `[watch "${title}"] FLOOD: ${WATCH_FLOOD_LINES_PER_SEC}+ lines/sec exceeds the limit. ` + `Watch suspended (${dropped} line(s) dropped so far); the process keeps running.`;
+}
+function formatWatchBudgetMessage(title) {
+  return `[watch "${title}"] BUDGET: push limit (${WATCH_MAX_PUSHES_PER_COMMAND}) reached. ` + `Watch exhausted; further matches are dropped. The process keeps running.`;
+}
+var WATCH_COALESCE_WINDOW_MS = 2000, WATCH_MAX_LINES_PER_PUSH = 20, WATCH_MAX_BYTES_PER_PUSH, WATCH_MAX_PUSHES_PER_COMMAND = 30, WATCH_FLOOD_LINES_PER_SEC = 100, MAX_WATCH_MESSAGE_BYTES, DANGEROUS_REGEXES, ANSI_PATTERN;
+var init_command_watch = __esm(() => {
+  init_command_await();
+  WATCH_MAX_BYTES_PER_PUSH = 4 * 1024;
+  MAX_WATCH_MESSAGE_BYTES = 4 * 1024;
+  DANGEROUS_REGEXES = [
+    /\(\?:.*\)\*.*\(\?:.*\)\*/,
+    /.*\(\.\*\?\)\{2,\}.*/,
+    /.*\(.*\|.*\)\{3,\}.*/,
+    /\([^()]*[+*][^()]*\)[+*]/,
+    /\([^()]*(\.\*.*\.\*|\.\+.*\.\+|\\w\+.*\\s\*|\\s\*.*\\w\+)[^()]*\)/
+  ];
+  ANSI_PATTERN = new RegExp("\x1B\\[[0-9;?]*[ -/]*[@-~]|\x1B\\][^\x07]*(?:\x07|\x1B\\\\)|\x1B[()][0-9A-Z]", "g");
+});
+
 // src/application/command-await.ts
 import { randomUUID } from "crypto";
 function ledgerEvent(base) {
@@ -610,6 +849,18 @@ async function requestCommandAwait(directory, input) {
   if (goal.ownerSessionID !== command.ownerSessionID) {
     return { ok: false, message: "Owner mismatch: goal and command are owned by different sessions." };
   }
+  const until = input.until !== undefined && input.until !== "" ? input.until : undefined;
+  const ignoreCase = input.ignoreCase === true;
+  if (input.until !== undefined && until === undefined) {
+    return { ok: false, message: "Await 'until' must be a non-empty regex." };
+  }
+  if (until !== undefined) {
+    try {
+      compileWatchPattern("until", until, ignoreCase);
+    } catch (e) {
+      return { ok: false, message: e instanceof Error ? e.message : String(e) };
+    }
+  }
   const existing = (snapshot.commandAwaits ?? []).some((a) => a.goalID === input.goalID && a.commandID === input.commandID);
   if (existing) {
     return { ok: true, message: `Already awaiting "${command.title}" for goal "${goal.name}".` };
@@ -620,7 +871,8 @@ async function requestCommandAwait(directory, input) {
         goalID: input.goalID,
         commandID: input.commandID,
         ownerSessionID: input.ownerSessionID,
-        createdAt: new Date().toISOString()
+        createdAt: new Date().toISOString(),
+        ...until !== undefined ? { until, ignoreCase } : {}
       }];
       return s;
     });
@@ -641,7 +893,8 @@ async function requestCommandAwait(directory, input) {
         goalID: input.goalID,
         commandID: input.commandID,
         ownerSessionID: input.ownerSessionID,
-        createdAt: new Date().toISOString()
+        createdAt: new Date().toISOString(),
+        ...until !== undefined ? { until, ignoreCase } : {}
       }];
     }
     const current = (s.commands ?? []).find((c) => c.id === input.commandID);
@@ -660,12 +913,133 @@ async function requestCommandAwait(directory, input) {
       active: mine?.active ?? goal.status === "active"
     };
   }
+  if (until !== undefined) {
+    const retained = await readRetainedLines(directory, input.commandID);
+    const hit = retained.find((line) => testUntil(until, ignoreCase, line));
+    if (hit !== undefined) {
+      const fired = await fireUntilAwaits(directory, input.commandID, [hit]);
+      const mine = fired.find((f) => f.goalID === input.goalID);
+      if (mine) {
+        return {
+          ok: true,
+          message: `Pattern "${until}" already present in "${command.title}" output; wake-up delivered to goal "${goal.name}".`,
+          fired: true,
+          active: mine.active
+        };
+      }
+      const again = await fireCommandAwaits(directory, input.commandID);
+      const second = again.find((f) => f.goalID === input.goalID);
+      if (second) {
+        return {
+          ok: true,
+          message: `Command "${command.title}" exited while registering; wake-up delivered to goal "${goal.name}".`,
+          fired: true,
+          active: second.active
+        };
+      }
+    }
+  }
   await appendEvent(directory, ledgerEvent({
     goalID: input.goalID,
     commandID: input.commandID,
-    type: "command.await-requested"
+    type: "command.await-requested",
+    ...until !== undefined ? { until } : {}
   })).catch(() => {});
-  return { ok: true, message: `Goal "${goal.name}" now awaits "${command.title}" (fires once on exit).` };
+  return {
+    ok: true,
+    message: until !== undefined ? `Goal "${goal.name}" now awaits pattern "${until}" in "${command.title}" (fires once on first match; the command keeps running).` : `Goal "${goal.name}" now awaits "${command.title}" (fires once on exit).`
+  };
+}
+function testUntil(until, ignoreCase, line) {
+  try {
+    const re = new RegExp(until, ignoreCase ? "i" : "");
+    const hit = re.test(line);
+    re.lastIndex = 0;
+    return hit;
+  } catch {
+    return false;
+  }
+}
+async function readRetainedLines(directory, commandID) {
+  try {
+    const full = await readCommandLog(directory, commandID, {
+      offsetBytes: 0,
+      limitBytes: 512 * 1024
+    });
+    if (!full.text)
+      return [];
+    return full.text.split(`
+`).filter((l) => l.trim() !== "");
+  } catch {
+    return [];
+  }
+}
+async function fireUntilAwaits(directory, commandID, lines) {
+  if (lines.length === 0)
+    return [];
+  let candidates = [];
+  let command;
+  await mutateState(directory, `cmd.await-until-consume:${commandID}`, async (s) => {
+    const outstanding = (s.commandAwaits ?? []).filter((a) => a.commandID === commandID && typeof a.until === "string" && a.until !== "");
+    if (outstanding.length === 0)
+      return s;
+    const current = (s.commands ?? []).find((c) => c.id === commandID);
+    if (!current)
+      return s;
+    command = current;
+    const hits = [];
+    for (const a of outstanding) {
+      const pattern = a.until;
+      if (lines.some((line) => testUntil(pattern, a.ignoreCase === true, line)))
+        hits.push(a);
+    }
+    if (hits.length === 0)
+      return s;
+    const hitKeys = new Set(hits.map((h) => `${h.goalID}:${h.commandID}`));
+    s.commandAwaits = (s.commandAwaits ?? []).filter((a) => !(a.commandID === commandID && hitKeys.has(`${a.goalID}:${a.commandID}`)));
+    candidates = hits;
+    return s;
+  });
+  if (candidates.length === 0 || !command)
+    return [];
+  const cmd = command;
+  const tail = await readBoundedTail(directory, commandID);
+  const fired = [];
+  for (const a of candidates) {
+    const pattern = a.until;
+    const matched = lines.filter((line) => testUntil(pattern, a.ignoreCase === true, line));
+    const fresh = await readState(directory);
+    const goal = fresh.goals.find((g) => g.id === a.goalID);
+    if (!goal) {
+      await appendEvent(directory, ledgerEvent({
+        goalID: a.goalID,
+        commandID,
+        type: "command.await-discarded",
+        reason: "goal gone"
+      })).catch(() => {});
+      continue;
+    }
+    const short = commandID.slice(0, 8);
+    const header = `[command "${cmd.title}" (${[cmd.command, ...cmd.args].join(" ") || cmd.title}) ${cmd.status}` + ` ${short}... watch-until "${pattern}" matched]`;
+    const matchedText = tailLastBytes(matched.slice(0, 20).join(`
+`), MAX_AWAIT_TAIL_BYTES);
+    const evidence = tail ? `${header}
+${matchedText}
+--- tail ---
+${tail}` : `${header}
+${matchedText}`;
+    await appendGoalInbox(directory, a.goalID, "worker", evidence);
+    await appendEvent(directory, ledgerEvent({
+      goalID: a.goalID,
+      commandID,
+      type: "command.await-fired",
+      until: pattern,
+      matchedLines: matched.length,
+      status: cmd.status
+    })).catch(() => {});
+    fired.push({ goalID: a.goalID, commandID, active: goal.status === "active" });
+  }
+  return fired;
 }
 async function readBoundedTail(directory, commandID) {
   try {
@@ -848,6 +1222,7 @@ async function wakeGoalForAwait(directory, continuation, goalID) {
 }
 var init_command_await2 = __esm(() => {
   init_command_await();
+  init_command_watch();
   init_state_repository();
 });
 
@@ -1313,7 +1688,8 @@ function createControlWorker(options) {
       case "cmd_interrupt":
       case "cmd_terminate":
       case "cmd_remove":
-      case "cmd_resize": {
+      case "cmd_resize":
+      case "cmd_watch": {
         const cmdSvc = options.commandService;
         if (!cmdSvc) {
           response = {
@@ -1367,6 +1743,16 @@ function createControlWorker(options) {
               const r = await cmdSvc.remove(directory, id, ownerSessionID);
               const state = await readState(directory);
               response = { ...base, ok: r.ok, message: r.message, stateRevision: state.revision };
+            } else if (request.command === "cmd_watch") {
+              const r = await cmdSvc.watch(directory, id, ownerSessionID, {
+                ...typeof args.watchFilter === "string" ? { filter: args.watchFilter } : {},
+                ...typeof args.watchUntil === "string" ? { until: args.watchUntil } : {},
+                ...typeof args.watchIgnoreCase === "boolean" ? { ignoreCase: args.watchIgnoreCase } : {},
+                ...typeof args.watchUntilAction === "string" ? { untilAction: args.watchUntilAction } : {},
+                ...typeof args.clear === "boolean" ? { clear: args.clear } : {}
+              }).catch((error) => ({ ok: false, message: error instanceof Error ? error.message : String(error) }));
+              const state = await readState(directory);
+              response = { ...base, ok: r.ok, message: r.message, stateRevision: state.revision };
             } else {
               const r = await cmdSvc.resize(directory, id, ownerSessionID, Number(args.cols), Number(args.rows));
               const state = await readState(directory);
@@ -2383,6 +2769,108 @@ import { promises as fs2 } from "fs";
 
 // src/server/host-adapter.ts
 import { randomUUID as randomUUID4 } from "crypto";
+
+// src/v2/native-rpc.ts
+var NATIVE_RPC_ID = "loopd.native";
+var CLAIM_TIMEOUT_MS = 3000;
+var CLAIMED_TIMEOUT_MS = 15000;
+function resolveNativeParentID(child) {
+  return child.fork?.sessionID ?? child.parentID ?? undefined;
+}
+var requestSchema = {
+  type: "object",
+  properties: {
+    requestID: { type: "string" },
+    goalID: { type: "string" },
+    parentSessionID: { type: "string" },
+    title: { type: "string" },
+    agent: { type: "string" },
+    model: {
+      type: "object",
+      properties: {
+        id: { type: "string" },
+        providerID: { type: "string" }
+      },
+      required: ["id", "providerID"],
+      additionalProperties: false
+    },
+    permissions: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          action: { type: "string" },
+          resource: { type: "string" },
+          effect: { type: "string", enum: ["allow", "deny", "ask"] }
+        },
+        required: ["action", "resource", "effect"],
+        additionalProperties: false
+      }
+    },
+    directory: { type: "string" }
+  },
+  required: ["requestID", "goalID", "parentSessionID", "title"],
+  additionalProperties: false
+};
+var claimResultSchema = {
+  type: "object",
+  properties: {
+    requestID: { type: "string" },
+    claimantID: { type: "string" }
+  },
+  required: ["requestID", "claimantID"],
+  additionalProperties: false
+};
+var claimAckSchema = {
+  type: "object",
+  properties: {
+    requestID: { type: "string" },
+    claimantID: { type: "string" },
+    won: { type: "boolean" }
+  },
+  required: ["requestID", "claimantID", "won"],
+  additionalProperties: false
+};
+var createResultSchema = {
+  type: "object",
+  properties: {
+    requestID: { type: "string" },
+    childSessionID: { type: "string" },
+    parentSessionID: { type: "string" },
+    topology: { type: "string", const: "v2-native-child" }
+  },
+  required: ["requestID", "childSessionID", "parentSessionID", "topology"],
+  additionalProperties: false
+};
+var failureSchema = {
+  type: "object",
+  properties: {
+    requestID: { type: "string" },
+    reason: { type: "string" },
+    detail: { type: "string" },
+    preCreation: { type: "boolean" }
+  },
+  required: ["requestID", "reason", "preCreation"],
+  additionalProperties: false
+};
+var emptySchema = {
+  type: "object",
+  properties: {},
+  additionalProperties: false
+};
+var nativeRpcDefinition = {
+  id: NATIVE_RPC_ID,
+  methods: {
+    claimRequest: { input: claimResultSchema, output: claimAckSchema, errors: {} },
+    completeWorkerCreate: { input: createResultSchema, output: emptySchema, errors: {} },
+    failRequest: { input: failureSchema, output: emptySchema, errors: {} }
+  },
+  events: {
+    workerCreateRequested: { schema: requestSchema }
+  }
+};
+
+// src/server/host-adapter.ts
 function parseModelRef(value) {
   if (value === undefined)
     return;
@@ -2596,20 +3084,83 @@ function createRealHost(client, directory) {
     }
   };
 }
-function createV2Host(context, statuses) {
+function toWorkerCreation(result) {
+  return typeof result === "string" ? { sessionID: result } : result;
+}
+function createV2Host(context, statuses, options = {}) {
   const directory = context.location.directory;
   return {
-    async createWorker({ parentID, title, agent, model }) {
+    async createWorker({ parentID, title, agent, model, goalID }) {
+      if (options.native) {
+        let outcome;
+        try {
+          outcome = await options.native.requestWorker({
+            goalID,
+            parentSessionID: parentID,
+            title,
+            agent,
+            model,
+            directory
+          });
+        } catch (error) {
+          await logServerEvent(directory, "worker.create.native-failed", {
+            parentID,
+            title,
+            detail: describeError(error)
+          });
+          throw error;
+        }
+        if (outcome.kind === "native-child") {
+          const childID = outcome.childSessionID;
+          const child = await context.session.get({ sessionID: childID });
+          const actualParent = resolveNativeParentID(child);
+          if (actualParent !== parentID) {
+            const detail = `resolved-parent=${JSON.stringify(actualParent)} expected=${JSON.stringify(parentID)}`;
+            await logServerEvent(directory, "worker.create.parent-mismatch", { parentID, workerSessionID: childID, detail });
+            throw new Error(`loopd native worker creation failed for parent "${parentID}" (parent-mismatch): ${detail}`);
+          }
+          if (agent)
+            await context.session.switchAgent({ sessionID: childID, agent });
+          if (model) {
+            await context.session.switchModel({
+              sessionID: childID,
+              model: { id: model.modelID, providerID: model.providerID }
+            });
+          }
+          const rename = context.session.update;
+          if (rename)
+            await rename({ sessionID: childID, title });
+          statuses.set(childID, "idle");
+          await logServerEvent(directory, "worker.created", {
+            parentID,
+            workerSessionID: childID,
+            title,
+            topology: "v2-native-child",
+            nativeParentID: parentID
+          });
+          return { sessionID: childID, topology: "v2-native-child", nativeParentID: parentID };
+        }
+        await logServerEvent(directory, "worker.create.native-fallback", {
+          parentID,
+          title,
+          reason: outcome.kind === "fallback-safe" ? outcome.reason : "unclaimed"
+        });
+      }
       const session = await context.session.create({
         title,
-        agent,
-        model: model ? { id: model.modelID, providerID: model.providerID } : undefined,
+        ...agent !== undefined ? { agent } : {},
+        ...model !== undefined ? { model: { id: model.modelID, providerID: model.providerID } } : {},
         location: { directory },
         metadata: { "loopd.parentID": parentID }
       });
       statuses.set(session.id, "idle");
-      await logServerEvent(directory, "worker.created", { parentID, workerSessionID: session.id, title });
-      return session.id;
+      await logServerEvent(directory, "worker.created", {
+        parentID,
+        workerSessionID: session.id,
+        title,
+        topology: "v2-root-fallback"
+      });
+      return { sessionID: session.id, topology: "v2-root-fallback" };
     },
     async promptWorker({ sessionID, prompt, messageID, model, agent }) {
       if (agent)
@@ -2727,16 +3278,18 @@ async function withTimeout(promise, timeoutMs, operation) {
 function createWorkerManager(host) {
   return {
     async createWorker(goal) {
-      const workerSessionID = await host.createWorker({
+      const created = toWorkerCreation(await host.createWorker({
         parentID: goal.ownerSessionID,
         title: `loopd: ${goal.name}`,
         agent: goal.config.agent,
-        model: parseModelRef(goal.config.model)
-      });
+        model: parseModelRef(goal.config.model),
+        goalID: goal.id
+      }));
       return {
         goalID: goal.id,
-        workerSessionID,
-        startedAt: new Date().toISOString()
+        workerSessionID: created.sessionID,
+        startedAt: new Date().toISOString(),
+        ...created.topology ? { topology: created.topology, nativeParentID: created.nativeParentID } : {}
       };
     },
     async continueWorker(worker, goal, runtime, context) {
@@ -2980,8 +3533,13 @@ function createGoalService(host) {
     sessions.set(goal.id, session);
     await mutateState(directory, `goal.set-worker:${goal.id}`, async (s) => {
       const persisted = s.goals.find((item) => item.id === goal.id);
-      if (persisted)
+      if (persisted) {
         persisted.workerSessionID = session.workerSessionID;
+        if (session.topology) {
+          persisted.workerTopology = session.topology;
+          persisted.nativeParentID = session.nativeParentID;
+        }
+      }
       return s;
     });
     return session;
@@ -3085,6 +3643,12 @@ function createGoalService(host) {
         return state;
       g.workerSessionID = worker.workerSessionID;
       goal.workerSessionID = worker.workerSessionID;
+      if (worker.topology) {
+        g.workerTopology = worker.topology;
+        g.nativeParentID = worker.nativeParentID;
+        goal.workerTopology = worker.topology;
+        goal.nativeParentID = worker.nativeParentID;
+      }
       const rt = state.runtimes.find((item) => item.goalID === id);
       if (rt) {
         Object.assign(rt, acquireLease(rt, g.config.timeoutMs || 300000));
@@ -3522,6 +4086,10 @@ function createGoalService(host) {
           const g = s.goals.find((item) => item.id === goal.id);
           if (g) {
             g.workerSessionID = worker.workerSessionID;
+            if (worker.topology) {
+              g.workerTopology = worker.topology;
+              g.nativeParentID = worker.nativeParentID;
+            }
             g.updatedAt = new Date().toISOString();
           }
           return s;
@@ -3790,6 +4358,168 @@ function createScheduleWorker(options) {
   return { start, stop, isRunning, tick };
 }
 
+// src/v2/native-server.ts
+import { randomUUID as randomUUID7 } from "crypto";
+
+// src/v2/native-bridge.ts
+class NativeBridgeError extends Error {
+  code;
+  requestID;
+  constructor(code, requestID, message) {
+    super(message);
+    this.name = "NativeBridgeError";
+    this.code = code;
+    this.requestID = requestID;
+  }
+}
+function createNativeBridge(options = {}) {
+  const claimTimeoutMs = options.claimTimeoutMs ?? CLAIM_TIMEOUT_MS;
+  const claimedTimeoutMs = options.claimedTimeoutMs ?? CLAIMED_TIMEOUT_MS;
+  const pending = new Map;
+  let disposed = false;
+  function settle(requestID, settleFn) {
+    const entry = pending.get(requestID);
+    if (!entry || entry.state === "settled")
+      return false;
+    entry.state = "settled";
+    if (entry.claimTimer)
+      clearTimeout(entry.claimTimer);
+    if (entry.claimedTimer)
+      clearTimeout(entry.claimedTimer);
+    pending.delete(requestID);
+    settleFn(entry);
+    return true;
+  }
+  return {
+    pendingCount: () => pending.size,
+    isDisposed: () => disposed,
+    requestWorker(request, emit) {
+      if (disposed) {
+        return Promise.reject(new NativeBridgeError("disposed", request.requestID, "native bridge is disposed"));
+      }
+      return new Promise((resolve, reject) => {
+        const entry = { state: "awaiting-claim", resolve, reject };
+        pending.set(request.requestID, entry);
+        let emitResult;
+        try {
+          emitResult = emit(request);
+        } catch {
+          settle(request.requestID, (e) => e.resolve({ kind: "unclaimed" }));
+          return;
+        }
+        const afterEmit = () => {
+          const live = pending.get(request.requestID);
+          if (!live || live.state !== "awaiting-claim")
+            return;
+          live.claimTimer = setTimeout(() => {
+            settle(request.requestID, (e) => e.resolve({ kind: "unclaimed" }));
+          }, claimTimeoutMs);
+          if (typeof live.claimTimer?.unref === "function")
+            live.claimTimer.unref();
+        };
+        if (emitResult && typeof emitResult.then === "function") {
+          emitResult.then(afterEmit, () => {
+            settle(request.requestID, (e) => e.resolve({ kind: "unclaimed" }));
+          });
+        } else {
+          afterEmit();
+        }
+      });
+    },
+    handleClaim(claim) {
+      const entry = pending.get(claim.requestID);
+      if (!entry || entry.state !== "awaiting-claim")
+        return { won: false };
+      entry.state = "claimed";
+      entry.claimantID = claim.claimantID;
+      if (entry.claimTimer)
+        clearTimeout(entry.claimTimer);
+      entry.claimedTimer = setTimeout(() => {
+        settle(claim.requestID, (e) => e.reject(new NativeBridgeError("claimed-timeout", claim.requestID, `claimant "${claim.claimantID}" vanished before completing worker creation; failing startup rather than duplicating`)));
+      }, claimedTimeoutMs);
+      if (typeof entry.claimedTimer?.unref === "function")
+        entry.claimedTimer.unref();
+      return { won: true };
+    },
+    handleComplete(result) {
+      return settle(result.requestID, (entry) => entry.resolve({
+        kind: "native-child",
+        childSessionID: result.childSessionID,
+        parentSessionID: result.parentSessionID,
+        topology: "v2-native-child"
+      }));
+    },
+    handleFailure(failure) {
+      if (failure.preCreation) {
+        return settle(failure.requestID, (entry) => entry.resolve({ kind: "fallback-safe", reason: failure.reason, detail: failure.detail }));
+      }
+      return settle(failure.requestID, (entry) => entry.reject(new NativeBridgeError(failure.reason === "parent-mismatch" ? "parent-mismatch" : "fork-failed", failure.requestID, `native worker creation failed post-creation (${failure.reason}): ${failure.detail ?? "no detail"}`)));
+    },
+    dispose() {
+      disposed = true;
+      const ids = [...pending.keys()];
+      for (const id of ids) {
+        settle(id, (entry) => entry.reject(new NativeBridgeError("disposed", id, "native bridge disposed with request pending")));
+      }
+    }
+  };
+}
+
+// src/v2/native-server.ts
+async function setupNativeServer(context) {
+  if (!context || !context.rpc || typeof context.rpc.register !== "function")
+    return;
+  const bridge = createNativeBridge();
+  let registration;
+  try {
+    registration = await context.rpc.register(nativeRpcDefinition, {
+      claimRequest: async (input) => {
+        const { won } = bridge.handleClaim(input);
+        return { requestID: input.requestID, claimantID: input.claimantID, won };
+      },
+      completeWorkerCreate: async (input) => {
+        bridge.handleComplete(input);
+        return {};
+      },
+      failRequest: async (input) => {
+        bridge.handleFailure(input);
+        return {};
+      }
+    });
+  } catch {
+    bridge.dispose();
+    return;
+  }
+  if (!registration || !registration.events || typeof registration.events.emit !== "function") {
+    bridge.dispose();
+    try {
+      await registration?.dispose();
+    } catch {}
+    return;
+  }
+  return {
+    bridge,
+    requestWorker: async (input) => {
+      const request = {
+        requestID: `req_${randomUUID7()}`,
+        goalID: input.goalID ?? "",
+        parentSessionID: input.parentSessionID,
+        title: input.title,
+        ...input.agent ? { agent: input.agent } : {},
+        ...input.model ? { model: { id: input.model.modelID, providerID: input.model.providerID } } : {},
+        directory: input.directory
+      };
+      return bridge.requestWorker(request, (req) => registration.events.emit("workerCreateRequested", req));
+    },
+    dispose: async () => {
+      bridge.dispose();
+      try {
+        await registration.dispose();
+      } catch {}
+    }
+  };
+}
+
 // src/server/command-host.ts
 import { createRequire } from "module";
 var COMMAND_HOST_CAPABILITIES = {
@@ -4040,21 +4770,44 @@ function createCommandHost(opts) {
 }
 
 // src/application/command-service.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 import { promises as fs3 } from "fs";
 import path3 from "path";
 
 // src/domain/command-session.ts
+function normalizeTimeoutSeconds(timeoutSeconds) {
+  if (timeoutSeconds === undefined)
+    return;
+  if (!Number.isInteger(timeoutSeconds) || timeoutSeconds <= 0) {
+    throw new Error("timeoutSeconds must be a positive integer in seconds");
+  }
+  return timeoutSeconds;
+}
+function computeDeadlineAt(from, timeoutSeconds) {
+  return new Date(from.getTime() + timeoutSeconds * 1000).toISOString();
+}
 function createCommandSession(input) {
   const now = new Date().toISOString();
+  const timeout = normalizeTimeoutSeconds(input.timeoutSeconds);
   return {
     id: input.id,
     title: input.title,
     command: input.command,
     args: input.args ?? [],
+    shell: input.shell,
+    endReason: input.endReason,
+    timeoutSeconds: timeout,
+    deadlineAt: input.deadlineAt ?? (timeout !== undefined ? computeDeadlineAt(new Date(now), timeout) : undefined),
+    envKeys: input.envKeys,
+    watchFilter: input.watchFilter,
+    watchUntil: input.watchUntil,
+    watchIgnoreCase: input.watchIgnoreCase,
+    watchUntilAction: input.watchUntilAction,
+    watchState: input.watchState,
     cwd: input.cwd,
     ownerSessionID: input.ownerSessionID,
     goalID: input.goalID,
+    notifyOnExit: input.notifyOnExit,
     status: "running",
     pid: input.pid,
     cols: input.cols,
@@ -4067,6 +4820,35 @@ function createCommandSession(input) {
   };
 }
 var MAX_COMMAND_OUTPUT_BYTES = 512 * 1024;
+var MAX_COMMAND_READ_LINES = 500;
+var NOTIFY_LONG_RUNNING_MS = 2 * 60 * 1000;
+function shouldNotifyOwnerOnExit(session) {
+  if (session.endReason === "until")
+    return false;
+  if (session.notifyOnExit === false)
+    return false;
+  if (session.notifyOnExit === true)
+    return true;
+  if (session.endReason === "timeout")
+    return true;
+  if (session.status === "missing")
+    return true;
+  if (session.status === "terminated")
+    return false;
+  if (session.status !== "exited")
+    return false;
+  if (session.exitCode !== undefined && session.exitCode !== 0)
+    return true;
+  const started = Date.parse(session.createdAt);
+  const ended = session.endedAt ? Date.parse(session.endedAt) : Date.now();
+  if (!Number.isFinite(started) || !Number.isFinite(ended))
+    return false;
+  return ended - started >= NOTIFY_LONG_RUNNING_MS;
+}
+
+// src/application/command-service.ts
+init_command_watch();
+init_command_await();
 
 // src/domain/command-events.ts
 var _encoder = new TextEncoder;
@@ -4243,6 +5025,37 @@ function validateCommandStreamMessage(value) {
 // src/application/command-service.ts
 init_command_await2();
 init_state_repository();
+var ANSI_PATTERN2 = new RegExp("\x1B\\[[0-9;?]*[ -/]*[@-~]|\x1B\\][^\x07]*(?:\x07|\x1B\\\\)|\x1B[()][0-9A-Z]", "g");
+function stripAnsiForMatch(line) {
+  return line.replace(ANSI_PATTERN2, "");
+}
+var DANGEROUS_REGEXES2 = [
+  /\(\?:.*\)\*.*\(\?:.*\)\*/,
+  /.*\(\.\*\?\)\{2,\}.*/,
+  /.*\(.*\|.*\)\{3,\}.*/,
+  /\([^()]*[+*][^()]*\)[+*]/,
+  /\([^()]*(\.\*.*\.\*|\.\+.*\.\+|\\w\+.*\\s\*|\\s\*.*\\w\+)[^()]*\)/
+];
+function validateReadPattern(pattern) {
+  let compiled;
+  try {
+    compiled = new RegExp(pattern);
+  } catch (e) {
+    return { error: `Invalid regex pattern '${pattern}': ${e instanceof Error ? e.message : String(e)}` };
+  }
+  if (DANGEROUS_REGEXES2.some((d) => d.test(pattern))) {
+    return { error: `Potentially dangerous regex pattern rejected: '${pattern}'. Please use a safer pattern.` };
+  }
+  return compiled;
+}
+function shellQuote(word) {
+  if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(word))
+    return word;
+  return `'${word.replace(/'/g, `'\\''`)}'`;
+}
+function shellJoin(command, args) {
+  return [command, ...args].map(shellQuote).join(" ");
+}
 function loopCommandsDir(directory) {
   return path3.join(directory, ".opencode", "loopd", "commands");
 }
@@ -4251,6 +5064,112 @@ function createCommandService(host, opts) {
   const operations = new Map;
   const broker = opts?.broker;
   const commandDirs = new Map;
+  const timeouts = new Map;
+  const timeoutOwners = new Map;
+  const watchers = new Map;
+  const watchTimers = new Map;
+  const awaitAsm = new Map;
+  const watchCoalesceMs = opts?.watchCoalesceMs ?? WATCH_COALESCE_WINDOW_MS;
+  function clearWatchTimer(id) {
+    const t = watchTimers.get(id);
+    if (t) {
+      try {
+        globalThis.clearTimeout(t);
+      } catch {}
+    }
+    watchTimers.delete(id);
+  }
+  function deleteWatch(id) {
+    clearWatchTimer(id);
+    watchers.delete(id);
+    awaitAsm.delete(id);
+  }
+  function scheduleWatchFlush(directory, id) {
+    if (watchTimers.has(id))
+      return;
+    const handle = setTimeout(() => {
+      watchTimers.delete(id);
+      enqueue(id, () => flushWatch(directory, id)).catch(() => {});
+    }, Math.max(0, watchCoalesceMs));
+    try {
+      handle.unref?.();
+    } catch {}
+    watchTimers.set(id, handle);
+  }
+  async function persistWatchState(directory, id, state) {
+    await mutateState(directory, `cmd.watch:${id}`, async (s) => {
+      const c = (s.commands ?? []).find((x) => x.id === id);
+      if (c) {
+        c.watchState = { ...state };
+        c.updatedAt = new Date().toISOString();
+      }
+      return s;
+    });
+  }
+  function watchLedger(directory, commandID, type, extra) {
+    return appendEvent(directory, {
+      version: 1,
+      eventID: randomUUID8(),
+      commandID,
+      type,
+      timestamp: new Date().toISOString(),
+      revision: 0,
+      ...extra
+    }).catch(() => {});
+  }
+  function clearCommandTimeout(id) {
+    const t = timeouts.get(id);
+    if (t) {
+      try {
+        globalThis.clearTimeout(t);
+      } catch {}
+    }
+    timeouts.delete(id);
+    timeoutOwners.delete(id);
+  }
+  function scheduleTimeout(directory, id, ownerSessionID, timeoutSeconds) {
+    clearCommandTimeout(id);
+    const handle = setTimeout(() => {
+      timeouts.delete(id);
+      fireTimeout(directory, id).catch(() => {});
+    }, timeoutSeconds * 1000);
+    try {
+      handle.unref?.();
+    } catch {}
+    timeouts.set(id, handle);
+    timeoutOwners.set(id, { directory, ownerSessionID });
+  }
+  async function fireTimeout(directory, id) {
+    const owner = timeoutOwners.get(id)?.ownerSessionID;
+    timeoutOwners.delete(id);
+    if (!owner)
+      return;
+    const before = await readState(directory).then((s) => (s.commands ?? []).find((x) => x.id === id));
+    if (!before || before.status !== "running")
+      return;
+    await service.terminate(directory, id, owner).catch(() => {});
+    await mutateState(directory, `cmd.timeout:${id}`, async (s) => {
+      const c = (s.commands ?? []).find((x) => x.id === id);
+      if (!c)
+        return s;
+      c.endReason = "timeout";
+      c.lastError = c.lastError ?? `Command timed out after ${c.timeoutSeconds ?? "?"}s (timeoutSeconds deadline reached; terminated via the standard SIGTERM\u2192SIGKILL path).`;
+      if (!c.endedAt) {
+        c.endedAt = new Date().toISOString();
+        c.updatedAt = c.endedAt;
+      } else {
+        c.updatedAt = new Date().toISOString();
+      }
+      return s;
+    }).catch(() => {});
+    try {
+      const fresh = await readState(directory).then((st) => (st.commands ?? []).find((x) => x.id === id));
+      if (fresh)
+        emitBroker(id, { type: "status", command: fresh });
+    } catch {}
+    await fireAwaits(directory, id);
+    await notifyOwnerIfNeeded(directory, id);
+  }
   function tailText(entry, limitBytes = 64 * 1024) {
     let want = limitBytes;
     const parts = [];
@@ -4294,6 +5213,131 @@ function createCommandService(host, opts) {
       await opts?.onAwaitFired?.(directory, fired);
     } catch {}
   }
+  async function notifyOwnerIfNeeded(directory, id) {
+    try {
+      let target;
+      await mutateState(directory, `cmd.notify-claim:${id}`, async (s) => {
+        const c = (s.commands ?? []).find((x) => x.id === id);
+        if (!c)
+          return s;
+        if (c.ownerNotifiedAt)
+          return s;
+        if (!isTerminalCommandStatus(c.status))
+          return s;
+        if (!shouldNotifyOwnerOnExit(c))
+          return s;
+        c.ownerNotifiedAt = new Date().toISOString();
+        target = { ...c };
+        return s;
+      });
+      if (!target)
+        return;
+      const tail = await readBoundedTail(directory, id);
+      const message = formatAwaitEvidence({
+        title: target.title,
+        argv: [target.command, ...target.args],
+        commandID: target.id,
+        status: target.status,
+        exitCode: target.exitCode,
+        signal: target.signal,
+        tail
+      });
+      await opts?.onOwnerNotify?.(directory, target.ownerSessionID, message);
+    } catch {}
+  }
+  async function flushWatch(directory, id) {
+    const watcher = watchers.get(id);
+    if (!watcher || watcher.pendingCount === 0)
+      return;
+    let session;
+    try {
+      session = await readState(directory).then((s) => (s.commands ?? []).find((x) => x.id === id));
+    } catch {
+      return;
+    }
+    if (!session || session.status !== "running")
+      return;
+    const push = watcher.takePush();
+    await persistWatchState(directory, id, watcher.state).catch(() => {});
+    if (!push)
+      return;
+    if (push.exhaustedNow) {
+      await watchLedger(directory, id, "command.watch-suspended", { reason: "budget", pushes: watcher.state.pushes });
+      try {
+        await opts?.onWatchNotify?.(directory, session.ownerSessionID, formatWatchBudgetMessage(session.title));
+      } catch {}
+      return;
+    }
+    await watchLedger(directory, id, "command.watch-matched", {
+      lines: push.lines.length,
+      matches: watcher.state.matches,
+      pushes: watcher.state.pushes
+    });
+    try {
+      await opts?.onWatchNotify?.(directory, session.ownerSessionID, formatWatchMessage(session.title, push.lines));
+    } catch {}
+    if (watcher.pendingCount > 0)
+      scheduleWatchFlush(directory, id);
+  }
+  async function handleUntilMatch(directory, id) {
+    const watcher = watchers.get(id);
+    if (!watcher)
+      return;
+    clearWatchTimer(id);
+    let session;
+    try {
+      session = await readState(directory).then((s) => (s.commands ?? []).find((x) => x.id === id));
+    } catch {
+      return;
+    }
+    if (!session)
+      return;
+    const action = watcher.untilAction;
+    const lines = watcher.takeUntilPush();
+    const snapshot = { ...watcher.state };
+    const message = formatWatchMessage(session.title, lines, `-- until "${session.watchUntil ?? ""}" matched (action=${action})`);
+    await mutateState(directory, `cmd.until-claim:${id}`, async (s) => {
+      const c = (s.commands ?? []).find((x) => x.id === id);
+      if (!c)
+        return s;
+      c.watchState = { ...snapshot };
+      if (action === "stop" && !c.ownerNotifiedAt)
+        c.ownerNotifiedAt = new Date().toISOString();
+      c.updatedAt = new Date().toISOString();
+      return s;
+    }).catch(() => {});
+    await watchLedger(directory, id, "command.watch-matched", {
+      until: session.watchUntil ?? "",
+      lines: lines.length,
+      pushes: snapshot.pushes
+    });
+    try {
+      await opts?.onWatchNotify?.(directory, session.ownerSessionID, message);
+    } catch {}
+    if (action !== "stop")
+      return;
+    if (session.status !== "running")
+      return;
+    await watchLedger(directory, id, "command.until-stopped", { until: session.watchUntil ?? "" });
+    await service.terminate(directory, id, session.ownerSessionID).catch(() => {});
+    await mutateState(directory, `cmd.until:${id}`, async (s) => {
+      const c = (s.commands ?? []).find((x) => x.id === id);
+      if (!c)
+        return s;
+      if (c.status === "terminated" && c.endReason !== "timeout") {
+        c.endReason = "until";
+        c.lastError = c.lastError ?? `Watch until pattern "${c.watchUntil ?? ""}" matched; command stopped (untilAction=stop).`;
+        c.updatedAt = new Date().toISOString();
+      }
+      return s;
+    }).catch(() => {});
+    try {
+      const fresh = await readState(directory).then((st) => (st.commands ?? []).find((x) => x.id === id));
+      if (fresh)
+        emitBroker(id, { type: "status", command: fresh });
+    } catch {}
+    await fireAwaits(directory, id);
+  }
   async function readBrokerSnapshot(commandID, ownerSessionID) {
     const directory = commandDirs.get(commandID);
     if (!directory)
@@ -4343,6 +5387,43 @@ function createCommandService(host, opts) {
         entry.bufferedBytes -= dropped.length;
       }
     }
+    let watcher;
+    let feed;
+    let bareLines = [];
+    try {
+      watcher = watchers.get(id);
+      if (!watcher) {
+        const spec = await readState(directory).then((s) => (s.commands ?? []).find((x) => x.id === id)).catch(() => {
+          return;
+        });
+        if (spec && spec.status === "running" && (spec.watchFilter !== undefined || spec.watchUntil !== undefined)) {
+          try {
+            watcher = new CommandWatcher({
+              ...spec.watchFilter !== undefined ? { filter: spec.watchFilter } : {},
+              ...spec.watchUntil !== undefined ? { until: spec.watchUntil } : {},
+              ...spec.watchIgnoreCase !== undefined ? { ignoreCase: spec.watchIgnoreCase } : {},
+              ...spec.watchUntilAction !== undefined ? { untilAction: spec.watchUntilAction } : {}
+            });
+            watchers.set(id, watcher);
+          } catch {
+            watcher = undefined;
+          }
+        }
+      }
+      if (watcher) {
+        feed = watcher.feedChunk(chunk, Date.now());
+      } else {
+        let asm = awaitAsm.get(id);
+        if (!asm) {
+          asm = createLineAssembler();
+          awaitAsm.set(id, asm);
+        }
+        bareLines = asm.push(chunk).filter((l) => l.trim() !== "");
+      }
+    } catch {
+      watcher = undefined;
+      feed = undefined;
+    }
     await appendCommandLog(directory, id, chunk);
     let retainedBytes = 0;
     let truncated = false;
@@ -4372,6 +5453,8 @@ function createCommandService(host, opts) {
       c.outputBytes = retainedBytes;
       if (truncated)
         c.truncated = true;
+      if (watcher)
+        c.watchState = { ...watcher.state };
       c.updatedAt = new Date().toISOString();
       return s;
     });
@@ -4389,19 +5472,104 @@ function createCommandService(host, opts) {
         });
       }
     } catch {}
+    try {
+      if (watcher && feed) {
+        if (feed.floodNow) {
+          await persistWatchState(directory, id, watcher.state).catch(() => {});
+          const dropped = watcher.state.droppedLines;
+          let owner;
+          let title = id;
+          try {
+            const snap = await readState(directory).then((s) => (s.commands ?? []).find((x) => x.id === id));
+            owner = snap?.ownerSessionID;
+            title = snap?.title ?? id;
+          } catch {}
+          await watchLedger(directory, id, "command.watch-suspended", { reason: "flood", dropped });
+          if (owner) {
+            try {
+              await opts?.onWatchNotify?.(directory, owner, formatWatchFloodMessage(title, dropped));
+            } catch {}
+          }
+        }
+        if (watcher.pendingCount > 0)
+          scheduleWatchFlush(directory, id);
+        if (feed.untilLine) {
+          clearWatchTimer(id);
+          enqueue(id, () => handleUntilMatch(directory, id)).catch(() => {});
+        }
+      }
+    } catch {}
+    try {
+      const completed = feed ? feed.completed : bareLines;
+      if (completed.length > 0) {
+        const fired = await fireUntilAwaits(directory, id, completed);
+        if (fired.length > 0) {
+          await opts?.onAwaitFired?.(directory, fired);
+        }
+      }
+    } catch {}
   }
   async function persistExit(directory, id, info) {
     rememberDir(id, directory);
     live.delete(id);
+    clearCommandTimeout(id);
+    const exitWatcher = watchers.get(id);
+    if (exitWatcher) {
+      try {
+        const handledStop = exitWatcher.state.state === "until-matched" && exitWatcher.untilAction === "stop";
+        exitWatcher.finish(Date.now());
+        let snap;
+        try {
+          snap = await readState(directory).then((s) => (s.commands ?? []).find((x) => x.id === id));
+        } catch {
+          snap = undefined;
+        }
+        if (snap && !handledStop && exitWatcher.pendingCount > 0) {
+          const push = exitWatcher.takePush();
+          await persistWatchState(directory, id, exitWatcher.state).catch(() => {});
+          if (push && !push.exhaustedNow && push.lines.length > 0) {
+            await watchLedger(directory, id, "command.watch-matched", {
+              lines: push.lines.length,
+              atExit: true,
+              pushes: exitWatcher.state.pushes
+            });
+            try {
+              await opts?.onWatchNotify?.(directory, snap.ownerSessionID, formatWatchMessage(snap.title, push.lines));
+            } catch {}
+          } else if (push?.exhaustedNow) {
+            await watchLedger(directory, id, "command.watch-suspended", {
+              reason: "budget",
+              atExit: true,
+              pushes: exitWatcher.state.pushes
+            });
+            try {
+              await opts?.onWatchNotify?.(directory, snap.ownerSessionID, formatWatchBudgetMessage(snap.title));
+            } catch {}
+          }
+        } else {
+          await persistWatchState(directory, id, exitWatcher.state).catch(() => {});
+        }
+      } catch {}
+    }
+    deleteWatch(id);
     await mutateState(directory, `cmd.exit:${id}`, async (s) => {
       const c = (s.commands ?? []).find((x) => x.id === id);
       if (!c || c.status !== "running")
         return s;
+      if (c.endReason === "timeout") {
+        if (!c.endedAt) {
+          c.endedAt = new Date().toISOString();
+          c.updatedAt = c.endedAt;
+        }
+        return s;
+      }
       c.exitCode = info.exitCode;
       if (info.signal && (c.signal === "SIGKILL" || c.signal === "SIGTERM")) {
         c.status = "terminated";
+        c.endReason = "terminate";
       } else {
         c.status = "exited";
+        c.endReason = "exit";
         if (info.signal)
           c.signal = info.signal;
       }
@@ -4411,7 +5579,7 @@ function createCommandService(host, opts) {
     }).catch(() => {});
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID7(),
+      eventID: randomUUID8(),
       commandID: id,
       type: "command.exited",
       exitCode: info.exitCode,
@@ -4424,11 +5592,12 @@ function createCommandService(host, opts) {
         emitBroker(id, { type: "status", command: fresh });
     } catch {}
     await fireAwaits(directory, id);
+    await notifyOwnerIfNeeded(directory, id);
   }
   function owned(cmd, ownerSessionID) {
     return !!cmd && cmd.ownerSessionID === ownerSessionID;
   }
-  return {
+  const service = {
     async start(directory, input) {
       const title = input.title.trim();
       const command = input.command.trim();
@@ -4439,11 +5608,29 @@ function createCommandService(host, opts) {
       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 timeoutSeconds = normalizeTimeoutSeconds(input.timeoutSeconds);
+      const watchFilter = input.watchFilter !== undefined && input.watchFilter !== "" ? input.watchFilter : undefined;
+      const watchUntil = input.watchUntil !== undefined && input.watchUntil !== "" ? input.watchUntil : undefined;
+      const hasWatch = watchFilter !== undefined || watchUntil !== undefined;
+      let watcher;
+      let watchState;
+      if (hasWatch) {
+        watcher = new CommandWatcher({
+          ...watchFilter !== undefined ? { filter: watchFilter } : {},
+          ...watchUntil !== undefined ? { until: watchUntil } : {},
+          ...input.watchIgnoreCase !== undefined ? { ignoreCase: input.watchIgnoreCase } : {},
+          ...input.watchUntilAction !== undefined ? { untilAction: input.watchUntilAction } : {}
+        });
+        watchState = initialWatchState();
+      }
+      const startedAt = new Date;
+      const id = randomUUID8();
       const cwd = input.cwd || directory;
+      const useShell = input.shell === true;
+      const spawnOpts = useShell ? { command: "/bin/sh", args: ["-c", shellJoin(command, input.args ?? [])], cwd, cols: input.cols, rows: input.rows, env: input.env } : { command, args: input.args ?? [], cwd, cols: input.cols, rows: input.rows, env: input.env };
       const pending = [];
       let ready = false;
-      const handle = host.spawn({ command, args: input.args ?? [], cwd, cols: input.cols, rows: input.rows }, (chunk) => {
+      const handle = host.spawn(spawnOpts, (chunk) => {
         if (!ready)
           pending.push({ type: "output", chunk });
         else
@@ -4462,9 +5649,19 @@ function createCommandService(host, opts) {
         cwd,
         ownerSessionID: input.ownerSessionID,
         goalID: input.goalID,
+        notifyOnExit: input.notifyOnExit,
         pid: handle.pid,
         cols: input.cols,
-        rows: input.rows
+        rows: input.rows,
+        shell: useShell ? true : undefined,
+        timeoutSeconds,
+        deadlineAt: timeoutSeconds !== undefined ? computeDeadlineAt(startedAt, timeoutSeconds) : undefined,
+        envKeys: input.env ? Object.keys(input.env) : undefined,
+        watchFilter,
+        watchUntil,
+        watchIgnoreCase: input.watchIgnoreCase,
+        watchUntilAction: watcher?.untilAction,
+        watchState
       });
       try {
         await mutateState(directory, `cmd.start:${id}`, async (s) => {
@@ -4482,10 +5679,14 @@ function createCommandService(host, opts) {
         throw error;
       }
       live.set(id, { handle, buffers: [], bufferedBytes: 0 });
+      if (watcher)
+        watchers.set(id, watcher);
+      if (timeoutSeconds !== undefined)
+        scheduleTimeout(directory, id, input.ownerSessionID, timeoutSeconds);
       rememberDir(id, directory);
       await appendEvent(directory, {
         version: 1,
-        eventID: randomUUID7(),
+        eventID: randomUUID8(),
         ...input.goalID ? { goalID: input.goalID } : {},
         commandID: id,
         type: "command.started",
@@ -4505,7 +5706,7 @@ function createCommandService(host, opts) {
         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;
+      return await service.get(directory, id, input.ownerSessionID) ?? session;
     },
     async list(directory, ownerSessionID) {
       const s = await readState(directory);
@@ -4521,9 +5722,52 @@ function createCommandService(host, opts) {
     },
     async read(directory, id, ownerSessionID, opts) {
       await waitForOperations(id);
-      const session = await this.get(directory, id, ownerSessionID);
+      const session = await service.get(directory, id, ownerSessionID);
       if (!session)
         return;
+      if (opts?.pattern !== undefined) {
+        const flags = opts.ignoreCase ? "i" : "";
+        const checked = validateReadPattern(opts.pattern);
+        if (typeof checked !== "object" || !(checked instanceof RegExp)) {
+          throw new Error(checked.error);
+        }
+        const regex = new RegExp(opts.pattern, flags);
+        const full = await readCommandLog(directory, id, { offsetBytes: 0, limitBytes: MAX_COMMAND_OUTPUT_BYTES });
+        const lines = full.text.length === 0 ? [] : full.text.split(`
+`);
+        const matches = [];
+        for (const line of lines) {
+          let stripped;
+          try {
+            stripped = stripAnsiForMatch(line);
+          } catch {
+            stripped = line;
+          }
+          let hit = false;
+          try {
+            hit = regex.test(stripped);
+          } catch {
+            throw new Error(`Invalid regex pattern '${opts.pattern}'.`);
+          }
+          regex.lastIndex = 0;
+          if (hit)
+            matches.push(line);
+        }
+        const skip = Math.max(0, opts.offsetBytes ?? 0);
+        const take = Math.min(opts.limitBytes ?? MAX_COMMAND_READ_LINES, MAX_COMMAND_READ_LINES);
+        const page = matches.slice(skip, skip + Math.max(0, take));
+        return {
+          session,
+          text: page.join(`
+`) + (page.length > 0 ? `
+` : ""),
+          totalBytes: matches.length,
+          startByte: skip,
+          live: session.status === "running",
+          pattern: opts.pattern,
+          totalMatches: matches.length
+        };
+      }
       const entry = live.get(id);
       const offset = opts?.offsetBytes ?? 0;
       const limit = Math.min(opts?.limitBytes ?? 64 * 1024, 256 * 1024);
@@ -4539,7 +5783,7 @@ function createCommandService(host, opts) {
       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);
+      const session = await service.get(directory, id, ownerSessionID);
       if (!session)
         return { ok: false, message: "Command not found." };
       if (session.status !== "running")
@@ -4551,7 +5795,7 @@ function createCommandService(host, opts) {
       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);
+      const session = await service.get(directory, id, ownerSessionID);
       if (!session)
         return { ok: false, message: "Command not found." };
       if (!Number.isInteger(cols) || !Number.isInteger(rows) || cols <= 0 || rows <= 0) {
@@ -4580,7 +5824,7 @@ function createCommandService(host, opts) {
       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);
+      const session = await service.get(directory, id, ownerSessionID);
       if (!session)
         return { ok: false, message: "Command not found." };
       if (session.status !== "running")
@@ -4601,13 +5845,18 @@ function createCommandService(host, opts) {
       });
       return { ok: true, message: `SIGINT delivered to "${session.title}" (process may continue if it traps the signal).` };
     },
-    async terminate(directory, id, ownerSessionID) {
+    async terminate(directory, id, ownerSessionID, opts) {
       rememberDir(id, directory);
-      const session = await this.get(directory, id, ownerSessionID);
+      const session = await service.get(directory, id, ownerSessionID);
       if (!session)
         return { ok: false, message: "Command not found." };
-      if (session.status !== "running")
+      if (session.status !== "running") {
+        if (opts?.remove) {
+          const removed = await service.remove(directory, id, ownerSessionID);
+          return removed.ok ? { ok: true, message: `Command was already ${session.status}; removed.`, removed: true } : { ok: false, message: `Command is ${session.status}; remove failed: ${removed.message}` };
+        }
         return { ok: false, message: `Command is ${session.status}; nothing to terminate.` };
+      }
       await mutateState(directory, `cmd.terminate-claim:${id}`, async (s) => {
         const c = (s.commands ?? []).find((x) => x.id === id);
         if (c && c.ownerSessionID === ownerSessionID && c.status === "running") {
@@ -4642,18 +5891,24 @@ function createCommandService(host, opts) {
         live.delete(id);
       }
       const exitCode = status === "terminated" ? 143 : undefined;
+      clearCommandTimeout(id);
+      clearWatchTimer(id);
       await mutateState(directory, `cmd.terminate:${id}`, async (s) => {
         const c = (s.commands ?? []).find((x) => x.id === id);
         if (!c || c.ownerSessionID !== ownerSessionID)
           return s;
         if (c.status === "running") {
           c.status = status;
+          if (c.endReason !== "timeout")
+            c.endReason = status === "terminated" ? "terminate" : "exit";
           if (exitCode !== undefined)
             c.exitCode = c.exitCode ?? exitCode;
           c.signal = c.signal ?? "SIGTERM";
           c.endedAt = new Date().toISOString();
           c.updatedAt = c.endedAt;
         } else if (c.status === "terminated" && !c.endedAt) {
+          if (c.endReason !== "timeout" && !c.endReason)
+            c.endReason = "terminate";
           if (exitCode !== undefined)
             c.exitCode = c.exitCode ?? exitCode;
           c.endedAt = new Date().toISOString();
@@ -4667,16 +5922,24 @@ function createCommandService(host, opts) {
           emitBroker(id, { type: "status", command: fresh });
       } catch {}
       await fireAwaits(directory, id);
+      await notifyOwnerIfNeeded(directory, id);
+      if (opts?.remove) {
+        const removed = await service.remove(directory, id, ownerSessionID);
+        if (removed.ok)
+          return { ok: true, message: `Command "${session.title}" ${status}; removed.`, removed: true };
+        return { ok: true, message: `Command "${session.title}" ${status}; remove failed: ${removed.message}` };
+      }
       return { ok: true, message: `Command "${session.title}" ${status}.` };
     },
     async remove(directory, id, ownerSessionID) {
       rememberDir(id, directory);
-      const session = await this.get(directory, id, ownerSessionID);
+      const session = await service.get(directory, id, ownerSessionID);
       if (!session)
         return { ok: false, message: "Command not found." };
       if (session.status === "running") {
         return { ok: false, message: `Command "${session.title}" is still running \u2014 terminate it first (terminate \u2260 remove).` };
       }
+      deleteWatch(id);
       const lastKnown = { ...session };
       await mutateState(directory, `cmd.remove:${id}`, async (s) => {
         s.commands = (s.commands ?? []).filter((x) => !(x.id === id && x.ownerSessionID === ownerSessionID));
@@ -4687,6 +5950,86 @@ function createCommandService(host, opts) {
       await clearAwaitsForCommand(directory, id, "command removed").catch(() => {});
       return { ok: true, message: `Command "${session.title}" removed.` };
     },
+    async watch(directory, id, ownerSessionID, opts) {
+      rememberDir(id, directory);
+      const session = await service.get(directory, id, ownerSessionID);
+      if (!session)
+        return { ok: false, message: "Command not found." };
+      if (session.status !== "running") {
+        return { ok: false, message: `Command is ${session.status}; watch is meaningless after exit.` };
+      }
+      if (opts?.untilAction !== undefined && opts.untilAction !== "stop" && opts.untilAction !== "keep") {
+        throw new Error(`Invalid watch untilAction '${opts.untilAction}': must be "stop" or "keep".`);
+      }
+      if (opts?.clear === true) {
+        deleteWatch(id);
+        await mutateState(directory, `cmd.watch-clear:${id}`, async (s) => {
+          const c = (s.commands ?? []).find((x) => x.id === id);
+          if (c && c.ownerSessionID === ownerSessionID) {
+            delete c.watchFilter;
+            delete c.watchUntil;
+            delete c.watchIgnoreCase;
+            delete c.watchUntilAction;
+            delete c.watchState;
+            c.updatedAt = new Date().toISOString();
+          }
+          return s;
+        });
+        await watchLedger(directory, id, "command.watch-suspended", { reason: "cleared" }).catch(() => {});
+        try {
+          const fresh = await readState(directory).then((st) => (st.commands ?? []).find((x) => x.id === id));
+          if (fresh)
+            emitBroker(id, { type: "status", command: fresh });
+        } catch {}
+        const cleared = await service.get(directory, id, ownerSessionID);
+        return { ok: true, message: `Watch cleared for "${session.title}".`, command: cleared };
+      }
+      const filter = opts?.filter !== undefined && opts.filter !== "" ? opts.filter : undefined;
+      const until = opts?.until !== undefined && opts.until !== "" ? opts.until : undefined;
+      const watcher = new CommandWatcher({
+        ...filter !== undefined ? { filter } : {},
+        ...until !== undefined ? { until } : {},
+        ...opts?.ignoreCase !== undefined ? { ignoreCase: opts.ignoreCase } : {},
+        ...opts?.untilAction !== undefined ? { untilAction: opts.untilAction } : {}
+      });
+      clearWatchTimer(id);
+      watchers.set(id, watcher);
+      awaitAsm.delete(id);
+      const freshState = initialWatchState();
+      await mutateState(directory, `cmd.watch:${id}`, async (s) => {
+        const c = (s.commands ?? []).find((x) => x.id === id);
+        if (c && c.ownerSessionID === ownerSessionID) {
+          if (filter !== undefined)
+            c.watchFilter = filter;
+          else
+            delete c.watchFilter;
+          if (until !== undefined)
+            c.watchUntil = until;
+          else
+            delete c.watchUntil;
+          if (opts?.ignoreCase !== undefined)
+            c.watchIgnoreCase = opts.ignoreCase;
+          else
+            delete c.watchIgnoreCase;
+          c.watchUntilAction = watcher.untilAction;
+          c.watchState = { ...freshState };
+          c.updatedAt = new Date().toISOString();
+        }
+        return s;
+      });
+      try {
+        const fresh = await readState(directory).then((st) => (st.commands ?? []).find((x) => x.id === id));
+        if (fresh)
+          emitBroker(id, { type: "status", command: fresh });
+      } catch {}
+      const updated = await service.get(directory, id, ownerSessionID);
+      const desc = [
+        filter !== undefined ? `filter="${filter}"` : "filter=\u2014",
+        until !== undefined ? `until="${until}"` : "until=\u2014",
+        `action=${watcher.untilAction}`
+      ].join(" ");
+      return { ok: true, message: `Watch set for "${session.title}" (${desc}; counters reset to active).`, command: updated };
+    },
     async reconcile(directory) {
       const state = await readState(directory);
       const cmds = state.commands ?? [];
@@ -4700,10 +6043,13 @@ function createCommandService(host, opts) {
         if (entry) {
           if (!entry.handle.isAlive()) {
             live.delete(c.id);
+            clearCommandTimeout(c.id);
+            deleteWatch(c.id);
             await mutateState(directory, `cmd.reconcile-exit:${c.id}`, async (s) => {
               const x = (s.commands ?? []).find((y) => y.id === c.id);
               if (x && x.status === "running") {
                 x.status = "exited";
+                x.endReason = "exit";
                 x.endedAt = new Date().toISOString();
                 x.updatedAt = x.endedAt;
                 x.lastError = x.lastError ?? "Process handle died without an exit event.";
@@ -4716,14 +6062,19 @@ function createCommandService(host, opts) {
                 emitBroker(c.id, { type: "status", command: fresh });
             } catch {}
             await fireAwaits(directory, c.id);
+            await notifyOwnerIfNeeded(directory, c.id);
           }
           continue;
         }
+        clearCommandTimeout(c.id);
+        deleteWatch(c.id);
+        const deadlinePassed = c.deadlineAt ? Date.parse(c.deadlineAt) <= Date.now() : false;
         await mutateState(directory, `cmd.reconcile-missing:${c.id}`, async (s) => {
           const x = (s.commands ?? []).find((y) => y.id === c.id);
           if (x && x.status === "running") {
             x.status = "missing";
-            x.lastError = "Host restarted or handle lost \u2014 no live execution found. Output log retained; remove to clean up.";
+            x.endReason = "missing";
+            x.lastError = deadlinePassed ? `Host restarted or handle lost \u2014 no live execution found (timeoutSeconds=${x.timeoutSeconds ?? "?"}s deadline ${x.deadlineAt} already passed; treated as missing, timeout elapsed). Output log retained; remove to clean up.` : "Host restarted or handle lost \u2014 no live execution found. Output log retained; remove to clean up.";
             x.updatedAt = new Date().toISOString();
             markedMissing++;
           }
@@ -4735,16 +6086,21 @@ function createCommandService(host, opts) {
             emitBroker(c.id, { type: "status", command: fresh });
         } catch {}
         await fireAwaits(directory, c.id);
+        await notifyOwnerIfNeeded(directory, c.id);
       }
       return { markedMissing };
     },
     async dispose(directory) {
+      for (const id of [...watchTimers.keys()])
+        clearWatchTimer(id);
+      watchers.clear();
+      awaitAsm.clear();
       const state = await readState(directory);
       const owned = new Map((state.commands ?? []).map((command) => [command.id, command.ownerSessionID]));
       await Promise.all([...live.entries()].map(async ([id, entry]) => {
         const owner = owned.get(id);
         if (owner) {
-          await this.terminate(directory, id, owner).catch(() => {});
+          await service.terminate(directory, id, owner).catch(() => {});
           return;
         }
         entry.handle.terminate();
@@ -4756,12 +6112,15 @@ function createCommandService(host, opts) {
           entry.handle.kill();
         live.delete(id);
       }));
+      for (const id of [...timeouts.keys()])
+        clearCommandTimeout(id);
     }
   };
+  return service;
 }
 
 // src/application/command-event-broker.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 function safeDeliver(sink, msg) {
   try {
     sink(msg);
@@ -4804,7 +6163,7 @@ function createCommandEventBroker(resolver) {
         throw new Error("ownerSessionID is required.");
       if (typeof sink !== "function")
         throw new Error("sink must be a function.");
-      const sinkID = randomUUID8();
+      const sinkID = randomUUID9();
       const entry = { sinkID, sink, state: "subscribing", buffer: [] };
       entriesFor(commandID).set(sinkID, entry);
       try {
@@ -4893,7 +6252,7 @@ function createCommandEventBroker(resolver) {
 }
 
 // src/server/command-stream-server.ts
-import { randomBytes, randomUUID as randomUUID9, timingSafeEqual } from "crypto";
+import { randomBytes, randomUUID as randomUUID10, timingSafeEqual } from "crypto";
 import { promises as fs4 } from "fs";
 import path4 from "path";
 function streamEndpointPath(directory) {
@@ -4927,7 +6286,7 @@ 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 generation = randomUUID10();
   const startedAt = new Date().toISOString();
   let server;
   let serverURL;
@@ -5247,7 +6606,7 @@ function createCommandStreamServer(directory, commandService, broker) {
 
 // src/server/goal-tools.ts
 init_state_repository();
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 import { tool } from "@opencode-ai/plugin/tool";
 // src/domain/verification.ts
 var MAX_RECENT_ATTEMPTS = 10;
@@ -5266,7 +6625,7 @@ var execAsync = promisify(execChild);
 function goalTools(dir, goalService, hostSessionID, defaults = {}, host) {
   return {
     loopd_create_goal: tool({
-      description: "Create a new background loop goal (contract: objective + checks + agent/model + workspaceWrite). " + "The engine spawns a dedicated worker session that does the work autonomously \u2014 it never runs in this chat. " + "Call this after clarifying the contract with the user. " + "Worker identity is free-form: agent is any OpenCode agent name (built-in, ~/.config/opencode/agents/*.md, or opencode.jsonc agent.* \u2014 discover with `opencode agent list`), " + 'model is any "providerID/modelID" (discover with `opencode models [provider]`). When omitted, both inherit the CALLING session\'s live agent/model (read at creation), then plugin defaultAgent/defaultModel. ' + "Host is the acceptance authority: checks must pass for complete_goal (free retry if rejected <3, blocked after 3). " + "Workspace-writing goals are serialized (only one active writer) and require checks.",
+      description: "Create a new background loop GOAL: an autonomous AI worker that loops turn-by-turn on a multi-step objective until deterministic checks pass or it needs you (contract: objective + checks + agent/model + workspaceWrite). " + "The engine spawns a dedicated worker session that does the work autonomously \u2014 it never runs in this chat. " + "Use this for AI reasoning work spanning multiple turns (implement a feature, fix a failing suite, research and write a report) \u2014 NOT for running a single process you just want to start, watch, and type into. " + "For that (dev servers, `npm test --watch`, REPLs, log tails, one-off scripts, interactive shells with a fullscreen terminal UI), use loopd_command_start instead: it is lighter-weight, has no agent/checks/turn loop, and is a raw OS process, not an AI worker. " + "Call this after clarifying the contract with the user. " + "Worker identity is free-form: agent is any OpenCode agent name (built-in, ~/.config/opencode/agents/*.md, or opencode.jsonc agent.* \u2014 discover with `opencode agent list`), " + 'model is any "providerID/modelID" (discover with `opencode models [provider]`). When omitted, both inherit the CALLING session\'s live agent/model (read at creation), then plugin defaultAgent/defaultModel. ' + "Host is the acceptance authority: checks must pass for complete_goal (free retry if rejected <3, blocked after 3). " + "Workspace-writing goals are serialized (only one active writer) and require checks. " + "Monitor with the /loop dashboard's Goals tab (Tab/h to switch there if Commands is focused).",
       args: {
         name: tool.schema.string().describe("Short goal name (used in the dashboard)."),
         objective: tool.schema.string().describe("What the goal should accomplish, in detail."),
@@ -5386,6 +6745,8 @@ function goalTools(dir, goalService, hostSessionID, defaults = {}, host) {
               ok: true,
               goalID: goal.id,
               workerSessionID: worker.workerSessionID,
+              workerTopology: worker.topology,
+              ...worker.nativeParentID ? { nativeParentID: worker.nativeParentID } : {},
               artifactDir: goal.config.artifactDir,
               agent: resolution.config.agent,
               model: resolution.config.model,
@@ -5472,7 +6833,7 @@ function goalTools(dir, goalService, hostSessionID, defaults = {}, host) {
         await writeState(dir, state);
         const event = {
           version: 1,
-          eventID: randomUUID10(),
+          eventID: randomUUID11(),
           goalID: goal.id,
           type: "goal.progress",
           summary: args.summary,
@@ -5537,7 +6898,7 @@ Exit code: ${f.exitCode}${stdoutSnippet}${stderrSnippet}`;
 Working directory: ${cwd}
 
 ${failureDetails}`;
-              attemptID = randomUUID10();
+              attemptID = randomUUID11();
               const verificationAttempt = {
                 id: attemptID,
                 sequence: runtime.evaluatorRejectionCount,
@@ -5582,7 +6943,7 @@ ${failureDetails.slice(0, 500)}`,
             if (attemptID) {
               await appendEvent(dir, {
                 version: 1,
-                eventID: randomUUID10(),
+                eventID: randomUUID11(),
                 goalID: goal.id,
                 type: "goal.completion_rejected",
                 attemptID,
@@ -5600,7 +6961,7 @@ ${failureDetails.slice(0, 500)}`,
             if (blocked && rejectedGoal?.blocker) {
               await appendEvent(dir, {
                 version: 1,
-                eventID: randomUUID10(),
+                eventID: randomUUID11(),
                 goalID: goal.id,
                 type: "goal.blocked",
                 reason: rejectedGoal.blocker.reason,
@@ -5660,7 +7021,7 @@ ${failureDetails.slice(0, 500)}`,
             }
             runtime.updatedAt = new Date().toISOString();
           }
-          const attemptID = randomUUID10();
+          const attemptID = randomUUID11();
           const cwd = goal.config.checkCwd || goal.config.artifactDir || dir;
           const checks = (goal.config.checks || []).map((cmd) => ({
             command: cmd,
@@ -5684,7 +7045,7 @@ ${failureDetails.slice(0, 500)}`,
         await writeState(dir, state);
         const event = {
           version: 1,
-          eventID: randomUUID10(),
+          eventID: randomUUID11(),
           goalID: goal.id,
           type: "goal.completed",
           summary: args.summary,
@@ -5744,7 +7105,7 @@ ${failureDetails.slice(0, 500)}`,
         await writeState(dir, state);
         const event = {
           version: 1,
-          eventID: randomUUID10(),
+          eventID: randomUUID11(),
           goalID: goal.id,
           type: "goal.blocked",
           reason: args.reason,
@@ -6059,6 +7420,8 @@ function ownerTools(options) {
             stateSummary: describeGoalState(goal.status, runtime?.phase),
             ownerSessionID: goal.ownerSessionID,
             workerSessionID: goal.workerSessionID,
+            workerTopology: goal.workerTopology,
+            ...goal.nativeParentID ? { nativeParentID: goal.nativeParentID } : {},
             config: {
               maxTurns: goal.config.maxTurns,
               maxFailures: goal.config.maxFailures,
@@ -6532,9 +7895,20 @@ function summarize(c) {
     status: c.status,
     exitCode: c.exitCode,
     signal: c.signal,
+    endReason: c.endReason,
+    timeoutSeconds: c.timeoutSeconds,
+    deadlineAt: c.deadlineAt,
+    envKeys: c.envKeys,
+    shell: c.shell,
+    watchFilter: c.watchFilter,
+    watchUntil: c.watchUntil,
+    watchIgnoreCase: c.watchIgnoreCase,
+    watchUntilAction: c.watchUntilAction,
+    watchState: c.watchState,
     outputBytes: c.outputBytes,
     truncated: c.truncated,
     goalID: c.goalID,
+    notifyOnExit: c.notifyOnExit,
     updatedAt: c.updatedAt
   };
 }
@@ -6544,15 +7918,23 @@ function commandTools(options) {
   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.",
+      description: "Start a standalone interactive OS process (arbitrary shell command) in the background \u2014 a dev server, `npm test --watch`, a REPL, a log tail, a build, or a one-off script. This is a raw process, NOT an AI worker: no agent, no checks, no turn loop. For multi-turn autonomous AI work with completion criteria, use loopd_create_goal instead. " + "Returns a command_id for loopd_command_get (read output)/loopd_command_write (send stdin)/loopd_command_interrupt (Ctrl+C)/loopd_command_terminate (kill)/loopd_command_remove (delete). " + "The user can also open it live: /loop or /commands \u2192 Tab/l to the Commands tab \u2192 select it \u2192 `o` opens a fullscreen interactive terminal page (type directly, Ctrl+C interrupts, Ctrl+] detaches without stopping it). " + "Independent from goals: an optional goal_id is display-only metadata and never couples lifecycles \u2014 pausing/clearing a goal never touches the command, and terminating a command never touches the goal. " + "To make a specific goal wake up when this command finishes, call loopd_command_await separately after starting it (linking alone does not wake anything). " + "The OWNER session (you) gets pushed a real message when the command reaches a terminal status \u2014 no polling required to find out: by default (auto) that fires on a non-zero exit, on 'missing' (host restarted mid-run), on 'timeout' (timeout_seconds deadline reached \u2014 always notifies), or once total runtime crosses ~2 minutes (the long-running/monitor case); quick successful commands stay silent. Override with notify_on_exit.",
       args: {
         title: tool3.schema.string().describe("Short human label for the session."),
         command: tool3.schema.string().describe('Executable to spawn (e.g. "bun", "python3").'),
         args: tool3.schema.array(tool3.schema.string()).optional().describe("Arguments for the command."),
         cwd: tool3.schema.string().optional().describe("Working directory. Defaults to the project root."),
         goal_id: tool3.schema.string().optional().describe("Optional goal linkage (display only \u2014 no lifecycle coupling)."),
+        notify_on_exit: tool3.schema.boolean().optional().describe("Owner-exit-notification override. true = always push a message to you when this command finishes. false = never (dashboard/loopd_command_get only). Omit for auto (failure, lost-host, timeout, or long-running success)."),
         cols: tool3.schema.number().optional().describe(`Requested terminal width (${sizeNote}).`),
-        rows: tool3.schema.number().optional().describe(`Requested terminal height (${sizeNote}).`)
+        rows: tool3.schema.number().optional().describe(`Requested terminal height (${sizeNote}).`),
+        env: tool3.schema.record(tool3.schema.string(), tool3.schema.string()).optional().describe("Extra environment variables for the child. Values are passed to the host but never persisted \u2014 only names appear as envKeys in summaries."),
+        timeout_seconds: tool3.schema.number().optional().describe("Per-command timeout in seconds (positive integer). The command is terminated via the standard SIGTERM\u2192SIGKILL path when the deadline passes; endReason becomes 'timeout' and the owner is always notified (auto policy). In-memory only \u2014 never resurrected across restarts."),
+        shell: tool3.schema.boolean().optional().describe("When true, spawn via /bin/sh -c with command+args joined into one shell string (POSIX single-quote escaping). Shell metacharacters are interpreted; prefer argv form for untrusted input."),
+        watch_filter: tool3.schema.string().optional().describe("Watch line filter (regex on ANSI-stripped lines): only matching lines buffer toward a coalesced owner push (one push per ~2s window, \u226420 lines/\u22644KB each, \u226430 pushes per command; 100+ lines/sec suspends with one notice). For never-exiting processes (dev servers, log tails). Adjust later via loopd_command_watch."),
+        watch_until: tool3.schema.string().optional().describe("Watch until pattern (regex on the filter-surviving stream): first match notifies the owner immediately with the matched lines. With watch_until_action=stop (default) the command is terminated with endReason=until (exactly one owner message total); with keep it keeps running (until fires once, filter stream continues)."),
+        watch_ignore_case: tool3.schema.boolean().optional().describe("Case-insensitive watch matching (default false)."),
+        watch_until_action: tool3.schema.string().optional().describe('Until action: "stop" (default) terminates the command on first until-match; "keep" notifies but keeps running (until fires once, filter stream continues).')
       },
       execute: async (args, context) => {
         const owner = ownerID(context);
@@ -6566,6 +7948,9 @@ function commandTools(options) {
             always: [args.command],
             metadata: { command: args.command, args: args.args ?? [], cwd: args.cwd ?? directory }
           });
+          if (args.watch_until_action !== undefined && args.watch_until_action !== "stop" && args.watch_until_action !== "keep") {
+            throw new Error(`Invalid watch_until_action '${args.watch_until_action}': must be "stop" or "keep".`);
+          }
           const session = await commandService.start(directory, {
             title: args.title,
             command: args.command,
@@ -6573,8 +7958,16 @@ function commandTools(options) {
             cwd: args.cwd,
             ownerSessionID: owner,
             goalID: args.goal_id,
+            notifyOnExit: args.notify_on_exit,
             cols: args.cols,
-            rows: args.rows
+            rows: args.rows,
+            env: args.env,
+            timeoutSeconds: args.timeout_seconds,
+            shell: args.shell,
+            watchFilter: args.watch_filter,
+            watchUntil: args.watch_until,
+            watchIgnoreCase: args.watch_ignore_case,
+            watchUntilAction: args.watch_until_action
           });
           return {
             title: "Command started",
@@ -6589,7 +7982,7 @@ function commandTools(options) {
       }
     }),
     loopd_command_list: tool3({
-      description: "List standalone command sessions owned by this session.",
+      description: "List standalone command sessions owned by this session (same set the TUI Commands tab shows for this session). Use before reading/writing to find a command's ID, or to check if a dev server/watcher you started earlier is still running.",
       args: {},
       execute: async (_args, context) => {
         const owner = ownerID(context);
@@ -6603,20 +7996,29 @@ function commandTools(options) {
       }
     }),
     loopd_command_get: tool3({
-      description: "Get a command session's metadata plus a bounded output snapshot. Closing a view detaches; it never terminates.",
+      description: "Read a command session's status plus its output so far (bounded snapshot; page with offset_bytes for more). For progress checks on plain one-shot commands, read once or twice as needed \u2014 but for never-exiting processes (dev servers, log tails, watch mode) prefer watch_filter/watch_until at start (or loopd_command_watch on a running command) and loopd_command_await for goal wakes: the owner gets pushed on match/exit with no repeated reads. Never terminates the command; detach/inspect is always read-only. With pattern, only matching lines return (regex on ANSI-stripped text, original lines kept; dangerous nested-quantifier patterns are rejected) and offset_bytes/limit_bytes page over MATCHES (match index + max matched lines, default 500).",
       args: {
         command_id: tool3.schema.string().describe("Command session ID."),
-        offset_bytes: tool3.schema.number().optional().describe("Byte offset into the output log (paging)."),
-        limit_bytes: tool3.schema.number().optional().describe("Max bytes to return (default 64KB, cap 256KB).")
+        offset_bytes: tool3.schema.number().optional().describe("Byte offset into the output log (paging). With pattern: number of matching lines to skip."),
+        limit_bytes: tool3.schema.number().optional().describe("Max bytes to return (default 64KB, cap 256KB). With pattern: max matching lines (default 500)."),
+        pattern: tool3.schema.string().optional().describe("Regex to filter lines (matched against ANSI-stripped text; original lines returned). Dangerous nested-quantifier patterns are rejected."),
+        ignore_case: tool3.schema.boolean().optional().describe("Case-insensitive pattern matching (default false).")
       },
       execute: async (args, context) => {
         const owner = ownerID(context);
         if (!owner)
           return denied();
-        const result = await commandService.read(directory, args.command_id, owner, {
-          offsetBytes: args.offset_bytes,
-          limitBytes: args.limit_bytes
-        });
+        let result;
+        try {
+          result = await commandService.read(directory, args.command_id, owner, {
+            offsetBytes: args.offset_bytes,
+            limitBytes: args.limit_bytes,
+            pattern: args.pattern,
+            ignoreCase: args.ignore_case
+          });
+        } catch (error) {
+          return { title: "Read failed", output: JSON.stringify({ ok: false, message: error instanceof Error ? error.message : String(error) }) };
+        }
         if (!result) {
           return { title: "Not found", output: JSON.stringify({ ok: false, message: "Command not found for this session." }) };
         }
@@ -6628,13 +8030,14 @@ function commandTools(options) {
             output: result.text,
             startByte: result.startByte,
             totalBytes: result.totalBytes,
-            live: result.live
+            live: result.live,
+            ...result.pattern !== undefined ? { pattern: result.pattern, totalMatches: result.totalMatches } : {}
           }, null, 2)
         };
       }
     }),
     loopd_command_write: tool3({
-      description: "Send raw input (stdin bytes) to a running command session.",
+      description: "Send raw input (stdin bytes) to a running command session \u2014 e.g. answer a REPL prompt, confirm a y/n, or type a command into an interactive shell you started. Include a trailing newline yourself if the program is line-buffered.",
       args: {
         command_id: tool3.schema.string().describe("Command session ID."),
         input: tool3.schema.string().describe("Raw text to write to stdin (include trailing newline for line-buffered programs).")
@@ -6661,15 +8064,16 @@ function commandTools(options) {
       }
     }),
     loopd_command_terminate: tool3({
-      description: "Terminate a running command (SIGTERM, escalates to SIGKILL). Stopping a command never pauses/blocks any goal.",
+      description: "Terminate a running command (SIGTERM, escalates to SIGKILL). Stopping a command never pauses/blocks any goal. With remove:true, the record+log are deleted in the same call (atomic from the caller's perspective; proceeds to remove even when the command is already terminal).",
       args: {
-        command_id: tool3.schema.string().describe("Command session ID.")
+        command_id: tool3.schema.string().describe("Command session ID."),
+        remove: tool3.schema.boolean().optional().describe("Also remove the record+log after terminating (or when already terminal).")
       },
       execute: async (args, context) => {
         const owner = ownerID(context);
         if (!owner)
           return denied();
-        const result = await commandService.terminate(directory, args.command_id, owner);
+        const result = await commandService.terminate(directory, args.command_id, owner, { remove: args.remove });
         return { title: result.ok ? "Terminated" : "Terminate failed", output: JSON.stringify({ ...result, command_id: args.command_id }) };
       }
     }),
@@ -6686,11 +8090,53 @@ function commandTools(options) {
         return { title: result.ok ? "Removed" : "Remove failed", output: JSON.stringify({ ...result, command_id: args.command_id }) };
       }
     }),
+    loopd_command_watch: tool3({
+      description: 'Set, replace, or clear a watch on an ALREADY-RUNNING command \u2014 line-level filter/until notifications for never-exiting processes (dev servers, log tails, watch mode). watch_filter buffers only matching lines toward a coalesced owner push (one push per ~2s window, \u226420 lines/\u22644KB each, \u226430 pushes per command); watch_until fires once on the first matching line of the filter-surviving stream with an immediate owner notice. watch_until_action "stop" (default) terminates the command on first until-match (endReason=until); "keep" notifies but keeps running (until fires once, the filter stream continues). Replacing the spec resets counters/state to active. Fail closed: invalid or dangerous regexes are rejected and the previous watch (if any) is left untouched; watching a terminal command returns ok:false (watch is meaningless after exit).',
+      args: {
+        command_id: tool3.schema.string().describe("Command session ID (must be running)."),
+        watch_filter: tool3.schema.string().optional().describe("Watch line filter (regex on ANSI-stripped lines): only matching lines buffer toward a coalesced owner push. Omit (or pair with clear) to remove."),
+        watch_until: tool3.schema.string().optional().describe("Watch until pattern (regex on the filter-surviving stream): first match notifies the owner immediately. With watch_until_action=stop (default) the command is terminated with endReason=until; with keep it keeps running."),
+        watch_ignore_case: tool3.schema.boolean().optional().describe("Case-insensitive watch matching (default false)."),
+        watch_until_action: tool3.schema.string().optional().describe('Until action: "stop" (default) terminates the command on first until-match; "keep" notifies but keeps running (until fires once, filter stream continues).'),
+        clear: tool3.schema.boolean().optional().describe("When true, drop the watch entirely (spec + counters + in-memory watcher) instead of setting one.")
+      },
+      execute: async (args, context) => {
+        const owner = ownerID(context);
+        if (!owner)
+          return denied();
+        try {
+          if (args.watch_until_action !== undefined && args.watch_until_action !== "stop" && args.watch_until_action !== "keep") {
+            throw new Error(`Invalid watch_until_action '${args.watch_until_action}': must be "stop" or "keep".`);
+          }
+          const result = await commandService.watch(directory, args.command_id, owner, {
+            ...args.watch_filter !== undefined ? { filter: args.watch_filter } : {},
+            ...args.watch_until !== undefined ? { until: args.watch_until } : {},
+            ...args.watch_ignore_case !== undefined ? { ignoreCase: args.watch_ignore_case } : {},
+            ...args.watch_until_action !== undefined ? { untilAction: args.watch_until_action } : {},
+            ...args.clear !== undefined ? { clear: args.clear } : {}
+          });
+          if (!result.ok) {
+            return { title: "Watch not set", output: JSON.stringify({ ...result, command_id: args.command_id }) };
+          }
+          return {
+            title: "Watch updated",
+            output: JSON.stringify({ ok: true, message: result.message, command: summarize(result.command), command_id: args.command_id }, null, 2)
+          };
+        } catch (error) {
+          return {
+            title: "Watch not set",
+            output: JSON.stringify({ ok: false, message: error instanceof Error ? error.message : String(error), command_id: args.command_id })
+          };
+        }
+      }
+    }),
     loopd_command_await: tool3({
-      description: "Opt in to a one-shot wake-up: the given goal wakes when the given command reaches a terminal status (exited/terminated/missing) with the exit code, signal, and last 4KB of output as evidence. 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.",
+      description: "Opt in to a one-shot wake-up: the given goal wakes when the given command reaches a terminal status (exited/terminated/missing) with the exit code, signal, and last 4KB of output as evidence. With 'until', the goal instead wakes ONCE on the first output line matching the regex (evidence: matched lines + bounded tail) and the command keeps running \u2014 use this to have a GOAL worker block until a never-exiting process prints something (e.g. 'wait until the dev server prints ready') without polling. Explicit opt-in only \u2014 a merely linked command (goal_id passed to loopd_command_start) never wakes its goal on its own; this call is required. Exactly-once: the await is consumed on fire, output chunks never fire exit-awaits, pausing/clearing the goal or removing the command cancels it.",
       args: {
         command_id: tool3.schema.string().describe("Command session ID to await."),
-        goal_id: tool3.schema.string().describe("Goal ID to wake on exit. You must own both the goal and the command.")
+        goal_id: tool3.schema.string().describe("Goal ID to wake on exit. You must own both the goal and the command."),
+        until: tool3.schema.string().optional().describe("Regex to wake on: fires once on the first matching output line (matched lines + bounded tail as evidence) without stopping the command. Dangerous nested-quantifier patterns are rejected."),
+        ignore_case: tool3.schema.boolean().optional().describe("Case-insensitive until matching (default false).")
       },
       execute: async (args, context) => {
         const owner = ownerID(context);
@@ -6699,7 +8145,9 @@ function commandTools(options) {
         const result = await requestCommandAwait(directory, {
           goalID: args.goal_id,
           commandID: args.command_id,
-          ownerSessionID: owner
+          ownerSessionID: owner,
+          ...args.until !== undefined ? { until: args.until } : {},
+          ...args.ignore_case !== undefined ? { ignoreCase: args.ignore_case } : {}
         });
         if (result.ok && result.fired && result.active && options.goalService) {
           await wakeGoalForAwait(directory, options.goalService, args.goal_id).catch(() => {});
@@ -6731,7 +8179,7 @@ function commandTools(options) {
 // src/server/plugin.ts
 init_state_repository();
 // package.json
-var version = "1.10.3";
+var version = "1.10.4";
 
 // src/server/plugin.ts
 var PLUGIN_ID = "opencode-loopd.server";
@@ -6758,6 +8206,18 @@ function createServerHooks(directory, host, defaults) {
           detail: describeError(error)
         }));
       }
+    },
+    onOwnerNotify: async (dir, ownerSessionID, message) => {
+      await host.notifyOwner(ownerSessionID, message).catch((error) => logServerEvent(dir, "command.owner-notify-failed", {
+        ownerSessionID,
+        detail: describeError(error)
+      }));
+    },
+    onWatchNotify: async (dir, ownerSessionID, message) => {
+      await host.notifyOwner(ownerSessionID, message).catch((error) => logServerEvent(dir, "command.watch-notify-failed", {
+        ownerSessionID,
+        detail: describeError(error)
+      }));
     }
   });
   const commandStream = createCommandStreamServer(directory, commandService, commandBroker);
@@ -6921,9 +8381,17 @@ var v2 = {
     const directory = context.location.directory;
     logServerEvent(directory, "plugin.loaded", { pluginID: PLUGIN_ID, host: "v2", version });
     const statuses = new Map;
-    const host = createV2Host(context, statuses);
+    const native = await setupNativeServer(context);
+    if (native) {
+      logServerEvent(directory, "native-bridge.ready", { pluginID: PLUGIN_ID });
+    } else {
+      logServerEvent(directory, "native-bridge.unsupported", { pluginID: PLUGIN_ID });
+    }
+    const host = createV2Host(context, statuses, native ? { native } : undefined);
     const hooks = createServerHooks(directory, host, parsePluginDefaults(context.options));
     const registrations = [];
+    if (native)
+      registrations.push({ dispose: () => native.dispose() });
     const eventController = new AbortController;
     let eventTask = Promise.resolve();
     let disposed = false;