@heidi-dang/oh-my-opencode 3.12.4 → 3.13.0

package/dist/cli/index.js

@@ -6294,142 +6294,140 @@ var init_binary_downloader = __esm(() => {
 });
 
 // src/shared/model-requirements.ts
-var AGENT_MODEL_REQUIREMENTS, CATEGORY_MODEL_REQUIREMENTS;
+var DEFAULT_AGENT_MODEL_REQUIREMENTS, DEFAULT_CATEGORY_MODEL_REQUIREMENTS, AGENT_MODEL_REQUIREMENTS, CATEGORY_MODEL_REQUIREMENTS;
 var init_model_requirements = __esm(() => {
-  AGENT_MODEL_REQUIREMENTS = {
+  DEFAULT_AGENT_MODEL_REQUIREMENTS = {
     sisyphus: {
       fallbackChain: [
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-6", variant: "max" },
-        { providers: ["zai-coding-plan", "opencode"], model: "glm-5" },
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-3-5-sonnet", variant: "max" },
         { providers: ["opencode"], model: "big-pickle" }
       ],
       requiresAnyModel: true
     },
     hephaestus: {
       fallbackChain: [
-        { providers: ["openai", "venice", "opencode"], model: "gpt-5.3-codex", variant: "medium" },
-        { providers: ["github-copilot"], model: "gpt-5.2", variant: "medium" }
+        { providers: ["openai", "opencode"], model: "gpt-4o", variant: "medium" },
+        { providers: ["anthropic", "opencode"], model: "claude-3-5-sonnet", variant: "max" }
       ],
-      requiresProvider: ["openai", "github-copilot", "venice", "opencode"]
+      requiresAnyModel: true
     },
     oracle: {
       fallbackChain: [
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3.1-pro", variant: "high" },
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-6", variant: "max" }
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-4o", variant: "high" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-1.5-pro", variant: "high" },
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-3-5-sonnet", variant: "max" }
       ]
     },
     librarian: {
       fallbackChain: [
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" },
-        { providers: ["opencode"], model: "minimax-m2.5-free" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-1.5-flash" },
+        { providers: ["opencode"], model: "minimax-text-01" },
         { providers: ["opencode"], model: "big-pickle" }
       ]
     },
     explore: {
       fallbackChain: [
-        { providers: ["github-copilot"], model: "grok-code-fast-1" },
-        { providers: ["opencode"], model: "minimax-m2.5-free" },
-        { providers: ["anthropic", "opencode"], model: "claude-haiku-4-5" },
-        { providers: ["opencode"], model: "gpt-5-nano" }
+        { providers: ["github-copilot"], model: "gpt-4o-mini" },
+        { providers: ["opencode"], model: "minimax-text-01" },
+        { providers: ["anthropic", "opencode"], model: "claude-3-5-haiku" },
+        { providers: ["opencode"], model: "gpt-4o-mini" }
       ]
     },
     "multimodal-looker": {
       fallbackChain: [
-        { providers: ["openai", "opencode"], model: "gpt-5.3-codex", variant: "medium" },
-        { providers: ["kimi-for-coding"], model: "k2p5" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" },
-        { providers: ["zai-coding-plan"], model: "glm-4.6v" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5-nano" }
+        { providers: ["openai", "opencode"], model: "gpt-4o", variant: "medium" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-1.5-flash" },
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-4o-mini" }
       ]
     },
     prometheus: {
       fallbackChain: [
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-6", variant: "max" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3.1-pro" }
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-3-5-sonnet", variant: "max" },
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-4o", variant: "high" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-1.5-pro" }
       ]
     },
     metis: {
       fallbackChain: [
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-6", variant: "max" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3.1-pro", variant: "high" }
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-3-5-sonnet", variant: "max" },
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-4o", variant: "high" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-1.5-pro", variant: "high" }
       ]
     },
     momus: {
       fallbackChain: [
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "medium" },
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-6", variant: "max" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3.1-pro", variant: "high" }
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-4o", variant: "medium" },
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-3-5-sonnet", variant: "max" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-1.5-pro", variant: "high" }
       ]
     },
     atlas: {
       fallbackChain: [
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-6" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2" }
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-3-5-sonnet" },
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-4o" }
       ]
     }
   };
-  CATEGORY_MODEL_REQUIREMENTS = {
+  DEFAULT_CATEGORY_MODEL_REQUIREMENTS = {
     "visual-engineering": {
       fallbackChain: [
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3.1-pro", variant: "high" },
-        { providers: ["zai-coding-plan", "opencode"], model: "glm-5" },
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-6", variant: "max" }
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-1.5-pro", variant: "high" },
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-3-5-sonnet", variant: "max" }
       ]
     },
     ultrabrain: {
       fallbackChain: [
-        { providers: ["openai", "opencode"], model: "gpt-5.3-codex", variant: "xhigh" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3.1-pro", variant: "high" },
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-6", variant: "max" }
+        { providers: ["openai", "opencode"], model: "o3-mini", variant: "xhigh" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-1.5-pro", variant: "high" },
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-3-5-sonnet", variant: "max" }
       ]
     },
     deep: {
       fallbackChain: [
-        { providers: ["openai", "opencode"], model: "gpt-5.3-codex", variant: "medium" },
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-6", variant: "max" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3.1-pro", variant: "high" }
+        { providers: ["openai", "opencode"], model: "o3-mini", variant: "medium" },
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-3-5-sonnet", variant: "max" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-1.5-pro", variant: "high" }
       ],
-      requiresModel: "gpt-5.3-codex"
+      requiresModel: "o3-mini"
     },
     artistry: {
       fallbackChain: [
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3.1-pro", variant: "high" },
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-6", variant: "max" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2" }
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-1.5-pro", variant: "high" },
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-3-5-sonnet", variant: "max" },
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-4o" }
       ],
-      requiresModel: "gemini-3.1-pro"
+      requiresModel: "gemini-1.5-pro"
     },
     quick: {
       fallbackChain: [
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-haiku-4-5" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" },
-        { providers: ["opencode"], model: "gpt-5-nano" }
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-3-5-haiku" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-1.5-flash" },
+        { providers: ["opencode"], model: "gpt-4o-mini" }
       ]
     },
     "unspecified-low": {
       fallbackChain: [
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-6" },
-        { providers: ["openai", "opencode"], model: "gpt-5.3-codex", variant: "medium" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" }
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-3-5-sonnet" },
+        { providers: ["openai", "opencode"], model: "gpt-4o", variant: "medium" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-1.5-flash" }
       ]
     },
     "unspecified-high": {
       fallbackChain: [
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-6", variant: "max" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3.1-pro" }
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-3-5-sonnet", variant: "max" },
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-4o", variant: "high" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-1.5-pro" }
       ]
     },
     writing: {
       fallbackChain: [
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" },
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-6" }
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-1.5-flash" },
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-3-5-sonnet" }
       ]
     }
   };
+  AGENT_MODEL_REQUIREMENTS = DEFAULT_AGENT_MODEL_REQUIREMENTS;
+  CATEGORY_MODEL_REQUIREMENTS = DEFAULT_CATEGORY_MODEL_REQUIREMENTS;
 });
 
 // src/shared/agent-variant.ts
@@ -6447,8 +6445,15 @@ var init_system_directive = () => {};
 
 // src/shared/agent-tool-restrictions.ts
 var init_agent_tool_restrictions = () => {};
+
+// src/shared/model-normalization.ts
+function normalizeModel(model) {
+  const trimmed = model?.trim();
+  return trimmed || undefined;
+}
+
 // src/shared/connected-providers-cache.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync, statSync } from "fs";
 import { join as join4 } from "path";
 function getCacheFilePath(filename) {
   return join4(getOmoOpenCodeCacheDir(), filename);
@@ -6459,6 +6464,30 @@ function ensureCacheDir() {
     mkdirSync(cacheDir, { recursive: true });
   }
 }
+function readConnectedProvidersCache() {
+  const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
+  if (!existsSync3(cacheFile)) {
+    memoryConnectedProviders = null;
+    memoryConnectedProvidersMtime = 0;
+    log("[connected-providers-cache] Cache file not found", { cacheFile });
+    return null;
+  }
+  try {
+    const mtime = statSync(cacheFile).mtimeMs;
+    if (memoryConnectedProviders && memoryConnectedProvidersMtime === mtime) {
+      return memoryConnectedProviders;
+    }
+    const content = readFileSync2(cacheFile, "utf-8");
+    const data = JSON.parse(content);
+    memoryConnectedProviders = data.connected;
+    memoryConnectedProvidersMtime = mtime;
+    log("[connected-providers-cache] Read cache", { count: data.connected.length, updatedAt: data.updatedAt });
+    return data.connected;
+  } catch (err) {
+    log("[connected-providers-cache] Error reading cache", { error: String(err) });
+    return null;
+  }
+}
 function writeConnectedProvidersCache(connected) {
   ensureCacheDir();
   const cacheFile = getCacheFilePath(CONNECTED_PROVIDERS_CACHE_FILE);
@@ -6468,6 +6497,7 @@ function writeConnectedProvidersCache(connected) {
   };
   try {
     writeFileSync2(cacheFile, JSON.stringify(data, null, 2));
+    memoryConnectedProviders = null;
     log("[connected-providers-cache] Cache written", { count: connected.length });
   } catch (err) {
     log("[connected-providers-cache] Error writing cache", { error: String(err) });
@@ -6486,6 +6516,7 @@ function writeProviderModelsCache(data) {
   };
   try {
     writeFileSync2(cacheFile, JSON.stringify(cacheData, null, 2));
+    memoryProviderModels = null;
     log("[connected-providers-cache] Provider-models cache written", {
       providerCount: Object.keys(data.models).length
     });
@@ -6525,15 +6556,62 @@ async function updateConnectedProvidersCache(client) {
     log("[connected-providers-cache] Error updating cache", { error: String(err) });
   }
 }
-var CONNECTED_PROVIDERS_CACHE_FILE = "connected-providers.json", PROVIDER_MODELS_CACHE_FILE = "provider-models.json";
+var CONNECTED_PROVIDERS_CACHE_FILE = "connected-providers.json", PROVIDER_MODELS_CACHE_FILE = "provider-models.json", memoryConnectedProviders = null, memoryConnectedProvidersMtime = 0, memoryProviderModels = null;
 var init_connected_providers_cache = __esm(() => {
   init_logger();
   init_data_path();
 });
 
 // src/shared/model-availability.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
 import { join as join5 } from "path";
+function normalizeModelName(name) {
+  return name.toLowerCase().replace(/claude-(opus|sonnet|haiku)-(\d+)[.-](\d+)/g, "claude-$1-$2.$3");
+}
+function fuzzyMatchModel(target, available, providers) {
+  log("[fuzzyMatchModel] called", { target, availableCount: available.size, providers });
+  if (available.size === 0) {
+    log("[fuzzyMatchModel] empty available set");
+    return null;
+  }
+  const targetNormalized = normalizeModelName(target);
+  let candidates = Array.from(available);
+  if (providers && providers.length > 0) {
+    const providerSet = new Set(providers);
+    candidates = candidates.filter((model) => {
+      const [provider] = model.split("/");
+      return providerSet.has(provider);
+    });
+    log("[fuzzyMatchModel] filtered by providers", { candidateCount: candidates.length, candidates: candidates.slice(0, 10) });
+  }
+  if (candidates.length === 0) {
+    log("[fuzzyMatchModel] no candidates after filter");
+    return null;
+  }
+  const matches = candidates.filter((model) => normalizeModelName(model).includes(targetNormalized));
+  log("[fuzzyMatchModel] substring matches", { targetNormalized, matchCount: matches.length, matches });
+  if (matches.length === 0) {
+    log("[fuzzyMatchModel] WARNING: no match found", { target, availableCount: available.size, providers });
+    return null;
+  }
+  const exactMatch = matches.find((model) => normalizeModelName(model) === targetNormalized);
+  if (exactMatch) {
+    log("[fuzzyMatchModel] exact match found", { exactMatch });
+    return exactMatch;
+  }
+  const exactModelIdMatches = matches.filter((model) => {
+    const modelId = model.split("/").slice(1).join("/");
+    return normalizeModelName(modelId) === targetNormalized;
+  });
+  if (exactModelIdMatches.length > 0) {
+    const result2 = exactModelIdMatches.reduce((shortest, current) => current.length < shortest.length ? current : shortest);
+    log("[fuzzyMatchModel] exact model ID match found", { result: result2, candidateCount: exactModelIdMatches.length });
+    return result2;
+  }
+  const result = matches.reduce((shortest, current) => current.length < shortest.length ? current : shortest);
+  log("[fuzzyMatchModel] shortest match", { result });
+  return result;
+}
 function isModelCacheAvailable() {
   if (hasProviderModelsCache()) {
     return true;
@@ -6559,6 +6637,113 @@ function transformModelForProvider(provider, model) {
 }
 
 // src/shared/model-resolution-pipeline.ts
+function resolveModelPipeline(request) {
+  const attempted = [];
+  const { intent, constraints, policy } = request;
+  const availableModels = constraints.availableModels;
+  const fallbackChain = policy?.fallbackChain;
+  const systemDefaultModel = policy?.systemDefaultModel;
+  const tryResolve = (model, provenance = "override") => {
+    const normalized = normalizeModel(model);
+    if (!normalized)
+      return;
+    attempted.push(normalized);
+    if (availableModels.size > 0) {
+      const parts = normalized.split("/");
+      const providerHint = parts.length >= 2 ? [parts[0]] : undefined;
+      const match = fuzzyMatchModel(normalized, availableModels, providerHint);
+      if (match) {
+        log(`[MODEL-RESOLUTION] Resolved via ${provenance}`, { requested: normalized, resolved: match });
+        return { model: match, provenance, attempted };
+      }
+      log(`[MODEL-RESOLUTION] Requested model not available in current providers`, { requested: normalized, provenance });
+      return;
+    } else {
+      log(`[MODEL-RESOLUTION] Resolved via ${provenance} (no availability cache)`, { model: normalized });
+      return { model: normalized, provenance, attempted };
+    }
+  };
+  const uiResult = tryResolve(intent?.uiSelectedModel);
+  if (uiResult)
+    return uiResult;
+  const userResult = tryResolve(intent?.userModel);
+  if (userResult)
+    return userResult;
+  const userFallbackResult = tryResolve(intent?.userFallbackModel, "user-fallback");
+  if (userFallbackResult)
+    return userFallbackResult;
+  const sessionResult = tryResolve(intent?.sessionModel);
+  if (sessionResult)
+    return sessionResult;
+  const categoryResult = tryResolve(intent?.categoryDefaultModel, "category-default");
+  if (categoryResult)
+    return categoryResult;
+  const categoryFallbackResult = tryResolve(intent?.categoryFallbackModel, "category-default");
+  if (categoryFallbackResult)
+    return categoryFallbackResult;
+  const userFallbackModels = intent?.userFallbackModels;
+  if (userFallbackModels && userFallbackModels.length > 0) {
+    for (const model of userFallbackModels) {
+      const res = tryResolve(model, "user-fallback");
+      if (res)
+        return res;
+    }
+  }
+  if (fallbackChain && fallbackChain.length > 0) {
+    if (availableModels.size === 0) {
+      const connectedProviders = constraints.connectedProviders ?? readConnectedProvidersCache();
+      const connectedSet = connectedProviders ? new Set(connectedProviders) : null;
+      if (connectedSet !== null) {
+        for (const entry of fallbackChain) {
+          for (const provider of entry.providers) {
+            if (connectedSet.has(provider)) {
+              const transformedModelId = transformModelForProvider(provider, entry.model);
+              const model = `${provider}/${transformedModelId}`;
+              log("[MODEL-RESOLUTION] Resolved via provider-specific fallback chain (no cache)", {
+                provider,
+                model: transformedModelId
+              });
+              return {
+                model,
+                provenance: "provider-fallback",
+                variant: entry.variant,
+                attempted
+              };
+            }
+          }
+        }
+      }
+    } else {
+      for (const entry of fallbackChain) {
+        for (const provider of entry.providers) {
+          const fullModel = `${provider}/${entry.model}`;
+          const match = fuzzyMatchModel(fullModel, availableModels, [provider]);
+          if (match) {
+            log("[MODEL-RESOLUTION] Resolved via provider-specific fallback chain", {
+              provider,
+              model: entry.model,
+              match
+            });
+            return {
+              model: match,
+              provenance: "provider-fallback",
+              variant: entry.variant,
+              attempted
+            };
+          }
+        }
+      }
+    }
+  }
+  const systemDefaultResult = tryResolve(systemDefaultModel, "system-default");
+  if (systemDefaultResult)
+    return systemDefaultResult;
+  const systemDefaultFallbackResult = tryResolve(policy?.systemDefaultFallbackModel, "system-default");
+  if (systemDefaultFallbackResult)
+    return systemDefaultFallbackResult;
+  log("[MODEL-RESOLUTION] FAILED to resolve any supported model", { attempted });
+  return;
+}
 var init_model_resolution_pipeline = __esm(() => {
   init_logger();
   init_connected_providers_cache();
@@ -6570,6 +6755,39 @@ var init_model_resolver = __esm(() => {
   init_model_resolution_pipeline();
 });
 
+// src/shared/model-resolution-tracker.ts
+class ModelResolutionTracker {
+  lastResolved = new Map;
+  resolve(contextKey, request) {
+    const result = resolveModelPipeline(request);
+    if (!result)
+      return;
+    const previousVisibleModel = this.lastResolved.get(contextKey);
+    const currentModel = result.model;
+    if (currentModel !== previousVisibleModel) {
+      this.lastResolved.set(contextKey, currentModel);
+      if (true) {
+        console.log(`[MODEL-RESOLUTION] [${contextKey}] Resolved to: ${currentModel} (via ${result.provenance})`);
+      }
+      log(`Model resolution changed for ${contextKey}`, {
+        model: currentModel,
+        provenance: result.provenance,
+        previous: previousVisibleModel
+      });
+    }
+    return result;
+  }
+  clear(contextKey) {
+    this.lastResolved.delete(contextKey);
+  }
+}
+var modelResolutionTracker;
+var init_model_resolution_tracker = __esm(() => {
+  init_model_resolution_pipeline();
+  init_logger();
+  modelResolutionTracker = new ModelResolutionTracker;
+});
+
 // src/shared/fallback-model-availability.ts
 var init_fallback_model_availability = __esm(() => {
   init_connected_providers_cache();
@@ -6877,11 +7095,84 @@ var init_session_category_registry = __esm(() => {
   sessionCategoryMap = new Map;
 });
 
+// src/shared/verify-task-completion.ts
+async function verifyTaskCompletionState(client, sessionID) {
+  try {
+    const response = await client.session.messages({
+      path: { id: sessionID }
+    });
+    const messages = normalizeSDKResponse(response, [], { preferResponseOnMissingData: true });
+    let lastCompleteTaskIndex = -1;
+    let lastCompleteTaskPart = null;
+    for (let i2 = messages.length - 1;i2 >= 0; i2--) {
+      const msg = messages[i2];
+      if (msg.info?.role === "assistant" || msg.info?.role === "tool") {
+        const parts = msg.parts ?? [];
+        for (const p of parts) {
+          if (p.type === "tool" && (p.toolName === "complete_task" || p.name === "complete_task" || p.tool === "complete_task")) {
+            lastCompleteTaskIndex = i2;
+            lastCompleteTaskPart = p;
+            break;
+          }
+        }
+      }
+      if (lastCompleteTaskIndex !== -1)
+        break;
+    }
+    if (lastCompleteTaskIndex !== -1 && lastCompleteTaskPart) {
+      let hasErrorResult = false;
+      let foundResult = false;
+      if (lastCompleteTaskPart.state && (lastCompleteTaskPart.state.status === "completed" || lastCompleteTaskPart.state.status === "error")) {
+        foundResult = true;
+        const output = typeof lastCompleteTaskPart.state.output === "string" ? lastCompleteTaskPart.state.output : JSON.stringify(lastCompleteTaskPart.state.output || "");
+        if (output.includes("[ERROR] TASK COMPLETION REJECTED") || output.includes("[ERROR] STRICT ISSUE RESOLUTION MODE") || output.includes("explicitly failed") || lastCompleteTaskPart.state.status === "error") {
+          hasErrorResult = true;
+        }
+      }
+      if (!foundResult) {
+        for (let i2 = lastCompleteTaskIndex + 1;i2 < messages.length; i2++) {
+          const msg = messages[i2];
+          if (msg.info?.role === "user" || msg.info?.role === "tool") {
+            const parts = msg.parts ?? [];
+            for (const p of parts) {
+              if (p.type === "tool_result" || p.type === "tool") {
+                foundResult = true;
+                const content = typeof p.content === "string" ? p.content : typeof p.state?.output === "string" ? p.state.output : JSON.stringify(p.content || p.state?.output || "");
+                if (content.includes("[ERROR] TASK COMPLETION REJECTED") || content.includes("[ERROR] STRICT ISSUE RESOLUTION MODE") || content.includes("explicitly failed") || p.state?.status === "error") {
+                  hasErrorResult = true;
+                }
+              } else if (p.type === "text" && typeof p.text === "string" && p.text.includes("[tool result]")) {
+                if (p.text.includes("[ERROR] TASK COMPLETION REJECTED") || p.text.includes("[ERROR] STRICT ISSUE RESOLUTION MODE") || p.text.includes("explicitly failed")) {
+                  foundResult = true;
+                  hasErrorResult = true;
+                }
+              }
+            }
+          }
+        }
+      }
+      if (foundResult && hasErrorResult) {
+        log("[verifyTaskCompletionState] Rejected completion because the last complete_task call failed:", sessionID);
+        return false;
+      }
+    }
+    return true;
+  } catch (error) {
+    log("[verifyTaskCompletionState] Error verifying task completion state, defaulting to true:", error);
+    return true;
+  }
+}
+var init_verify_task_completion = __esm(() => {
+  init_logger();
+});
+
 // src/shared/index.ts
 var init_shared = __esm(() => {
   init_model_resolver();
   init_model_resolution_pipeline();
+  init_model_resolution_tracker();
   init_session_category_registry();
+  init_verify_task_completion();
   init_frontmatter();
   init_command_executor();
   init_file_reference_resolver();
@@ -7056,13 +7347,13 @@ var init_opencode_config_format = __esm(() => {
 });
 
 // src/cli/config-manager/parse-opencode-config-file.ts
-import { readFileSync as readFileSync4, statSync } from "fs";
+import { readFileSync as readFileSync4, statSync as statSync3 } from "fs";
 function isEmptyOrWhitespace(content) {
   return content.trim().length === 0;
 }
 function parseOpenCodeConfigFileWithError(path3) {
   try {
-    const stat = statSync(path3);
+    const stat = statSync3(path3);
     if (stat.size === 0) {
       return { config: null, error: `Config file is empty: ${path3}. Delete it or add valid JSON content.` };
     }
@@ -7183,9 +7474,10 @@ var init_model_fallback_requirements = __esm(() => {
     },
     hephaestus: {
       fallbackChain: [
-        { providers: ["openai", "opencode"], model: "gpt-5.3-codex", variant: "medium" }
+        { providers: ["openai", "opencode"], model: "gpt-5.3-codex", variant: "medium" },
+        { providers: ["opencode"], model: "claude-opus-4-6", variant: "max" }
       ],
-      requiresProvider: ["openai", "opencode"]
+      requiresAnyModel: true
     },
     oracle: {
       fallbackChain: [
@@ -7270,8 +7562,7 @@ var init_model_fallback_requirements = __esm(() => {
         { providers: ["openai", "opencode"], model: "gpt-5.3-codex", variant: "medium" },
         { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-6", variant: "max" },
         { providers: ["google", "github-copilot", "opencode"], model: "gemini-3.1-pro", variant: "high" }
-      ],
-      requiresModel: "gpt-5.3-codex"
+      ]
     },
     artistry: {
       fallbackChain: [
@@ -7385,7 +7676,7 @@ function generateModelConfig(config) {
   if (!hasAnyProvider) {
     return {
       $schema: SCHEMA_URL,
-      agents: Object.fromEntries(Object.entries(CLI_AGENT_MODEL_REQUIREMENTS).filter(([role, req]) => !(role === "sisyphus" && req.requiresAnyModel)).map(([role]) => [role, { model: ULTIMATE_FALLBACK }])),
+      agents: Object.fromEntries(Object.entries(CLI_AGENT_MODEL_REQUIREMENTS).filter(([_, req]) => !req.requiresAnyModel).map(([role]) => [role, { model: ULTIMATE_FALLBACK }])),
       categories: Object.fromEntries(Object.keys(CLI_CATEGORY_MODEL_REQUIREMENTS).map((cat) => [cat, { model: ULTIMATE_FALLBACK }]))
     };
   }
@@ -7430,7 +7721,7 @@ function generateModelConfig(config) {
     if (resolved) {
       const variant = resolved.variant ?? req.variant;
       agents[role] = variant ? { model: resolved.model, variant } : { model: resolved.model };
-    } else {
+    } else if (!req.requiresAnyModel) {
       agents[role] = { model: ULTIMATE_FALLBACK };
     }
   }
@@ -7488,7 +7779,7 @@ function deepMergeRecord(target, source) {
 }
 
 // src/cli/config-manager/write-omo-config.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6, statSync as statSync4, writeFileSync as writeFileSync4 } from "fs";
 function isEmptyOrWhitespace2(content) {
   return content.trim().length === 0;
 }
@@ -7507,7 +7798,7 @@ function writeOmoConfig(installConfig) {
     const newConfig = generateOmoConfig(installConfig);
     if (existsSync7(omoConfigPath)) {
       try {
-        const stat = statSync2(omoConfigPath);
+        const stat = statSync4(omoConfigPath);
         const content = readFileSync6(omoConfigPath, "utf-8");
         if (stat.size === 0 || isEmptyOrWhitespace2(content)) {
           writeFileSync4(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
@@ -8633,7 +8924,7 @@ var {
 // package.json
 var package_default = {
   name: "@heidi-dang/oh-my-opencode",
-  version: "3.12.4",
+  version: "3.13.0",
   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",
@@ -8699,30 +8990,31 @@ var package_default = {
     picocolors: "^1.1.1",
     picomatch: "^4.0.2",
     "vscode-jsonrpc": "^8.2.0",
-    zod: "^4.1.8"
+    zod: "^4.1.8",
+    playwright: "^1.58.2"
   },
   devDependencies: {
     "@types/js-yaml": "^4.0.9",
     "@types/picomatch": "^3.0.2",
     "bun-types": "1.3.6",
-    typescript: "^5.7.3",
-    playwright: "^1.58.2"
+    typescript: "^5.7.3"
   },
   optionalDependencies: {
-    "@heidi-dang/oh-my-opencode-darwin-arm64": "3.12.4",
-    "@heidi-dang/oh-my-opencode-darwin-x64": "3.12.4",
-    "@heidi-dang/oh-my-opencode-darwin-x64-baseline": "3.12.4",
-    "@heidi-dang/oh-my-opencode-linux-arm64": "3.12.4",
-    "@heidi-dang/oh-my-opencode-linux-arm64-musl": "3.12.4",
-    "@heidi-dang/oh-my-opencode-linux-x64": "3.12.4",
-    "@heidi-dang/oh-my-opencode-linux-x64-baseline": "3.12.4",
-    "@heidi-dang/oh-my-opencode-linux-x64-musl": "3.12.4",
-    "@heidi-dang/oh-my-opencode-linux-x64-musl-baseline": "3.12.4",
-    "@heidi-dang/oh-my-opencode-windows-x64": "3.12.4",
-    "@heidi-dang/oh-my-opencode-windows-x64-baseline": "3.12.4"
+    "@heidi-dang/oh-my-opencode-darwin-arm64": "3.12.5",
+    "@heidi-dang/oh-my-opencode-darwin-x64": "3.12.5",
+    "@heidi-dang/oh-my-opencode-darwin-x64-baseline": "3.12.5",
+    "@heidi-dang/oh-my-opencode-linux-arm64": "3.12.5",
+    "@heidi-dang/oh-my-opencode-linux-arm64-musl": "3.12.5",
+    "@heidi-dang/oh-my-opencode-linux-x64": "3.12.5",
+    "@heidi-dang/oh-my-opencode-linux-x64-baseline": "3.12.5",
+    "@heidi-dang/oh-my-opencode-linux-x64-musl": "3.12.5",
+    "@heidi-dang/oh-my-opencode-linux-x64-musl-baseline": "3.12.5",
+    "@heidi-dang/oh-my-opencode-windows-x64": "3.12.5",
+    "@heidi-dang/oh-my-opencode-windows-x64-baseline": "3.12.5"
   },
   overrides: {
-    "@opencode-ai/sdk": "^1.2.17"
+    "@opencode-ai/sdk": "^1.2.17",
+    zod: "^4.1.8"
   },
   trustedDependencies: [
     "@ast-grep/cli",
@@ -9754,39 +10046,274 @@ function loadDefaultConfig() {
 `;
 }
 var EMBEDDED_DEFAULT_CONFIG = {
-  $schema: "https://raw.githubusercontent.com/heidi-dang/oh-my-opencode/refs/heads/dev/assets/oh-my-opencode.schema.json",
+  $schema: "https://raw.githubusercontent.com/code-yeongyu/oh-my-opencode/dev/assets/oh-my-opencode.schema.json",
+  new_task_system_enabled: true,
+  default_run_agent: "sisyphus",
+  hashline_edit: true,
+  model_fallback: true,
+  fallback_model: "github-copilot/gpt-5-mini",
+  disabled_skills: [],
+  disabled_hooks: [],
+  disabled_tools: [],
+  disabled_commands: [],
+  experimental: {
+    aggressive_truncation: true,
+    auto_resume: true,
+    preemptive_compaction: true,
+    truncate_all_tool_outputs: true,
+    task_system: true,
+    safe_hook_creation: true,
+    disable_omo_env: false,
+    hashline_edit: true,
+    model_fallback_title: true,
+    dynamic_context_pruning: {
+      enabled: true,
+      notification: "minimal",
+      turn_protection: {
+        enabled: true,
+        turns: 3
+      },
+      protected_tools: [
+        "task",
+        "todowrite",
+        "todoread",
+        "lsp_rename",
+        "session_read",
+        "session_write",
+        "session_search"
+      ],
+      strategies: {
+        deduplication: {
+          enabled: true
+        },
+        supersede_writes: {
+          enabled: true,
+          aggressive: false
+        },
+        purge_errors: {
+          enabled: true,
+          turns: 5
+        }
+      }
+    }
+  },
+  runtime_fallback: {
+    enabled: true,
+    max_fallback_attempts: 2,
+    cooldown_seconds: 8,
+    timeout_seconds: 45,
+    notify_on_fallback: true
+  },
+  background_task: {
+    defaultConcurrency: 2,
+    providerConcurrency: {
+      xai: 2,
+      "github-copilot": 2,
+      "opencode-go": 1
+    },
+    modelConcurrency: {
+      "xai/grok-4-1-fast": 2,
+      "xai/grok-4-1-fast-non-reasoning": 2,
+      "github-copilot/gpt-5-mini": 2,
+      "opencode-go/minimax-m2.5": 1
+    },
+    staleTimeoutMs: 120000,
+    messageStalenessTimeoutMs: 120000,
+    syncPollTimeoutMs: 120000
+  },
+  babysitting: {
+    timeout_ms: 120000
+  },
+  browser_automation_engine: {
+    provider: "playwright"
+  },
+  sisyphus_agent: {
+    disabled: false,
+    default_builder_enabled: true,
+    planner_enabled: true,
+    replace_plan: false
+  },
   agents: {
     sisyphus: {
       model: "xai/grok-4-1-fast",
-      ultrawork: { model: "xai/grok-4-1-fast", variant: "max" }
+      fallback_model: "github-copilot/gpt-5-mini",
+      reasoningEffort: "medium",
+      textVerbosity: "medium",
+      temperature: 0.2,
+      top_p: 0.95,
+      maxTokens: 120000,
+      thinking: {
+        type: "enabled",
+        budgetTokens: 24000
+      },
+      mode: "primary",
+      description: "Main orchestrator. Strong planning, routing, and repo-wide coordination."
+    },
+    plan: {
+      model: "xai/grok-4-1-fast",
+      fallback_model: "github-copilot/gpt-5-mini",
+      reasoningEffort: "high",
+      textVerbosity: "medium",
+      temperature: 0.1,
+      top_p: 0.9,
+      maxTokens: 64000,
+      thinking: {
+        type: "enabled",
+        budgetTokens: 32000
+      },
+      mode: "all",
+      description: "Deterministic planner. Keep conservative and low-noise."
+    },
+    build: {
+      model: "xai/grok-4-1-fast-non-reasoning",
+      fallback_models: [
+        "github-copilot/gpt-5-mini",
+        "opencode-go/minimax-m2.5"
+      ],
+      reasoningEffort: "low",
+      textVerbosity: "low",
+      temperature: 0.1,
+      top_p: 0.9,
+      maxTokens: 64000,
+      thinking: {
+        type: "disabled"
+      },
+      mode: "all",
+      description: "Fast code execution/build lane."
+    },
+    hephaestus: {
+      model: "xai/grok-4-1-fast-non-reasoning",
+      fallback_models: [
+        "github-copilot/gpt-5-mini",
+        "opencode-go/minimax-m2.5"
+      ],
+      reasoningEffort: "low",
+      textVerbosity: "low",
+      temperature: 0.1,
+      top_p: 0.9,
+      maxTokens: 64000,
+      thinking: {
+        type: "disabled"
+      },
+      mode: "subagent",
+      allow_non_gpt_model: true,
+      description: "Deep worker optimized for fast implementation, not long reasoning."
     },
-    librarian: { model: "xai/grok-4-1-fast-non-reasoning" },
-    explore: { model: "xai/grok-4-1-fast-non-reasoning" },
-    oracle: { model: "xai/grok-4-1-fast", variant: "high" },
     prometheus: {
-      prompt_append: "Prefer fast agents; only trigger ultrawork when necessary. Parallelize but avoid duplicate work."
+      model: "xai/grok-4-1-fast",
+      fallback_model: "github-copilot/gpt-5-mini",
+      reasoningEffort: "high",
+      textVerbosity: "medium",
+      temperature: 0.2,
+      top_p: 0.95,
+      maxTokens: 96000,
+      thinking: {
+        type: "enabled",
+        budgetTokens: 28000
+      },
+      mode: "subagent",
+      description: "Research/planning/strategy agent."
+    },
+    atlas: {
+      model: "xai/grok-4-1-fast",
+      fallback_model: "github-copilot/gpt-5-mini",
+      reasoningEffort: "medium",
+      textVerbosity: "medium",
+      temperature: 0.2,
+      top_p: 0.95,
+      maxTokens: 96000,
+      thinking: {
+        type: "enabled",
+        budgetTokens: 20000
+      },
+      mode: "subagent",
+      description: "Repository analysis and architecture navigation."
+    },
+    explore: {
+      model: "xai/grok-4-1-fast",
+      fallback_model: "github-copilot/gpt-5-mini",
+      reasoningEffort: "medium",
+      textVerbosity: "medium",
+      temperature: 0.3,
+      top_p: 0.95,
+      maxTokens: 64000,
+      thinking: {
+        type: "enabled",
+        budgetTokens: 16000
+      },
+      mode: "subagent",
+      description: "Codebase exploration and discovery."
+    },
+    librarian: {
+      model: "github-copilot/gpt-5-mini",
+      fallback_model: "xai/grok-4-1-fast",
+      reasoningEffort: "low",
+      textVerbosity: "low",
+      temperature: 0.1,
+      top_p: 0.9,
+      maxTokens: 32000,
+      thinking: {
+        type: "disabled"
+      },
+      mode: "subagent",
+      description: "Cheap summarizer and retrieval helper."
+    },
+    "multimodal-looker": {
+      model: "xai/grok-4-1-fast",
+      fallback_model: "github-copilot/gpt-5-mini",
+      reasoningEffort: "medium",
+      textVerbosity: "medium",
+      temperature: 0.2,
+      top_p: 0.95,
+      maxTokens: 48000,
+      thinking: {
+        type: "enabled",
+        budgetTokens: 12000
+      },
+      mode: "subagent",
+      description: "Image/screenshot-oriented inspection."
     }
   },
   categories: {
-    quick: { model: "opencode-go/minimax-m2.5" },
-    "unspecified-low": { model: "xai/grok-4-1-fast-non-reasoning" },
-    "unspecified-high": { model: "xai/grok-4-1-fast", variant: "high" },
-    "visual-engineering": { model: "google/gemini-3-pro-preview", variant: "high" },
-    writing: { model: "xai/grok-4-1-fast-non-reasoning" }
-  },
-  background_task: {
-    providerConcurrency: {
-      xai: 8,
-      "opencode-go": 6,
-      opencode: 2,
-      google: 1,
-      openai: 1,
-      anthropic: 1
+    "fast-build": {
+      description: "High-speed implementation path",
+      model: "xai/grok-4-1-fast-non-reasoning",
+      fallback_model: "github-copilot/gpt-5-mini",
+      temperature: 0.1,
+      top_p: 0.9,
+      thinking: {
+        type: "disabled"
+      },
+      reasoningEffort: "low",
+      textVerbosity: "low",
+      max_prompt_tokens: 120000
     },
-    modelConcurrency: {
-      "xai/grok-4-1-fast-non-reasoning": 8,
-      "xai/grok-4-1-fast": 2,
-      "opencode-go/minimax-m2.5": 6
+    "deep-plan": {
+      description: "High-quality planning path",
+      model: "xai/grok-4-1-fast",
+      fallback_model: "github-copilot/gpt-5-mini",
+      temperature: 0.1,
+      top_p: 0.9,
+      thinking: {
+        type: "enabled",
+        budgetTokens: 24000
+      },
+      reasoningEffort: "high",
+      textVerbosity: "medium",
+      max_prompt_tokens: 160000
+    },
+    "cheap-helper": {
+      description: "Low-cost utility path",
+      model: "github-copilot/gpt-5-mini",
+      fallback_model: "xai/grok-4-1-fast-non-reasoning",
+      temperature: 0.1,
+      top_p: 0.9,
+      thinking: {
+        type: "disabled"
+      },
+      reasoningEffort: "low",
+      textVerbosity: "low",
+      max_prompt_tokens: 48000
     }
   }
 };
@@ -9978,7 +10505,11 @@ function logEventVerbose(ctx, payload) {
     case "session.error": {
       const errorProps = props;
       const errorMsg = serializeError(errorProps?.error);
-      console.error(import_picocolors6.default.red(`${sessionTag} SESSION.ERROR: ${errorMsg}`));
+      if (errorMsg.includes("[Semantic Loop Guard]")) {
+        console.error(import_picocolors6.default.green(`${sessionTag} ${errorMsg}`));
+      } else {
+        console.error(import_picocolors6.default.red(`${sessionTag} SESSION.ERROR: ${errorMsg}`));
+      }
       break;
     }
     default:
@@ -10257,10 +10788,17 @@ function handleSessionError(ctx, payload, state) {
     return;
   const props = payload.properties;
   if (getSessionId(props) === ctx.sessionID) {
+    const errorName = props?.error?.name;
     state.mainSessionError = true;
-    state.lastError = serializeError(props?.error);
-    console.error(import_picocolors8.default.red(`
+    if (errorName === "AbortError" || errorName === "MessageAbortedError") {
+      state.lastError = "Task aborted.";
+      console.error(import_picocolors8.default.yellow(`
 [session.error] ${state.lastError}`));
+    } else {
+      state.lastError = serializeError(props?.error);
+      console.error(import_picocolors8.default.red(`
+[session.error] ${state.lastError}`));
+    }
   }
 }
 function handleMessagePartUpdated(ctx, payload, state) {
@@ -24069,7 +24607,8 @@ var BuiltinAgentNameSchema = exports_external.enum([
   "multimodal-looker",
   "metis",
   "momus",
-  "atlas"
+  "atlas",
+  "chat"
 ]);
 var BuiltinSkillNameSchema = exports_external.enum([
   "playwright",
@@ -24092,10 +24631,19 @@ var OverridableAgentNameSchema = exports_external.enum([
   "librarian",
   "explore",
   "multimodal-looker",
-  "atlas"
+  "atlas",
+  "chat"
 ]);
 // src/config/schema/fallback-models.ts
-var FallbackModelsSchema = exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]);
+var FallbackEntrySchema = exports_external.object({
+  providers: exports_external.array(exports_external.string()).optional(),
+  model: exports_external.string(),
+  variant: exports_external.string().optional()
+});
+var FallbackModelsSchema = exports_external.union([
+  exports_external.string(),
+  exports_external.array(exports_external.union([exports_external.string(), FallbackEntrySchema]))
+]);
 
 // src/config/schema/internal/permission.ts
 var PermissionValueSchema = exports_external.enum(["ask", "allow", "deny"]);
@@ -24115,6 +24663,7 @@ var AgentPermissionSchema = exports_external.object({
 // src/config/schema/agent-overrides.ts
 var AgentOverrideConfigSchema = exports_external.object({
   model: exports_external.string().optional(),
+  fallback_model: exports_external.string().optional(),
   fallback_models: FallbackModelsSchema.optional(),
   variant: exports_external.string().optional(),
   category: exports_external.string().optional(),
@@ -24137,6 +24686,9 @@ var AgentOverrideConfigSchema = exports_external.object({
   reasoningEffort: exports_external.enum(["low", "medium", "high", "xhigh"]).optional(),
   textVerbosity: exports_external.enum(["low", "medium", "high"]).optional(),
   providerOptions: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+  requires_model: exports_external.string().optional(),
+  requires_any_model: exports_external.boolean().optional(),
+  requires_provider: exports_external.array(exports_external.string()).optional(),
   ultrawork: exports_external.object({
     model: exports_external.string().optional(),
     variant: exports_external.string().optional()
@@ -24191,6 +24743,7 @@ var BrowserAutomationConfigSchema = exports_external.object({
 var CategoryConfigSchema = exports_external.object({
   description: exports_external.string().optional(),
   model: exports_external.string().optional(),
+  fallback_model: exports_external.string().optional(),
   fallback_models: FallbackModelsSchema.optional(),
   variant: exports_external.string().optional(),
   temperature: exports_external.number().min(0).max(2).optional(),
@@ -24206,7 +24759,11 @@ var CategoryConfigSchema = exports_external.object({
   prompt_append: exports_external.string().optional(),
   max_prompt_tokens: exports_external.number().int().positive().optional(),
   is_unstable_agent: exports_external.boolean().optional(),
-  disable: exports_external.boolean().optional()
+  disable: exports_external.boolean().optional(),
+  requires_model: exports_external.string().optional(),
+  requires_any_model: exports_external.boolean().optional(),
+  requires_provider: exports_external.array(exports_external.string()).optional(),
+  background_task: exports_external.never().optional().describe("Mis-nested background_task config - move to root level")
 });
 var BuiltinCategoryNameSchema = exports_external.enum([
   "visual-engineering",
@@ -24341,7 +24898,14 @@ var HookNameSchema = exports_external.enum([
   "write-existing-file-guard",
   "anthropic-effort",
   "hashline-read-enhancer",
-  "read-image-resizer"
+  "read-image-resizer",
+  "execution-journal",
+  "tool-contract",
+  "runtime-enforcement",
+  "plan-enforcement",
+  "semantic-loop-guard",
+  "edit-safeguard",
+  "xai-usage-patch"
 ]);
 // src/config/schema/notification.ts
 var NotificationConfigSchema = exports_external.object({
@@ -24460,6 +25024,7 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
   disabled_tools: exports_external.array(exports_external.string()).optional(),
   hashline_edit: exports_external.boolean().optional(),
   model_fallback: exports_external.boolean().optional(),
+  fallback_model: exports_external.string().optional(),
   agents: AgentOverridesSchema.optional(),
   categories: CategoriesConfigSchema.optional(),
   claude_code: ClaudeCodeConfigSchema.optional(),
@@ -26502,16 +27067,22 @@ function readState(directory, customPath) {
       const str3 = String(val ?? "");
       return str3.replace(/^["']|["']$/g, "");
     };
+    const ultrawork = data.ultrawork === true || data.ultrawork === "true" ? true : undefined;
+    const maxIterations = data.max_iterations === undefined || data.max_iterations === "" ? ultrawork ? undefined : DEFAULT_MAX_ITERATIONS : Number(data.max_iterations) || DEFAULT_MAX_ITERATIONS;
     return {
       active: isActive,
       iteration: iterationNum,
-      max_iterations: Number(data.max_iterations) || DEFAULT_MAX_ITERATIONS,
+      max_iterations: maxIterations,
       message_count_at_start: typeof data.message_count_at_start === "number" ? data.message_count_at_start : typeof data.message_count_at_start === "string" && data.message_count_at_start.trim() !== "" ? Number(data.message_count_at_start) : undefined,
       completion_promise: stripQuotes(data.completion_promise) || DEFAULT_COMPLETION_PROMISE,
+      initial_completion_promise: data.initial_completion_promise ? stripQuotes(data.initial_completion_promise) : undefined,
+      verification_attempt_id: data.verification_attempt_id ? stripQuotes(data.verification_attempt_id) : undefined,
+      verification_session_id: data.verification_session_id ? stripQuotes(data.verification_session_id) : undefined,
       started_at: stripQuotes(data.started_at) || new Date().toISOString(),
       prompt: body.trim(),
       session_id: data.session_id ? stripQuotes(data.session_id) : undefined,
-      ultrawork: data.ultrawork === true || data.ultrawork === "true" ? true : undefined,
+      ultrawork,
+      verification_pending: data.verification_pending === true || data.verification_pending === "true" ? true : undefined,
       strategy: data.strategy === "reset" || data.strategy === "continue" ? data.strategy : undefined
     };
   } catch {
@@ -26568,6 +27139,11 @@ async function checkCompletionConditions(ctx) {
     if (!areContinuationHooksIdle(ctx, continuationState)) {
       return false;
     }
+    const isLegitimatelyComplete = await verifyTaskCompletionState(ctx.client, ctx.sessionID);
+    if (!isLegitimatelyComplete) {
+      logWaiting(ctx, "failed verification constraints or complete_task explicitly rejected");
+      return false;
+    }
     return true;
   } catch (err) {
     console.error(import_picocolors14.default.red(`[completion] API error: ${err}`));
@@ -27164,7 +27740,10 @@ var CHECK_IDS = {
   TOOLS: "tools",
   MODELS: "models",
   FORK: "fork",
-  DEFAULT_CONFIG: "default-config"
+  DEFAULT_CONFIG: "default-config",
+  PLAN_COMPILER: "plan-compiler",
+  PROGRESS: "progress",
+  EDIT_ATOMICITY: "edit-atomicity"
 };
 var CHECK_NAMES = {
   [CHECK_IDS.SYSTEM]: "System",
@@ -27172,7 +27751,10 @@ var CHECK_NAMES = {
   [CHECK_IDS.TOOLS]: "Tools",
   [CHECK_IDS.MODELS]: "Models",
   [CHECK_IDS.FORK]: "Fork Integrity",
-  [CHECK_IDS.DEFAULT_CONFIG]: "Default Config"
+  [CHECK_IDS.DEFAULT_CONFIG]: "Default Config",
+  [CHECK_IDS.PLAN_COMPILER]: "Plan Compiler",
+  [CHECK_IDS.PROGRESS]: "Subagent Progress",
+  [CHECK_IDS.EDIT_ATOMICITY]: "Edit Atomicity & Validation"
 };
 var EXIT_CODES = {
   SUCCESS: 0,
@@ -27654,19 +28236,19 @@ function buildModelResolutionDetails(options) {
   details.push("");
   details.push("Agents:");
   for (const agent of options.info.agents) {
-    const marker = agent.userOverride ? "\u25CF" : "\u25CB";
+    const marker = agent.userOverride ? "\u25CF" : agent.requirement.fallbackModel ? "\u25D3" : "\u25CB";
     const display = formatModelWithVariant(agent.effectiveModel, getEffectiveVariant(agent.name, agent.requirement, options.config));
     details.push(`  ${marker} ${agent.name}: ${display}`);
   }
   details.push("");
   details.push("Categories:");
   for (const category of options.info.categories) {
-    const marker = category.userOverride ? "\u25CF" : "\u25CB";
+    const marker = category.userOverride ? "\u25CF" : category.requirement.fallbackModel ? "\u25D3" : "\u25CB";
     const display = formatModelWithVariant(category.effectiveModel, getCategoryEffectiveVariant(category.name, category.requirement, options.config));
     details.push(`  ${marker} ${category.name}: ${display}`);
   }
   details.push("");
-  details.push("\u25CF = user override, \u25CB = provider fallback");
+  details.push("\u25CF = user override, \u25D3 = config fallback (fallback_model), \u25CB = provider fallback");
   return details;
 }
 
@@ -27678,6 +28260,9 @@ function getEffectiveModel(requirement, userOverride) {
   if (userOverride) {
     return userOverride;
   }
+  if (requirement.fallbackModel) {
+    return requirement.fallbackModel;
+  }
   const firstEntry = requirement.fallbackChain[0];
   if (!firstEntry) {
     return "unknown";
@@ -27688,6 +28273,9 @@ function buildEffectiveResolution(requirement, userOverride) {
   if (userOverride) {
     return `User override: ${userOverride}`;
   }
+  if (requirement.fallbackModel) {
+    return `Config fallback: ${requirement.fallbackModel}`;
+  }
   const firstEntry = requirement.fallbackChain[0];
   if (!firstEntry) {
     return "No fallback chain defined";
@@ -28415,6 +29003,142 @@ async function checkFork() {
   };
 }
 
+// src/runtime/plan-compiler.ts
+class PlanCompiler {
+  static instance;
+  sessionStates = new Map;
+  constructor() {}
+  static getInstance() {
+    if (!PlanCompiler.instance) {
+      PlanCompiler.instance = new PlanCompiler;
+    }
+    return PlanCompiler.instance;
+  }
+  submit(sessionID, steps) {
+    const taskID = Math.random().toString(36).substring(7);
+    const graph = this.injectVerificationDependencies(steps.map((n) => ({ ...n, status: "pending" })));
+    this.sessionStates.set(sessionID, {
+      graph,
+      currentStepIndex: 0,
+      taskID
+    });
+    return taskID;
+  }
+  getActiveStep(sessionID) {
+    const state = this.sessionStates.get(sessionID);
+    if (!state)
+      return null;
+    if (state.currentStepIndex >= 0 && state.currentStepIndex < state.graph.length) {
+      return state.graph[state.currentStepIndex];
+    }
+    return null;
+  }
+  markStepComplete(sessionID, id) {
+    const state = this.sessionStates.get(sessionID);
+    if (!state)
+      return;
+    const node = state.graph.find((n) => n.id === id);
+    if (node) {
+      node.status = "completed";
+      state.currentStepIndex++;
+      if (state.currentStepIndex >= state.graph.length) {
+        this.clear(sessionID);
+      }
+    }
+  }
+  injectForcedReplan(sessionID, reason) {
+    const state = this.sessionStates.get(sessionID);
+    if (!state)
+      return;
+    const active = this.getActiveStep(sessionID);
+    if (active) {
+      active.status = "failed";
+    }
+    this.submit(sessionID, [
+      {
+        id: "forced_replan_" + Date.now(),
+        action: "submit_plan",
+        dependencies: []
+      }
+    ]);
+  }
+  clear(sessionID) {
+    this.sessionStates.delete(sessionID);
+  }
+  resetAll() {
+    this.sessionStates.clear();
+  }
+  injectVerificationDependencies(nodes) {
+    const compiled = [];
+    for (const node of nodes) {
+      compiled.push(node);
+      if (node.action.includes("commit") || node.action.includes("push") || node.action.includes("fix")) {
+        compiled.push({
+          id: `${node.id}_verify`,
+          action: "verify_action",
+          dependencies: [node.id],
+          status: "pending"
+        });
+      }
+    }
+    return compiled;
+  }
+}
+var compiler = PlanCompiler.getInstance();
+
+// src/cli/doctor/checks/plan-compiler.ts
+async function checkPlanCompiler() {
+  const findings = [];
+  let passed = true;
+  try {
+    const sessionA = "doctor-session-a-" + Date.now();
+    const sessionB = "doctor-session-b-" + Date.now();
+    compiler.submit(sessionA, [
+      { id: "step1", action: "exclusive-action-a", dependencies: [] }
+    ]);
+    const activeA = compiler.getActiveStep(sessionA);
+    const activeB = compiler.getActiveStep(sessionB);
+    if (activeA?.action !== "exclusive-action-a") {
+      passed = false;
+      findings.push(`${SYMBOLS3.cross} Session A plan not correctly stored.`);
+    }
+    if (activeB !== null) {
+      passed = false;
+      findings.push(`${SYMBOLS3.cross} Session B is polluted by Session A's plan. Cross-session leakage detected!`);
+    } else {
+      findings.push(`${SYMBOLS3.check} Session isolation verified.`);
+    }
+    compiler.clear(sessionA);
+    if (compiler.getActiveStep(sessionA) !== null) {
+      passed = false;
+      findings.push(`${SYMBOLS3.cross} Manual unlock failed to clear session state.`);
+    } else {
+      findings.push(`${SYMBOLS3.check} Manual unlock (clear) verified.`);
+    }
+    const taskID1 = compiler.submit(sessionA, [{ id: "s1", action: "a1", dependencies: [] }]);
+    const taskID2 = compiler.submit(sessionA, [{ id: "s2", action: "a2", dependencies: [] }]);
+    if (taskID1 === taskID2) {
+      findings.push(`${SYMBOLS3.warn} Task IDs are not unique across subsequent submits in the same session.`);
+    } else {
+      findings.push(`${SYMBOLS3.check} Task ID rotation verified.`);
+    }
+  } catch (error48) {
+    passed = false;
+    findings.push(`${SYMBOLS3.cross} Plan Compiler check crashed: ${error48.message}`);
+  }
+  return {
+    name: "Plan Compiler",
+    status: passed ? "pass" : "fail",
+    message: passed ? "Plan Compiler is healthy and correctly isolating sessions." : "Plan Compiler has integrity issues (isolation or recovery failure).",
+    details: findings,
+    issues: passed ? [] : [{
+      title: "Plan Compiler integrity failure",
+      description: "Deterministic plan enforcement or session isolation is broken.",
+      severity: "error"
+    }]
+  };
+}
+
 // src/cli/doctor/checks/default-config.ts
 import { existsSync as existsSync28, readFileSync as readFileSync28 } from "fs";
 import * as path10 from "path";
@@ -28528,20 +29252,1532 @@ async function checkDefaultConfig() {
     issues
   };
 }
-// src/cli/doctor/checks/index.ts
-function getAllCheckDefinitions() {
-  return [
-    {
-      id: CHECK_IDS.SYSTEM,
-      name: CHECK_NAMES[CHECK_IDS.SYSTEM],
-      check: checkSystem,
-      critical: true
-    },
-    {
-      id: CHECK_IDS.CONFIG,
-      name: CHECK_NAMES[CHECK_IDS.CONFIG],
-      check: checkConfig
-    },
+
+// src/shared/active-task-storage.ts
+init_opencode_config_dir();
+init_logger();
+import { join as join28 } from "path";
+import { writeFileSync as writeFileSync11, readFileSync as readFileSync29, existsSync as existsSync29, mkdirSync as mkdirSync7 } from "fs";
+var STORAGE_FILENAME = "active_background_tasks.json";
+function getStoragePath() {
+  const configDir = getOpenCodeConfigDir({ binary: "opencode" });
+  if (!existsSync29(configDir)) {
+    mkdirSync7(configDir, { recursive: true });
+  }
+  return join28(configDir, STORAGE_FILENAME);
+}
+function saveActiveTasks(tasks) {
+  try {
+    const path11 = getStoragePath();
+    writeFileSync11(path11, JSON.stringify(tasks, null, 2), "utf-8");
+  } catch (err) {
+    log("[active-task-storage] Failed to save active tasks:", err);
+  }
+}
+function readActiveTasks() {
+  try {
+    const path11 = getStoragePath();
+    if (!existsSync29(path11))
+      return [];
+    const content = readFileSync29(path11, "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    log("[active-task-storage] Failed to read active tasks:", err);
+    return [];
+  }
+}
+
+// src/cli/doctor/checks/progress.ts
+async function checkProgress() {
+  const findings = [];
+  let passed = true;
+  try {
+    const testTask = {
+      id: "doctor-test-task-" + Date.now(),
+      sessionID: "test-session",
+      description: "Doctor progress check",
+      agent: "sisyphus",
+      status: "running",
+      startedAt: new Date().toISOString(),
+      progress: {
+        phase: "Testing",
+        percent: 50,
+        message: "Halfway there"
+      }
+    };
+    const originalTasks = readActiveTasks();
+    saveActiveTasks([...originalTasks, testTask]);
+    const updatedTasks = readActiveTasks();
+    const found = updatedTasks.find((t) => t.id === testTask.id);
+    if (!found) {
+      passed = false;
+      findings.push(`${SYMBOLS3.cross} Failed to persist active task.`);
+    } else if (found.progress?.percent !== 50) {
+      passed = false;
+      findings.push(`${SYMBOLS3.cross} Persisted progress data is incorrect.`);
+    } else {
+      findings.push(`${SYMBOLS3.check} Progress storage persistence verified.`);
+    }
+    saveActiveTasks(originalTasks);
+  } catch (error48) {
+    passed = false;
+    findings.push(`${SYMBOLS3.cross} Progress check crashed: ${error48.message}`);
+  }
+  return {
+    name: "Subagent Progress",
+    status: passed ? "pass" : "fail",
+    message: passed ? "Subagent progress tracking is healthy." : "Subagent progress tracking has issues.",
+    issues: passed ? [] : [{
+      title: "Progress tracking failure",
+      description: "The system failed to persist or retrieve background task progress.",
+      severity: "error"
+    }]
+  };
+}
+
+// src/runtime/tools/fs-safe.ts
+import * as fs11 from "fs";
+import * as path11 from "path";
+
+// node_modules/@opencode-ai/plugin/dist/tool.js
+function tool(input) {
+  return input;
+}
+tool.schema = exports_external;
+// src/utils/safety-tool-result.ts
+function createSuccessResult(params) {
+  const result = {
+    success: true,
+    verified: params.verified,
+    changedState: params.changedState,
+    message: params.message
+  };
+  if (params.changedState) {
+    if (!params.stateChange) {
+      throw new Error("[Safety Helper] 'stateChange' metadata is required when 'changedState' is true.");
+    }
+    result.stateChange = params.stateChange;
+  }
+  return result;
+}
+function createFailureResult(message) {
+  return {
+    success: false,
+    verified: false,
+    changedState: false,
+    message
+  };
+}
+
+// src/features/tool-metadata-store/store.ts
+var pendingStore = new Map;
+var STALE_TIMEOUT_MS = 15 * 60 * 1000;
+function makeKey(sessionID, callID) {
+  return `${sessionID}:${callID}`;
+}
+function cleanupStaleEntries() {
+  const now = Date.now();
+  for (const [key, entry] of pendingStore) {
+    if (now - entry.storedAt > STALE_TIMEOUT_MS) {
+      pendingStore.delete(key);
+    }
+  }
+}
+function storeToolMetadata(sessionID, callID, data) {
+  cleanupStaleEntries();
+  pendingStore.set(makeKey(sessionID, callID), { ...data, storedAt: Date.now() });
+}
+function consumeToolMetadata(sessionID, callID) {
+  const key = makeKey(sessionID, callID);
+  const stored = pendingStore.get(key);
+  if (stored) {
+    pendingStore.delete(key);
+    const { storedAt: _3, ...data } = stored;
+    return data;
+  }
+  return;
+}
+function clearPendingStore() {
+  pendingStore.clear();
+}
+// src/utils/tool-contract-wrapper.ts
+function withToolContract(toolName, executeFn) {
+  const safetyCriticalTools = ["git_safe", "fs_safe", "verify_action", "submit_plan", "mark_step_complete", "unlock_plan", "query_ledger", "complete_task", "report_issue_verification"];
+  return async (args, context) => {
+    let metadataCalled = false;
+    let lastMetadata = null;
+    const originalMetadata = context.metadata.bind(context);
+    context.metadata = (data) => {
+      metadataCalled = true;
+      let flattened = data;
+      if (data && typeof data === "object") {
+        if (data.metadata && typeof data.metadata === "object") {
+          const { metadata, ...rest } = data;
+          flattened = { ...rest, ...metadata };
+        }
+      }
+      lastMetadata = flattened;
+      if (context.callID) {
+        const pendingData = {
+          title: flattened.title || toolName,
+          metadata: flattened
+        };
+        storeToolMetadata(context.sessionID, context.callID, pendingData);
+      }
+      return originalMetadata(flattened);
+    };
+    let executionMessage;
+    try {
+      executionMessage = await executeFn(args, context);
+      if (!metadataCalled) {
+        const result = createFailureResult(`[Tool Contract Violation] Tool ${toolName} finished without calling context.metadata().`);
+        const meta3 = {
+          title: `${toolName} protocol error`,
+          ...result,
+          success: false,
+          verified: false
+        };
+        context.metadata(meta3);
+        return result.message;
+      }
+    } catch (error48) {
+      const result = createFailureResult(`Exception in ${toolName}: ${error48.message}`);
+      const meta3 = {
+        title: `${toolName} failed`,
+        ...result,
+        success: false,
+        verified: false
+      };
+      context.metadata(meta3);
+      return result.message || error48.message;
+    }
+    return executionMessage;
+  };
+}
+
+// src/runtime/tools/fs-safe.ts
+function createFsSafeTool() {
+  return tool({
+    description: "Safe, structured execution of filesystem writes. Returns verifiable status.",
+    args: {
+      operation: exports_external.enum(["write", "delete", "mkdir"]).describe("The filesystem operation to perform."),
+      filePath: exports_external.string().describe("Absolute or relative path to the file/directory."),
+      content: exports_external.string().optional().describe("File content (only used if operation is 'write').")
+    },
+    execute: withToolContract("fs_safe", async (args, context) => {
+      try {
+        const { operation, filePath, content } = args;
+        const fullPath = path11.resolve(context.directory || process.cwd(), filePath);
+        let changedState = false;
+        let stateChangePayload = null;
+        if (operation === "write") {
+          const dir = path11.dirname(fullPath);
+          if (!fs11.existsSync(dir)) {
+            fs11.mkdirSync(dir, { recursive: true });
+          }
+          fs11.writeFileSync(fullPath, content || "", "utf8");
+          changedState = true;
+          stateChangePayload = { type: "file.write", key: filePath, details: { fullPath } };
+        } else if (operation === "delete") {
+          if (fs11.existsSync(fullPath)) {
+            const stats = fs11.statSync(fullPath);
+            if (stats.isDirectory()) {
+              fs11.rmSync(fullPath, { recursive: true, force: true });
+            } else {
+              fs11.unlinkSync(fullPath);
+            }
+            changedState = true;
+            stateChangePayload = { type: "file.delete", key: filePath, details: { fullPath } };
+          }
+        } else if (operation === "mkdir") {
+          if (!fs11.existsSync(fullPath)) {
+            fs11.mkdirSync(fullPath, { recursive: true });
+            changedState = true;
+            stateChangePayload = { type: "command.execute", key: `mkdir ${filePath}`, details: { fullPath } };
+          }
+        }
+        const result = createSuccessResult({
+          verified: true,
+          changedState,
+          stateChange: stateChangePayload || undefined
+        });
+        context.metadata({
+          title: `fs ${operation}`,
+          ...result
+        });
+        return `Successfully executed ${operation} on ${filePath}`;
+      } catch (err) {
+        const result = createFailureResult(`Failed: ${err.message}`);
+        context.metadata({
+          title: `fs ${args.operation} error`,
+          ...result
+        });
+        return result.message;
+      }
+    })
+  });
+}
+
+// src/runtime/tools/git-safe.ts
+var {spawn: spawn2 } = globalThis.Bun;
+function createGitSafeTool() {
+  return tool({
+    description: "Safe, structured execution of git commands. Returns verifiable status.",
+    args: {
+      command: exports_external.string().describe(`The git command without the 'git ' prefix (e.g. 'commit -m "msg"', 'push origin main')`)
+    },
+    execute: withToolContract("git_safe", async (args, context) => {
+      let commandArgs = [];
+      try {
+        commandArgs = args.command.match(/([^\\"]\S*|".+?")\s*/g)?.map((s) => s.trim().replace(/^"(.*)"$/, "$1")) || [];
+        if (commandArgs.length === 0) {
+          const result2 = createFailureResult("No command provided");
+          context.metadata({ title: "Git Exec Error", ...result2 });
+          return result2.message;
+        }
+        const proc = spawn2(["git", ...commandArgs], {
+          cwd: context.directory || process.cwd(),
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        const stdoutText = await new Response(proc.stdout).text();
+        const stderrText = await new Response(proc.stderr).text();
+        const exitCode = await proc.exited;
+        const success2 = exitCode === 0;
+        const isPush = commandArgs[0] === "push";
+        const isCommit = commandArgs[0] === "commit";
+        const isStateChanging = ["commit", "push", "checkout", "branch", "rebase", "merge", "reset", "revert", "clean", "rm", "add"].includes(commandArgs[0]);
+        const changedState = success2 && isStateChanging;
+        let stateChangePayload = null;
+        if (changedState) {
+          if (isPush)
+            stateChangePayload = { type: "git.push", key: "origin", details: { exitCode } };
+          else if (isCommit)
+            stateChangePayload = { type: "git.commit", key: "HEAD", details: { exitCode } };
+          else
+            stateChangePayload = { type: "command.execute", key: `git ${commandArgs[0]}`, details: { exitCode } };
+        }
+        const result = createSuccessResult({
+          verified: !isStateChanging,
+          changedState,
+          stateChange: stateChangePayload || undefined
+        });
+        context.metadata({
+          title: `git ${commandArgs[0]}`,
+          ...result
+        });
+        return `Exit Code: ${exitCode}
+
+STDOUT:
+${stdoutText}
+
+STDERR:
+${stderrText}`;
+      } catch (e2) {
+        const result = createFailureResult(`JSON parse error on args or execution failed: ${e2.message}`);
+        context.metadata({ title: "Git Exec Error", ...result });
+        return result.message;
+      }
+    })
+  });
+}
+
+// src/runtime/tools/plan.ts
+function createSubmitPlanTool() {
+  return tool({
+    description: "Submits a deterministic execution plan. The Runtime Compiler will take over and guide you strictly through the resulting dependency graph.",
+    args: {
+      steps: exports_external.array(exports_external.object({
+        id: exports_external.string().describe("Unique step ID (e.g. 'step1')"),
+        action: exports_external.string().describe("The high-level action (e.g. 'run_tests', 'fix_linter', 'commit')"),
+        dependencies: exports_external.array(exports_external.string()).describe("IDs of steps that must complete before this one")
+      })).describe("The execution DAG (Directed Acyclic Graph) of operations")
+    },
+    execute: withToolContract("submit_plan", async (args, toolContext) => {
+      const taskID = compiler.submit(toolContext.sessionID, args.steps);
+      const result = createSuccessResult({
+        verified: true,
+        changedState: false,
+        metadata: { planLength: args.steps.length, taskID }
+      });
+      toolContext.metadata({
+        title: "Plan Submitted",
+        ...result
+      });
+      const active = compiler.getActiveStep(toolContext.sessionID);
+      return `Plan successfully compiled into an executable graph (including implicit verification nodes).
+
+CURRENT FORCED STEP: ${active?.action} (ID: ${active?.id}).
+Do not execute any other tools until this step is complete.`;
+    })
+  });
+}
+function createMarkStepCompleteTool() {
+  return tool({
+    description: "Marks the current forced execution step as complete and retrieves the next step.",
+    args: {
+      id: exports_external.string().describe("The ID of the step that was completed")
+    },
+    execute: withToolContract("mark_step_complete", async (args, toolContext) => {
+      compiler.markStepComplete(toolContext.sessionID, args.id);
+      const result = createSuccessResult({
+        verified: true,
+        changedState: false,
+        metadata: { stepId: args.id }
+      });
+      toolContext.metadata({
+        title: `Step ${args.id} Complete`,
+        ...result
+      });
+      const active = compiler.getActiveStep(toolContext.sessionID);
+      if (!active) {
+        return `Step ${args.id} marked complete. The plan graph is now fully exhausted. You may report final success to the user.`;
+      }
+      return `Step ${args.id} marked complete.
+
+NEXT FORCED STEP: ${active.action} (ID: ${active.id}).`;
+    })
+  });
+}
+function createUnlockPlanTool() {
+  return tool({
+    description: "Manually unlocks the deterministic execution plan, clearing any active steps for the current session.",
+    args: {},
+    execute: withToolContract("unlock_plan", async (_3, toolContext) => {
+      compiler.clear(toolContext.sessionID);
+      const result = createSuccessResult({
+        verified: true,
+        changedState: false
+      });
+      toolContext.metadata({
+        title: "Plan Unlocked",
+        ...result
+      });
+      return "The deterministic execution plan has been cleared for this session. You are now in freestyle mode.";
+    })
+  });
+}
+
+// src/runtime/tools/verify.ts
+var {spawn: spawn3 } = globalThis.Bun;
+
+// src/agents/runtime/verify-action.ts
+var VERIFICATION_COMMANDS = {
+  gitPush: {
+    name: "Git Push Verification",
+    command: "git rev-list --count origin/${BRANCH}..HEAD",
+    successCondition: 'output === "0"',
+    failureMessage: "Push failed \u2014 unpushed commits remain"
+  },
+  gitCommit: {
+    name: "Git Commit Verification",
+    command: 'git log -1 --format="%H"',
+    successCondition: "output !== previousHash",
+    failureMessage: "Commit failed \u2014 hash unchanged from before work"
+  },
+  prCreated: {
+    name: "PR Creation Verification",
+    command: 'gh pr view --json url --jq ".url"',
+    successCondition: 'output starts with "https://"',
+    failureMessage: "PR not found \u2014 do not fabricate URL"
+  },
+  cleanWorkDir: {
+    name: "Clean Working Directory",
+    command: "git status --porcelain",
+    successCondition: "output is empty",
+    failureMessage: "Uncommitted changes exist \u2014 cannot proceed"
+  },
+  branchExists: {
+    name: "Branch Existence",
+    command: "git rev-parse --verify ${BRANCH}",
+    successCondition: "exit code === 0",
+    failureMessage: "Branch does not exist"
+  },
+  commandExit: {
+    name: "Command Exit Code",
+    command: undefined,
+    successCondition: "exit code === 0",
+    failureMessage: "Command failed with non-zero exit code"
+  },
+  fileWrite: {
+    name: "File Write Verification",
+    command: undefined,
+    successCondition: "write tool returned success",
+    failureMessage: "File write failed \u2014 check tool output"
+  }
+};
+
+// src/runtime/tools/verify.ts
+function createVerifyTool() {
+  return tool({
+    description: "Centrally verifies system state changes. Required before claiming success.",
+    args: {
+      action: exports_external.enum(Object.keys(VERIFICATION_COMMANDS)).describe("The predefined verification action to perform."),
+      context: exports_external.record(exports_external.string(), exports_external.any()).optional().describe("Context variables needed for the command (e.g., { BRANCH: 'feature-1' })")
+    },
+    execute: withToolContract("verify_action", async (args, toolContext) => {
+      const actionKey = args.action;
+      const config2 = VERIFICATION_COMMANDS[actionKey];
+      if (!config2 || !config2.command) {
+        const result2 = createFailureResult(`Unknown verification action or missing command: ${args.action}`);
+        toolContext.metadata({ title: "Verify Error", ...result2 });
+        return result2.message;
+      }
+      let cmdString = config2.command;
+      if (args.context) {
+        for (const [key, value] of Object.entries(args.context)) {
+          cmdString = cmdString.replace(`\${${key}}`, String(value));
+        }
+      }
+      const commandArgs = cmdString.split(" ");
+      const proc = spawn3(commandArgs, {
+        cwd: toolContext.directory || process.cwd(),
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const stdoutText = await new Response(proc.stdout).text();
+      const exitCode = await proc.exited;
+      let isSuccess = false;
+      if (config2.successCondition === 'output === "0"') {
+        isSuccess = stdoutText.trim() === "0";
+      } else if (config2.successCondition === "exit code === 0") {
+        isSuccess = exitCode === 0;
+      } else if (config2.successCondition === 'output starts with "https://"') {
+        isSuccess = stdoutText.trim().startsWith("https://");
+      } else if (config2.successCondition === "output is empty") {
+        isSuccess = stdoutText.trim() === "";
+      } else {
+        isSuccess = exitCode === 0;
+      }
+      const result = createSuccessResult({
+        verified: isSuccess,
+        changedState: false,
+        message: isSuccess ? undefined : config2.failureMessage
+      });
+      toolContext.metadata({
+        title: `Verify: ${config2.name}`,
+        ...result
+      });
+      return isSuccess ? `Verification SUCCESS. (Output: ${stdoutText.trim()})` : `Verification FAILED. ${config2.failureMessage} (Output: ${stdoutText.trim()})`;
+    })
+  });
+}
+
+// src/runtime/state-ledger.ts
+class StateLedger {
+  static instance;
+  entries = [];
+  lastFlowStartTime = 0;
+  constructor() {}
+  static getInstance() {
+    if (!StateLedger.instance) {
+      StateLedger.instance = new StateLedger;
+    }
+    return StateLedger.instance;
+  }
+  startNewFlow() {
+    this.lastFlowStartTime = Date.now();
+  }
+  record(type2, key, success2, verified, changedState, stdout, metadata, sessionID) {
+    this.entries.push({
+      type: type2,
+      timestamp: Date.now(),
+      key,
+      success: success2,
+      verified,
+      changedState,
+      stdout,
+      sessionID,
+      metadata
+    });
+  }
+  has(type2, keyOrCondition) {
+    const flowEntries = this.entries.filter((e2) => e2.timestamp >= this.lastFlowStartTime);
+    if (typeof keyOrCondition === "string") {
+      return flowEntries.some((e2) => e2.type === type2 && e2.key === keyOrCondition);
+    }
+    return flowEntries.some((e2) => e2.type === type2 && keyOrCondition(e2));
+  }
+  getEntries(type2) {
+    if (!type2) {
+      return [...this.entries];
+    }
+    return this.entries.filter((e2) => e2.type === type2);
+  }
+  get count() {
+    return this.entries.length;
+  }
+  clear() {
+    this.entries = [];
+    this.lastFlowStartTime = 0;
+  }
+}
+var ledger = StateLedger.getInstance();
+
+// src/runtime/tools/query-ledger.ts
+function createQueryLedgerTool(options) {
+  return tool({
+    description: "Query the verified state ledger to confirm if actions like git.commit or git.push have actually succeeded. Use this as the ONLY source of truth for system state.",
+    args: {
+      type: exports_external.string().optional().describe("Optional filter by type (e.g. 'git.commit', 'file.write', 'git.push')")
+    },
+    execute: withToolContract("query_ledger", async (args, toolContext) => {
+      const descendantSessions = options?.backgroundManager?.getAllDescendantTasks ? options.backgroundManager.getAllDescendantTasks(toolContext.sessionID).map((t) => t.sessionID).filter(Boolean) : [];
+      const sessionIDs = [toolContext.sessionID, ...descendantSessions];
+      const entries = ledger.getEntries().filter((e2) => e2.verified === true && e2.success === true && (!e2.sessionID || sessionIDs.includes(e2.sessionID)));
+      const filtered = args.type ? entries.filter((e2) => e2.type === args.type) : entries;
+      const result = createSuccessResult({
+        verified: true,
+        changedState: false,
+        recordCount: filtered.length
+      });
+      toolContext.metadata({
+        title: "Query Ledger",
+        ...result
+      });
+      if (filtered.length === 0) {
+        return "No matching verified actions found in the current completion flow.";
+      }
+      return JSON.stringify(filtered, null, 2);
+    })
+  });
+}
+
+// src/features/claude-code-session-state/state.ts
+var subagentSessions = new Set;
+var syncSubagentSessions = new Set;
+var issueModeSessions = new Set;
+var sessionAgentMap = new Map;
+function isSessionIssueMode(sessionID) {
+  return issueModeSessions.has(sessionID);
+}
+// src/features/issue-resolution/state.ts
+init_data_path();
+import { join as join29 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync30, writeFileSync as writeFileSync13, mkdirSync as mkdirSync9 } from "fs";
+var DATA_DIR = join29(getDataDir(), "oh-my-opencode");
+var ISSUE_STATE_FILE = join29(DATA_DIR, "issue-verification-state.json");
+function ensureDataDir() {
+  if (!existsSync31(DATA_DIR)) {
+    mkdirSync9(DATA_DIR, { recursive: true });
+  }
+}
+function loadFromDisk() {
+  try {
+    if (existsSync31(ISSUE_STATE_FILE)) {
+      const data = JSON.parse(readFileSync30(ISSUE_STATE_FILE, "utf8"));
+      return new Map(Object.entries(data));
+    }
+  } catch (e2) {}
+  return new Map;
+}
+function saveToDisk(states) {
+  ensureDataDir();
+  const data = Object.fromEntries(states);
+  writeFileSync13(ISSUE_STATE_FILE, JSON.stringify(data, null, 2));
+}
+var issueStates = loadFromDisk();
+function getIssueState(sessionID) {
+  if (!issueStates.has(sessionID)) {
+    issueStates.set(sessionID, {
+      reproduced: false,
+      fixApplied: false,
+      reproAfterPassed: false,
+      failureModeChecksPassed: false
+    });
+    saveToDisk(issueStates);
+  }
+  return issueStates.get(sessionID);
+}
+function updateIssueState(sessionID, partialState) {
+  const currentState = getIssueState(sessionID);
+  const newState = { ...currentState, ...partialState };
+  issueStates.set(sessionID, newState);
+  saveToDisk(issueStates);
+  return newState;
+}
+
+// src/runtime/tools/complete-task.ts
+function createCompleteTaskTool(options) {
+  return tool({
+    description: "Signal that the task is complete. The runtime will compose the final verified state report. DO NOT output your own summary, just call this tool.",
+    args: {
+      message: exports_external.string().describe("Optional short note about what was done. Do not include PR URLs or commit hashes here.")
+    },
+    execute: withToolContract("complete_task", async (args, toolContext) => {
+      const client3 = options?.client;
+      const sessionID = toolContext.sessionID;
+      if (client3) {
+        try {
+          const todosRes = await client3.session.todo({
+            path: { id: sessionID }
+          });
+          const todos = normalizeSDKResponse(todosRes, []);
+          const incompleteTodos = todos.filter((t) => t.status !== "completed" && t.status !== "cancelled" && t.status !== "blocked" && t.status !== "deleted");
+          if (incompleteTodos.length > 0) {
+            const failMsg = `[ERROR] TASK COMPLETION REJECTED.
+
+You have ${incompleteTodos.length} incomplete TODOs remaining in the UI tracker. You CANNOT mark the task as complete until all TODOs are explicitly marked as completed or cancelled using the TodoWrite tool (or TaskUpdate if experimental tasks are enabled).
+
+Please review your TODOs, complete them, and then retry calling complete_task.`;
+            const result2 = createFailureResult(failMsg);
+            const meta3 = { title: "Task Completion Rejected", ...result2 };
+            toolContext.metadata(meta3);
+            return failMsg;
+          }
+        } catch (e2) {}
+      }
+      if (isSessionIssueMode(sessionID)) {
+        const issueState = getIssueState(sessionID);
+        if (!issueState.reproduced || !issueState.fixApplied || !issueState.reproAfterPassed) {
+          const failMsg = `[ERROR] STRICT ISSUE RESOLUTION MODE ACTIVE.
+
+You cannot mark this task as complete until you have explicitly verified the fix.
+
+Current Verification State:
+- Reproduced: ${issueState.reproduced}
+- Fix Applied: ${issueState.fixApplied}
+- Repro After Fix Passed: ${issueState.reproAfterPassed}
+
+You MUST use the 'report_issue_verification' tool to truthfully log your progress as you perform each step. If you only performed static reasoning without live verification, your state is incomplete.`;
+          const result2 = createFailureResult(failMsg);
+          toolContext.metadata({ title: "Task Completion Rejected", ...result2 });
+          return failMsg;
+        }
+      }
+      const descendantSessions = options?.backgroundManager?.getAllDescendantTasks ? options.backgroundManager.getAllDescendantTasks(toolContext.sessionID).map((t) => t.sessionID).filter(Boolean) : [];
+      const sessionIDs = [toolContext.sessionID, ...descendantSessions];
+      const entries = ledger.getEntries().filter((e2) => e2.verified === true && e2.success === true && (!e2.sessionID || sessionIDs.includes(e2.sessionID)));
+      let report = `TASK COMPLETE.
+
+Runtime Verified Actions (Current Flow):
+`;
+      if (entries.length === 0) {
+        report += `- No state changes recorded in this session.
+`;
+      } else {
+        for (const entry of entries) {
+          report += `- [${entry.type}] ${entry.key}
+`;
+        }
+      }
+      if (args.message) {
+        report += `
+Agent Note: ${args.message}
+`;
+      }
+      const result = createSuccessResult({
+        verified: true,
+        changedState: false,
+        message: args.message
+      });
+      toolContext.metadata({
+        title: "Task Completed",
+        ...result,
+        sessionID: toolContext.sessionID,
+        entries: entries.length
+      });
+      return `[RUNTIME AUTHORIZATION]
+
+${report}
+
+You may now conclude your response using EXACTLY this report as your final output.`;
+    })
+  });
+}
+
+// src/cli/doctor/checks/tool-contract.ts
+async function checkToolContract() {
+  const issues = [];
+  const toolsToTest = [
+    { name: "fs_safe", factory: createFsSafeTool, args: { operation: "read", filePath: "non-existent-test-file" } },
+    { name: "git_safe", factory: createGitSafeTool, args: { command: "status" } },
+    { name: "submit_plan", factory: createSubmitPlanTool, args: { steps: [] } },
+    { name: "mark_step_complete", factory: createMarkStepCompleteTool, args: { id: "step1" } },
+    { name: "unlock_plan", factory: createUnlockPlanTool, args: {} },
+    { name: "verify_action", factory: createVerifyTool, args: { action: "LS_FILES" } },
+    { name: "query_ledger", factory: createQueryLedgerTool, args: {} },
+    { name: "complete_task", factory: createCompleteTaskTool, args: { message: "test completion" } }
+  ];
+  for (const toolSpec of toolsToTest) {
+    try {
+      const tool3 = toolSpec.factory();
+      const sessionID = `doctor-test-${Date.now()}`;
+      const callID = `call-${toolSpec.name}`;
+      clearPendingStore();
+      const mockContext = {
+        sessionID,
+        callID,
+        directory: process.cwd(),
+        metadata: () => {},
+        client: {}
+      };
+      await tool3.execute(toolSpec.args, mockContext).catch(() => {});
+      const stored = consumeToolMetadata(sessionID, callID);
+      if (!stored || !stored.metadata) {
+        issues.push({
+          title: `Tool Contract Violation: ${toolSpec.name}`,
+          description: `Tool did not call storeToolMetadata or returned no metadata.`,
+          severity: "error",
+          affects: [toolSpec.name]
+        });
+        continue;
+      }
+      const meta3 = stored.metadata;
+      if (typeof meta3.success !== "boolean" || typeof meta3.verified !== "boolean") {
+        issues.push({
+          title: `Tool Contract Violation: ${toolSpec.name}`,
+          description: `Tool metadata missing 'success' or 'verified' booleans. Found: ${JSON.stringify(meta3)}`,
+          severity: "error",
+          affects: [toolSpec.name]
+        });
+      }
+    } catch (e2) {
+      issues.push({
+        title: `Doctor internal error testing ${toolSpec.name}`,
+        description: e2.message,
+        severity: "warning"
+      });
+    }
+  }
+  return {
+    name: "Tool Contract Compliance",
+    status: issues.length === 0 ? "pass" : "fail",
+    message: issues.length === 0 ? "All safety tools comply with the result contract." : `${issues.length} tool contract violation(s) detected.`,
+    details: toolsToTest.map((t) => `${t.name}: tested`),
+    issues
+  };
+}
+
+// src/cli/doctor/checks/edit-atomicity.ts
+import { readFileSync as readFileSync32, writeFileSync as writeFileSync15, unlinkSync as unlinkSync3, existsSync as existsSync33 } from "fs";
+import { join as join30 } from "path";
+
+// src/hooks/edit-safeguard/hook.ts
+init_shared();
+import { existsSync as existsSync32, readFileSync as readFileSync31, writeFileSync as writeFileSync14 } from "fs";
+import { spawnSync } from "child_process";
+
+// src/shared/read-permission-tracker.ts
+init_logger();
+
+class ReadPermissionTracker {
+  readFiles = new Map;
+  recordRead(sessionID, filePath) {
+    if (!this.readFiles.has(sessionID)) {
+      this.readFiles.set(sessionID, new Set);
+    }
+    const normalizedPath = this.normalizePath(filePath);
+    this.readFiles.get(sessionID).add(normalizedPath);
+    log(`[ReadTracker] Recorded read for ${normalizedPath} in session ${sessionID}`);
+  }
+  hasRead(sessionID, filePath) {
+    const sessionReads = this.readFiles.get(sessionID);
+    if (!sessionReads)
+      return false;
+    const normalizedPath = this.normalizePath(filePath);
+    return sessionReads.has(normalizedPath);
+  }
+  clearSession(sessionID) {
+    this.readFiles.delete(sessionID);
+  }
+  normalizePath(filePath) {
+    return filePath.trim().replace(/\/+$/, "");
+  }
+}
+var readTracker = new ReadPermissionTracker;
+
+// src/hooks/edit-safeguard/hook.ts
+var FAILURE_PATTERNS = [
+  "oldstring not found",
+  "oldstring found multiple times",
+  "oldstring and newstring must be different",
+  "verification failed",
+  "failed to find expected lines"
+];
+function createEditSafeguardHook(ctx) {
+  const backups = new Map;
+  function getFilePath(toolName, args) {
+    if (toolName === "edit")
+      return args.filePath;
+    if (toolName === "apply_patch")
+      return args.path || args.filePath;
+    return;
+  }
+  return {
+    "tool.execute.before": async (input, output) => {
+      const toolName = input.tool?.toLowerCase();
+      const isEditTool = toolName === "edit" || toolName === "apply_patch";
+      if (!isEditTool)
+        return;
+      const filePath = getFilePath(toolName, output.args);
+      if (!filePath)
+        return;
+      if (!readTracker.hasRead(input.sessionID, filePath) && existsSync32(filePath)) {
+        log("[edit-safeguard] REJECTED: Read-before-write violation", { filePath, sessionID: input.sessionID });
+        throw new Error(`[Edit Discipline Violation] Path REJECTED: ${filePath}
+` + `You attempted to edit or patch a file that you have not read in the current session.
+` + `The rule is path-specific: you MUST read the exact target file path before attempting to edit or overwrite it.
+` + `Reading a different file or a grep snippet does not count.`);
+      }
+      try {
+        if (existsSync32(filePath)) {
+          const content = readFileSync31(filePath, "utf-8");
+          backups.set(`${input.sessionID}:${input.callID}:${filePath}`, content);
+        }
+      } catch (err) {
+        log("[edit-safeguard] Failed to create backup", { filePath, error: String(err) });
+      }
+    },
+    "tool.execute.after": async (input, output) => {
+      const toolName = input.tool?.toLowerCase();
+      const isEditTool = toolName === "edit" || toolName === "apply_patch";
+      if (!isEditTool)
+        return;
+      const filePath = getFilePath(toolName, output.metadata?.args || {});
+      if (!filePath)
+        return;
+      const backupKey = `${input.sessionID}:${input.callID}:${filePath}`;
+      const originalContent = backups.get(backupKey);
+      if (originalContent === undefined)
+        return;
+      const resultOutput = (output.output ?? "").toLowerCase();
+      const hasFailurePattern = FAILURE_PATTERNS.some((p2) => resultOutput.includes(p2));
+      let currentContent = "";
+      try {
+        currentContent = readFileSync31(filePath, "utf-8");
+      } catch (err) {
+        if (hasFailurePattern) {
+          writeFileSync14(filePath, originalContent);
+          log("[edit-safeguard] Restored deleted file after failed edit", { filePath });
+        }
+        return;
+      }
+      const contentChanged = currentContent !== originalContent;
+      if (hasFailurePattern && contentChanged) {
+        writeFileSync14(filePath, originalContent);
+        log("[edit-safeguard] Reverted partial mutation after " + resultOutput, { filePath });
+        output.output += `
+
+[SAFEGUARD] Reverted partial mutation to prevent corruption.`;
+      }
+      if (hasFailurePattern) {
+        output.output += `
+
+**ACTION REQUIRED**: The edit or patch verification failed. This usually means the file content has drifted or the match block is incorrect.
+` + `You MUST run 'read_file' (or equivalent) on '${filePath}' to synchronize your context with the real file contents, and then regenerate your edit/patch from the exact lines found in the file.`;
+        return;
+      }
+      if (!hasFailurePattern && contentChanged) {
+        if (filePath.endsWith(".py")) {
+          const isValid = validatePythonSyntax(filePath);
+          if (!isValid) {
+            writeFileSync14(filePath, originalContent);
+            log("[edit-safeguard] Reverted edit due to Python syntax error", { filePath });
+            throw new Error(`[edit-safeguard] Syntax validation failed for ${filePath}. Edit reverted to prevent corruption.`);
+          }
+        }
+      }
+      backups.delete(backupKey);
+    }
+  };
+}
+function validatePythonSyntax(filePath) {
+  try {
+    const result = spawnSync("python3", ["-m", "py_compile", filePath]);
+    return result.status === 0;
+  } catch (err) {
+    log("[edit-safeguard] Syntax validation execution failed", { error: String(err) });
+    return true;
+  }
+}
+
+// src/cli/doctor/checks/edit-atomicity.ts
+var checkEditAtomicity = {
+  id: "EDIT_ATOMICITY",
+  name: "Edit Atomicity & Validation",
+  async check() {
+    const testFile = join30(process.cwd(), "test_edit_atomicity.py");
+    const originalContent = `def main():
+    print("hello")
+`;
+    try {
+      writeFileSync15(testFile, originalContent);
+      const hook = createEditSafeguardHook({ directory: process.cwd() });
+      const sessionID = "test-session";
+      const callID = "test-call";
+      await hook["tool.execute.before"]?.({ tool: "edit", sessionID, callID }, { args: { filePath: testFile } });
+      writeFileSync15(testFile, `def main():
+    print("corrupted"
+`);
+      const output = {
+        title: "Edit",
+        output: "Error: oldString not found",
+        metadata: { args: { filePath: testFile } }
+      };
+      await hook["tool.execute.after"]?.({ tool: "edit", sessionID, callID, args: { filePath: testFile } }, output);
+      const contentAfterFail = readFileSync32(testFile, "utf-8");
+      if (contentAfterFail !== originalContent) {
+        return {
+          status: "fail",
+          name: this.name,
+          message: "Edit is NOT atomic. Partial mutation was not reverted after error.",
+          issues: [{
+            title: "Partial Mutation",
+            description: "File content changed despite tool reporting failure.",
+            severity: "error"
+          }]
+        };
+      }
+      await hook["tool.execute.before"]?.({ tool: "edit", sessionID, callID: "call2" }, { args: { filePath: testFile } });
+      writeFileSync15(testFile, `def main():
+    print("invalid")
+    x = [`);
+      const outputSuccess = {
+        title: "Edit",
+        output: "Successfully replaced string",
+        metadata: { args: { filePath: testFile } }
+      };
+      try {
+        await hook["tool.execute.after"]?.({ tool: "edit", sessionID, callID: "call2", args: { filePath: testFile } }, outputSuccess);
+        return {
+          status: "fail",
+          name: this.name,
+          message: "Syntax validation failed to block invalid Python code.",
+          issues: [{
+            title: "Validation Bypass",
+            description: "Edit tool allowed syntactically invalid Python code.",
+            severity: "error"
+          }]
+        };
+      } catch (err) {
+        if (!String(err).includes("Syntax validation failed")) {
+          return {
+            status: "fail",
+            name: this.name,
+            message: `Unexpected error during syntax validation: ${err}`,
+            issues: [{
+              title: "Unexpected Error",
+              description: String(err),
+              severity: "error"
+            }]
+          };
+        }
+      }
+      const contentAfterSyntaxFail = readFileSync32(testFile, "utf-8");
+      if (contentAfterSyntaxFail !== originalContent) {
+        return {
+          status: "fail",
+          name: this.name,
+          message: "File was not reverted after syntax validation failure.",
+          issues: [{
+            title: "Revert Failed",
+            description: "File was not restored to its original state after syntax error.",
+            severity: "error"
+          }]
+        };
+      }
+      return {
+        status: "pass",
+        name: this.name,
+        message: "Edit atomicity and syntax validation are working correctly.",
+        issues: []
+      };
+    } catch (err) {
+      return {
+        status: "fail",
+        name: this.name,
+        message: `Check failed with error: ${err}`,
+        issues: [{
+          title: "Check Error",
+          description: String(err),
+          severity: "error"
+        }]
+      };
+    } finally {
+      if (existsSync33(testFile))
+        unlinkSync3(testFile);
+    }
+  }
+};
+
+// src/cli/doctor/checks/issue-resolution.ts
+import { existsSync as existsSync35, mkdirSync as mkdirSync11, writeFileSync as writeFileSync17, unlinkSync as unlinkSync4 } from "fs";
+import { join as join32 } from "path";
+
+// src/runtime/tools/report-issue-verification.ts
+function createReportIssueVerificationTool() {
+  return tool({
+    name: "report_issue_verification",
+    description: "Report progress on issue verification. Use this tool to permanently record that you have reproduced the issue, applied a fix, and verified the fix. Required before completing any issue-resolution task. Fields are additive, so you can report them one at a time as you proceed.",
+    args: {
+      reproduced: exports_external.boolean().optional().describe("Set to true once you have successfully reproduced the issue live."),
+      errorSignatureBefore: exports_external.string().optional().describe("The exact error message, traceback, or symptom before the fix."),
+      fixApplied: exports_external.boolean().optional().describe("Set to true once you have applied a fix to the codebase."),
+      reproAfterPassed: exports_external.boolean().optional().describe("True if you re-ran the reproduction steps after the fix, and the issue is gone."),
+      failureModeChecksPassed: exports_external.boolean().optional().describe("Set to true if you checked nearby/related failure modes and they pass.")
+    },
+    execute: withToolContract("report_issue_verification", async (args, toolContext) => {
+      const sessionID = toolContext.sessionID;
+      const newState = updateIssueState(sessionID, args);
+      const result = createSuccessResult({
+        verified: true,
+        changedState: true,
+        stateChange: newState,
+        message: `Verification state updated.`
+      });
+      toolContext.metadata({
+        title: "Issue Verification Update",
+        ...result,
+        sessionID,
+        state: newState
+      });
+      let response = `[VERIFICATION LOGGED]
+
+Current Verification State:
+- Reproduced: ${newState.reproduced}
+- Error Signature: ${newState.errorSignatureBefore ?? "None"}
+- Fix Applied: ${newState.fixApplied}
+- Repro After Fix Passed: ${newState.reproAfterPassed}
+- Nearby Checks Passed: ${newState.failureModeChecksPassed}
+
+`;
+      if (isSessionIssueMode(sessionID)) {
+        response += `Note: You are in Strict Issue Resolution Mode. 'reproduced', 'fixApplied', and 'reproAfterPassed' MUST be true to complete this task.`;
+      }
+      return response;
+    })
+  });
+}
+
+// src/runtime/tools/gh-safe.ts
+var {spawn: spawn4 } = globalThis.Bun;
+
+// src/features/pr-state/storage.ts
+import { existsSync as existsSync34, readFileSync as readFileSync33, writeFileSync as writeFileSync16, mkdirSync as mkdirSync10 } from "fs";
+import { join as join31 } from "path";
+import { homedir as homedir9 } from "os";
+var STORAGE_DIR = join31(homedir9(), ".local", "share", "oh-my-opencode");
+var STORAGE_FILE = join31(STORAGE_DIR, "pr-state.json");
+var state2 = {};
+function loadPRState() {
+  try {
+    if (existsSync34(STORAGE_FILE)) {
+      state2 = JSON.parse(readFileSync33(STORAGE_FILE, "utf-8"));
+    }
+  } catch (e2) {
+    state2 = {};
+  }
+}
+function savePRState() {
+  try {
+    if (!existsSync34(STORAGE_DIR)) {
+      mkdirSync10(STORAGE_DIR, { recursive: true });
+    }
+    writeFileSync16(STORAGE_FILE, JSON.stringify(state2, null, 2));
+  } catch (e2) {}
+}
+function updatePRState(sessionID, pr) {
+  const current = state2[sessionID] || { updatedAt: new Date().toISOString() };
+  state2[sessionID] = {
+    ...current,
+    ...pr,
+    updatedAt: new Date().toISOString()
+  };
+  savePRState();
+}
+loadPRState();
+
+// src/runtime/tools/gh-safe.ts
+function createGhSafeTool() {
+  return tool({
+    description: "Safe, structured execution of GitHub CLI (gh) commands. Returns verifiable status.",
+    args: {
+      command: exports_external.string().describe(`The gh command without the 'gh ' prefix (e.g. 'pr create --title "..." --body "..."')`)
+    },
+    execute: withToolContract("gh_safe", async (args, context) => {
+      let commandArgs = [];
+      try {
+        commandArgs = args.command.match(/([^\\"]\S*|".+?")\s*/g)?.map((s) => s.trim().replace(/^"(.*)"$/, "$1")) || [];
+        if (commandArgs.length === 0) {
+          const result2 = createFailureResult("No command provided");
+          context.metadata({ title: "GH Exec Error", ...result2 });
+          return result2.message;
+        }
+        const proc = spawn4(["gh", ...commandArgs], {
+          cwd: context.directory || process.cwd(),
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        const stdoutText = await new Response(proc.stdout).text();
+        const stderrText = await new Response(proc.stderr).text();
+        const exitCode = await proc.exited;
+        const success2 = exitCode === 0;
+        let prURL = "";
+        if (success2 && commandArgs[0] === "pr" && commandArgs[1] === "create") {
+          const match = stdoutText.match(/https:\/\/github\.com\/[^\/]+\/[^\/]+\/pull\/\d+/);
+          if (match) {
+            prURL = match[0];
+            const prNumber = parseInt(prURL.split("/").pop() || "0");
+            updatePRState(context.sessionID, {
+              url: prURL,
+              number: prNumber,
+              status: "open"
+            });
+          }
+        }
+        if (success2 && commandArgs[0] === "pr" && commandArgs[1] === "merge") {
+          updatePRState(context.sessionID, {
+            status: "merged"
+          });
+        }
+        const isStateChanging = ["pr", "issue", "branch", "repo"].includes(commandArgs[0]);
+        const result = createSuccessResult({
+          verified: !isStateChanging,
+          changedState: success2 && isStateChanging,
+          stateChange: prURL ? { type: "git.pr", key: prURL, details: { url: prURL } } : undefined
+        });
+        context.metadata({
+          title: `gh ${commandArgs[0]} ${commandArgs[1] || ""}`,
+          ...result
+        });
+        return `Exit Code: ${exitCode}
+
+STDOUT:
+${stdoutText}
+
+STDERR:
+${stderrText}`;
+      } catch (e2) {
+        const result = createFailureResult(`Execution failed: ${e2.message}`);
+        context.metadata({ title: "GH Exec Error", ...result });
+        return result.message;
+      }
+    })
+  });
+}
+
+// src/runtime/tools/registry.ts
+var DETERMINISTIC_TOOLS = {
+  git_safe: createGitSafeTool,
+  fs_safe: createFsSafeTool,
+  verify_action: createVerifyTool,
+  submit_plan: createSubmitPlanTool,
+  mark_step_complete: createMarkStepCompleteTool,
+  unlock_plan: createUnlockPlanTool,
+  query_ledger: createQueryLedgerTool,
+  complete_task: createCompleteTaskTool,
+  report_issue_verification: createReportIssueVerificationTool,
+  gh_safe: createGhSafeTool
+};
+function getToolFromRegistry(name) {
+  const toolFactory = DETERMINISTIC_TOOLS[name];
+  if (!toolFactory) {
+    throw new Error(`[Tool Registry] Unsupported or unauthorized tool requested: ${name}`);
+  }
+  return toolFactory();
+}
+
+// src/cli/doctor/checks/issue-resolution.ts
+init_data_path();
+async function checkIssueResolutionWorkflow() {
+  const issues = [];
+  const requiredTools = ["report_issue_verification", "complete_task", "gh_safe", "query_ledger"];
+  for (const toolName of requiredTools) {
+    if (!DETERMINISTIC_TOOLS[toolName]) {
+      issues.push({
+        severity: "error",
+        title: "Missing Tool",
+        description: `${toolName} tool is missing from deterministic registry`,
+        fix: `Ensure ${toolName} is registered in src/runtime/tools/registry.ts`
+      });
+    }
+  }
+  try {
+    const dataDir = join32(getDataDir(), "oh-my-opencode");
+    const testFile = join32(dataDir, ".doctor-persistence-test");
+    if (!existsSync35(dataDir)) {
+      mkdirSync11(dataDir, { recursive: true });
+    }
+    writeFileSync17(testFile, "test");
+    unlinkSync4(testFile);
+  } catch (e2) {
+    issues.push({
+      severity: "warning",
+      title: "Persistence Issue",
+      description: `Cannot write to OMO data directory: ${e2.message}`,
+      fix: "Check permissions for your local share directory"
+    });
+  }
+  try {
+    if (DETERMINISTIC_TOOLS["complete_task"]) {
+      const tool3 = DETERMINISTIC_TOOLS["complete_task"]();
+      if (!tool3 || typeof tool3.execute !== "function") {
+        issues.push({
+          severity: "error",
+          title: "Invalid Tool Implementation",
+          description: "complete_task tool has missing or invalid execute function",
+          fix: "Check src/runtime/tools/complete-task.ts"
+        });
+      }
+    }
+  } catch (e2) {
+    issues.push({
+      severity: "error",
+      title: "Tool Initialization Error",
+      description: `Error initializing complete_task for check: ${e2.message}`,
+      fix: "Fix syntax or import errors in complete-task.ts"
+    });
+  }
+  return {
+    name: "Issue Resolution Workflow",
+    message: issues.length === 0 ? "Workflow is intact and persistent" : "Workflow check found issues",
+    status: issues.length === 0 ? "pass" : issues.some((i2) => i2.severity === "error") ? "fail" : "warn",
+    issues
+  };
+}
+
+// src/cli/doctor/checks/tool-metadata.ts
+var import_picocolors19 = __toESM(require_picocolors(), 1);
+var CRITICAL_TOOLS = ["complete_task", "fs_safe", "verify_action", "git_safe", "report_issue_verification"];
+var checkToolMetadataContract = {
+  id: "tool-metadata-contract",
+  name: "Tool Metadata Contract",
+  critical: true,
+  check: async () => {
+    const issues = [];
+    let hasError = false;
+    const mockContext = {
+      sessionID: "doctor-test",
+      callID: "call-test",
+      metadata: (meta3) => {
+        if (typeof meta3.success !== "boolean" || typeof meta3.verified !== "boolean") {
+          hasError = true;
+          issues.push({
+            severity: "error",
+            title: "Malformed Metadata",
+            description: `Tool did not return boolean 'success' and 'verified' fields in context.metadata(). Found: ${JSON.stringify(meta3)}`,
+            fix: "Wrap the tool with withToolContract."
+          });
+        }
+      }
+    };
+    for (const toolName of CRITICAL_TOOLS) {
+      try {
+        const toolSpec = getToolFromRegistry(toolName);
+        if (!toolSpec) {
+          issues.push({
+            severity: "warning",
+            title: "Unregistered Tool",
+            description: `Critical tool '${toolName}' is not registered.`,
+            fix: "Check src/runtime/tools/registry.ts."
+          });
+          continue;
+        }
+        await toolSpec.execute({ invalid_arg: "should_fail" }, mockContext);
+      } catch (err) {
+        issues.push({
+          severity: "error",
+          title: "Unhandled Tool Exception",
+          description: `Tool '${toolName}' threw an unhandled exception instead of returning a safe failure result. Error: ${err.message}`,
+          fix: "Wrap the tool's execute block with withToolContract to ensure safe fallbacks."
+        });
+        hasError = true;
+      }
+    }
+    if (hasError) {
+      return {
+        name: "Tool Metadata Contract",
+        status: "fail",
+        message: import_picocolors19.default.red("Critical tools are violating the metadata contract on error paths."),
+        issues
+      };
+    }
+    return {
+      name: "Tool Metadata Contract",
+      status: "pass",
+      message: import_picocolors19.default.green("All critical tools conform to the structured metadata contract."),
+      issues
+    };
+  }
+};
+
+// src/cli/doctor/checks/run-state-watchdog.ts
+var import_picocolors20 = __toESM(require_picocolors(), 1);
+
+// src/features/run-state-watchdog/manager.ts
+init_logger();
+
+class RunStateWatchdogManager {
+  client;
+  activeSessions = new Map;
+  pollingIntervalMs;
+  stallThresholdMs;
+  timer = null;
+  constructor(client3, opts) {
+    this.client = client3;
+    this.pollingIntervalMs = opts?.pollingIntervalMs ?? 5000;
+    this.stallThresholdMs = opts?.stallThresholdMs ?? 15000;
+  }
+  start() {
+    if (this.timer)
+      return;
+    this.timer = setInterval(() => this.checkStalledRuns(), this.pollingIntervalMs);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  updateState(sessionID, state3) {
+    const ctx = this.getOrCreate(sessionID);
+    ctx.currentState = state3;
+    ctx.lastActivityAt = Date.now();
+  }
+  recordActivity(sessionID, type2) {
+    const ctx = this.getOrCreate(sessionID);
+    const now = Date.now();
+    ctx.lastActivityAt = now;
+    if (type2 === "text") {
+      ctx.lastTextFragmentAt = now;
+    } else if (type2 === "tool") {
+      ctx.lastToolCallAt = now;
+    }
+  }
+  updateTodos(sessionID, count) {
+    const ctx = this.getOrCreate(sessionID);
+    ctx.openTodos = count;
+  }
+  getContext(sessionID) {
+    return this.activeSessions.get(sessionID);
+  }
+  getOrCreate(sessionID) {
+    let ctx = this.activeSessions.get(sessionID);
+    if (!ctx) {
+      ctx = {
+        sessionID,
+        currentState: "idle",
+        lastActivityAt: Date.now(),
+        lastTextFragmentAt: Date.now(),
+        lastToolCallAt: Date.now(),
+        openTodos: 0
+      };
+      this.activeSessions.set(sessionID, ctx);
+    }
+    return ctx;
+  }
+  async checkStalledRuns() {
+    const now = Date.now();
+    for (const [sessionID, ctx] of this.activeSessions.entries()) {
+      if (ctx.currentState !== "running" && ctx.currentState !== "waiting")
+        continue;
+      const timeSinceLastActivity = now - ctx.lastActivityAt;
+      const timeSinceText = now - ctx.lastTextFragmentAt;
+      const timeSinceTool = now - ctx.lastToolCallAt;
+      if (timeSinceText > this.stallThresholdMs && timeSinceTool > this.stallThresholdMs) {
+        log(`[RunStateWatchdog] Detected stalled run for session ${sessionID}.`, {
+          timeSinceText,
+          timeSinceTool,
+          openTodos: ctx.openTodos
+        });
+        log(`[RunStateWatchdog] TERMINATING stalled session ${sessionID}.`);
+        this.client.session.abort({
+          path: { id: sessionID }
+        }).catch((err) => {
+          log(`[RunStateWatchdog] Failed to abort stalled session ${sessionID}`, { error: String(err) });
+        });
+        const tuiClient = this.client;
+        if (tuiClient.tui?.showToast) {
+          tuiClient.tui.showToast({
+            body: {
+              title: "Task Aborted",
+              message: "Session terminated due to inactivity / stall detection.",
+              variant: "error",
+              duration: 5000
+            }
+          }).catch(() => {});
+        }
+        this.activeSessions.delete(sessionID);
+      }
+    }
+  }
+}
+
+// src/cli/doctor/checks/run-state-watchdog.ts
+var checkRunStateWatchdog = {
+  id: "run-state-watchdog",
+  name: "Run State Watchdog",
+  critical: true,
+  check: async () => {
+    const issues = [];
+    let hasError = false;
+    let toastCalls = 0;
+    const mockClient = {
+      tui: {
+        showToast: async () => {
+          toastCalls++;
+        }
+      }
+    };
+    const manager = new RunStateWatchdogManager(mockClient, { pollingIntervalMs: 5, stallThresholdMs: 20 });
+    manager.updateState("sess-doctor", "running");
+    manager.recordActivity("sess-doctor", "text");
+    await new Promise((r2) => setTimeout(r2, 25));
+    await manager.checkStalledRuns();
+    if (toastCalls === 0) {
+      hasError = true;
+      issues.push({
+        severity: "error",
+        title: "Watchdog Stall Detection Failed",
+        description: "Watchdog did not emit a toast when a session with status 'running' had no recent text/tool activity.",
+        fix: "Verify RunStateWatchdogManager polling thresholds and state storage."
+      });
+    }
+    toastCalls = 0;
+    manager.updateState("sess-doctor", "idle");
+    await new Promise((r2) => setTimeout(r2, 25));
+    await manager.checkStalledRuns();
+    if (toastCalls > 0) {
+      hasError = true;
+      issues.push({
+        severity: "warning",
+        title: "Watchdog False Positive",
+        description: "Watchdog emitted a stall toast for an 'idle' session.",
+        fix: "Watchdog should ignore idle or non-active sessions."
+      });
+    }
+    manager.stop();
+    if (hasError) {
+      return {
+        name: "Run State Watchdog",
+        status: "fail",
+        message: import_picocolors20.default.red("Run State Watchdog failed coverage checks."),
+        issues
+      };
+    }
+    return {
+      name: "Run State Watchdog",
+      status: "pass",
+      message: import_picocolors20.default.green("Watchdog detects and surfaces stalled runs correctly."),
+      issues
+    };
+  }
+};
+// src/cli/doctor/checks/index.ts
+function getAllCheckDefinitions() {
+  return [
+    {
+      id: CHECK_IDS.SYSTEM,
+      name: CHECK_NAMES[CHECK_IDS.SYSTEM],
+      check: checkSystem,
+      critical: true
+    },
+    {
+      id: CHECK_IDS.CONFIG,
+      name: CHECK_NAMES[CHECK_IDS.CONFIG],
+      check: checkConfig
+    },
     {
       id: CHECK_IDS.TOOLS,
       name: CHECK_NAMES[CHECK_IDS.TOOLS],
@@ -28561,15 +30797,50 @@ function getAllCheckDefinitions() {
       id: CHECK_IDS.DEFAULT_CONFIG,
       name: CHECK_NAMES[CHECK_IDS.DEFAULT_CONFIG],
       check: checkDefaultConfig
+    },
+    {
+      id: CHECK_IDS.PLAN_COMPILER,
+      name: CHECK_NAMES[CHECK_IDS.PLAN_COMPILER],
+      check: checkPlanCompiler
+    },
+    {
+      id: CHECK_IDS.PROGRESS,
+      name: CHECK_NAMES[CHECK_IDS.PROGRESS],
+      check: checkProgress
+    },
+    {
+      id: CHECK_IDS.EDIT_ATOMICITY,
+      name: CHECK_NAMES[CHECK_IDS.EDIT_ATOMICITY],
+      check: checkEditAtomicity.check
+    },
+    {
+      id: "issue-resolution",
+      name: "Issue Resolution Workflow",
+      check: checkIssueResolutionWorkflow
+    },
+    {
+      id: checkToolMetadataContract.id,
+      name: checkToolMetadataContract.name,
+      check: checkToolMetadataContract.check
+    },
+    {
+      id: checkRunStateWatchdog.id,
+      name: checkRunStateWatchdog.name,
+      check: checkRunStateWatchdog.check
+    },
+    {
+      id: "TOOL_CONTRACT",
+      name: "Tool Contract Compliance",
+      check: checkToolContract
     }
   ];
 }
 
 // src/cli/doctor/format-default.ts
-var import_picocolors20 = __toESM(require_picocolors(), 1);
+var import_picocolors22 = __toESM(require_picocolors(), 1);
 
 // src/cli/doctor/format-shared.ts
-var import_picocolors19 = __toESM(require_picocolors(), 1);
+var import_picocolors21 = __toESM(require_picocolors(), 1);
 function formatStatusSymbol(status) {
   const colorFn = STATUS_COLORS[status];
   switch (status) {
@@ -28584,23 +30855,23 @@ function formatStatusSymbol(status) {
   }
 }
 function formatStatusMark(available) {
-  return available ? import_picocolors19.default.green(SYMBOLS3.check) : import_picocolors19.default.red(SYMBOLS3.cross);
+  return available ? import_picocolors21.default.green(SYMBOLS3.check) : import_picocolors21.default.red(SYMBOLS3.cross);
 }
 function formatHeader() {
   return `
-${import_picocolors19.default.bgMagenta(import_picocolors19.default.white(" oMoMoMoMo Doctor "))}
+${import_picocolors21.default.bgMagenta(import_picocolors21.default.white(" oMoMoMoMo Doctor "))}
 `;
 }
 function formatIssue(issue2, index) {
   const lines = [];
-  const severityColor = issue2.severity === "error" ? import_picocolors19.default.red : import_picocolors19.default.yellow;
+  const severityColor = issue2.severity === "error" ? import_picocolors21.default.red : import_picocolors21.default.yellow;
   lines.push(`${index}. ${severityColor(issue2.title)}`);
-  lines.push(`   ${import_picocolors19.default.dim(issue2.description)}`);
+  lines.push(`   ${import_picocolors21.default.dim(issue2.description)}`);
   if (issue2.fix) {
-    lines.push(`   ${import_picocolors19.default.cyan("Fix:")} ${import_picocolors19.default.dim(issue2.fix)}`);
+    lines.push(`   ${import_picocolors21.default.cyan("Fix:")} ${import_picocolors21.default.dim(issue2.fix)}`);
   }
   if (issue2.affects && issue2.affects.length > 0) {
-    lines.push(`   ${import_picocolors19.default.cyan("Affects:")} ${import_picocolors19.default.dim(issue2.affects.join(", "))}`);
+    lines.push(`   ${import_picocolors21.default.cyan("Affects:")} ${import_picocolors21.default.dim(issue2.affects.join(", "))}`);
   }
   return lines.join(`
 `);
@@ -28614,12 +30885,12 @@ function formatDefault(result) {
   if (allIssues.length === 0) {
     const opencodeVer = result.systemInfo.opencodeVersion ?? "unknown";
     const pluginVer = result.systemInfo.pluginVersion ?? "unknown";
-    lines.push(` ${import_picocolors20.default.green(SYMBOLS3.check)} ${import_picocolors20.default.green(`System OK (opencode ${opencodeVer} \xB7 oh-my-opencode ${pluginVer})`)}`);
+    lines.push(` ${import_picocolors22.default.green(SYMBOLS3.check)} ${import_picocolors22.default.green(`System OK (opencode ${opencodeVer} \xB7 oh-my-opencode ${pluginVer})`)}`);
   } else {
     const issueCount = allIssues.filter((i2) => i2.severity === "error").length;
     const warnCount = allIssues.filter((i2) => i2.severity === "warning").length;
     const totalStr = `${issueCount + warnCount} ${issueCount + warnCount === 1 ? "issue" : "issues"}`;
-    lines.push(` ${import_picocolors20.default.yellow(SYMBOLS3.warn)} ${totalStr} found:
+    lines.push(` ${import_picocolors22.default.yellow(SYMBOLS3.warn)} ${totalStr} found:
 `);
     allIssues.forEach((issue2, index) => {
       lines.push(formatIssue(issue2, index + 1));
@@ -28631,7 +30902,7 @@ function formatDefault(result) {
 }
 
 // src/cli/doctor/format-status.ts
-var import_picocolors21 = __toESM(require_picocolors(), 1);
+var import_picocolors23 = __toESM(require_picocolors(), 1);
 function formatStatus(result) {
   const lines = [];
   lines.push(formatHeader());
@@ -28642,7 +30913,7 @@ function formatStatus(result) {
   const bunVer = systemInfo.bunVersion ?? "unknown";
   lines.push(` ${padding}System     ${opencodeVer} \xB7 ${pluginVer} \xB7 Bun ${bunVer}`);
   const configPath = systemInfo.configPath ?? "unknown";
-  const configStatus = systemInfo.configValid ? import_picocolors21.default.green("(valid)") : import_picocolors21.default.red("(invalid)");
+  const configStatus = systemInfo.configValid ? import_picocolors23.default.green("(valid)") : import_picocolors23.default.red("(invalid)");
   lines.push(` ${padding}Config     ${configPath} ${configStatus}`);
   const lspText = `LSP ${tools.lspInstalled}/${tools.lspTotal}`;
   const astGrepMark = formatStatusMark(tools.astGrepCli);
@@ -28654,18 +30925,40 @@ function formatStatus(result) {
   const builtinText = builtinCount > 0 ? tools.mcpBuiltin.join(" \xB7 ") : "none";
   const userText = userCount > 0 ? `+ ${userCount} user` : "";
   lines.push(` ${padding}MCPs       ${builtinText} ${userText}`);
+  if (result.activeTasks && result.activeTasks.length > 0) {
+    const activeTasks = result.activeTasks;
+    lines.push("");
+    lines.push(` ${padding}Active Tasks (${activeTasks.length}):`);
+    for (const task of activeTasks) {
+      const { agent, description, progress } = task;
+      const bar = renderProgressBar(progress?.percent);
+      const phase = progress?.phase ? ` [${progress.phase}]` : "";
+      const message = progress?.message ? ` (${progress.message})` : "";
+      lines.push(`   ${import_picocolors23.default.blue("\xB7")} ${import_picocolors23.default.bold(agent)}: ${description}${phase}${message}`);
+      lines.push(`     ${bar}`);
+    }
+  }
   return lines.join(`
 `);
 }
+function renderProgressBar(percent) {
+  if (percent === undefined)
+    return import_picocolors23.default.dim("[\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591]");
+  const totalBlocks = 10;
+  const filledBlocks = Math.round(percent / 100 * totalBlocks);
+  const emptyBlocks = totalBlocks - filledBlocks;
+  const bar = import_picocolors23.default.cyan("\u2588".repeat(filledBlocks)) + import_picocolors23.default.dim("\u2591".repeat(emptyBlocks));
+  return `[${bar}] ${import_picocolors23.default.bold(percent + "%")}`;
+}
 
 // src/cli/doctor/format-verbose.ts
-var import_picocolors22 = __toESM(require_picocolors(), 1);
+var import_picocolors24 = __toESM(require_picocolors(), 1);
 function formatVerbose(result) {
   const lines = [];
   lines.push(formatHeader());
   const { systemInfo, tools, results, summary } = result;
-  lines.push(`${import_picocolors22.default.bold("System Information")}`);
-  lines.push(`${import_picocolors22.default.dim("\u2500".repeat(40))}`);
+  lines.push(`${import_picocolors24.default.bold("System Information")}`);
+  lines.push(`${import_picocolors24.default.dim("\u2500".repeat(40))}`);
   lines.push(`  ${formatStatusSymbol("pass")} opencode    ${systemInfo.opencodeVersion ?? "unknown"}`);
   lines.push(`  ${formatStatusSymbol("pass")} oh-my-opencode ${systemInfo.pluginVersion ?? "unknown"}`);
   if (systemInfo.loadedVersion) {
@@ -28676,33 +30969,33 @@ function formatVerbose(result) {
   }
   lines.push(`  ${formatStatusSymbol("pass")} path        ${systemInfo.opencodePath ?? "unknown"}`);
   if (systemInfo.isLocalDev) {
-    lines.push(`  ${import_picocolors22.default.yellow("*")} ${import_picocolors22.default.dim("(local development mode)")}`);
+    lines.push(`  ${import_picocolors24.default.yellow("*")} ${import_picocolors24.default.dim("(local development mode)")}`);
   }
   lines.push("");
-  lines.push(`${import_picocolors22.default.bold("Configuration")}`);
-  lines.push(`${import_picocolors22.default.dim("\u2500".repeat(40))}`);
-  const configStatus = systemInfo.configValid ? import_picocolors22.default.green("valid") : import_picocolors22.default.red("invalid");
+  lines.push(`${import_picocolors24.default.bold("Configuration")}`);
+  lines.push(`${import_picocolors24.default.dim("\u2500".repeat(40))}`);
+  const configStatus = systemInfo.configValid ? import_picocolors24.default.green("valid") : import_picocolors24.default.red("invalid");
   lines.push(`  ${formatStatusSymbol(systemInfo.configValid ? "pass" : "fail")} ${systemInfo.configPath ?? "unknown"} (${configStatus})`);
   lines.push("");
-  lines.push(`${import_picocolors22.default.bold("Tools")}`);
-  lines.push(`${import_picocolors22.default.dim("\u2500".repeat(40))}`);
+  lines.push(`${import_picocolors24.default.bold("Tools")}`);
+  lines.push(`${import_picocolors24.default.dim("\u2500".repeat(40))}`);
   lines.push(`  ${formatStatusSymbol("pass")} LSP         ${tools.lspInstalled}/${tools.lspTotal} installed`);
   lines.push(`  ${formatStatusSymbol(tools.astGrepCli ? "pass" : "fail")} ast-grep CLI ${tools.astGrepCli ? "installed" : "not found"}`);
   lines.push(`  ${formatStatusSymbol(tools.astGrepNapi ? "pass" : "fail")} ast-grep napi ${tools.astGrepNapi ? "installed" : "not found"}`);
   lines.push(`  ${formatStatusSymbol(tools.commentChecker ? "pass" : "fail")} comment-checker ${tools.commentChecker ? "installed" : "not found"}`);
   lines.push(`  ${formatStatusSymbol(tools.ghCli.installed && tools.ghCli.authenticated ? "pass" : "fail")} gh CLI ${tools.ghCli.installed ? "installed" : "not found"}${tools.ghCli.authenticated && tools.ghCli.username ? ` (${tools.ghCli.username})` : ""}`);
   lines.push("");
-  lines.push(`${import_picocolors22.default.bold("MCPs")}`);
-  lines.push(`${import_picocolors22.default.dim("\u2500".repeat(40))}`);
+  lines.push(`${import_picocolors24.default.bold("MCPs")}`);
+  lines.push(`${import_picocolors24.default.dim("\u2500".repeat(40))}`);
   if (tools.mcpBuiltin.length === 0) {
-    lines.push(`  ${import_picocolors22.default.dim("No built-in MCPs")}`);
+    lines.push(`  ${import_picocolors24.default.dim("No built-in MCPs")}`);
   } else {
     for (const mcp of tools.mcpBuiltin) {
       lines.push(`  ${formatStatusSymbol("pass")} ${mcp}`);
     }
   }
   if (tools.mcpUser.length > 0) {
-    lines.push(`  ${import_picocolors22.default.cyan("+")} ${tools.mcpUser.length} user MCP(s):`);
+    lines.push(`  ${import_picocolors24.default.cyan("+")} ${tools.mcpUser.length} user MCP(s):`);
     for (const mcp of tools.mcpUser) {
       lines.push(`    ${formatStatusSymbol("pass")} ${mcp}`);
     }
@@ -28710,20 +31003,20 @@ function formatVerbose(result) {
   lines.push("");
   const allIssues = results.flatMap((r2) => r2.issues);
   if (allIssues.length > 0) {
-    lines.push(`${import_picocolors22.default.bold("Issues")}`);
-    lines.push(`${import_picocolors22.default.dim("\u2500".repeat(40))}`);
+    lines.push(`${import_picocolors24.default.bold("Issues")}`);
+    lines.push(`${import_picocolors24.default.dim("\u2500".repeat(40))}`);
     allIssues.forEach((issue2, index) => {
       lines.push(formatIssue(issue2, index + 1));
       lines.push("");
     });
   }
-  lines.push(`${import_picocolors22.default.bold("Summary")}`);
-  lines.push(`${import_picocolors22.default.dim("\u2500".repeat(40))}`);
-  const passText = summary.passed > 0 ? import_picocolors22.default.green(`${summary.passed} passed`) : `${summary.passed} passed`;
-  const failText = summary.failed > 0 ? import_picocolors22.default.red(`${summary.failed} failed`) : `${summary.failed} failed`;
-  const warnText = summary.warnings > 0 ? import_picocolors22.default.yellow(`${summary.warnings} warnings`) : `${summary.warnings} warnings`;
+  lines.push(`${import_picocolors24.default.bold("Summary")}`);
+  lines.push(`${import_picocolors24.default.dim("\u2500".repeat(40))}`);
+  const passText = summary.passed > 0 ? import_picocolors24.default.green(`${summary.passed} passed`) : `${summary.passed} passed`;
+  const failText = summary.failed > 0 ? import_picocolors24.default.red(`${summary.failed} failed`) : `${summary.failed} failed`;
+  const warnText = summary.warnings > 0 ? import_picocolors24.default.yellow(`${summary.warnings} warnings`) : `${summary.warnings} warnings`;
   lines.push(`  ${passText}, ${failText}, ${warnText}`);
-  lines.push(`  ${import_picocolors22.default.dim(`Total: ${summary.total} checks in ${summary.duration}ms`)}`);
+  lines.push(`  ${import_picocolors24.default.dim(`Total: ${summary.total} checks in ${summary.duration}ms`)}`);
   return lines.join(`
 `);
 }
@@ -28776,10 +31069,11 @@ function determineExitCode(results) {
 async function runDoctor(options) {
   const start = performance.now();
   const allChecks = getAllCheckDefinitions();
-  const [results, systemInfo, tools] = await Promise.all([
+  const [results, systemInfo, tools, activeTasks] = await Promise.all([
     Promise.all(allChecks.map(runCheck)),
     gatherSystemInfo(),
-    gatherToolsSummary()
+    gatherToolsSummary(),
+    Promise.resolve(readActiveTasks())
   ]);
   const duration3 = performance.now() - start;
   const summary = calculateSummary(results, duration3);
@@ -28789,6 +31083,7 @@ async function runDoctor(options) {
     systemInfo,
     tools,
     summary,
+    activeTasks,
     exitCode
   };
   if (options.json) {
@@ -28807,11 +31102,11 @@ async function doctor(options = { mode: "default" }) {
 
 // src/features/mcp-oauth/storage.ts
 init_shared();
-import { chmodSync, existsSync as existsSync29, mkdirSync as mkdirSync7, readFileSync as readFileSync29, unlinkSync as unlinkSync2, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname10, join as join28 } from "path";
+import { chmodSync, existsSync as existsSync36, mkdirSync as mkdirSync12, readFileSync as readFileSync34, unlinkSync as unlinkSync5, writeFileSync as writeFileSync18 } from "fs";
+import { dirname as dirname11, join as join33 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
-  return join28(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
+  return join33(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
 }
 function normalizeHost(serverHost) {
   let host = serverHost.trim();
@@ -28848,11 +31143,11 @@ function buildKey(serverHost, resource) {
 }
 function readStore() {
   const filePath = getMcpOauthStoragePath();
-  if (!existsSync29(filePath)) {
+  if (!existsSync36(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync29(filePath, "utf-8");
+    const content = readFileSync34(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -28861,11 +31156,11 @@ function readStore() {
 function writeStore(store2) {
   const filePath = getMcpOauthStoragePath();
   try {
-    const dir = dirname10(filePath);
-    if (!existsSync29(dir)) {
-      mkdirSync7(dir, { recursive: true });
+    const dir = dirname11(filePath);
+    if (!existsSync36(dir)) {
+      mkdirSync12(dir, { recursive: true });
     }
-    writeFileSync11(filePath, JSON.stringify(store2, null, 2), { encoding: "utf-8", mode: 384 });
+    writeFileSync18(filePath, JSON.stringify(store2, null, 2), { encoding: "utf-8", mode: 384 });
     chmodSync(filePath, 384);
     return true;
   } catch {
@@ -28897,8 +31192,8 @@ function deleteToken(serverHost, resource) {
   if (Object.keys(store2).length === 0) {
     try {
       const filePath = getMcpOauthStoragePath();
-      if (existsSync29(filePath)) {
-        unlinkSync2(filePath);
+      if (existsSync36(filePath)) {
+        unlinkSync5(filePath);
       }
       return true;
     } catch {
@@ -29077,7 +31372,7 @@ async function findAvailablePort2(startPort = DEFAULT_PORT) {
 }
 
 // src/features/mcp-oauth/oauth-authorization-flow.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import { createHash, randomBytes as randomBytes2 } from "crypto";
 import { createServer } from "http";
 function generateCodeVerifier() {
@@ -29104,13 +31399,13 @@ function buildAuthorizationUrl(authorizationEndpoint, options) {
 }
 var CALLBACK_TIMEOUT_MS = 5 * 60 * 1000;
 function startCallbackServer(port) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     let timeoutId;
     const server2 = createServer((request, response) => {
       clearTimeout(timeoutId);
       const requestUrl = new URL(request.url ?? "/", `http://localhost:${port}`);
       const code = requestUrl.searchParams.get("code");
-      const state = requestUrl.searchParams.get("state");
+      const state3 = requestUrl.searchParams.get("state");
       const error48 = requestUrl.searchParams.get("error");
       if (error48) {
         const errorDescription = requestUrl.searchParams.get("error_description") ?? error48;
@@ -29120,7 +31415,7 @@ function startCallbackServer(port) {
         reject(new Error(`OAuth authorization error: ${errorDescription}`));
         return;
       }
-      if (!code || !state) {
+      if (!code || !state3) {
         response.writeHead(400, { "content-type": "text/html" });
         response.end("<html><body><h1>Missing code or state</h1></body></html>");
         server2.close();
@@ -29130,7 +31425,7 @@ function startCallbackServer(port) {
       response.writeHead(200, { "content-type": "text/html" });
       response.end("<html><body><h1>Authorization successful. You can close this tab.</h1></body></html>");
       server2.close();
-      resolve2({ code, state });
+      resolve3({ code, state: state3 });
     });
     timeoutId = setTimeout(() => {
       server2.close();
@@ -29158,7 +31453,7 @@ function openBrowser(url2) {
     args = [url2];
   }
   try {
-    const child = spawn2(command, args, { stdio: "ignore", detached: true });
+    const child = spawn5(command, args, { stdio: "ignore", detached: true });
     child.on("error", () => {});
     child.unref();
   } catch {}
@@ -29166,19 +31461,19 @@ function openBrowser(url2) {
 async function runAuthorizationCodeRedirect(options) {
   const verifier = generateCodeVerifier();
   const challenge = generateCodeChallenge(verifier);
-  const state = randomBytes2(16).toString("hex");
+  const state3 = randomBytes2(16).toString("hex");
   const authorizationUrl = buildAuthorizationUrl(options.authorizationEndpoint, {
     clientId: options.clientId,
     redirectUri: options.redirectUri,
     codeChallenge: challenge,
-    state,
+    state: state3,
     scopes: options.scopes,
     resource: options.resource
   });
   const callbackPromise = startCallbackServer(options.callbackPort);
   openBrowser(authorizationUrl);
   const result = await callbackPromise;
-  if (result.state !== state) {
+  if (result.state !== state3) {
     throw new Error("OAuth state mismatch");
   }
   return { code: result.code, verifier };
@@ -29428,21 +31723,54 @@ function createMcpOAuthCommand() {
 }
 
 // src/cli/master-login/index.ts
-var import_picocolors23 = __toESM(require_picocolors(), 1);
-import { writeFileSync as writeFileSync12, mkdirSync as mkdirSync8, existsSync as existsSync30 } from "fs";
-import { join as join29, dirname as dirname11 } from "path";
+var import_picocolors25 = __toESM(require_picocolors(), 1);
+import { writeFileSync as writeFileSync19, mkdirSync as mkdirSync13, existsSync as existsSync37 } from "fs";
+import { join as join34, dirname as dirname12 } from "path";
 import * as os5 from "os";
+import { createRequire as createRequire2 } from "module";
+async function resolvePlaywright() {
+  try {
+    return await import("playwright");
+  } catch (e2) {}
+  const binaryDir = dirname12(process.execPath);
+  let currentDir = binaryDir;
+  for (let i2 = 0;i2 < 6; i2++) {
+    const potentialPath = join34(currentDir, "node_modules", "playwright");
+    if (existsSync37(potentialPath)) {
+      try {
+        const require2 = createRequire2(join34(currentDir, "index.js"));
+        return require2("playwright");
+      } catch (e2) {}
+    }
+    const parent = dirname12(currentDir);
+    if (parent === currentDir)
+      break;
+    currentDir = parent;
+  }
+  throw new Error("Cannot find package 'playwright'. Please ensure it's installed via 'npm install -g @heidi-dang/oh-my-opencode'.");
+}
 async function masterLogin(options) {
-  const configPath = join29(os5.homedir(), ".ygka_config.json");
-  if (existsSync30(configPath) && !options.force) {
-    console.log(`${import_picocolors23.default.yellow("[exists]")} ${import_picocolors23.default.dim(configPath)}`);
-    console.log(import_picocolors23.default.dim("YGKA config already exists. Use --force to overwrite."));
+  const configPath = join34(os5.homedir(), ".ygka_config.json");
+  if (existsSync37(configPath) && !options.force) {
+    console.log(`${import_picocolors25.default.yellow("[exists]")} ${import_picocolors25.default.dim(configPath)}`);
+    console.log(import_picocolors25.default.dim("YGKA config already exists. Use --force to overwrite."));
     return 0;
   }
-  console.log(import_picocolors23.default.cyan("\uD83D\uDE80 Launching browser for ChatGPT login..."));
-  console.log(import_picocolors23.default.dim("Please log in to chat.openai.com in the window that appears."));
-  console.log(import_picocolors23.default.dim("Once logged in, return here. I will automatically detect the session."));
-  const { chromium } = await import("playwright");
+  let playwrightModule;
+  try {
+    playwrightModule = await resolvePlaywright();
+  } catch (err) {
+    console.error(import_picocolors25.default.red(`
+[error] Playwright not found.`));
+    console.log(import_picocolors25.default.dim("This command requires Playwright to automate the login process."));
+    console.log(import_picocolors25.default.dim("Please try running: npm install -g @heidi-dang/oh-my-opencode"));
+    console.log(import_picocolors25.default.dim(`Diagnostic: looked for 'playwright' in ${dirname12(process.execPath)} and parents.`));
+    return 1;
+  }
+  console.log(import_picocolors25.default.cyan("\uD83D\uDE80 Launching browser for ChatGPT login..."));
+  console.log(import_picocolors25.default.dim("Please log in to chat.openai.com in the window that appears."));
+  console.log(import_picocolors25.default.dim("Once logged in, return here. I will automatically detect the session."));
+  const { chromium } = playwrightModule;
   const browser = await chromium.launch({ headless: false });
   const context = await browser.newContext();
   const page = await context.newPage();
@@ -29459,18 +31787,18 @@ async function masterLogin(options) {
       sessionToken = sessionCookie.value;
       break;
     }
-    process.stdout.write(`\r${import_picocolors23.default.blue(spinner[spinnerIdx])} Waiting for login... `);
+    process.stdout.write(`\r${import_picocolors25.default.blue(spinner[spinnerIdx])} Waiting for login... `);
     spinnerIdx = (spinnerIdx + 1) % spinner.length;
-    await new Promise((resolve2) => setTimeout(resolve2, 500));
+    await new Promise((resolve3) => setTimeout(resolve3, 500));
   }
   process.stdout.write("\r");
   if (!sessionToken) {
-    console.error(import_picocolors23.default.red(`
+    console.error(import_picocolors25.default.red(`
 [error] Login timed out or session token not found.`));
     await browser.close();
     return 1;
   }
-  console.log(import_picocolors23.default.green(`
+  console.log(import_picocolors25.default.green(`
 [ok] Session token captured successfully!`));
   let accessToken;
   try {
@@ -29491,12 +31819,12 @@ async function masterLogin(options) {
     browser_name: "playwright-internal"
   };
   try {
-    mkdirSync8(dirname11(configPath), { recursive: true });
-    writeFileSync12(configPath, JSON.stringify(config2, null, 2), "utf-8");
-    console.log(`${import_picocolors23.default.green("[ok]")} Saved YGKA config to ${import_picocolors23.default.white(configPath)}`);
+    mkdirSync13(dirname12(configPath), { recursive: true });
+    writeFileSync19(configPath, JSON.stringify(config2, null, 2), "utf-8");
+    console.log(`${import_picocolors25.default.green("[ok]")} Saved YGKA config to ${import_picocolors25.default.white(configPath)}`);
     return 0;
   } catch (err) {
-    console.error(import_picocolors23.default.red(`[error] Failed to write config: ${err instanceof Error ? err.message : String(err)}`));
+    console.error(import_picocolors25.default.red(`[error] Failed to write config: ${err instanceof Error ? err.message : String(err)}`));
     return 1;
   }
 }