oh-my-opencode 5.0.0-beta.51 → 5.0.0-beta.52

package/dist/index.js

@@ -23340,10 +23340,8 @@ function validationDiagnostic(path, issues) {
 function unrecognizedKeyIssues(issues) {
   return issues.flatMap((issue) => issue.code === "unrecognized_keys" ? [{ keys: issue.keys, path: issue.path.map((segment) => String(segment)) }] : []);
 }
-function hasUnsafeUnrecognizedKey(parsed, issues) {
-  if (issues.some((issue) => issue.keys.some((key) => isUnsafeObjectKey2(key))))
-    return true;
-  return hasTamperedPrototype(parsed);
+function hasUnsafeUnrecognizedKey(issues) {
+  return issues.some((issue) => issue.keys.some((key) => isUnsafeObjectKey2(key)));
 }
 function hasTamperedPrototype(value) {
   if (Array.isArray(value))
@@ -23416,11 +23414,17 @@ function readConfigSource(path, scope, fileSystem) {
       source: { exists: true, loaded: false, path, scope }
     };
   }
+  if (hasTamperedPrototype(parsed.data)) {
+    return {
+      diagnostic: { kind: "validation", message: `Invalid omo config at ${path}: "__proto__" member is not allowed`, path },
+      source: { exists: true, loaded: false, path, scope }
+    };
+  }
   const parsedRecord = toRecord2(parsed.data);
   const validation = OmoConfigLayerSchema.safeParse(parsed.data);
   if (!validation.success) {
     const unrecognized = unrecognizedKeyIssues(validation.error.issues);
-    if (unrecognized.length > 0 && hasUnsafeUnrecognizedKey(parsed.data, unrecognized)) {
+    if (hasUnsafeUnrecognizedKey(unrecognized)) {
       return {
         diagnostic: validationDiagnostic(path, validation.error.issues),
         source: { exists: true, loaded: false, path, scope }
@@ -82598,7 +82602,7 @@ function convertSDKMessageToStoredMessage(msg) {
     return null;
   const providerID = info.model?.providerID ?? info.providerID;
   const modelID = info.model?.modelID ?? info.modelID;
-  const variant = info.model?.variant;
+  const variant = info.model?.variant ?? info.variant;
   if (!info.agent && !providerID && !modelID) {
     return null;
   }
@@ -82695,6 +82699,10 @@ async function resolveMessageContext(sessionID, client, messageDir) {
 // packages/omo-opencode/src/features/hook-message-injector/id-generation.ts
 import { randomBytes } from "crypto";
 var processPrefix = randomBytes(4).toString("hex");
+var partCounter = 0;
+function generatePartId() {
+  return `prt_${processPrefix}_${String(++partCounter).padStart(6, "0")}`;
+}
 // packages/omo-opencode/src/shared/internal-initiator-marker.ts
 init_internal_initiator_marker();
 
@@ -86537,6 +86545,10 @@ var CHECK_NAMES = {
   [CHECK_IDS.TEAM_MODE]: "Team Mode",
   [CHECK_IDS.CODEX]: "Codex"
 };
+var UPDATE_COMMANDS = {
+  opencode: `bunx ${PUBLISHED_PACKAGE_NAME} install`,
+  codex: "npx lazycodex-ai install --no-tui --codex-autonomous"
+};
 
 // packages/omo-opencode/src/cli/doctor/checks/tui-plugin-config.ts
 var TUI_SUBPATH = "tui";
@@ -96387,7 +96399,7 @@ function getCachedVersion(options = {}) {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "5.0.0-beta.51",
+  version: "5.0.0-beta.52",
   description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   main: "./dist/index.js",
   types: "dist/index.d.ts",
@@ -96571,7 +96583,7 @@ var package_default = {
     zod: "^4.4.3"
   },
   devDependencies: {
-    "@code-yeongyu/senpi": "2026.9.9-2",
+    "@code-yeongyu/senpi": "2026.9.10",
     "@oh-my-opencode/agents-md-core": "workspace:*",
     "@oh-my-opencode/ast-grep-mcp": "workspace:*",
     "@oh-my-opencode/boulder-state": "workspace:*",
@@ -96612,18 +96624,18 @@ var package_default = {
     typescript: "^7.0.2"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "5.0.0-beta.51",
-    "oh-my-opencode-darwin-x64": "5.0.0-beta.51",
-    "oh-my-opencode-darwin-x64-baseline": "5.0.0-beta.51",
-    "oh-my-opencode-linux-arm64": "5.0.0-beta.51",
-    "oh-my-opencode-linux-arm64-musl": "5.0.0-beta.51",
-    "oh-my-opencode-linux-x64": "5.0.0-beta.51",
-    "oh-my-opencode-linux-x64-baseline": "5.0.0-beta.51",
-    "oh-my-opencode-linux-x64-musl": "5.0.0-beta.51",
-    "oh-my-opencode-linux-x64-musl-baseline": "5.0.0-beta.51",
-    "oh-my-opencode-windows-arm64": "5.0.0-beta.51",
-    "oh-my-opencode-windows-x64": "5.0.0-beta.51",
-    "oh-my-opencode-windows-x64-baseline": "5.0.0-beta.51"
+    "oh-my-opencode-darwin-arm64": "5.0.0-beta.52",
+    "oh-my-opencode-darwin-x64": "5.0.0-beta.52",
+    "oh-my-opencode-darwin-x64-baseline": "5.0.0-beta.52",
+    "oh-my-opencode-linux-arm64": "5.0.0-beta.52",
+    "oh-my-opencode-linux-arm64-musl": "5.0.0-beta.52",
+    "oh-my-opencode-linux-x64": "5.0.0-beta.52",
+    "oh-my-opencode-linux-x64-baseline": "5.0.0-beta.52",
+    "oh-my-opencode-linux-x64-musl": "5.0.0-beta.52",
+    "oh-my-opencode-linux-x64-musl-baseline": "5.0.0-beta.52",
+    "oh-my-opencode-windows-arm64": "5.0.0-beta.52",
+    "oh-my-opencode-windows-x64": "5.0.0-beta.52",
+    "oh-my-opencode-windows-x64-baseline": "5.0.0-beta.52"
   },
   overrides: {
     "@earendil-works/pi-agent-core": "0.84.2",
@@ -103400,8 +103412,7 @@ function getDefaultUltraworkMessage() {
   return ULTRAWORK_DEFAULT_MESSAGE;
 }
 // packages/omo-opencode/src/hooks/keyword-detector/ultrawork/index.ts
-function getUltraworkMessage(agentName, modelID) {
-  const source = getUltraworkSource(agentName, modelID);
+function getUltraworkMessageForSource(source) {
   switch (source) {
     case "planner":
       return getPlannerUltraworkMessage();
@@ -103416,6 +103427,9 @@ function getUltraworkMessage(agentName, modelID) {
       return getDefaultUltraworkMessage();
   }
 }
+function getUltraworkMessage(agentName, modelID) {
+  return getUltraworkMessageForSource(getUltraworkSource(agentName, modelID));
+}
 
 // packages/omo-opencode/src/hooks/keyword-detector/team/default.ts
 var TEAM_PATTERN = /\bteam[\s_-]?mode\b/i;
@@ -103498,6 +103512,7 @@ function extractPromptText2(parts) {
 // packages/omo-opencode/src/hooks/keyword-detector/hook.ts
 var defaultModeUltraworkInjectedSessions = new Set;
 var DEFAULT_MODE_ULTRAWORK_SESSION_CAP = 256;
+var ULTRAWORK_CONTINUATION_MARKER = "<ultrawork-mode>active</ultrawork-mode>";
 function rememberDefaultModeUltraworkInjectedSession(sessionID) {
   if (defaultModeUltraworkInjectedSessions.has(sessionID))
     return;
@@ -103526,6 +103541,7 @@ function filterAlreadyInjectedKeywords(detected, text) {
 function createKeywordDetectorHook(ctx, _collector, _ralphLoop, config, defaultMode) {
   const disabledKeywords = config?.disabled_keywords;
   const enabledExpansions = config?.enabled_expansions;
+  const explicitUltraworkSessions = new Map;
   function getRuntimeVariant(input, message) {
     if (typeof message.variant === "string") {
       return message.variant;
@@ -103538,12 +103554,15 @@ function createKeywordDetectorHook(ctx, _collector, _ralphLoop, config, defaultM
         log2(`[keyword-detector] Skipping synthetic/internal text message`, { sessionID: input.sessionID });
         return;
       }
-      const promptText = extractPromptText2(output.parts);
+      const promptText = extractPromptText2(output.parts.filter(isRealUserTextPart));
       if (isSystemDirective(promptText)) {
         log2(`[keyword-detector] Skipping system directive message`, { sessionID: input.sessionID });
         return;
       }
       if (looksLikeSlashCommand(promptText)) {
+        if (/^\s*\/stop-continuation(?:\s|$)/i.test(promptText)) {
+          explicitUltraworkSessions.delete(input.sessionID);
+        }
         log2(`[keyword-detector] Skipping slash command invocation`, { sessionID: input.sessionID });
         return;
       }
@@ -103553,8 +103572,17 @@ function createKeywordDetectorHook(ctx, _collector, _ralphLoop, config, defaultM
         return;
       }
       const cleanText = removeSystemReminders(promptText);
-      const modelID = input.model?.modelID;
+      const selectedModel = output.message.model;
+      const modelID = selectedModel !== null && typeof selectedModel === "object" && "modelID" in selectedModel && typeof selectedModel.modelID === "string" ? selectedModel.modelID : input.model?.modelID;
+      const promptSource = getUltraworkSource(currentAgent, modelID);
       let detectedKeywords = detectKeywordsWithType(cleanText, currentAgent, modelID, disabledKeywords, enabledExpansions);
+      const explicitUltrawork = detectedKeywords.some((k) => k.type === "ultrawork" || k.type === "hyperplan-ultrawork");
+      const activeUltrawork = explicitUltraworkSessions.get(input.sessionID);
+      const replayUltrawork = !explicitUltrawork && activeUltrawork !== undefined;
+      const compactUltrawork = activeUltrawork !== undefined && !activeUltrawork.needsRestoration && activeUltrawork.source === promptSource;
+      if (replayUltrawork) {
+        detectedKeywords.push({ type: "ultrawork", message: getUltraworkMessageForSource(promptSource) });
+      }
       detectedKeywords = suppressComboStandalones(detectedKeywords);
       if (isPlannerAgent(currentAgent)) {
         const preFilterCount = detectedKeywords.length;
@@ -103606,7 +103634,7 @@ function createKeywordDetectorHook(ctx, _collector, _ralphLoop, config, defaultM
         return;
       }
       const hasUltrawork = detectedKeywords.some((k) => k.type === "ultrawork");
-      if (hasUltrawork) {
+      if (hasUltrawork && explicitUltrawork) {
         const runtimeVariant = getRuntimeVariant(input, output.message);
         const isRuntimeMax = runtimeVariant === "max";
         log2(`[keyword-detector] Ultrawork mode activated`, {
@@ -103654,34 +103682,83 @@ function createKeywordDetectorHook(ctx, _collector, _ralphLoop, config, defaultM
           }
         }).catch((err) => log2(`[keyword-detector] Failed to show toast`, { error: err, sessionID: input.sessionID }));
       }
-      const textPartIndex = output.parts.findIndex(isRealUserTextPart);
-      if (textPartIndex === -1) {
-        log2(`[keyword-detector] No text part found, skipping injection`, { sessionID: input.sessionID });
-        return;
-      }
-      const allMessages = detectedKeywords.map((k) => k.message).join(`
+      const allMessages = detectedKeywords.filter((k) => !(compactUltrawork && k.type === "ultrawork")).map((k) => k.message).join(`
 
 `);
-      const originalText = output.parts[textPartIndex].text ?? "";
-      output.parts[textPartIndex].text = `${originalText}
+      const textPart = output.parts.find(isRealUserTextPart);
+      const requiresFullGuidance = (hasUltrawork || hasHyperplanUltrawork) && !compactUltrawork && allMessages.length > 0;
+      const messageID = input.messageID ?? (typeof output.message.id === "string" ? output.message.id : undefined);
+      let fullGuidanceDurablyAdded = textPart !== undefined && requiresFullGuidance;
+      if (textPart && allMessages) {
+        textPart.text = `${textPart.text}
 
 ---
 
 ${allMessages}`;
+      }
+      if (!textPart && requiresFullGuidance && messageID) {
+        output.parts.push({
+          id: generatePartId(),
+          sessionID: input.sessionID,
+          messageID,
+          type: "text",
+          text: allMessages,
+          synthetic: true
+        });
+        fullGuidanceDurablyAdded = true;
+      }
+      if (hasUltrawork && compactUltrawork && !output.parts.some((part) => part.synthetic === true && part.text === ULTRAWORK_CONTINUATION_MARKER) && messageID) {
+        output.parts.push({
+          id: generatePartId(),
+          sessionID: input.sessionID,
+          messageID,
+          type: "text",
+          text: ULTRAWORK_CONTINUATION_MARKER,
+          synthetic: true
+        });
+      }
+      if ((explicitUltrawork || replayUltrawork) && (hasUltrawork || hasHyperplanUltrawork) && (!requiresFullGuidance || fullGuidanceDurablyAdded)) {
+        if (!explicitUltraworkSessions.has(input.sessionID) && explicitUltraworkSessions.size >= DEFAULT_MODE_ULTRAWORK_SESSION_CAP) {
+          const oldest = explicitUltraworkSessions.keys().next().value;
+          if (oldest !== undefined)
+            explicitUltraworkSessions.delete(oldest);
+        }
+        explicitUltraworkSessions.set(input.sessionID, { source: promptSource, needsRestoration: false });
+      }
       log2(`[keyword-detector] Detected ${detectedKeywords.length} keywords`, {
         sessionID: input.sessionID,
         types: detectedKeywords.map((k) => k.type)
       });
     },
+    clearSession: (sessionID) => {
+      explicitUltraworkSessions.delete(sessionID);
+    },
+    getSystemTransformGuidance: (sessionID, modelID) => {
+      const activeUltrawork = explicitUltraworkSessions.get(sessionID);
+      const agent = getSessionAgent(sessionID);
+      if (!activeUltrawork?.needsRestoration || isPlannerAgent(agent) || isNonOmoAgent(agent) || subagentSessions.has(sessionID))
+        return;
+      return getUltraworkMessageForSource(modelID === undefined ? activeUltrawork.source : getUltraworkSource(agent, modelID));
+    },
     event: ({ event }) => {
-      if (event.type !== "session.deleted")
+      if (event.type !== "session.deleted" && event.type !== "session.compacted")
         return;
       const sessionID = resolveSessionEventID(event.properties);
-      if (sessionID)
+      if (sessionID) {
+        if (event.type === "session.compacted") {
+          const activeUltrawork = explicitUltraworkSessions.get(sessionID);
+          if (activeUltrawork) {
+            explicitUltraworkSessions.set(sessionID, { ...activeUltrawork, needsRestoration: true });
+          }
+          return;
+        }
         clearDefaultModeUltraworkInjectedSession(sessionID);
+        explicitUltraworkSessions.delete(sessionID);
+      }
     },
     dispose: () => {
       clearAllDefaultModeUltraworkInjectedSessions();
+      explicitUltraworkSessions.clear();
     }
   };
 }
@@ -113354,7 +113431,14 @@ async function resolveRecentPromptContextForSession(ctx, sessionID, deps = defau
         };
       }
       if (info?.providerID && info?.modelID) {
-        return { model: { providerID: info.providerID, modelID: info.modelID }, tools };
+        return {
+          model: {
+            providerID: info.providerID,
+            modelID: info.modelID,
+            ...info.variant ? { variant: info.variant } : {}
+          },
+          tools
+        };
       }
     }
   } catch (error) {
@@ -116577,6 +116661,7 @@ function getMessageInfo(value) {
     model,
     providerID: typeof info.providerID === "string" ? info.providerID : undefined,
     modelID: typeof info.modelID === "string" ? info.modelID : undefined,
+    variant: typeof info.variant === "string" ? info.variant : undefined,
     tools: isRecord(info.tools) ? Object.entries(info.tools).reduce((acc, [key, value]) => {
       if (value === true || value === false || value === "allow" || value === "deny" || value === "ask") {
         acc[key] = value;
@@ -116672,7 +116757,11 @@ async function resolveMainSessionTarget(ctx, sessionID) {
       const info = getMessageInfo(messages[i]);
       if (info?.agent || info?.model || info?.providerID && info?.modelID) {
         agent = agent ?? info?.agent;
-        model = info?.model ?? (info?.providerID && info?.modelID ? { providerID: info.providerID, modelID: info.modelID } : undefined);
+        model = info?.model ?? (info?.providerID && info?.modelID ? {
+          providerID: info.providerID,
+          modelID: info.modelID,
+          ...info.variant ? { variant: info.variant } : {}
+        } : undefined);
         tools = resolveInheritedPromptTools(sessionID, info?.tools) ?? tools;
         break;
       }
@@ -129573,6 +129662,7 @@ async function executeSyncContinuation(args, ctx, executorCtx, parentContext, de
     throw new Error("task_id is required to continue a sync task");
   }
   cancelSyncSessionDeletion(continuationID);
+  const detachFromManager = executorCtx.manager?.attachSyncContinuation?.(continuationID);
   const taskId = `resume_sync_${continuationID.slice(0, 8)}`;
   const startTime = new Date;
   if (toastManager) {
@@ -129644,6 +129734,7 @@ async function executeSyncContinuation(args, ctx, executorCtx, parentContext, de
       toastManager.removeTask(taskId);
     }
     const errorMessage = promptError instanceof Error ? promptError.message : String(promptError);
+    detachFromManager?.();
     scheduleSyncSessionDeletion(client, continuationID);
     return `Failed to send continuation prompt: ${errorMessage}
 
@@ -129718,6 +129809,7 @@ ${buildTaskMetadataBlock({
         });
       }
     }
+    detachFromManager?.();
     scheduleSyncSessionDeletion(client, continuationID);
   }
 }
@@ -131857,21 +131949,39 @@ function writeJsonAtomic(filePath, data) {
   }
 }
 var STALE_LOCK_THRESHOLD_MS = 30000;
+var DEFAULT_LOCK_WAIT_TIMEOUT_MS = 5000;
+var DEFAULT_LOCK_RETRY_DELAY_MS = 10;
+var MAX_LOCK_RETRY_DELAY_MS = 50;
+function resolveLockWaitTimeoutMs() {
+  const raw = process.env.OMO_TASK_LOCK_WAIT_TIMEOUT_MS?.trim();
+  if (!raw)
+    return DEFAULT_LOCK_WAIT_TIMEOUT_MS;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 0)
+    return DEFAULT_LOCK_WAIT_TIMEOUT_MS;
+  return parsed;
+}
+function delay5(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
 function generateTaskId() {
   return `T-${randomUUID9()}`;
 }
-function acquireLock2(dirPath) {
+async function acquireLock2(dirPath, options = {}) {
   const lockPath = join113(dirPath, ".lock");
   const lockId = randomUUID9();
+  const waitTimeoutMs = options.waitTimeoutMs ?? resolveLockWaitTimeoutMs();
+  const baseRetryDelayMs = options.retryDelayMs ?? DEFAULT_LOCK_RETRY_DELAY_MS;
   const createLock = (timestamp) => {
     writeFileSync22(lockPath, JSON.stringify({ id: lockId, timestamp }), {
       encoding: "utf-8",
       flag: "wx"
     });
   };
-  const isStale = () => {
+  const isStale = (lockContent) => {
     try {
-      const lockContent = readFileSync62(lockPath, "utf-8");
       const lockData = JSON.parse(lockContent);
       const lockAge = Date.now() - lockData.timestamp;
       return lockAge > STALE_LOCK_THRESHOLD_MS;
@@ -131880,6 +131990,25 @@ function acquireLock2(dirPath) {
       return true;
     }
   };
+  const reclaimStaleLock = () => {
+    let snapshot;
+    try {
+      snapshot = readFileSync62(lockPath, "utf-8");
+    } catch (error) {
+      ignoreClaudeTaskStorageError(error);
+      return true;
+    }
+    if (!isStale(snapshot))
+      return false;
+    try {
+      if (readFileSync62(lockPath, "utf-8") !== snapshot)
+        return false;
+      unlinkSync16(lockPath);
+    } catch (error) {
+      ignoreClaudeTaskStorageError(error);
+    }
+    return true;
+  };
   const tryAcquire = () => {
     const now = Date.now();
     try {
@@ -131892,15 +132021,27 @@ function acquireLock2(dirPath) {
       throw error;
     }
   };
+  const nextDelayMs = (attempt, deadline) => {
+    const cap = Math.max(MAX_LOCK_RETRY_DELAY_MS, baseRetryDelayMs);
+    const step = Math.min(baseRetryDelayMs * 2 ** attempt, cap);
+    const jittered = step / 2 + Math.random() * (step / 2);
+    return Math.max(1, Math.min(jittered, deadline - Date.now()));
+  };
   ensureDir(dirPath);
-  let acquired = tryAcquire();
-  if (!acquired && isStale()) {
-    try {
-      unlinkSync16(lockPath);
-    } catch (error) {
-      ignoreClaudeTaskStorageError(error);
+  const deadline = Date.now() + waitTimeoutMs;
+  let acquired = false;
+  for (let attempt = 0;; attempt++) {
+    if (tryAcquire()) {
+      acquired = true;
+      break;
+    }
+    if (reclaimStaleLock() && tryAcquire()) {
+      acquired = true;
+      break;
     }
-    acquired = tryAcquire();
+    if (Date.now() >= deadline)
+      break;
+    await delay5(nextDelayMs(attempt, deadline));
   }
   if (!acquired) {
     return {
@@ -132059,10 +132200,11 @@ async function handleCreate(args, config, ctx, context) {
   try {
     const validatedArgs = TaskCreateInputSchema.parse(args);
     const taskDir = getTaskDir(config);
-    const lock = acquireLock2(taskDir);
+    const lock = await acquireLock2(taskDir);
     if (!lock.acquired) {
-      return JSON.stringify({ error: "task_lock_unavailable" });
+      return JSON.stringify({ error: "task_lock_unavailable", retryable: true });
     }
+    let validatedTask;
     try {
       const taskId = generateTaskId();
       const task = {
@@ -132078,18 +132220,18 @@ async function handleCreate(args, config, ctx, context) {
         parentID: validatedArgs.parentID,
         threadID: context.sessionID
       };
-      const validatedTask = TaskObjectSchema.parse(task);
+      validatedTask = TaskObjectSchema.parse(task);
       writeJsonAtomic(join114(taskDir, `${taskId}.json`), validatedTask);
-      await syncTaskTodoUpdate(ctx, validatedTask, context.sessionID);
-      return JSON.stringify({
-        task: {
-          id: validatedTask.id,
-          subject: validatedTask.subject
-        }
-      });
     } finally {
       lock.release();
     }
+    await syncTaskTodoUpdate(ctx, validatedTask, context.sessionID);
+    return JSON.stringify({
+      task: {
+        id: validatedTask.id,
+        subject: validatedTask.subject
+      }
+    });
   } catch (error) {
     if (error instanceof Error && error.message.includes("Required")) {
       return JSON.stringify({
@@ -132223,6 +132365,44 @@ Properly managed dependencies enable maximum parallel execution.`,
     }
   });
 }
+function applyTaskUpdate(taskPath, input) {
+  const task = readJsonSafe(taskPath, TaskObjectSchema);
+  if (!task) {
+    return null;
+  }
+  if (input.subject !== undefined) {
+    task.subject = input.subject;
+  }
+  if (input.description !== undefined) {
+    task.description = input.description;
+  }
+  if (input.status !== undefined) {
+    task.status = input.status;
+  }
+  if (input.activeForm !== undefined) {
+    task.activeForm = input.activeForm;
+  }
+  if (input.owner !== undefined) {
+    task.owner = input.owner;
+  }
+  if (input.addBlocks) {
+    task.blocks = [...new Set([...task.blocks, ...input.addBlocks])];
+  }
+  if (input.addBlockedBy) {
+    task.blockedBy = [...new Set([...task.blockedBy, ...input.addBlockedBy])];
+  }
+  if (input.metadata !== undefined) {
+    task.metadata = { ...task.metadata, ...input.metadata };
+    Object.keys(task.metadata).forEach((key) => {
+      if (task.metadata?.[key] === null) {
+        delete task.metadata[key];
+      }
+    });
+  }
+  const updatedTask = TaskObjectSchema.parse(task);
+  writeJsonAtomic(taskPath, updatedTask);
+  return updatedTask;
+}
 async function handleUpdate(args, config, ctx, context) {
   try {
     const validatedArgs = TaskUpdateInputSchema.parse(args);
@@ -132231,54 +132411,21 @@ async function handleUpdate(args, config, ctx, context) {
       return JSON.stringify({ error: "invalid_task_id" });
     }
     const taskDir = getTaskDir(config);
-    const lock = acquireLock2(taskDir);
+    const lock = await acquireLock2(taskDir);
     if (!lock.acquired) {
-      return JSON.stringify({ error: "task_lock_unavailable" });
+      return JSON.stringify({ error: "task_lock_unavailable", retryable: true });
     }
+    let updatedTask = null;
     try {
-      const taskPath = join117(taskDir, `${taskId}.json`);
-      const task = readJsonSafe(taskPath, TaskObjectSchema);
-      if (!task) {
-        return JSON.stringify({ error: "task_not_found" });
-      }
-      if (validatedArgs.subject !== undefined) {
-        task.subject = validatedArgs.subject;
-      }
-      if (validatedArgs.description !== undefined) {
-        task.description = validatedArgs.description;
-      }
-      if (validatedArgs.status !== undefined) {
-        task.status = validatedArgs.status;
-      }
-      if (validatedArgs.activeForm !== undefined) {
-        task.activeForm = validatedArgs.activeForm;
-      }
-      if (validatedArgs.owner !== undefined) {
-        task.owner = validatedArgs.owner;
-      }
-      const addBlocks = args.addBlocks;
-      if (addBlocks) {
-        task.blocks = [...new Set([...task.blocks, ...addBlocks])];
-      }
-      const addBlockedBy = args.addBlockedBy;
-      if (addBlockedBy) {
-        task.blockedBy = [...new Set([...task.blockedBy, ...addBlockedBy])];
-      }
-      if (validatedArgs.metadata !== undefined) {
-        task.metadata = { ...task.metadata, ...validatedArgs.metadata };
-        Object.keys(task.metadata).forEach((key) => {
-          if (task.metadata?.[key] === null) {
-            delete task.metadata[key];
-          }
-        });
-      }
-      const validatedTask = TaskObjectSchema.parse(task);
-      writeJsonAtomic(taskPath, validatedTask);
-      await syncTaskTodoUpdate(ctx, validatedTask, context.sessionID);
-      return JSON.stringify({ task: validatedTask });
+      updatedTask = applyTaskUpdate(join117(taskDir, `${taskId}.json`), validatedArgs);
     } finally {
       lock.release();
     }
+    if (!updatedTask) {
+      return JSON.stringify({ error: "task_not_found" });
+    }
+    await syncTaskTodoUpdate(ctx, updatedTask, context.sessionID);
+    return JSON.stringify({ task: updatedTask });
   } catch (error) {
     if (error instanceof Error && error.message.includes("Required")) {
       return JSON.stringify({
@@ -134858,6 +135005,7 @@ async function tryFallbackRetry(args) {
     sessionPermission: task.sessionPermission,
     category: task.category,
     isUnstableAgent: task.isUnstableAgent,
+    cwd: task.cwd,
     onSessionCreated: task.onSessionCreated
   };
   if (previousSessionID) {
@@ -137330,6 +137478,7 @@ class BackgroundManager {
   queuesByKey = new Map;
   processingKeys = new Set;
   completionTimers = new Map;
+  syncAttachedSessions = new Set;
   completedTaskArchive = new Map;
   completedTaskSummaries = new Map;
   idleDeferralTimers = new Map;
@@ -137636,6 +137785,7 @@ class BackgroundManager {
         sessionPermission: input.sessionPermission,
         attemptCount: 0,
         category: input.category,
+        cwd: input.cwd,
         onSessionCreated: input.onSessionCreated
       };
       const firstAttempt = startAttempt(task, input.model);
@@ -137750,7 +137900,8 @@ class BackgroundManager {
       return null;
     });
     const parentDirectory = parentSession?.data?.directory ?? this.directory;
-    log2(`[background-agent] Parent dir: ${parentSession?.data?.directory}, using: ${parentDirectory}`);
+    const childDirectory = input.cwd ?? parentDirectory;
+    log2(`[background-agent] Parent dir: ${parentSession?.data?.directory}, using: ${childDirectory}`);
     const createResult = await this.client.session.create({
       body: {
         parentID: input.parentSessionId,
@@ -137765,7 +137916,7 @@ class BackgroundManager {
         } : {}
       },
       query: {
-        directory: parentDirectory
+        directory: childDirectory
       }
     });
     if (createResult.error) {
@@ -137816,7 +137967,7 @@ class BackgroundManager {
     task.concurrencyGroup = concurrencyKey;
     if (task.retryNotification) {
       const attemptNumber = boundAttempt.attemptNumber;
-      const retrySessionUrl = buildLocalSessionUrl(parentDirectory, sessionID);
+      const retrySessionUrl = buildLocalSessionUrl(childDirectory, sessionID);
       const previousAttempt = getPreviousAttempt(task, boundAttempt.attemptId);
       const failedSessionID = previousAttempt?.sessionId ?? task.retryNotification.previousSessionID;
       const failedSessionLine = failedSessionID ? `
@@ -137901,7 +138052,7 @@ The fallback retry session is now created and can be inspected directly.
     promptWithRetryInDirectory(this.client, {
       path: { id: sessionID },
       body: promptBody
-    }, parentDirectory).catch(async (error) => {
+    }, childDirectory).catch(async (error) => {
       if (isAgentNotFoundError(error) && input.agent !== FALLBACK_AGENT) {
         log2("[background-agent] Agent not found, retrying with fallback agent", {
           original: input.agent,
@@ -137927,7 +138078,7 @@ The fallback retry session is now created and can be inspected directly.
           await promptWithRetryInDirectory(this.client, {
             path: { id: sessionID },
             body: fallbackBody
-          }, parentDirectory);
+          }, childDirectory);
           task.agent = FALLBACK_AGENT;
           return;
         } catch (retryError) {
@@ -138057,6 +138208,19 @@ The fallback retry session is now created and can be inspected directly.
     }
     return;
   }
+  attachSyncContinuation(sessionID) {
+    this.syncAttachedSessions.add(sessionID);
+    return () => {
+      if (!this.syncAttachedSessions.delete(sessionID))
+        return;
+      const task = this.findBySession(sessionID);
+      if (!task || !TERMINAL_BACKGROUND_TASK_STATUSES.has(task.status))
+        return;
+      if (this.completionTimers.has(task.id))
+        return;
+      this.scheduleTaskRemoval(task.id);
+    };
+  }
   resolveTaskAttemptBySession(sessionID) {
     const task = this.findBySession(sessionID);
     if (!task) {
@@ -138247,7 +138411,7 @@ The fallback retry session is now created and can be inspected directly.
           })(),
           parts: [createInternalAgentTextPart(input.prompt)]
         },
-        query: { directory: this.directory }
+        query: { directory: existingTask.cwd ?? this.directory }
       }
     }).then((promptResult) => {
       if (promptResult.status === "failed") {
@@ -138984,6 +139148,8 @@ The task was re-queued on a fallback model after a retryable failure.
       const task = this.tasks.get(taskId);
       if (!task)
         return;
+      if (task.sessionId && this.syncAttachedSessions.has(task.sessionId))
+        return;
       if (task.parentSessionId) {
         const siblings = this.getTasksByParentSession(task.parentSessionId);
         const runningOrPendingSiblings = siblings.filter((sibling) => sibling.id !== taskId && (sibling.status === "running" || sibling.status === "pending"));
@@ -139622,6 +139788,7 @@ The task was re-queued on a fallback model after a retryable failure.
       clearTimeout(timer);
     }
     this.completionTimers.clear();
+    this.syncAttachedSessions.clear();
     for (const timer of this.idleDeferralTimers.values()) {
       clearTimeout(timer);
     }
@@ -169753,6 +169920,7 @@ async function createTeamRun(spec, leadSessionId, ctx, config, bgMgr, tmuxMgr, o
             skillContent: resolvedMember.systemContent,
             category: member.kind === "category" ? member.category : undefined,
             sessionPermission: QUESTION_DENIED_SESSION_PERMISSION,
+            ...resource.worktreePath ? { cwd: resource.worktreePath } : {},
             onSessionCreated: async (sessionId) => {
               registerTeamSession(sessionId, {
                 teamRunId: runtimeState.teamRunId,
@@ -171589,6 +171757,7 @@ init_logger2();
 // packages/omo-opencode/src/plugin/stop-continuation.ts
 function stopContinuation(args) {
   const { directory, hooks, sessionID } = args;
+  hooks.keywordDetector?.clearSession?.(sessionID);
   hooks.stopContinuationGuard?.stop?.(sessionID);
   hooks.todoContinuationEnforcer?.cancelAllCountdowns();
   hooks.goal?.clearGoal(sessionID);
@@ -171928,9 +172097,16 @@ function toCanonicalModel(model) {
     return model.id;
   return `${model.providerID}/${model.id}`;
 }
-function createSystemTransformHandler(defaultMode, getUltraworkMessage) {
+function createSystemTransformHandler(defaultMode, getUltraworkMessage, ultraworkRestoration) {
   return async (input, output) => {
     reconcileSisyphusRuntimePrompt(output.system, toCanonicalModel(input.model));
+    const restoredGuidance = input.sessionID ? ultraworkRestoration?.getSystemTransformGuidance?.(input.sessionID, input.model?.id) : undefined;
+    if (restoredGuidance) {
+      if (!output.system.some((part) => part.includes(ULTRAWORK_MODE_TAG))) {
+        output.system.push(restoredGuidance);
+      }
+      return;
+    }
     if (!defaultMode?.ultrawork || !getUltraworkMessage)
       return;
     if (output.system.some((part) => part.includes(ULTRAWORK_MODE_TAG)))
@@ -172103,6 +172279,7 @@ function createEventHookDispatcher(hooks, runEventHookSafely) {
     await runEventHookSafely("directoryAgentsInjector", hooks.directoryAgentsInjector?.event, input);
     await runEventHookSafely("directoryReadmeInjector", hooks.directoryReadmeInjector?.event, input);
     await runEventHookSafely("rulesInjector", hooks.rulesInjector?.event, input);
+    await runEventHookSafely("keywordDetector", hooks.keywordDetector?.event, input);
     await runEventHookSafely("hephaestusAgentsMdInjector", hooks.hephaestusAgentsMdInjector?.event, input);
     await runEventHookSafely("thinkMode", hooks.thinkMode?.event, input);
     await runEventHookSafely("anthropicContextWindowLimitRecovery", hooks.anthropicContextWindowLimitRecovery?.event, input);
@@ -173663,7 +173840,7 @@ function createPluginInterface(args) {
     "experimental.chat.messages.transform": createMessagesTransformHandler({
       hooks
     }),
-    "experimental.chat.system.transform": createSystemTransformHandler(pluginConfig.default_mode, getUltraworkMessage),
+    "experimental.chat.system.transform": createSystemTransformHandler(pluginConfig.default_mode, getUltraworkMessage, hooks.keywordDetector),
     config: managers.configHandler,
     event: createEventHandler2({
       ctx,
@@ -174410,7 +174587,7 @@ async function killTargets(targets, options, config) {
     const terminated = await safelyTerminate(target.pid, context);
     if (!terminated)
       continue;
-    await delay5(options.graceMs ?? DEFAULT_GRACE_MS);
+    await delay6(options.graceMs ?? DEFAULT_GRACE_MS);
     if (!await context.killer.isAlive(target.pid)) {
       killed.push(target);
       continue;
@@ -174469,7 +174646,7 @@ function writeSweepStamp(stampFile, nowMs) {
   const stampDate = new Date(nowMs);
   utimesSync(stampFile, stampDate, stampDate);
 }
-function delay5(ms) {
+function delay6(ms) {
   if (ms <= 0)
     return Promise.resolve();
   return new Promise((resolvePromise) => {