@bojackduy/opencode-loopd 1.5.2 → 1.6.0

package/dist/server.js

@@ -13,32 +13,141 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
-// src/infrastructure/state-repository.ts
-var exports_state_repository = {};
-__export(exports_state_repository, {
-  appendEvent: () => appendEvent,
-  appendGoalInbox: () => appendGoalInbox,
-  claimControlRequest: () => claimControlRequest,
-  drainGoalInbox: () => drainGoalInbox,
-  ensureGoalArtifactDir: () => ensureGoalArtifactDir,
-  goalArtifactDir: () => goalArtifactDir,
-  listPendingRequests: () => listPendingRequests,
-  mutateState: () => mutateState,
-  readControlRequest: () => readControlRequest,
-  readControlResponse: () => readControlResponse,
-  readEvents: () => readEvents,
-  readState: () => readState,
-  recoverStaleProcessing: () => recoverStaleProcessing,
-  writeControlRequest: () => writeControlRequest,
-  writeControlResponse: () => writeControlResponse,
-  writeState: () => writeState
+// src/domain/runtime.ts
+var exports_runtime = {};
+__export(exports_runtime, {
+  acquireLease: () => acquireLease,
+  addToolCall: () => addToolCall,
+  createRuntimeState: () => createRuntimeState,
+  hasActiveToolCalls: () => hasActiveToolCalls,
+  leaseIsValid: () => leaseIsValid,
+  markParentNotified: () => markParentNotified,
+  markProgress: () => markProgress,
+  recordActivity: () => recordActivity,
+  releaseLease: () => releaseLease,
+  removeToolCall: () => removeToolCall,
+  shouldNotifyParent: () => shouldNotifyParent
 });
+function createRuntimeState(goalID) {
+  const now = new Date().toISOString();
+  return {
+    goalID,
+    phase: "idle",
+    consecutiveFailures: 0,
+    runCount: 0,
+    budgetTurnCount: 0,
+    noProgressCount: 0,
+    progressDuringTurn: false,
+    unknownStatusCount: 0,
+    runGeneration: 0,
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function acquireLease(rt, timeoutMs) {
+  const now = Date.now();
+  const expires = new Date(now + timeoutMs).toISOString();
+  return {
+    ...rt,
+    phase: "running",
+    leaseExpiresAt: expires,
+    turnStartedAt: new Date(now).toISOString(),
+    progressDuringTurn: false,
+    turnTokensUsed: 0,
+    runGeneration: rt.runGeneration + 1,
+    lastActivityAt: new Date(now).toISOString(),
+    idleCandidateAt: undefined,
+    idleCandidateGeneration: undefined,
+    activePromptObservedAt: undefined,
+    activeAssistantMessageID: undefined,
+    activeAssistantCompletedAt: undefined,
+    activeToolCallIDs: [],
+    updatedAt: new Date(now).toISOString()
+  };
+}
+function releaseLease(rt) {
+  return {
+    ...rt,
+    phase: "idle",
+    leaseExpiresAt: undefined,
+    turnStartedAt: undefined,
+    activePromptMessageID: undefined,
+    activePromptObservedAt: undefined,
+    activeAssistantMessageID: undefined,
+    activeAssistantCompletedAt: undefined,
+    idleCandidateAt: undefined,
+    idleCandidateGeneration: undefined,
+    activeToolCallIDs: [],
+    updatedAt: new Date().toISOString()
+  };
+}
+function leaseIsValid(rt) {
+  if (!rt.leaseExpiresAt)
+    return false;
+  return Date.now() < Date.parse(rt.leaseExpiresAt);
+}
+function markProgress(rt) {
+  return { ...rt, progressDuringTurn: true, lastProgressAt: new Date().toISOString() };
+}
+function shouldNotifyParent(runtime, type) {
+  if (!runtime.lastParentNotifiedAt || !runtime.lastParentNotifiedFor)
+    return true;
+  if (runtime.lastParentNotifiedFor !== type)
+    return true;
+  const elapsed = Date.now() - Date.parse(runtime.lastParentNotifiedAt);
+  return !Number.isFinite(elapsed) || elapsed > PARENT_NOTIFY_DEDUPE_MS;
+}
+function markParentNotified(runtime, type) {
+  runtime.lastParentNotifiedFor = type;
+  runtime.lastParentNotifiedAt = new Date().toISOString();
+  runtime.updatedAt = new Date().toISOString();
+}
+function recordActivity(rt) {
+  return {
+    ...rt,
+    lastActivityAt: new Date().toISOString(),
+    idleCandidateAt: undefined,
+    idleCandidateGeneration: undefined,
+    updatedAt: new Date().toISOString()
+  };
+}
+function addToolCall(rt, callID) {
+  const ids = new Set(rt.activeToolCallIDs || []);
+  ids.add(callID);
+  return {
+    ...rt,
+    activeToolCallIDs: Array.from(ids),
+    lastActivityAt: new Date().toISOString(),
+    idleCandidateAt: undefined,
+    idleCandidateGeneration: undefined,
+    updatedAt: new Date().toISOString()
+  };
+}
+function removeToolCall(rt, callID) {
+  const ids = (rt.activeToolCallIDs || []).filter((id) => id !== callID);
+  return {
+    ...rt,
+    activeToolCallIDs: ids,
+    lastActivityAt: new Date().toISOString(),
+    idleCandidateAt: undefined,
+    idleCandidateGeneration: undefined,
+    updatedAt: new Date().toISOString()
+  };
+}
+function hasActiveToolCalls(rt) {
+  return (rt.activeToolCallIDs?.length ?? 0) > 0;
+}
+var PARENT_NOTIFY_DEDUPE_MS = 60000;
+
+// src/application/control-worker.ts
+import { randomUUID } from "crypto";
+
+// src/infrastructure/state-repository.ts
 import { promises as fs } from "fs";
 import path from "path";
 import os from "os";
-import { randomUUID } from "crypto";
+var CURRENT_VERSION = 5;
 function emptyState() {
   return { version: CURRENT_VERSION, revision: 0, goals: [], runtimes: [], commandLedger: [] };
 }
@@ -58,11 +167,11 @@ function lockDir(directory) {
 function lockFile(directory, key) {
   return path.join(lockDir(directory), `${key}.lock`);
 }
+var LOCK_STALE_MS = 1e4;
 async function acquireLock(directory, key, operation) {
   const dir = lockDir(directory);
   await fs.mkdir(dir, { recursive: true });
   const lockPath = lockFile(directory, key);
-  const lockID = randomUUID();
   for (let attempt = 0;attempt < 10; attempt++) {
     try {
       try {
@@ -73,31 +182,44 @@ async function acquireLock(directory, key, operation) {
           await fs.rm(lockPath, { force: true });
         }
       } catch {}
-      const temp = lockPath + `.${lockID}.tmp`;
       const meta = { pid: process.pid, operation, acquiredAt: new Date().toISOString() };
-      await fs.writeFile(temp, JSON.stringify(meta), "utf8");
+      const fd = await fs.open(lockPath, "wx");
       try {
-        await fs.rename(temp, lockPath);
-        return;
-      } catch (error) {
-        await fs.rm(temp, { force: true });
-        if (error?.code !== "EEXIST")
-          throw error;
+        await fd.writeFile(JSON.stringify(meta), "utf8");
+      } finally {
+        await fd.close();
       }
+      return;
     } catch (error) {
-      if (error?.code === "ENOENT") {
+      if (error?.code === "EEXIST") {} else if (error?.code === "ENOENT") {
         await fs.mkdir(dir, { recursive: true });
         continue;
+      } else {
+        throw error;
       }
-      throw error;
     }
     await delay(25 * (attempt + 1));
   }
   throw new Error(`failed to acquire lock "${key}" for "${operation}" after retries`);
 }
 async function releaseLock(directory, key) {
+  const lockPath = lockFile(directory, key);
   try {
-    await fs.rm(lockFile(directory, key), { force: true });
+    const raw = await fs.readFile(lockPath, "utf8");
+    const meta = JSON.parse(raw);
+    const age = Date.now() - Date.parse(meta.acquiredAt);
+    const shouldRelease = meta.pid === process.pid || age > LOCK_STALE_MS;
+    if (!shouldRelease)
+      return;
+    try {
+      const raw2 = await fs.readFile(lockPath, "utf8");
+      const meta2 = JSON.parse(raw2);
+      if (meta2.acquiredAt !== meta.acquiredAt || meta2.pid !== meta.pid)
+        return;
+    } catch {
+      return;
+    }
+    await fs.rm(lockPath, { force: true });
   } catch {}
 }
 async function readState(directory) {
@@ -141,6 +263,53 @@ function migrate(state) {
       blocker: g.blocker ?? undefined
     }));
   }
+  if (result.version < 3) {
+    result.version = 3;
+    result.runtimes = result.runtimes.map((rt) => {
+      const oldTurnCount = rt.turnCount ?? 0;
+      const { turnCount: _deprecatedTurnCount, ...rest } = rt;
+      return {
+        ...rest,
+        budgetTurnCount: rest.budgetTurnCount ?? oldTurnCount,
+        runCount: rest.runCount ?? oldTurnCount,
+        runGeneration: rest.runGeneration ?? 0,
+        freeRetryPending: rest.freeRetryPending ?? false,
+        lastRejectionDetails: rest.lastRejectionDetails ?? undefined,
+        activePromptMessageID: rest.activePromptMessageID ?? undefined,
+        lastActivityAt: rest.lastActivityAt ?? undefined,
+        idleCandidateAt: rest.idleCandidateAt ?? undefined,
+        activeToolCallIDs: rest.activeToolCallIDs ?? []
+      };
+    });
+  }
+  if (result.version < 4) {
+    result.version = 4;
+    result.runtimes = result.runtimes.map((rt) => ({
+      ...rt,
+      lastVerificationAttempt: rt.lastVerificationAttempt ?? undefined,
+      recentVerificationAttempts: rt.recentVerificationAttempts ?? []
+    }));
+  }
+  if (result.version < 5) {
+    result.version = 5;
+    result.goals = result.goals.map((goal) => ({
+      ...goal,
+      config: {
+        ...goal.config,
+        workspaceWrite: goal.config?.workspaceWrite ?? true
+      }
+    }));
+    result.runtimes = result.runtimes.map((rt) => ({
+      ...rt,
+      activePromptObservedAt: rt.activePromptObservedAt ?? undefined,
+      activeAssistantMessageID: rt.activeAssistantMessageID ?? undefined,
+      activeAssistantCompletedAt: rt.activeAssistantCompletedAt ?? undefined,
+      idleCandidateGeneration: rt.idleCandidateGeneration ?? undefined,
+      unknownStatusCount: rt.unknownStatusCount ?? 0,
+      lastUnknownStatusAt: rt.lastUnknownStatusAt ?? undefined,
+      workerUnreachableNotifiedAt: rt.workerUnreachableNotifiedAt ?? undefined
+    }));
+  }
   return result;
 }
 async function writeAtomic(target, contents) {
@@ -213,19 +382,6 @@ function processingFile(directory, requestID) {
 function responseFile(directory, requestID) {
   return path.join(controlDir(directory), "responses", `${requestID}.json`);
 }
-async function writeControlRequest(directory, request) {
-  const dir = path.join(controlDir(directory), "requests");
-  await fs.mkdir(dir, { recursive: true });
-  await writeAtomic(requestFile(directory, request.requestID), JSON.stringify(request, null, 2));
-}
-async function readControlRequest(directory, requestID) {
-  try {
-    const raw = await fs.readFile(requestFile(directory, requestID), "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return;
-  }
-}
 async function claimControlRequest(directory, requestID) {
   const src = requestFile(directory, requestID);
   const dst = processingFile(directory, requestID);
@@ -271,28 +427,6 @@ async function listPendingRequests(directory) {
     return [];
   }
 }
-async function recoverStaleProcessing(directory) {
-  const dir = path.join(controlDir(directory), "processing");
-  try {
-    const files = await fs.readdir(dir);
-    const recovered = [];
-    for (const file of files) {
-      if (!file.endsWith(".json"))
-        continue;
-      const processingPath = path.join(dir, file);
-      const requestPath = path.join(controlDir(directory), "requests", file);
-      try {
-        const raw = await fs.readFile(processingPath, "utf8");
-        const request = JSON.parse(raw);
-        await fs.rename(processingPath, requestPath);
-        recovered.push(request);
-      } catch {}
-    }
-    return recovered;
-  } catch {
-    return [];
-  }
-}
 function goalArtifactDir(directory, goalID) {
   return path.join(loopDir(directory), "goals", goalID);
 }
@@ -329,82 +463,58 @@ async function drainGoalInbox(directory, goalID) {
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-var CURRENT_VERSION = 2, LOCK_STALE_MS = 1e4;
-var init_state_repository = () => {};
 
-// src/domain/runtime.ts
-var exports_runtime = {};
-__export(exports_runtime, {
-  acquireLease: () => acquireLease,
-  createRuntimeState: () => createRuntimeState,
-  leaseIsValid: () => leaseIsValid,
-  markParentNotified: () => markParentNotified,
-  markProgress: () => markProgress,
-  releaseLease: () => releaseLease,
-  shouldNotifyParent: () => shouldNotifyParent
-});
-function createRuntimeState(goalID) {
-  const now = new Date().toISOString();
-  return {
-    goalID,
-    phase: "idle",
-    consecutiveFailures: 0,
-    runCount: 0,
-    turnCount: 0,
-    noProgressCount: 0,
-    progressDuringTurn: false,
-    createdAt: now,
-    updatedAt: now
-  };
-}
-function acquireLease(rt, timeoutMs) {
-  const now = Date.now();
-  const expires = new Date(now + timeoutMs).toISOString();
-  return {
-    ...rt,
-    phase: "running",
-    leaseExpiresAt: expires,
-    turnStartedAt: new Date(now).toISOString(),
-    progressDuringTurn: false,
-    turnTokensUsed: 0,
-    updatedAt: new Date(now).toISOString()
-  };
-}
-function releaseLease(rt) {
+// src/application/goal-policy.ts
+function resolveGoalCreationConfig(input) {
+  const requested = input.config || {};
+  const defaults = input.defaults || {};
+  const explicitAgent = cleanText(requested.agent);
+  const defaultAgent = cleanText(defaults.defaultAgent);
+  const agent = explicitAgent || defaultAgent;
+  if (!agent) {
+    return {
+      ok: false,
+      errorCode: "missing_agent",
+      message: "An agent is required. Pass agent explicitly or configure plugin option defaultAgent."
+    };
+  }
+  const workspaceWrite = requested.workspaceWrite ?? true;
+  const explicitChecks = cleanList(requested.checks);
+  const defaultChecks = workspaceWrite ? cleanList(defaults.defaultChecks) : [];
+  const checks = explicitChecks.length > 0 ? explicitChecks : defaultChecks;
+  if (workspaceWrite && checks.length === 0) {
+    return {
+      ok: false,
+      errorCode: "missing_checks",
+      message: "Workspace-writing goals require completion checks. Pass checks or configure plugin option defaultChecks."
+    };
+  }
   return {
-    ...rt,
-    phase: "idle",
-    leaseExpiresAt: undefined,
-    turnStartedAt: undefined,
-    updatedAt: new Date().toISOString()
+    ok: true,
+    config: {
+      ...requested,
+      agent,
+      workspaceWrite,
+      checks: checks.length > 0 ? checks : undefined,
+      checkCwd: requested.checkCwd || (workspaceWrite ? input.directory : undefined)
+    },
+    defaultsApplied: {
+      agent: !explicitAgent && Boolean(defaultAgent),
+      checks: explicitChecks.length === 0 && defaultChecks.length > 0
+    }
   };
 }
-function leaseIsValid(rt) {
-  if (!rt.leaseExpiresAt)
-    return false;
-  return Date.now() < Date.parse(rt.leaseExpiresAt);
-}
-function markProgress(rt) {
-  return { ...rt, progressDuringTurn: true, lastProgressAt: new Date().toISOString() };
-}
-function shouldNotifyParent(runtime, type) {
-  if (!runtime.lastParentNotifiedAt || !runtime.lastParentNotifiedFor)
-    return true;
-  if (runtime.lastParentNotifiedFor !== type)
-    return true;
-  const elapsed = Date.now() - Date.parse(runtime.lastParentNotifiedAt);
-  return !Number.isFinite(elapsed) || elapsed > PARENT_NOTIFY_DEDUPE_MS;
+function cleanText(value) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed || undefined;
 }
-function markParentNotified(runtime, type) {
-  runtime.lastParentNotifiedFor = type;
-  runtime.lastParentNotifiedAt = new Date().toISOString();
-  runtime.updatedAt = new Date().toISOString();
+function cleanList(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.map(cleanText).filter((item) => Boolean(item));
 }
-var PARENT_NOTIFY_DEDUPE_MS = 60000;
-
-// src/application/control-worker.ts
-init_state_repository();
-import { randomUUID as randomUUID2 } from "crypto";
 
 // src/infrastructure/server-log.ts
 import { appendFile } from "fs/promises";
@@ -548,11 +658,26 @@ function createControlWorker(options) {
           };
           break;
         }
+        const resolution = resolveGoalCreationConfig({
+          directory,
+          objective: args.objective,
+          config: args.config,
+          defaults: options.defaults
+        });
+        if (!resolution.ok) {
+          response = {
+            ...base,
+            ok: false,
+            message: resolution.message,
+            errorCode: resolution.errorCode
+          };
+          break;
+        }
         const { goal } = await goalSvc.start(directory, {
           name: args.name,
           objective: args.objective,
           ownerSessionID: args.ownerSessionID,
-          config: args.config
+          config: resolution.config
         });
         const state2 = await readState(directory);
         response = {
@@ -654,7 +779,7 @@ function createControlWorker(options) {
         await writeState(directory, state2);
         await appendEvent(directory, {
           version: 1,
-          eventID: randomUUID2(),
+          eventID: randomUUID(),
           goalID: goal.id,
           type: "goal.completed",
           summary: goal.completionEvidence.summary,
@@ -694,7 +819,7 @@ function createControlWorker(options) {
         await writeState(directory, state2);
         await appendEvent(directory, {
           version: 1,
-          eventID: randomUUID2(),
+          eventID: randomUUID(),
           goalID: goal.id,
           type: "goal.blocked",
           reason: goal.blocker.reason,
@@ -740,8 +865,7 @@ function createControlWorker(options) {
 }
 
 // src/application/loop-engine.ts
-init_state_repository();
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // src/domain/goal.ts
 var MODEL_TRANSITIONS = {
@@ -780,15 +904,20 @@ function createGoal(input) {
   return { ...input, tokensUsed: 0, timeUsedSeconds: 0, createdAt: now, updatedAt: now };
 }
 // src/application/loop-engine.ts
+var CONFIRM_IDLE_DURATION_MS = 2000;
 var HANDLED_EVENT_TYPES = new Set([
   "session.idle",
   "session.status",
   "session.error",
-  "session.compacted"
+  "session.compacted",
+  "message.updated",
+  "message.part.updated"
 ]);
 function createLoopEngine(options) {
   const { directory, host, goalService } = options;
   const maintenanceMs = options.pollIntervalMs ?? 30000;
+  const confirmIdleMs = options.confirmIdleMs ?? CONFIRM_IDLE_DURATION_MS;
+  const unknownStatusThreshold = Math.max(1, options.unknownStatusThreshold ?? 3);
   let running = false;
   let maintenanceTimer;
   let knownWorkerSessions = new Set;
@@ -853,7 +982,7 @@ function createLoopEngine(options) {
     const type = event.type;
     if (!type || !HANDLED_EVENT_TYPES.has(type))
       return false;
-    const sessionID = event.properties?.sessionID;
+    const sessionID = eventSessionID(event);
     if (!sessionID)
       return false;
     await loadWorkerSessionsIfneeded();
@@ -868,7 +997,7 @@ function createLoopEngine(options) {
       return false;
     if (goal.workerSessionID)
       knownWorkerSessions.add(goal.workerSessionID);
-    if (isTerminal(goal.status) || goal.status === "paused")
+    if (goal.status !== "active")
       return false;
     switch (type) {
       case "session.idle":
@@ -879,98 +1008,253 @@ function createLoopEngine(options) {
         return await handleSessionError(state, goal, event);
       case "session.compacted":
         return await handleSessionCompacted(state, goal);
+      case "message.updated":
+      case "message.part.updated":
+        return await handleMessageActivity(goal, event);
       default:
         return false;
     }
   }
+  function eventSessionID(event) {
+    return event.properties?.sessionID || event.properties?.info?.sessionID || event.properties?.part?.sessionID;
+  }
+  async function handleMessageActivity(goal, event) {
+    let matched = false;
+    await mutateState(directory, `message-activity:${goal.id}`, async (s) => {
+      const rt = s.runtimes.find((r) => r.goalID === goal.id);
+      if (!rt || rt.phase !== "running" || !rt.activePromptMessageID)
+        return s;
+      if (event.type === "message.updated") {
+        const info = event.properties?.info;
+        if (info?.role === "user" && info.id === rt.activePromptMessageID) {
+          Object.assign(rt, recordActivity(rt));
+          rt.activePromptObservedAt = new Date().toISOString();
+          matched = true;
+        } else if (info?.role === "assistant" && info.parentID === rt.activePromptMessageID) {
+          Object.assign(rt, recordActivity(rt));
+          rt.activeAssistantMessageID = info.id;
+          if (info.time?.completed) {
+            rt.activeAssistantCompletedAt = new Date(info.time.completed).toISOString();
+          }
+          matched = true;
+        }
+      } else {
+        const part = event.properties?.part;
+        if (part?.messageID && part.messageID === rt.activeAssistantMessageID) {
+          Object.assign(rt, recordActivity(rt));
+          matched = true;
+        }
+      }
+      return s;
+    });
+    return matched;
+  }
   async function handleSessionIdle(state, goal) {
-    const runtime = state.runtimes.find((r) => r.goalID === goal.id);
-    if (!runtime)
-      return false;
-    if (inflightContinuations.has(goal.id))
+    const goalID = goal.id;
+    if (inflightContinuations.has(goalID))
       return false;
-    if (runtime.phase === "running") {
-      const completedRunID = runtime.activeRunID;
-      Object.assign(runtime, releaseLease(runtime));
-      runtime.activeRunID = undefined;
-      runtime.lastWorkerStatus = "idle";
-      await writeState(directory, state);
-      if (completedRunID) {
-        await appendEvent(directory, {
-          version: 1,
-          eventID: randomUUID3(),
-          goalID: goal.id,
-          type: "run.completed",
-          runID: completedRunID,
-          timestamp: new Date().toISOString(),
-          revision: state.revision
-        });
+    let completedRunID;
+    let confirmation;
+    let afterIdle = await mutateState(directory, `idle:${goalID}`, async (s) => {
+      const g = s.goals.find((item) => item.id === goalID);
+      if (!g)
+        return s;
+      if (isTerminal(g.status) || g.status === "paused")
+        return s;
+      const rt = s.runtimes.find((r) => r.goalID === goalID);
+      if (!rt)
+        return s;
+      if (rt.phase !== "running")
+        return s;
+      if ((rt.activeToolCallIDs?.length ?? 0) > 0) {
+        rt.idleCandidateAt = undefined;
+        rt.idleCandidateGeneration = undefined;
+        return s;
+      }
+      const now = Date.now();
+      if (!rt.idleCandidateAt || rt.idleCandidateGeneration !== rt.runGeneration) {
+        rt.idleCandidateAt = new Date(now).toISOString();
+        rt.idleCandidateGeneration = rt.runGeneration;
+        return s;
+      }
+      const elapsed = now - Date.parse(rt.idleCandidateAt);
+      if (elapsed < confirmIdleMs)
+        return s;
+      if (rt.lastActivityAt && rt.lastActivityAt > rt.idleCandidateAt) {
+        rt.idleCandidateAt = undefined;
+        rt.idleCandidateGeneration = undefined;
+        return s;
       }
+      if (rt.activePromptMessageID) {
+        confirmation = {
+          generation: rt.runGeneration,
+          promptMessageID: rt.activePromptMessageID,
+          candidateAt: rt.idleCandidateAt,
+          assistantCompleted: Boolean(rt.activeAssistantCompletedAt)
+        };
+      } else {
+        completedRunID = rt.activeRunID;
+        Object.assign(rt, releaseLease(rt));
+        rt.activeRunID = undefined;
+        rt.lastWorkerStatus = "idle";
+      }
+      return s;
+    });
+    if (confirmation) {
+      const candidate = confirmation;
+      const transcript = await inspectPromptTurn(goal.workerSessionID, candidate.promptMessageID);
+      if (!transcript.latestUserPrompt || !candidate.assistantCompleted && !transcript.assistantCompleted) {
+        return true;
+      }
+      afterIdle = await mutateState(directory, `idle.confirm:${goalID}`, async (s) => {
+        const g = s.goals.find((item) => item.id === goalID);
+        const rt = s.runtimes.find((r) => r.goalID === goalID);
+        if (!g || !rt || isTerminal(g.status) || g.status === "paused")
+          return s;
+        if (rt.phase !== "running")
+          return s;
+        if (rt.runGeneration !== candidate.generation)
+          return s;
+        if (rt.activePromptMessageID !== candidate.promptMessageID)
+          return s;
+        if (rt.idleCandidateGeneration !== candidate.generation)
+          return s;
+        if (rt.idleCandidateAt !== candidate.candidateAt)
+          return s;
+        if (rt.lastActivityAt && rt.lastActivityAt > candidate.candidateAt)
+          return s;
+        if ((rt.activeToolCallIDs?.length ?? 0) > 0)
+          return s;
+        completedRunID = rt.activeRunID;
+        Object.assign(rt, releaseLease(rt));
+        rt.activeRunID = undefined;
+        rt.lastWorkerStatus = "idle";
+        return s;
+      });
     }
-    if (goal.status !== "active")
+    if (completedRunID) {
+      await appendEvent(directory, {
+        version: 1,
+        eventID: randomUUID2(),
+        goalID,
+        type: "run.completed",
+        runID: completedRunID,
+        timestamp: new Date().toISOString(),
+        revision: afterIdle.revision
+      });
+    } else {
+      return true;
+    }
+    const freshState = await readState(directory);
+    const freshGoal = freshState.goals.find((g) => g.id === goalID);
+    if (!freshGoal || freshGoal.status !== "active")
+      return false;
+    const freshRuntime = freshState.runtimes.find((r) => r.goalID === goalID);
+    if (!freshRuntime)
       return false;
-    const limitResult = enforceLimits(goal, runtime);
+    const limitResult = enforceLimits(freshGoal, freshRuntime);
     if (limitResult.stop === "force_finish") {
-      if (!runtime.forceFinishRequested) {
-        runtime.forceFinishRequested = true;
-        await writeState(directory, state);
-        await goalService.continueTurn(directory, goal.id, { forceFinish: true });
+      if (!freshRuntime.forceFinishRequested) {
+        await mutateState(directory, `idle.force-finish:${goalID}`, async (s) => {
+          const rt = s.runtimes.find((r) => r.goalID === goalID);
+          if (rt)
+            rt.forceFinishRequested = true;
+          return s;
+        });
+        await goalService.continueTurn(directory, goalID, { forceFinish: true });
         return true;
       }
-      const blockedKey = goal.id;
+      const blockedKey = goalID;
       const nowBlocked = Date.now();
       const lastBlocked = recentForceFinishBlocked.get(blockedKey);
       if (lastBlocked !== undefined && nowBlocked - lastBlocked < 60000)
         return true;
       recentForceFinishBlocked.set(blockedKey, nowBlocked);
-      goal.status = "blocked";
-      goal.updatedAt = new Date().toISOString();
-      goal.blocker = {
-        reason: limitResult.reason + " (force-finish ignored)",
-        needed: "User intervention required. Use retry to attempt again.",
-        at: new Date().toISOString()
-      };
-      runtime.forceFinishRequested = undefined;
-      const shouldNotify = shouldNotifyParent(runtime, "stopped");
-      if (shouldNotify)
-        markParentNotified(runtime, "stopped");
-      await writeState(directory, state);
+      let shouldNotifyBlocked = false;
+      const blockedState = await mutateState(directory, `idle.blocked:${goalID}`, async (s) => {
+        const g = s.goals.find((item) => item.id === goalID);
+        if (!g)
+          return s;
+        g.status = "blocked";
+        g.updatedAt = new Date().toISOString();
+        g.blocker = {
+          reason: limitResult.reason + " (force-finish ignored)",
+          needed: "User intervention required. Use retry to attempt again.",
+          at: new Date().toISOString()
+        };
+        const rt = s.runtimes.find((r) => r.goalID === goalID);
+        if (rt) {
+          rt.forceFinishRequested = undefined;
+          if (shouldNotifyParent(rt, "stopped")) {
+            markParentNotified(rt, "stopped");
+            shouldNotifyBlocked = true;
+          }
+        }
+        return s;
+      });
       await appendEvent(directory, {
         version: 1,
-        eventID: randomUUID3(),
-        goalID: goal.id,
+        eventID: randomUUID2(),
+        goalID,
         type: "goal.blocked",
         reason: limitResult.reason + " (force-finish ignored)",
-        needed: goal.blocker.needed,
+        needed: "User intervention required. Use retry to attempt again.",
         timestamp: new Date().toISOString(),
-        revision: state.revision
+        revision: blockedState.revision
       });
-      if (shouldNotify) {
+      if (shouldNotifyBlocked) {
         await host.notifyOwner(goal.ownerSessionID, `Loop goal "${goal.name}" stopped: ${limitResult.reason} (child did not wrap up). Status: blocked. Last progress: ${goal.lastProgress?.summary || "none"}.`);
       }
       return true;
     }
     if (limitResult.stop === "budget") {
-      await writeState(directory, state);
+      const budgetState = await mutateState(directory, `idle.budget:${goalID}`, async (s) => {
+        const g = s.goals.find((item) => item.id === goalID);
+        if (g) {
+          g.status = "budget_limited";
+          g.updatedAt = new Date().toISOString();
+        }
+        return s;
+      });
       await appendEvent(directory, {
         version: 1,
-        eventID: randomUUID3(),
-        goalID: goal.id,
+        eventID: randomUUID2(),
+        goalID,
         type: "goal.status_changed",
         from: "active",
-        to: goal.status,
+        to: "budget_limited",
         timestamp: new Date().toISOString(),
-        revision: state.revision
+        revision: budgetState.revision
       });
       return true;
     }
-    if (shouldCompact(goal, runtime)) {
-      await doCompact(goal, runtime);
+    if (shouldCompact(freshGoal, freshRuntime)) {
+      await doCompact(freshGoal, freshRuntime);
       return true;
     }
-    await continueGoal(goal.id);
+    await continueGoal(goalID);
     return true;
   }
+  async function inspectPromptTurn(workerSessionID, promptMessageID) {
+    const noMatch = { latestUserPrompt: false, assistantCompleted: false };
+    if (!workerSessionID)
+      return noMatch;
+    let messages;
+    try {
+      messages = await host.readMessages(workerSessionID, 50);
+    } catch {
+      return noMatch;
+    }
+    const users = messages.filter((message) => message.role === "user");
+    if (users.length === 0)
+      return noMatch;
+    const allTimestamped = users.every((message) => message.timestamp && Number.isFinite(Date.parse(message.timestamp)));
+    const ordered = allTimestamped ? [...users].sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp)) : users;
+    return {
+      latestUserPrompt: ordered.at(-1)?.messageID === promptMessageID,
+      assistantCompleted: messages.some((message) => message.role === "assistant" && message.parentMessageID === promptMessageID && Boolean(message.completedAt))
+    };
+  }
   async function handleSessionStatus(state, goal, event) {
     const runtime = state.runtimes.find((r) => r.goalID === goal.id);
     if (!runtime)
@@ -981,9 +1265,17 @@ function createLoopEngine(options) {
       return false;
     if (statusType === "idle")
       return handleSessionIdle(state, goal);
-    runtime.lastWorkerStatus = statusType;
-    runtime.updatedAt = new Date().toISOString();
-    await writeState(directory, state);
+    await mutateState(directory, `status:${goal.id}`, async (s) => {
+      const rt = s.runtimes.find((r) => r.goalID === goal.id);
+      if (!rt)
+        return s;
+      if (statusType === "busy" || statusType === "retry") {
+        Object.assign(rt, recordActivity(rt));
+      }
+      rt.lastWorkerStatus = statusType;
+      rt.updatedAt = new Date().toISOString();
+      return s;
+    });
     return true;
   }
   async function handleSessionError(state, goal, event) {
@@ -992,75 +1284,95 @@ function createLoopEngine(options) {
       return false;
     const error = event.properties?.error;
     const message = describeError(error) || "unknown error";
-    runtime.consecutiveFailures += 1;
-    runtime.lastError = message;
-    runtime.updatedAt = new Date().toISOString();
-    if (runtime.phase === "running") {
-      Object.assign(runtime, releaseLease(runtime));
-    }
+    let shouldNotify = false;
+    const newState = await mutateState(directory, `error:${goal.id}`, async (s) => {
+      const g = s.goals.find((item) => item.id === goal.id);
+      const rt = s.runtimes.find((r) => r.goalID === goal.id);
+      if (!rt)
+        return s;
+      rt.consecutiveFailures += 1;
+      rt.lastError = message;
+      rt.updatedAt = new Date().toISOString();
+      rt.idleCandidateAt = undefined;
+      if (rt.phase === "running") {
+        Object.assign(rt, releaseLease(rt));
+      }
+      if (rt.consecutiveFailures >= (goal.config?.maxFailures || 5)) {
+        if (g) {
+          g.status = "blocked";
+          g.updatedAt = new Date().toISOString();
+          g.blocker = {
+            reason: `Failed ${rt.consecutiveFailures} times. Last error: ${message}`,
+            needed: "User intervention required. Use retry to attempt again.",
+            at: new Date().toISOString()
+          };
+        }
+        if (shouldNotifyParent(rt, "failed")) {
+          markParentNotified(rt, "failed");
+          shouldNotify = true;
+        }
+      } else {
+        const backoffMs = Math.min(30000, 1000 * Math.pow(2, rt.consecutiveFailures));
+        rt.retryAfter = new Date(Date.now() + backoffMs).toISOString();
+        rt.phase = "waiting_retry";
+      }
+      return s;
+    });
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID3(),
+      eventID: randomUUID2(),
       goalID: goal.id,
       type: "run.failed",
       runID: runtime.activeRunID || "unknown",
       error: message,
-      consecutiveFailures: runtime.consecutiveFailures,
+      consecutiveFailures: runtime.consecutiveFailures + 1,
       timestamp: new Date().toISOString(),
-      revision: state.revision
+      revision: newState.revision
     });
-    const maxFailures = goal.config?.maxFailures || 5;
-    if (runtime.consecutiveFailures >= maxFailures) {
-      goal.status = "blocked";
-      goal.updatedAt = new Date().toISOString();
-      goal.blocker = {
-        reason: `Failed ${runtime.consecutiveFailures} times. Last error: ${message}`,
-        needed: "User intervention required. Use retry to attempt again.",
-        at: new Date().toISOString()
-      };
+    const updatedGoal = newState.goals.find((g) => g.id === goal.id);
+    if (updatedGoal?.status === "blocked") {
       await appendEvent(directory, {
         version: 1,
-        eventID: randomUUID3(),
+        eventID: randomUUID2(),
         goalID: goal.id,
         type: "goal.blocked",
-        reason: `Failed ${runtime.consecutiveFailures} times`,
+        reason: `Failed ${runtime.consecutiveFailures + 1} times`,
         needed: "User intervention required",
         timestamp: new Date().toISOString(),
-        revision: state.revision
+        revision: newState.revision
       });
-      if (shouldNotifyParent(runtime, "failed")) {
-        markParentNotified(runtime, "failed");
-        await host.notifyOwner(goal.ownerSessionID, `Loop goal "${goal.name}" blocked after ${runtime.consecutiveFailures} failures. Last error: ${message}.`);
+      if (shouldNotify) {
+        await host.notifyOwner(goal.ownerSessionID, `Loop goal "${goal.name}" blocked after ${runtime.consecutiveFailures + 1} failures. Last error: ${message}.`);
       }
-    } else {
-      const backoffMs = Math.min(30000, 1000 * Math.pow(2, runtime.consecutiveFailures));
-      runtime.retryAfter = new Date(Date.now() + backoffMs).toISOString();
-      runtime.phase = "waiting_retry";
     }
-    await writeState(directory, state);
     return true;
   }
   async function handleSessionCompacted(state, goal) {
     const runtime = state.runtimes.find((r) => r.goalID === goal.id);
     if (!runtime)
       return false;
-    runtime.lastCompactAt = new Date().toISOString();
-    runtime.updatedAt = new Date().toISOString();
-    await writeState(directory, state);
+    const newState = await mutateState(directory, `compacted:${goal.id}`, async (s) => {
+      const rt = s.runtimes.find((r) => r.goalID === goal.id);
+      if (!rt)
+        return s;
+      rt.lastCompactAt = new Date().toISOString();
+      rt.updatedAt = new Date().toISOString();
+      return s;
+    });
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID3(),
+      eventID: randomUUID2(),
       goalID: goal.id,
       type: "compaction.completed",
       timestamp: new Date().toISOString(),
-      revision: state.revision
+      revision: newState.revision
     });
     return true;
   }
   function enforceLimits(goal, runtime) {
     const noResult = { stop: "none", blocked: false, event: "goal.status_changed", reason: "" };
     const maxTurns = goal.config?.maxTurns;
-    if (maxTurns && runtime.turnCount >= maxTurns) {
+    if (maxTurns && runtime.budgetTurnCount >= maxTurns) {
       return {
         stop: "force_finish",
         blocked: true,
@@ -1093,19 +1405,23 @@ function createLoopEngine(options) {
     const compactEvery = goal.config?.compactEvery;
     if (!compactEvery)
       return false;
-    return runtime.turnCount > 0 && runtime.turnCount % compactEvery === 0;
+    return runtime.runCount > 0 && runtime.runCount % compactEvery === 0;
   }
   async function doCompact(goal, runtime) {
     if (!goal.workerSessionID)
       return;
     const prevPhase = runtime.phase;
-    runtime.phase = "compacting";
-    runtime.lastCompactAt = new Date().toISOString();
-    const state = await readState(directory);
-    await writeState(directory, state);
+    const state = await mutateState(directory, `compact.start:${goal.id}`, async (s) => {
+      const rt = s.runtimes.find((r) => r.goalID === goal.id);
+      if (!rt)
+        return s;
+      rt.phase = "compacting";
+      rt.lastCompactAt = new Date().toISOString();
+      return s;
+    });
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID3(),
+      eventID: randomUUID2(),
       goalID: goal.id,
       type: "compaction.started",
       timestamp: new Date().toISOString(),
@@ -1114,39 +1430,99 @@ function createLoopEngine(options) {
     try {
       await host.compactSession(goal.workerSessionID);
     } catch {}
-    const updatedState = await readState(directory);
-    const updatedRuntime = updatedState.runtimes.find((r) => r.goalID === goal.id);
-    if (updatedRuntime) {
-      updatedRuntime.phase = prevPhase;
-      await writeState(directory, updatedState);
-    }
+    await mutateState(directory, `compact.end:${goal.id}`, async (s) => {
+      const rt = s.runtimes.find((r) => r.goalID === goal.id);
+      if (rt)
+        rt.phase = prevPhase;
+      return s;
+    });
   }
   async function maintenance() {
     syncWorkerSessionsFromService();
     if (knownWorkerSessions.size === 0)
       return;
     const state = await readState(directory);
-    const hasActiveGoals = state.goals.some((g) => !isTerminal(g.status) && g.status !== "paused");
+    const hasActiveGoals = state.goals.some((g) => g.status === "active");
     if (!hasActiveGoals)
       return;
     for (const goal of state.goals) {
-      if (isTerminal(goal.status) || goal.status === "paused")
+      if (goal.status !== "active")
         continue;
       const runtime = state.runtimes.find((r) => r.goalID === goal.id);
       if (!runtime)
         continue;
       if (runtime.phase === "waiting_retry" && runtime.retryAfter) {
         if (Date.now() >= Date.parse(runtime.retryAfter)) {
-          runtime.retryAfter = undefined;
-          runtime.phase = "idle";
-          await writeState(directory, state);
+          await mutateState(directory, `retry-ready:${goal.id}`, async (s) => {
+            const rt = s.runtimes.find((r) => r.goalID === goal.id);
+            if (rt) {
+              rt.retryAfter = undefined;
+              rt.phase = "idle";
+            }
+            return s;
+          });
           goalService.continueTurn(directory, goal.id).catch(() => {});
         }
       }
       if ((runtime.phase === "running" || runtime.phase === "idle") && goal.workerSessionID) {
+        if (runtime.phase === "idle" && runtime.activeRunID) {
+          await mutateState(directory, `maintenance.clear-stale-run:${goal.id}`, async (s) => {
+            const rt = s.runtimes.find((r) => r.goalID === goal.id);
+            if (rt?.phase === "idle" && rt.activeRunID) {
+              Object.assign(rt, releaseLease(rt));
+              rt.activeRunID = undefined;
+              rt.lastWorkerStatus = "idle";
+            }
+            return s;
+          });
+          await logServerEvent(directory, "maintenance.stale-run-cleared", { goalID: goal.id });
+        }
         const status = await host.sessionStatus(goal.workerSessionID);
+        if (status === "unknown") {
+          let shouldNotify = false;
+          const unknownState = await mutateState(directory, `maintenance.unknown-status:${goal.id}`, async (s) => {
+            const rt = s.runtimes.find((r) => r.goalID === goal.id);
+            if (!rt)
+              return s;
+            rt.unknownStatusCount = Math.min(unknownStatusThreshold, (rt.unknownStatusCount ?? 0) + 1);
+            rt.lastUnknownStatusAt = new Date().toISOString();
+            if (rt.unknownStatusCount >= unknownStatusThreshold && !rt.workerUnreachableNotifiedAt) {
+              rt.workerUnreachableNotifiedAt = new Date().toISOString();
+              shouldNotify = true;
+            }
+            rt.updatedAt = new Date().toISOString();
+            return s;
+          });
+          const unknownRuntime = unknownState.runtimes.find((r) => r.goalID === goal.id);
+          if (shouldNotify) {
+            await logServerEvent(directory, "maintenance.worker-unreachable", {
+              goalID: goal.id,
+              workerSessionID: goal.workerSessionID,
+              count: unknownRuntime?.unknownStatusCount
+            });
+            await host.notifyOwner(goal.ownerSessionID, `Loop goal "${goal.name}" worker is unreachable after ${unknownRuntime?.unknownStatusCount ?? unknownStatusThreshold} status checks. The goal remains active; use inspect_background_goal, nudge_goal, pause_goal, or resume_goal to recover it.`);
+          }
+          continue;
+        }
+        if ((runtime.unknownStatusCount ?? 0) > 0 || runtime.workerUnreachableNotifiedAt) {
+          await mutateState(directory, `maintenance.status-recovered:${goal.id}`, async (s) => {
+            const rt = s.runtimes.find((r) => r.goalID === goal.id);
+            if (rt) {
+              rt.unknownStatusCount = 0;
+              rt.lastUnknownStatusAt = undefined;
+              rt.workerUnreachableNotifiedAt = undefined;
+              rt.updatedAt = new Date().toISOString();
+            }
+            return s;
+          });
+          await logServerEvent(directory, "maintenance.worker-recovered", { goalID: goal.id });
+        }
         if (status === "idle") {
-          await handleSessionIdle(state, goal);
+          if (runtime.phase === "idle") {
+            await continueGoal(goal.id);
+          } else {
+            await handleSessionIdle(state, goal);
+          }
           continue;
         }
       }
@@ -1156,8 +1532,7 @@ function createLoopEngine(options) {
 }
 
 // src/application/goal-service.ts
-import { randomUUID as randomUUID4 } from "crypto";
-init_state_repository();
+import { randomUUID as randomUUID3 } from "crypto";
 import * as path2 from "path";
 import { promises as fs2 } from "fs";
 
@@ -1178,11 +1553,13 @@ function createWorkerManager(host) {
     },
     async continueWorker(worker, goal, runtime, context) {
       const prompt = buildContinuationSteering(goal, runtime, context);
-      await host.promptWorker({
+      const result = await host.promptWorker({
         sessionID: worker.workerSessionID,
         prompt,
+        messageID: runtime.activePromptMessageID,
         agent: goal.config.agent
       });
+      return result;
     },
     async isIdle(workerSessionID) {
       const status = await host.sessionStatus(workerSessionID);
@@ -1211,11 +1588,11 @@ function buildContinuationSteering(goal, runtime, context) {
       `Exception: if the objective explicitly specifies a different output directory, follow the objective instead.`
     ];
   }
-  if (runtime.turnCount <= 1) {
+  if (runtime.runCount <= 1) {
     parts.push(`You are a worker for an active goal.`, ``, `Call get_goal to read the authoritative objective, acceptance criteria, and current state.`, `Perform one concrete batch of work. After durable verification:`, ``, `- Call report_goal_progress if work remains.`, `- Call complete_goal only if ALL acceptance criteria pass with concrete evidence.`, `- Call block_goal only for a real external blocker requiring user intervention.`, `- Use the built-in question tool when you need clarification only the user can provide.`, ``, `Do not ask questions unnecessarily. Make reasonable assumptions and work directly.`);
     parts.push(...outputLocationBlock());
   } else {
-    parts.push(`This is continuation turn ${runtime.turnCount} for the goal below.`, ``, `## GOAL (user-provided data)`, goal.objective);
+    parts.push(`This is continuation run ${runtime.runCount} for the goal below.`, ``, `## GOAL (user-provided data)`, goal.objective);
     const progress = context?.progressHistory;
     if (progress && progress.length > 0) {
       parts.push(``, `## PROGRESS SO FAR`);
@@ -1243,22 +1620,32 @@ function buildContinuationSteering(goal, runtime, context) {
     parts.push(...outputLocationBlock());
     if (context?.verification) {
       const v = context.verification;
-      parts.push(``, `## VERIFICATION (deterministic pre-screen)`);
-      if (v.checksPassed !== undefined) {
-        if (v.checksPassed)
-          parts.push(`- checks: all passed`);
-        else if (v.failedChecks?.length)
-          parts.push(`- checks FAILED: ${v.failedChecks.join(", ")} \u2014 fix before claiming completion`);
-        else
-          parts.push(`- checks: not yet run`);
-      }
-      if (v.artifactSummary)
-        parts.push(`- artifacts: ${v.artifactSummary}`);
       if (v.evaluatorRejectionCount && v.evaluatorRejectionCount > 0) {
-        parts.push(`- evaluator rejected ${v.evaluatorRejectionCount} time(s): previous completion claim had weak evidence \u2014 fix the issues and call complete_goal again with stronger evidence`);
+        parts.push(``, `## HOST VERDICT: COMPLETION REJECTED`);
+        parts.push(`Rejection #${v.evaluatorRejectionCount}`);
+        if (v.lastRejectionDetails) {
+          parts.push(v.lastRejectionDetails);
+        }
+        parts.push(``, `Required action:`);
+        parts.push(`- Fix the behavior causing the command(s) above to fail.`);
+        parts.push(`- Do NOT merely rewrite the completion evidence.`);
+        parts.push(`- Rerun the command from the stated directory.`);
+        parts.push(`- Call complete_goal only after the command passes.`);
+      } else {
+        parts.push(``, `## VERIFICATION (deterministic pre-screen)`);
+        if (v.checksPassed !== undefined) {
+          if (v.checksPassed)
+            parts.push(`- checks: all passed`);
+          else if (v.failedChecks?.length)
+            parts.push(`- checks FAILED: ${v.failedChecks.join(", ")} \u2014 fix before claiming completion`);
+          else
+            parts.push(`- checks: not yet run`);
+        }
+        if (v.artifactSummary)
+          parts.push(`- artifacts: ${v.artifactSummary}`);
       }
     }
-    parts.push(``, `## COMPLETION AUDIT \u2014 you ARE the evaluator`, `Before deciding the goal is achieved, treat completion as unproven:`, `1. Derive concrete requirements from the objective and any referenced files/plans/specs/issues. Preserve original scope; do not redefine success.`, `2. For _every_ explicit requirement, numbered item, named artifact, command, test, gate, invariant, deliverable \u2192 identify authoritative evidence: files, command output, test results, PR state, rendered artifacts, runtime behavior.`, `3. Judge each per-requirement: proves | contradicts | incomplete | too weak/indirect | missing \u2014 matching scope narrowly (narrow check \u2260 broad claim).`, `4. Treat tests/manifests/verifiers as evidence only after confirming they cover the relevant requirement. Treat uncertain/indirect as NOT achieved.`, `5. Only call complete_goal when _every_ requirement's current-state evidence proves it and no required work remains. If any requirement is missing/incomplete/weak \u2192 keep working, do not call complete_goal.`);
+    parts.push(``, `## COMPLETION REVIEW`, `You are the semantic reviewer. The host is the acceptance authority.`, `Before proposing completion:`, `1. Derive concrete requirements from the objective and any referenced files/plans/specs/issues.`, `2. For each requirement, identify authoritative evidence: files, command output, test results.`, `3. Judge each: proves | contradicts | incomplete | missing.`, `4. Only call complete_goal when you have verified every requirement yourself.`, `5. If objective and checks appear contradictory, call block_goal \u2014 do not silently violate either.`);
     if (context?.forceFinish) {
       parts.push(``, `## FINAL REPORT REQUIRED \u2014 STOPPING SOON`, `The system requires you to wrap up now. Do NOT start new work.`, `Call complete_goal NOW with:`, `- summary: a specific semantic summary of what was accomplished (files changed, results, key findings)`, `- evidence: concrete proof (commands run, files created, checks passed)`, `If you cannot complete truthfully, call block_goal with the reason \u2014 do not fabricate evidence.`);
     } else {
@@ -1279,9 +1666,119 @@ function buildContinuationSteering(goal, runtime, context) {
 function createGoalService(host) {
   const workers = createWorkerManager(host);
   const sessions = new Map;
+  const goalOperations = new Map;
+  async function withGoalOperation(goalID, fn) {
+    const previous = goalOperations.get(goalID) || Promise.resolve();
+    let release;
+    const gate = new Promise((resolve) => {
+      release = resolve;
+    });
+    const current = previous.catch(() => {}).then(() => gate);
+    goalOperations.set(goalID, current);
+    await previous.catch(() => {});
+    try {
+      return await fn();
+    } finally {
+      release();
+      if (goalOperations.get(goalID) === current)
+        goalOperations.delete(goalID);
+    }
+  }
+  function assertWorkspaceWriteAvailable(state, goal) {
+    if (!goal.config.workspaceWrite)
+      return;
+    const activeWriter = state.goals.find((item) => item.id !== goal.id && item.status === "active" && item.config.workspaceWrite);
+    if (activeWriter) {
+      throw new Error(`Workspace-writing goal "${activeWriter.name}" (${activeWriter.id}) is already active. ` + "Pause, block, complete, or clear it before activating another workspace-writing goal.");
+    }
+  }
+  async function recordPromptFailure(directory, goalID, error, blockImmediately = false) {
+    const detail = describeError(error);
+    let runID = "unknown";
+    let failureCount = 0;
+    let blocked = false;
+    let blockerNeeded = "Retry after the OpenCode worker/session API is available.";
+    const state = await mutateState(directory, `turn.prompt-failed:${goalID}`, async (s) => {
+      const goal = s.goals.find((item) => item.id === goalID);
+      const rt = s.runtimes.find((item) => item.goalID === goalID);
+      if (!goal || !rt)
+        return s;
+      runID = rt.activeRunID || "unknown";
+      failureCount = rt.consecutiveFailures + 1;
+      Object.assign(rt, releaseLease(rt));
+      rt.activeRunID = undefined;
+      rt.consecutiveFailures = failureCount;
+      rt.lastError = detail;
+      blocked = blockImmediately || failureCount >= (goal.config.maxFailures || 5);
+      if (blocked) {
+        blockerNeeded = blockImmediately ? "Retry after the OpenCode worker/session API is available." : "Fix the underlying error and use retry_goal to attempt again.";
+        goal.status = "blocked";
+        goal.blocker = {
+          reason: `Worker prompt delivery failed: ${detail}`,
+          needed: blockerNeeded,
+          at: new Date().toISOString()
+        };
+      } else {
+        const backoffMs = Math.min(30000, 1000 * Math.pow(2, failureCount));
+        rt.phase = "waiting_retry";
+        rt.retryAfter = new Date(Date.now() + backoffMs).toISOString();
+      }
+      goal.updatedAt = new Date().toISOString();
+      rt.updatedAt = new Date().toISOString();
+      return s;
+    });
+    await appendEvent(directory, {
+      version: 1,
+      eventID: randomUUID3(),
+      goalID,
+      type: "run.failed",
+      runID,
+      error: detail,
+      consecutiveFailures: failureCount,
+      timestamp: new Date().toISOString(),
+      revision: state.revision
+    });
+    if (blocked) {
+      await appendEvent(directory, {
+        version: 1,
+        eventID: randomUUID3(),
+        goalID,
+        type: "goal.blocked",
+        reason: `Worker prompt delivery failed: ${detail}`,
+        needed: blockerNeeded,
+        timestamp: new Date().toISOString(),
+        revision: state.revision
+      });
+    }
+  }
+  async function ensureWorkerSession(directory, goal) {
+    let session = sessions.get(goal.id);
+    if (session)
+      return session;
+    if (goal.workerSessionID) {
+      session = {
+        goalID: goal.id,
+        workerSessionID: goal.workerSessionID,
+        startedAt: goal.createdAt
+      };
+      sessions.set(goal.id, session);
+      return session;
+    }
+    session = await workers.createWorker(goal);
+    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)
+        persisted.workerSessionID = session.workerSessionID;
+      return s;
+    });
+    return session;
+  }
   async function start(directory, input) {
-    const state = await readState(directory);
-    const id = randomUUID4();
+    const id = randomUUID3();
+    return withGoalOperation(id, () => startUnlocked(directory, input, id));
+  }
+  async function startUnlocked(directory, input, id) {
     const goal = createGoal({
       id,
       name: input.name,
@@ -1290,6 +1787,7 @@ function createGoalService(host) {
       ownerSessionID: input.ownerSessionID,
       config: {
         maxTurns: 50,
+        workspaceWrite: true,
         ...input.config
       }
     });
@@ -1298,86 +1796,109 @@ function createGoalService(host) {
     if (!goal.config.progressFile)
       goal.config.progressFile = path2.join(artifactDir, "progress.md");
     await ensureGoalArtifactDir(directory, id);
-    state.goals.push(goal);
-    state.runtimes.push(createRuntimeState(id));
-    const runtime = state.runtimes.find((r) => r.goalID === id);
-    if (runtime) {
-      runtime.phase = "queued";
-      await writeState(directory, state);
-    }
+    const state1 = await mutateState(directory, `goal.create:${id}`, async (state) => {
+      assertWorkspaceWriteAvailable(state, goal);
+      state.goals.push(goal);
+      state.runtimes.push(createRuntimeState(id));
+      const runtime2 = state.runtimes.find((r) => r.goalID === id);
+      if (runtime2)
+        runtime2.phase = "queued";
+      return state;
+    });
+    let runtime = state1.runtimes.find((r) => r.goalID === id);
     let worker;
     try {
       worker = await workers.createWorker(goal);
     } catch (error) {
       const detail = describeError(error);
-      goal.status = "blocked";
-      goal.updatedAt = new Date().toISOString();
-      goal.blocker = {
-        reason: detail,
-        needed: "Start the goal again from a valid OpenCode session after correcting the worker creation error.",
-        at: new Date().toISOString()
-      };
-      if (runtime) {
-        runtime.phase = "idle";
-        runtime.lastError = detail;
-        runtime.updatedAt = new Date().toISOString();
-      }
-      await writeState(directory, state);
+      const blockedState = await mutateState(directory, `goal.blocked:${id}`, async (state) => {
+        const g = state.goals.find((item) => item.id === id);
+        if (!g)
+          return state;
+        g.status = "blocked";
+        g.updatedAt = new Date().toISOString();
+        g.blocker = {
+          reason: detail,
+          needed: "Start the goal again from a valid OpenCode session after correcting the worker creation error.",
+          at: new Date().toISOString()
+        };
+        const rt = state.runtimes.find((item) => item.goalID === id);
+        if (rt) {
+          rt.phase = "idle";
+          rt.lastError = detail;
+          rt.updatedAt = new Date().toISOString();
+        }
+        return state;
+      });
       await appendEvent(directory, {
         version: 1,
-        eventID: randomUUID4(),
+        eventID: randomUUID3(),
         goalID: id,
         type: "goal.blocked",
         reason: detail,
-        needed: goal.blocker.needed,
+        needed: goal.blocker?.needed || "",
         timestamp: new Date().toISOString(),
-        revision: state.revision
+        revision: blockedState.revision
       });
       await logServerEvent(directory, "goal.start.failed", { goalID: id, ownerSessionID: input.ownerSessionID, detail });
       throw error;
     }
     sessions.set(id, worker);
-    goal.workerSessionID = worker.workerSessionID;
-    await writeState(directory, state);
+    const state2 = await mutateState(directory, `goal.worker-assign:${id}`, async (state) => {
+      const g = state.goals.find((item) => item.id === id);
+      if (!g)
+        return state;
+      g.workerSessionID = worker.workerSessionID;
+      goal.workerSessionID = worker.workerSessionID;
+      const rt = state.runtimes.find((item) => item.goalID === id);
+      if (rt) {
+        Object.assign(rt, acquireLease(rt, g.config.timeoutMs || 300000));
+        rt.activeRunID = randomUUID3();
+        rt.activePromptMessageID = `msg-${randomUUID3()}`;
+        rt.runCount = 1;
+        rt.budgetTurnCount = 1;
+        rt.lastRunAt = new Date().toISOString();
+      }
+      return state;
+    });
+    runtime = state2.runtimes.find((r) => r.goalID === id);
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID4(),
+      eventID: randomUUID3(),
       goalID: id,
       type: "goal.created",
       name: input.name,
       objective: input.objective,
       ownerSessionID: input.ownerSessionID,
       timestamp: new Date().toISOString(),
-      revision: state.revision
+      revision: state2.revision
     });
     if (runtime) {
-      const runID = randomUUID4();
-      Object.assign(runtime, acquireLease(runtime, goal.config.timeoutMs || 300000));
-      runtime.activeRunID = runID;
-      runtime.turnCount = 1;
-      runtime.runCount = 1;
-      runtime.lastRunAt = new Date().toISOString();
-      await writeState(directory, state);
       await appendEvent(directory, {
         version: 1,
-        eventID: randomUUID4(),
+        eventID: randomUUID3(),
         goalID: id,
         type: "run.started",
-        runID,
-        turnCount: runtime.turnCount,
+        runID: runtime.activeRunID,
+        turnCount: runtime.runCount,
         timestamp: new Date().toISOString(),
-        revision: state.revision
+        revision: state2.revision
       });
-      await workers.continueWorker(worker, goal, runtime);
+      try {
+        await workers.continueWorker(worker, goal, runtime);
+      } catch (error) {
+        await recordPromptFailure(directory, id, error, true);
+        throw error;
+      }
     }
     return { goal, worker };
   }
-  async function continueTurn(directory, goalID, opts) {
-    const state = await readState(directory);
-    const goal = state.goals.find((g) => g.id === goalID);
-    if (!goal || isTerminal(goal.status))
+  async function continueTurnUnlocked(directory, goalID, opts) {
+    const preState = await readState(directory);
+    const goal = preState.goals.find((g) => g.id === goalID);
+    if (!goal || goal.status !== "active")
       return;
-    const runtime = state.runtimes.find((r) => r.goalID === goalID);
+    const runtime = preState.runtimes.find((r) => r.goalID === goalID);
     if (!runtime)
       return;
     if (runtime.phase === "running" && leaseIsValid(runtime))
@@ -1393,24 +1914,43 @@ function createGoalService(host) {
     }
     if (!session)
       return;
-    if (!await workers.isIdle(session.workerSessionID))
+    if (!opts?.force && !await workers.isIdle(session.workerSessionID))
+      return;
+    let acquired = false;
+    const state = await mutateState(directory, `turn.acquire:${goalID}`, async (s) => {
+      const g = s.goals.find((item) => item.id === goalID);
+      if (!g || g.status !== "active")
+        return s;
+      const rt = s.runtimes.find((item) => item.goalID === goalID);
+      if (!rt)
+        return s;
+      if (rt.phase === "running" && leaseIsValid(rt))
+        return s;
+      const timeoutMs = g.config.timeoutMs || 300000;
+      Object.assign(rt, acquireLease(rt, timeoutMs));
+      rt.activeRunID = randomUUID3();
+      rt.activePromptMessageID = `msg-${randomUUID3()}`;
+      rt.runCount += 1;
+      if (rt.freeRetryPending) {
+        rt.freeRetryPending = false;
+      } else {
+        rt.budgetTurnCount += 1;
+      }
+      rt.lastRunAt = new Date().toISOString();
+      acquired = true;
+      return s;
+    });
+    const freshGoal = state.goals.find((g) => g.id === goalID);
+    const freshRuntime = state.runtimes.find((r) => r.goalID === goalID);
+    if (!acquired || !freshGoal || freshGoal.status !== "active" || !freshRuntime?.activeRunID)
       return;
-    const timeoutMs = goal.config.timeoutMs || 300000;
-    const leased = acquireLease(runtime, timeoutMs);
-    Object.assign(runtime, leased);
-    const runID = randomUUID4();
-    runtime.activeRunID = runID;
-    runtime.turnCount += 1;
-    runtime.runCount += 1;
-    runtime.lastRunAt = new Date().toISOString();
-    await writeState(directory, state);
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID4(),
+      eventID: randomUUID3(),
       goalID,
       type: "run.started",
-      runID,
-      turnCount: runtime.turnCount,
+      runID: freshRuntime.activeRunID,
+      turnCount: freshRuntime.runCount,
       timestamp: new Date().toISOString(),
       revision: state.revision
     });
@@ -1423,13 +1963,13 @@ function createGoalService(host) {
     }));
     let transcriptTail;
     try {
-      transcriptTail = await host.readMessages(goal.workerSessionID, 5);
+      transcriptTail = await host.readMessages(freshGoal.workerSessionID, 5);
     } catch {
       transcriptTail = [];
     }
     let verification;
     try {
-      const artifactDir = goal.config.artifactDir;
+      const artifactDir = freshGoal.config.artifactDir;
       if (artifactDir) {
         try {
           const files = await fs2.readdir(artifactDir);
@@ -1438,12 +1978,15 @@ function createGoalService(host) {
           verification = { artifactSummary: "no artifacts yet" };
         }
       }
-      if (goal.config.checks?.length) {
-        const c = `checks configured: ${goal.config.checks.length} \u2014 run them before claiming completion`;
+      if (freshGoal.config.checks?.length) {
+        const c = `checks configured: ${freshGoal.config.checks.length} \u2014 run them before claiming completion`;
         verification = { ...verification || {}, failedChecks: [c], checksPassed: undefined };
       }
-      if (runtime.evaluatorRejectionCount && runtime.evaluatorRejectionCount > 0) {
-        verification = { ...verification || {}, evaluatorRejectionCount: runtime.evaluatorRejectionCount };
+      if (freshRuntime.evaluatorRejectionCount && freshRuntime.evaluatorRejectionCount > 0) {
+        verification = { ...verification || {}, evaluatorRejectionCount: freshRuntime.evaluatorRejectionCount };
+      }
+      if (freshRuntime.lastRejectionDetails) {
+        verification = { ...verification || {}, lastRejectionDetails: freshRuntime.lastRejectionDetails };
       }
     } catch {}
     const context = {
@@ -1453,17 +1996,31 @@ function createGoalService(host) {
       forceFinish: opts?.forceFinish || undefined,
       verification
     };
-    await workers.continueWorker(session, goal, runtime, context);
+    try {
+      await workers.continueWorker(session, freshGoal, freshRuntime, context);
+    } catch (error) {
+      await recordPromptFailure(directory, goalID, error);
+      throw error;
+    }
   }
-  async function pause(directory, goalID) {
-    const state = await readState(directory);
-    const goal = state.goals.find((g) => g.id === goalID);
+  async function pauseUnlocked(directory, goalID) {
+    const preState = await readState(directory);
+    const goal = preState.goals.find((g) => g.id === goalID);
     if (!goal)
       return;
     if (!canTransition(goal.status, "paused", "user"))
       return;
-    goal.status = "paused";
-    goal.updatedAt = new Date().toISOString();
+    const state = await mutateState(directory, `goal.pause:${goalID}`, async (s) => {
+      const g = s.goals.find((item) => item.id === goalID);
+      if (!g)
+        return s;
+      g.status = "paused";
+      g.updatedAt = new Date().toISOString();
+      const rt = s.runtimes.find((r) => r.goalID === goalID);
+      if (rt)
+        Object.assign(rt, releaseLease(rt));
+      return s;
+    });
     const session = sessions.get(goalID) || (goal.workerSessionID ? {
       goalID: goal.id,
       workerSessionID: goal.workerSessionID,
@@ -1473,14 +2030,9 @@ function createGoalService(host) {
       await workers.abortWorker(session.workerSessionID);
       sessions.delete(goalID);
     }
-    const runtime = state.runtimes.find((r) => r.goalID === goalID);
-    if (runtime) {
-      Object.assign(runtime, releaseLease(runtime));
-    }
-    await writeState(directory, state);
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID4(),
+      eventID: randomUUID3(),
       goalID,
       type: "goal.status_changed",
       from: "active",
@@ -1489,25 +2041,37 @@ function createGoalService(host) {
       revision: state.revision
     });
   }
-  async function resume(directory, goalID) {
-    const state = await readState(directory);
+  async function resumeUnlocked(directory, goalID) {
+    let resumed = false;
+    const state = await mutateState(directory, `goal.resume:${goalID}`, async (state2) => {
+      const goal2 = state2.goals.find((g) => g.id === goalID);
+      if (!goal2)
+        return state2;
+      if (!canTransition(goal2.status, "active", "user"))
+        return state2;
+      assertWorkspaceWriteAvailable(state2, goal2);
+      goal2.status = "active";
+      goal2.updatedAt = new Date().toISOString();
+      resumed = true;
+      return state2;
+    });
     const goal = state.goals.find((g) => g.id === goalID);
-    if (!goal)
+    if (!goal || !resumed)
       return;
-    if (!canTransition(goal.status, "active", "user"))
-      return;
-    goal.status = "active";
-    goal.updatedAt = new Date().toISOString();
-    let session = sessions.get(goalID);
-    if (!session) {
-      session = await workers.createWorker(goal);
-      sessions.set(goalID, session);
-      goal.workerSessionID = session.workerSessionID;
+    try {
+      await ensureWorkerSession(directory, goal);
+    } catch (error) {
+      await mutateState(directory, `goal.resume-rollback:${goalID}`, async (s) => {
+        const g = s.goals.find((item) => item.id === goalID);
+        if (g?.status === "active")
+          g.status = "paused";
+        return s;
+      });
+      throw error;
     }
-    await writeState(directory, state);
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID4(),
+      eventID: randomUUID3(),
       goalID,
       type: "goal.status_changed",
       from: "paused",
@@ -1515,29 +2079,47 @@ function createGoalService(host) {
       timestamp: new Date().toISOString(),
       revision: state.revision
     });
-    await continueTurn(directory, goalID);
+    await continueTurnUnlocked(directory, goalID);
   }
-  async function retry(directory, goalID) {
-    const state = await readState(directory);
+  async function retryUnlocked(directory, goalID) {
+    let retried = false;
+    const state = await mutateState(directory, `goal.retry:${goalID}`, async (state2) => {
+      const goal2 = state2.goals.find((g) => g.id === goalID);
+      if (!goal2 || goal2.status !== "blocked")
+        return state2;
+      assertWorkspaceWriteAvailable(state2, goal2);
+      goal2.status = "active";
+      goal2.updatedAt = new Date().toISOString();
+      retried = true;
+      const runtime = state2.runtimes.find((r) => r.goalID === goalID);
+      if (runtime) {
+        runtime.consecutiveFailures = 0;
+        runtime.lastError = undefined;
+        runtime.forceFinishRequested = undefined;
+        runtime.lastParentNotifiedAt = undefined;
+        runtime.lastParentNotifiedFor = undefined;
+        runtime.phase = "idle";
+        runtime.updatedAt = new Date().toISOString();
+      }
+      return state2;
+    });
     const goal = state.goals.find((g) => g.id === goalID);
-    if (!goal || goal.status !== "blocked")
+    if (!goal || !retried)
       return;
-    goal.status = "active";
-    goal.updatedAt = new Date().toISOString();
-    const runtime = state.runtimes.find((r) => r.goalID === goalID);
-    if (runtime) {
-      runtime.consecutiveFailures = 0;
-      runtime.lastError = undefined;
-      runtime.forceFinishRequested = undefined;
-      runtime.lastParentNotifiedAt = undefined;
-      runtime.lastParentNotifiedFor = undefined;
-      runtime.phase = "idle";
-      runtime.updatedAt = new Date().toISOString();
+    try {
+      await ensureWorkerSession(directory, goal);
+    } catch (error) {
+      await mutateState(directory, `goal.retry-rollback:${goalID}`, async (s) => {
+        const g = s.goals.find((item) => item.id === goalID);
+        if (g?.status === "active")
+          g.status = "blocked";
+        return s;
+      });
+      throw error;
     }
-    await writeState(directory, state);
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID4(),
+      eventID: randomUUID3(),
       goalID,
       type: "goal.status_changed",
       from: "blocked",
@@ -1545,9 +2127,9 @@ function createGoalService(host) {
       timestamp: new Date().toISOString(),
       revision: state.revision
     });
-    await continueTurn(directory, goalID);
+    await continueTurnUnlocked(directory, goalID);
   }
-  async function clear(directory, goalID) {
+  async function clearUnlocked(directory, goalID) {
     const state = await readState(directory);
     const goal = state.goals.find((g) => g.id === goalID);
     if (!goal)
@@ -1561,17 +2143,19 @@ function createGoalService(host) {
       await workers.abortWorker(session.workerSessionID);
       sessions.delete(goalID);
     }
+    await mutateState(directory, `goal.clear:${goalID}`, async (s) => {
+      s.goals = s.goals.filter((g) => g.id !== goalID);
+      s.runtimes = s.runtimes.filter((r) => r.goalID !== goalID);
+      return s;
+    });
     await appendEvent(directory, {
       version: 1,
-      eventID: randomUUID4(),
+      eventID: randomUUID3(),
       goalID,
       type: "goal.cleared",
       timestamp: new Date().toISOString(),
       revision: state.revision
     });
-    state.goals = state.goals.filter((g) => g.id !== goalID);
-    state.runtimes = state.runtimes.filter((r) => r.goalID !== goalID);
-    await writeState(directory, state);
   }
   function getWorker(goalID) {
     return sessions.get(goalID);
@@ -1587,29 +2171,42 @@ function createGoalService(host) {
       if (goal.status === "paused")
         continue;
       if (!goal.workerSessionID) {
+        let worker;
         try {
-          const worker = await workers.createWorker(goal);
+          worker = await workers.createWorker(goal);
           sessions.set(goal.id, worker);
-          goal.workerSessionID = worker.workerSessionID;
-          goal.updatedAt = new Date().toISOString();
         } catch (error) {
           const detail = describeError(error);
-          goal.status = "blocked";
-          goal.updatedAt = new Date().toISOString();
-          goal.blocker = {
-            reason: detail,
-            needed: "Clear this goal and start it again from a valid OpenCode session.",
-            at: new Date().toISOString()
-          };
-          const runtime2 = state.runtimes.find((item) => item.goalID === goal.id);
-          if (runtime2) {
-            runtime2.phase = "idle";
-            runtime2.lastError = detail;
-            runtime2.updatedAt = new Date().toISOString();
-          }
+          await mutateState(directory, `reconcile.block:${goal.id}`, async (s) => {
+            const g = s.goals.find((item) => item.id === goal.id);
+            if (!g)
+              return s;
+            g.status = "blocked";
+            g.updatedAt = new Date().toISOString();
+            g.blocker = {
+              reason: detail,
+              needed: "Clear this goal and start it again from a valid OpenCode session.",
+              at: new Date().toISOString()
+            };
+            const rt = s.runtimes.find((item) => item.goalID === goal.id);
+            if (rt) {
+              rt.phase = "idle";
+              rt.lastError = detail;
+              rt.updatedAt = new Date().toISOString();
+            }
+            return s;
+          });
           await logServerEvent(directory, "goal.reconcile.failed", { goalID: goal.id, ownerSessionID: goal.ownerSessionID, detail });
           continue;
         }
+        await mutateState(directory, `reconcile.set-worker:${goal.id}`, async (s) => {
+          const g = s.goals.find((item) => item.id === goal.id);
+          if (g) {
+            g.workerSessionID = worker.workerSessionID;
+            g.updatedAt = new Date().toISOString();
+          }
+          return s;
+        });
       }
       if (goal.workerSessionID && !sessions.has(goal.id)) {
         sessions.set(goal.id, {
@@ -1618,18 +2215,70 @@ function createGoalService(host) {
           startedAt: goal.createdAt
         });
       }
-      const runtime = state.runtimes.find((r) => r.goalID === goal.id);
-      if (runtime?.phase === "running" && !leaseIsValid(runtime)) {
+      const preRt = state.runtimes.find((r) => r.goalID === goal.id);
+      if (preRt?.phase === "running" && !leaseIsValid(preRt)) {
         const session = sessions.get(goal.id);
         if (session && await workers.isIdle(session.workerSessionID)) {
-          Object.assign(runtime, releaseLease(runtime));
-          goal.updatedAt = new Date().toISOString();
+          await mutateState(directory, `reconcile.release-lease:${goal.id}`, async (s) => {
+            const rt = s.runtimes.find((r) => r.goalID === goal.id);
+            if (rt) {
+              Object.assign(rt, releaseLease(rt));
+              const g = s.goals.find((item) => item.id === goal.id);
+              if (g)
+                g.updatedAt = new Date().toISOString();
+            }
+            return s;
+          });
         }
       }
     }
-    await writeState(directory, state);
   }
-  return { start, continueTurn, pause, resume, retry, clear, getWorker, getActiveWorkers, reconcile };
+  async function nudgeUnlocked(directory, goalID) {
+    const preState = await readState(directory);
+    const goal = preState.goals.find((g) => g.id === goalID);
+    if (!goal)
+      return { ok: false, message: "Goal not found." };
+    if (goal.status !== "active") {
+      return { ok: false, message: `Goal is ${goal.status}; resume or retry it before nudging.` };
+    }
+    const cleared = await mutateState(directory, `goal.nudge:${goalID}`, async (s) => {
+      const rt = s.runtimes.find((r) => r.goalID === goalID);
+      if (!rt)
+        return s;
+      rt.phase = "idle";
+      rt.activeRunID = undefined;
+      rt.idleCandidateAt = undefined;
+      rt.activePromptMessageID = undefined;
+      rt.activeToolCallIDs = [];
+      rt.updatedAt = new Date().toISOString();
+      return s;
+    });
+    const freshGoal = cleared.goals.find((g) => g.id === goalID);
+    if (!freshGoal || !freshGoal.workerSessionID) {
+      return { ok: false, message: "Goal has no worker session. Use resume_goal or retry_goal." };
+    }
+    await continueTurnUnlocked(directory, goalID, { force: true });
+    return { ok: true, message: `Re-prompted worker for "${freshGoal.name}".` };
+  }
+  function continueTurn(directory, goalID, opts) {
+    return withGoalOperation(goalID, () => continueTurnUnlocked(directory, goalID, opts));
+  }
+  function pause(directory, goalID) {
+    return withGoalOperation(goalID, () => pauseUnlocked(directory, goalID));
+  }
+  function resume(directory, goalID) {
+    return withGoalOperation(goalID, () => resumeUnlocked(directory, goalID));
+  }
+  function retry(directory, goalID) {
+    return withGoalOperation(goalID, () => retryUnlocked(directory, goalID));
+  }
+  function clear(directory, goalID) {
+    return withGoalOperation(goalID, () => clearUnlocked(directory, goalID));
+  }
+  function nudge(directory, goalID) {
+    return withGoalOperation(goalID, () => nudgeUnlocked(directory, goalID));
+  }
+  return { start, continueTurn, nudge, pause, resume, retry, clear, getWorker, getActiveWorkers, reconcile };
 }
 
 // src/server/host-adapter.ts
@@ -1672,10 +2321,14 @@ function createRealHost(client, directory) {
         throw new Error(`OpenCode session.create failed for parent "${parentID}": ${detail}`);
       }
     },
-    async promptWorker({ sessionID, prompt, model, agent }) {
+    async promptWorker({ sessionID, prompt, messageID, model, agent }) {
       const body = {
         parts: [{ type: "text", text: prompt }]
       };
+      if (messageID) {
+        const collapsed = messageID.replace(/^(msg-)+/, "msg-");
+        body.messageID = collapsed.startsWith("msg-") ? collapsed : `msg-${messageID}`;
+      }
       if (model)
         body.model = model;
       if (agent)
@@ -1690,22 +2343,23 @@ function createRealHost(client, directory) {
         throw new Error(`OpenCode session.promptAsync failed for worker "${sessionID}": ${detail}`);
       }
       await logServerEvent(directory, "worker.prompted", { sessionID });
+      return { messageID: result?.data?.messageID };
     },
     async sessionStatus(sessionID) {
       try {
         const result = await client.session.status({});
         const data = result?.data;
         if (!data || typeof data !== "object")
-          return "idle";
+          return "unknown";
         const status = data[sessionID];
         if (!status || typeof status !== "object")
-          return "idle";
+          return "unknown";
         const type = status.type;
         if (type === "busy" || type === "retry")
           return type;
         return "idle";
       } catch {
-        return "idle";
+        return "unknown";
       }
     },
     async abortSession(sessionID) {
@@ -1726,8 +2380,10 @@ function createRealHost(client, directory) {
           role: m.info?.role || "assistant",
           content: m.parts?.filter((p) => p.type === "text").map((p) => p.text).join(`
 `) || "",
-          timestamp: m.info?.time?.completed ? new Date(m.info.time.completed).toISOString() : undefined,
-          messageID: m.id
+          timestamp: m.info?.time?.completed || m.info?.time?.created ? new Date(m.info.time.completed || m.info.time.created).toISOString() : undefined,
+          messageID: m.info?.id || m.id,
+          parentMessageID: m.info?.parentID,
+          completedAt: m.info?.time?.completed ? new Date(m.info.time.completed).toISOString() : undefined
         }));
       } catch {
         return [];
@@ -1775,27 +2431,39 @@ async function withTimeout(promise, timeoutMs, operation) {
 }
 
 // src/server/goal-tools.ts
-init_state_repository();
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { tool } from "@opencode-ai/plugin/tool";
+// src/domain/verification.ts
+var MAX_RECENT_ATTEMPTS = 10;
+function appendVerificationAttempt(recent, attempt) {
+  const next = [...recent, attempt];
+  if (next.length > MAX_RECENT_ATTEMPTS) {
+    return next.slice(next.length - MAX_RECENT_ATTEMPTS);
+  }
+  return next;
+}
+
+// src/server/goal-tools.ts
 import { exec as execChild } from "child_process";
 import { promisify } from "util";
 var execAsync = promisify(execChild);
-function goalTools(dir, goalService, hostSessionID) {
+function goalTools(dir, goalService, hostSessionID, defaults = {}) {
   return {
     loopd_create_goal: tool({
-      description: "Create a new background loop goal. The engine spawns a dedicated worker session " + "that does the work autonomously \u2014 it never runs in this chat. " + "Call this after clarifying the goal name, objective, and any config with the user. " + "The goal immediately starts in the background; the user can monitor it via /loop.",
+      description: "Create a new background loop goal (contract: objective + checks + agent + 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. " + "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. " + "Specify 'agent' or configure plugin defaultAgent.",
       args: {
         name: tool.schema.string().describe("Short goal name (used in the dashboard)."),
         objective: tool.schema.string().describe("What the goal should accomplish, in detail."),
+        agent: tool.schema.string().optional().describe("Agent to run the worker as. Required unless the plugin has defaultAgent configured."),
         checks: tool.schema.array(tool.schema.string()).optional().describe('Shell commands that must pass for completion to be accepted. E.g. ["npm test"].'),
+        checkCwd: tool.schema.string().optional().describe("Directory where completion checks run. Workspace-writing goals default to the project root."),
+        workspaceWrite: tool.schema.boolean().optional().describe("Whether this goal edits the shared project workspace. Defaults to true; explicitly set false for artifact-only/read-only work."),
         progressFile: tool.schema.string().optional().describe("Markdown file the worker reads/writes as its transaction state."),
         maxTurns: tool.schema.number().optional().describe("Max turns before auto-block."),
         maxNoProgress: tool.schema.number().optional().describe("Block after N turns without progress."),
         maxFailures: tool.schema.number().optional().describe("Block after N consecutive failures."),
         compactEvery: tool.schema.number().optional().describe("Compact the worker session every N turns."),
-        timeoutMs: tool.schema.number().optional().describe("Per-turn timeout in ms."),
-        agent: tool.schema.string().optional().describe('Agent to run the worker as (e.g. "dumb-agent", "build"). Defaults to primary agent.')
+        timeoutMs: tool.schema.number().optional().describe("Per-turn timeout in ms.")
       },
       execute: async (args, context) => {
         const sessionID = context?.sessionID || hostSessionID;
@@ -1811,8 +2479,14 @@ function goalTools(dir, goalService, hostSessionID) {
         const config = {
           maxTurns: 50
         };
+        if (args.agent)
+          config.agent = args.agent;
         if (args.checks)
           config.checks = args.checks;
+        if (args.checkCwd)
+          config.checkCwd = args.checkCwd;
+        if (args.workspaceWrite !== undefined)
+          config.workspaceWrite = args.workspaceWrite;
         if (args.progressFile)
           config.progressFile = args.progressFile;
         if (args.maxTurns !== undefined)
@@ -1825,14 +2499,28 @@ function goalTools(dir, goalService, hostSessionID) {
           config.compactEvery = args.compactEvery;
         if (args.timeoutMs !== undefined)
           config.timeoutMs = args.timeoutMs;
-        if (args.agent !== undefined)
-          config.agent = args.agent;
+        const resolution = resolveGoalCreationConfig({
+          directory: dir,
+          objective: args.objective,
+          config,
+          defaults
+        });
+        if (!resolution.ok) {
+          return {
+            title: "Goal not created",
+            output: JSON.stringify({
+              ok: false,
+              message: resolution.message,
+              errorCode: resolution.errorCode
+            })
+          };
+        }
         try {
           const { goal, worker } = await goalService.start(dir, {
             name: args.name,
             objective: args.objective,
             ownerSessionID: sessionID,
-            config
+            config: resolution.config
           });
           return {
             title: "Goal created",
@@ -1841,8 +2529,12 @@ function goalTools(dir, goalService, hostSessionID) {
               goalID: goal.id,
               workerSessionID: worker.workerSessionID,
               artifactDir: goal.config.artifactDir,
+              agent: resolution.config.agent,
+              checks: resolution.config.checks || [],
+              workspaceWrite: resolution.config.workspaceWrite,
+              defaultsApplied: resolution.defaultsApplied,
               name: args.name,
-              message: `Goal "${args.name}" created and started in the background. Artifacts: ${goal.config.artifactDir}. Monitor with /loop (<leader>d).`
+              message: `Goal "${args.name}" created and started in the background. Artifacts: ${goal.config.artifactDir}. Monitor with /loop (<leader>o).`
             })
           };
         } catch (error) {
@@ -1859,7 +2551,7 @@ function goalTools(dir, goalService, hostSessionID) {
       }
     }),
     get_goal: tool({
-      description: "Get the current goal state. Call at the start of every continuation turn " + "to retrieve the objective, current state, acceptance criteria, and recent failures.",
+      description: "Get the current goal contract and state. Call at the start of every turn to retrieve the objective, checks, limits, and recent failures (including HOST VERDICT if the last completion was rejected). Returns structured JSON with config and runtime (phase, runGeneration, rejectionCount).",
       args: {},
       execute: async (_args, context) => {
         const state = await readState(dir);
@@ -1882,7 +2574,7 @@ function goalTools(dir, goalService, hostSessionID) {
       }
     }),
     report_goal_progress: tool({
-      description: "Report meaningful progress on the current goal without completing it. " + "Call after durable state changes (file writes, verifications).",
+      description: "Report meaningful progress (resets consecutiveFailures/noProgressCount). Call after durable state changes (file writes, verifications) \u2014 not after thinking. The engine uses this to avoid force-finish.",
       args: {
         summary: tool.schema.string().describe("What was accomplished."),
         next: tool.schema.string().describe("The next concrete step."),
@@ -1912,7 +2604,7 @@ function goalTools(dir, goalService, hostSessionID) {
         await writeState(dir, state);
         const event = {
           version: 1,
-          eventID: randomUUID5(),
+          eventID: randomUUID4(),
           goalID: goal.id,
           type: "goal.progress",
           summary: args.summary,
@@ -1927,13 +2619,13 @@ function goalTools(dir, goalService, hostSessionID) {
             goalName: goal.name,
             summary: args.summary,
             next: args.next,
-            turn: runtime?.turnCount
+            turn: runtime?.runCount
           })
         };
       }
     }),
     complete_goal: tool({
-      description: "Mark the current goal as completed. " + "Use only when all acceptance criteria pass with concrete evidence. " + "Runs configured completion checks before accepting.",
+      description: "Propose completion. Host runs checks from checkCwd (writers default to project root) \u2014 if any fail, host rejects (rejectionCount++, freeRetryPending if <3, blocked after 3 with HOST VERDICT). Only call when every requirement is proved with evidence; the host decides, not the model.",
       args: {
         summary: tool.schema.string().describe("What was completed."),
         evidence: tool.schema.string().describe("Concrete evidence of completion.")
@@ -1949,16 +2641,84 @@ function goalTools(dir, goalService, hostSessionID) {
           return { title: "Invalid transition", output: `Cannot complete goal in ${goal.status} state.` };
         }
         if (goal.config.checks?.length) {
-          const checkResults = await runCompletionChecks(goal.config.checks);
+          const cwd = goal.config.checkCwd || goal.config.artifactDir || dir;
+          const checkResults = await runCompletionChecks(goal.config.checks, cwd);
           if (!checkResults.passed) {
             const runtime2 = state.runtimes.find((r) => r.goalID === goal.id);
             if (runtime2) {
               runtime2.evaluatorRejectionCount = (runtime2.evaluatorRejectionCount || 0) + 1;
-              if (runtime2.evaluatorRejectionCount >= 3) {
-                runtime2.forceFinishRequested = true;
+              const failureDetails = checkResults.failures.map((f) => {
+                const stdoutSnippet = f.stdout ? `
+Stdout: ${f.stdout.slice(0, 500)}` : "";
+                const stderrSnippet = f.stderr ? `
+Stderr: ${f.stderr.slice(0, 500)}` : "";
+                return `Command: ${f.command}
+Exit code: ${f.exitCode}${stdoutSnippet}${stderrSnippet}`;
+              }).join(`
+
+`);
+              runtime2.lastRejectionDetails = `Rejection #${runtime2.evaluatorRejectionCount} at ${new Date().toISOString()}
+
+Working directory: ${cwd}
+
+${failureDetails}`;
+              const attemptID = randomUUID4();
+              const verificationAttempt = {
+                id: attemptID,
+                sequence: runtime2.evaluatorRejectionCount,
+                runGeneration: runtime2.runGeneration,
+                claimedSummary: args.summary,
+                claimedEvidence: args.evidence,
+                startedAt: new Date().toISOString(),
+                completedAt: new Date().toISOString(),
+                status: "failed",
+                cwd,
+                checks: checkResults.failures.map((f) => ({
+                  command: f.command,
+                  exitCode: f.exitCode,
+                  stderr: f.stderr,
+                  stdout: f.stdout
+                }))
+              };
+              runtime2.lastVerificationAttempt = verificationAttempt;
+              runtime2.recentVerificationAttempts = appendVerificationAttempt(runtime2.recentVerificationAttempts || [], verificationAttempt);
+              const rejectEvent = {
+                version: 1,
+                eventID: randomUUID4(),
+                goalID: goal.id,
+                type: "goal.completion_rejected",
+                attemptID,
+                rejectionCount: runtime2.evaluatorRejectionCount,
+                failedCheckCount: checkResults.failures.length,
+                failureSummary: failureDetails.slice(0, 500),
+                timestamp: new Date().toISOString(),
+                revision: state.revision
+              };
+              await appendEvent(dir, rejectEvent);
+              const maxRejections = goal.config.maxEvaluatorRejections || 3;
+              if (runtime2.evaluatorRejectionCount >= maxRejections) {
+                goal.status = "blocked";
+                goal.updatedAt = new Date().toISOString();
+                goal.blocker = {
+                  reason: `Evaluator rejected ${runtime2.evaluatorRejectionCount} time(s). Last failure:
+${failureDetails.slice(0, 500)}`,
+                  needed: "Fix the failing checks and retry the goal.",
+                  at: new Date().toISOString()
+                };
+                runtime2.forceFinishRequested = undefined;
+                await appendEvent(dir, {
+                  version: 1,
+                  eventID: randomUUID4(),
+                  goalID: goal.id,
+                  type: "goal.blocked",
+                  reason: goal.blocker.reason,
+                  needed: goal.blocker.needed,
+                  timestamp: new Date().toISOString(),
+                  revision: state.revision
+                });
               } else {
                 runtime2.forceFinishRequested = false;
-                runtime2.turnCount = Math.max(0, runtime2.turnCount - 1);
+                runtime2.freeRetryPending = true;
               }
               runtime2.updatedAt = new Date().toISOString();
               await writeState(dir, state);
@@ -1969,7 +2729,8 @@ function goalTools(dir, goalService, hostSessionID) {
                 passed: false,
                 failedChecks: checkResults.failures,
                 message: "Evaluator rejected completion. Fix the issues above and try again.",
-                rejectionCount: runtime2?.evaluatorRejectionCount || 0
+                rejectionCount: runtime2?.evaluatorRejectionCount || 0,
+                status: goal.status
               })
             };
           }
@@ -1985,11 +2746,31 @@ function goalTools(dir, goalService, hostSessionID) {
         if (runtime) {
           runtime.phase = "idle";
           runtime.lastError = undefined;
+          const attemptID = randomUUID4();
+          const cwd = goal.config.checkCwd || goal.config.artifactDir || dir;
+          const checks = (goal.config.checks || []).map((cmd) => ({
+            command: cmd,
+            exitCode: 0
+          }));
+          const verificationAttempt = {
+            id: attemptID,
+            sequence: (runtime.evaluatorRejectionCount || 0) + 1,
+            runGeneration: runtime.runGeneration,
+            claimedSummary: args.summary,
+            claimedEvidence: args.evidence,
+            startedAt: new Date().toISOString(),
+            completedAt: new Date().toISOString(),
+            status: "passed",
+            cwd,
+            checks
+          };
+          runtime.lastVerificationAttempt = verificationAttempt;
+          runtime.recentVerificationAttempts = appendVerificationAttempt(runtime.recentVerificationAttempts || [], verificationAttempt);
         }
         await writeState(dir, state);
         const event = {
           version: 1,
-          eventID: randomUUID5(),
+          eventID: randomUUID4(),
           goalID: goal.id,
           type: "goal.completed",
           summary: args.summary,
@@ -2011,7 +2792,7 @@ function goalTools(dir, goalService, hostSessionID) {
       }
     }),
     block_goal: tool({
-      description: "Mark the current goal as blocked. " + "Use only for a real external blocker requiring user intervention.",
+      description: "Mark blocked for a real external blocker (missing creds, contradictory objective vs checks). Use only when you cannot proceed \u2014 the engine will not auto-continue blocked goals until resume/retry.",
       args: {
         reason: tool.schema.string().describe("Why the goal is blocked."),
         needed: tool.schema.string().describe("What is needed to unblock.")
@@ -2041,7 +2822,7 @@ function goalTools(dir, goalService, hostSessionID) {
         await writeState(dir, state);
         const event = {
           version: 1,
-          eventID: randomUUID5(),
+          eventID: randomUUID4(),
           goalID: goal.id,
           type: "goal.blocked",
           reason: args.reason,
@@ -2082,6 +2863,9 @@ function formatGoalStructured(goal, runtime) {
       progressFile: goal.config.progressFile,
       includeFiles: goal.config.includeFiles,
       checks: goal.config.checks,
+      checkCwd: goal.config.checkCwd,
+      workspaceWrite: goal.config.workspaceWrite,
+      agent: goal.config.agent,
       maxTurns: goal.config.maxTurns,
       maxNoProgress: goal.config.maxNoProgress,
       maxFailures: goal.config.maxFailures,
@@ -2097,28 +2881,43 @@ function formatGoalStructured(goal, runtime) {
   if (runtime) {
     output.runtime = {
       phase: runtime.phase,
-      turnCount: runtime.turnCount,
       runCount: runtime.runCount,
+      budgetTurnCount: runtime.budgetTurnCount,
+      runGeneration: runtime.runGeneration,
+      evaluatorRejectionCount: runtime.evaluatorRejectionCount,
+      freeRetryPending: runtime.freeRetryPending,
+      lastRejectionDetails: runtime.lastRejectionDetails,
       consecutiveFailures: runtime.consecutiveFailures,
       noProgressCount: runtime.noProgressCount,
       lastError: runtime.lastError,
       lastProgressAt: runtime.lastProgressAt,
       lastRunAt: runtime.lastRunAt,
-      lastCompactAt: runtime.lastCompactAt
+      lastCompactAt: runtime.lastCompactAt,
+      lastActivityAt: runtime.lastActivityAt,
+      activePromptMessageID: runtime.activePromptMessageID,
+      activeAssistantMessageID: runtime.activeAssistantMessageID,
+      activeAssistantCompletedAt: runtime.activeAssistantCompletedAt,
+      idleCandidateGeneration: runtime.idleCandidateGeneration,
+      unknownStatusCount: runtime.unknownStatusCount,
+      lastUnknownStatusAt: runtime.lastUnknownStatusAt,
+      workerUnreachableNotifiedAt: runtime.workerUnreachableNotifiedAt,
+      lastVerificationAttempt: runtime.lastVerificationAttempt,
+      recentVerificationAttempts: runtime.recentVerificationAttempts
     };
   }
   return JSON.stringify(output, null, 2);
 }
-async function runCompletionChecks(checks) {
+async function runCompletionChecks(checks, cwd) {
   const failures = [];
   for (const cmd of checks) {
     try {
-      await execAsync(cmd, { timeout: 30000 });
+      const { stdout, stderr } = await execAsync(cmd, { timeout: 30000, cwd });
     } catch (error) {
       failures.push({
         command: cmd,
-        exitCode: error.code || 1,
-        stderr: error.stderr || error.message || "unknown error"
+        exitCode: error.code ?? 1,
+        stderr: String(error.stderr || error.message || "unknown error").slice(0, 1000),
+        stdout: String(error.stdout || "").slice(0, 1000)
       });
     }
   }
@@ -2129,13 +2928,12 @@ async function runCompletionChecks(checks) {
 }
 
 // src/server/owner-tools.ts
-init_state_repository();
 import { tool as tool2 } from "@opencode-ai/plugin/tool";
 function ownerTools(options) {
   const { directory, host, goalService } = options;
   return {
     list_background_goals: tool2({
-      description: "List all background loop goals visible to this session. " + "Shows name, status, progress, and whether any goal is waiting for user input.",
+      description: "List all active background goals owned by this session. Shows contract (name, status, phase, turn, last progress, blocker) \u2014 only goals with your ownerSessionID appear.",
       args: {},
       execute: async (_args, context) => {
         const state = await readState(directory);
@@ -2164,7 +2962,7 @@ function ownerTools(options) {
             name: g.name,
             status: g.status,
             phase: runtime?.phase ?? "unknown",
-            turn: runtime?.turnCount ?? 0,
+            turn: runtime?.runCount ?? 0,
             lastProgress: g.lastProgress?.summary?.slice(0, 120),
             lastProgressAt: g.lastProgress?.at,
             blocker: g.blocker?.reason?.slice(0, 120)
@@ -2177,7 +2975,7 @@ function ownerTools(options) {
       }
     }),
     inspect_background_goal: tool2({
-      description: "Inspect a background goal in detail: objective, contract, progress, " + "blockers, questions, runtime state, and recent events.",
+      description: "Inspect a goal\u2019s full contract and runtime: objective, config{agent,checks,checkCwd,workspaceWrite,limits}, progress, blocker, and runtime{phase,runCount,budgetTurnCount,runGeneration,evaluatorRejectionCount,unknownStatusCount,lastActivityAt,activePromptMessageID}. The source for recovery decisions.",
       args: {
         goal_id: tool2.schema.string().optional().describe("Goal ID. Omit to inspect the first active goal.")
       },
@@ -2207,7 +3005,10 @@ function ownerTools(options) {
               maxFailures: goal.config.maxFailures,
               timeoutMs: goal.config.timeoutMs,
               progressFile: goal.config.progressFile,
-              checks: goal.config.checks
+              checks: goal.config.checks,
+              checkCwd: goal.config.checkCwd,
+              workspaceWrite: goal.config.workspaceWrite,
+              agent: goal.config.agent
             },
             lastProgress: goal.lastProgress,
             completionEvidence: goal.completionEvidence,
@@ -2216,8 +3017,11 @@ function ownerTools(options) {
             timeUsedSeconds: goal.timeUsedSeconds,
             runtime: runtime ? {
               phase: runtime.phase,
-              turnCount: runtime.turnCount,
               runCount: runtime.runCount,
+              budgetTurnCount: runtime.budgetTurnCount,
+              runGeneration: runtime.runGeneration,
+              evaluatorRejectionCount: runtime.evaluatorRejectionCount,
+              freeRetryPending: runtime.freeRetryPending,
               consecutiveFailures: runtime.consecutiveFailures,
               lastError: runtime.lastError,
               lastProgressAt: runtime.lastProgressAt,
@@ -2228,7 +3032,7 @@ function ownerTools(options) {
       }
     }),
     read_goal_transcript: tool2({
-      description: "Read the last N messages from a goal's worker session transcript. " + "Shows what the worker has been doing: tool calls, file changes, responses.",
+      description: "Read the last N messages from the worker transcript (role, content, messageID). Shows HOST VERDICT, steering, and whether the worker\u2019s last prompt was correlated. Use to debug why a completion was rejected or why a worker is stuck.",
       args: {
         goal_id: tool2.schema.string().optional().describe("Goal ID. Omit to read the first active goal."),
         limit: tool2.schema.number().optional().describe("Max messages to return (default: 20).")
@@ -2277,7 +3081,7 @@ function ownerTools(options) {
       }
     }),
     send_goal_input: tool2({
-      description: "Send a message, instruction, or answer to a background goal's worker session. " + "The message will be injected into the worker's next continuation prompt. " + "Use this to answer worker questions, redirect work, or refine scope.",
+      description: "Send an inbox message to the worker (injected as ## USER INSTRUCTIONS on next turn). Use to answer `question`, redirect, or refine scope. Does NOT itself re-prompt \u2014 the engine re-prompts on next idle/maintenance; use nudge_goal if the worker is stuck with no activity.",
       args: {
         goal_id: tool2.schema.string().optional().describe("Goal ID. Omit to target the first active goal."),
         message: tool2.schema.string().describe("Message to send to the worker.")
@@ -2305,7 +3109,7 @@ function ownerTools(options) {
       }
     }),
     pause_goal: tool2({
-      description: "Pause a background goal. The worker session is aborted and the goal stops running. " + "Use when you need to temporarily stop work (e.g., to investigate an issue or change priorities).",
+      description: "Pause an active goal: status active \u2192 paused, releaseLease, abortWorker, per-goal mutex. Frees the workspaceWrite slot. Use to investigate or to free the single-writer slot.",
       args: {
         goal_id: tool2.schema.string().optional().describe("Goal ID. Omit to pause the first active goal.")
       },
@@ -2349,7 +3153,7 @@ function ownerTools(options) {
       }
     }),
     resume_goal: tool2({
-      description: "Resume a paused or blocked background goal. " + "For paused goals, creates a new worker session if needed. " + "For blocked goals, resets failure count and retries.",
+      description: "Resume a paused (\u2192active, reuses existing worker if sessionStatus still idle/busy) or retry a blocked (\u2192active, resets consecutiveFailures/forceFinish). Fails with 'already active' if another workspaceWrite writer is active. Per-goal mutex.",
       args: {
         goal_id: tool2.schema.string().optional().describe("Goal ID. Omit to resume the first paused/blocked goal.")
       },
@@ -2399,8 +3203,41 @@ function ownerTools(options) {
         }
       }
     }),
+    nudge_goal: tool2({
+      description: "Force re-prompt a stuck active worker (the hardened recovery). Clears stale activeRunID/idleCandidate/generation/lease (phase\u2192idle) and calls continueTurn({force:true}) even if sessionStatus is not idle. Use when unknownStatusCount\u22653, lastActivityAt is stale, or maintenance notified 'worker is unreachable'. Per-goal mutex.",
+      args: {
+        goal_id: tool2.schema.string().optional().describe("Goal ID. Omit to nudge the first active goal.")
+      },
+      execute: async (args, context) => {
+        const state = await readState(directory);
+        const ownerID = context?.sessionID;
+        const goal = args.goal_id ? state.goals.find((g) => g.id === args.goal_id && g.ownerSessionID === ownerID) : state.goals.find((g) => g.ownerSessionID === ownerID && g.status !== "complete");
+        if (!goal) {
+          return {
+            title: "No goal found",
+            output: JSON.stringify({ ok: false, message: "No matching active goal for this session." })
+          };
+        }
+        try {
+          const result = await goalService.nudge(directory, goal.id);
+          return {
+            title: result.ok ? "Goal nudged" : "Nudge failed",
+            output: JSON.stringify({ ...result, goalID: goal.id, goalName: goal.name })
+          };
+        } catch (error) {
+          return {
+            title: "Nudge failed",
+            output: JSON.stringify({
+              ok: false,
+              goalName: goal.name,
+              message: error instanceof Error ? error.message : String(error)
+            })
+          };
+        }
+      }
+    }),
     clear_goal: tool2({
-      description: "Clear a background goal. Aborts the worker and removes the goal from the dashboard. " + "This action cannot be undone. Use when the goal is no longer needed.",
+      description: "Clear a goal: aborts worker and removes goal+runtime+ledger (cannot be undone). Use when the goal is no longer needed or to free a stuck writer slot after inspection.",
       args: {
         goal_id: tool2.schema.string().optional().describe("Goal ID. Omit to clear the first active goal.")
       },
@@ -2439,16 +3276,17 @@ function ownerTools(options) {
     })
   };
 }
-
 // src/server/plugin.ts
 var PLUGIN_ID = "opencode-loopd.server";
-var server = async ({ client, directory }) => {
+var server = async ({ client, directory }, pluginOptions) => {
+  const defaults = parsePluginDefaults(pluginOptions);
   const host = createRealHost(client, directory);
   const goalService = createGoalService(host);
   const worker = createControlWorker({
     directory,
     goalService,
-    pollIntervalMs: 1000
+    pollIntervalMs: 1000,
+    defaults
   });
   const engine = createLoopEngine({
     directory,
@@ -2482,12 +3320,50 @@ var server = async ({ client, directory }) => {
       if (type?.startsWith("session."))
         reconcileInBackground();
     },
-    tool: { ...goalTools(directory, goalService), ...ownerTools({ directory, host, goalService }) },
+    tool: { ...goalTools(directory, goalService, undefined, defaults), ...ownerTools({ directory, host, goalService }) },
+    "tool.execute.before": async (input, _output) => {
+      const activeWorkers = goalService.getActiveWorkers();
+      let matchedGoalID;
+      for (const [goalID, worker2] of activeWorkers) {
+        if (worker2.workerSessionID === input.sessionID) {
+          matchedGoalID = goalID;
+          break;
+        }
+      }
+      if (!matchedGoalID)
+        return;
+      try {
+        await mutateState(directory, `tool-call.start:${matchedGoalID}:${input.callID}`, async (s) => {
+          const runtime = s.runtimes.find((r) => r.goalID === matchedGoalID);
+          if (runtime)
+            Object.assign(runtime, addToolCall(runtime, input.callID));
+          return s;
+        });
+      } catch {}
+    },
     "tool.execute.after": async (input, output) => {
       if (input.tool === "loopd_create_goal" || input.tool === "get_goal" || input.tool === "report_goal_progress") {
         ensureStarted();
         reconcileInBackground();
       }
+      const activeWorkers = goalService.getActiveWorkers();
+      let matchedGoalID;
+      for (const [goalID, worker2] of activeWorkers) {
+        if (worker2.workerSessionID === input.sessionID) {
+          matchedGoalID = goalID;
+          break;
+        }
+      }
+      if (matchedGoalID) {
+        try {
+          await mutateState(directory, `tool-call.end:${matchedGoalID}:${input.callID}`, async (s) => {
+            const runtime = s.runtimes.find((r) => r.goalID === matchedGoalID);
+            if (runtime)
+              Object.assign(runtime, removeToolCall(runtime, input.callID));
+            return s;
+          });
+        } catch {}
+      }
       if (input.tool === "complete_goal" || input.tool === "block_goal") {
         try {
           const raw = output?.output;
@@ -2499,9 +3375,8 @@ var server = async ({ client, directory }) => {
           const goalID = parsed.goalID;
           if (!goalID)
             return;
-          const { readState: readState2, writeState: writeState2 } = await Promise.resolve().then(() => (init_state_repository(), exports_state_repository));
           const { shouldNotifyParent: shouldNotifyParent2, markParentNotified: markParentNotified2 } = await Promise.resolve().then(() => exports_runtime);
-          const state = await readState2(directory);
+          const state = await readState(directory);
           const goal = state.goals.find((g) => g.id === goalID);
           if (!goal)
             return;
@@ -2510,8 +3385,12 @@ var server = async ({ client, directory }) => {
           if (runtime && !shouldNotifyParent2(runtime, notifyType))
             return;
           if (runtime) {
-            markParentNotified2(runtime, notifyType);
-            await writeState2(directory, state);
+            await mutateState(directory, `notify-parent:${goalID}`, async (s) => {
+              const rt = s.runtimes.find((r) => r.goalID === goalID);
+              if (rt)
+                markParentNotified2(rt, notifyType);
+              return s;
+            });
           }
           const message = parsed.status === "complete" ? `Loop goal "${goal.name}" completed: ${parsed.summary || ""}. Evidence: ${parsed.evidence || ""}. Artifacts: ${goal.config.artifactDir || "n/a"}.` : `Loop goal "${goal.name}" blocked: ${parsed.reason || ""}. Needed: ${parsed.needed || ""}.`;
           await host.notifyOwner(goal.ownerSessionID, message);
@@ -2524,6 +3403,14 @@ var server = async ({ client, directory }) => {
     }
   };
 };
+function parsePluginDefaults(options) {
+  const agent = typeof options?.defaultAgent === "string" ? options.defaultAgent.trim() : "";
+  const checks = Array.isArray(options?.defaultChecks) ? options.defaultChecks.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean) : [];
+  return {
+    defaultAgent: agent || undefined,
+    defaultChecks: checks.length > 0 ? checks : undefined
+  };
+}
 var plugin_default = {
   id: PLUGIN_ID,
   server