oh-my-opencode 4.16.2 → 4.16.3

package/dist/index.js

@@ -20933,6 +20933,11 @@ var AGENT_MODEL_REQUIREMENTS = {
   },
   hephaestus: {
     fallbackChain: [
+      {
+        providers: ["openai", "vercel"],
+        model: "gpt-5.6-sol",
+        variant: "medium"
+      },
       {
         providers: ["openai", "github-copilot", "opencode", "vercel"],
         model: "gpt-5.5",
@@ -20959,7 +20964,7 @@ var AGENT_MODEL_REQUIREMENTS = {
         model: "claude-opus-4-7",
         variant: "max"
       },
-      { providers: ["opencode-go", "vercel"], model: "glm-5.1" }
+      { providers: ["opencode-go", "vercel"], model: "glm-5.2" }
     ]
   },
   librarian: {
@@ -21006,7 +21011,7 @@ var AGENT_MODEL_REQUIREMENTS = {
         model: "gpt-5.5",
         variant: "high"
       },
-      { providers: ["opencode-go", "vercel"], model: "glm-5.1" },
+      { providers: ["opencode-go", "vercel"], model: "glm-5.2" },
       {
         providers: ["google", "github-copilot", "opencode", "vercel"],
         model: "gemini-3.1-pro"
@@ -21029,12 +21034,17 @@ var AGENT_MODEL_REQUIREMENTS = {
         model: "gpt-5.5",
         variant: "high"
       },
-      { providers: ["opencode-go", "vercel"], model: "glm-5.1" },
+      { providers: ["opencode-go", "vercel"], model: "glm-5.2" },
       { providers: ["kimi-for-coding"], model: "k2p5" }
     ]
   },
   momus: {
     fallbackChain: [
+      {
+        providers: ["openai", "vercel"],
+        model: "gpt-5.6-sol",
+        variant: "xhigh"
+      },
       {
         providers: ["openai", "github-copilot", "opencode", "vercel"],
         model: "gpt-5.5",
@@ -21050,7 +21060,7 @@ var AGENT_MODEL_REQUIREMENTS = {
         model: "gemini-3.1-pro",
         variant: "high"
       },
-      { providers: ["opencode-go", "vercel"], model: "glm-5.1" }
+      { providers: ["opencode-go", "vercel"], model: "glm-5.2" }
     ]
   },
   atlas: {
@@ -21098,12 +21108,17 @@ var CATEGORY_MODEL_REQUIREMENTS = {
         model: "claude-opus-4-7",
         variant: "max"
       },
-      { providers: ["opencode-go", "vercel"], model: "glm-5.1" },
+      { providers: ["opencode-go", "vercel"], model: "glm-5.2" },
       { providers: ["kimi-for-coding"], model: "k2p5" }
     ]
   },
   ultrabrain: {
     fallbackChain: [
+      {
+        providers: ["openai", "vercel"],
+        model: "gpt-5.6-sol",
+        variant: "xhigh"
+      },
       {
         providers: ["openai", "opencode", "vercel"],
         model: "gpt-5.5",
@@ -21119,11 +21134,16 @@ var CATEGORY_MODEL_REQUIREMENTS = {
         model: "claude-opus-4-7",
         variant: "max"
       },
-      { providers: ["opencode-go", "vercel"], model: "glm-5.1" }
+      { providers: ["opencode-go", "vercel"], model: "glm-5.2" }
     ]
   },
   deep: {
     fallbackChain: [
+      {
+        providers: ["openai", "vercel"],
+        model: "gpt-5.6-sol",
+        variant: "high"
+      },
       {
         providers: ["openai", "github-copilot", "opencode", "vercel"],
         model: "gpt-5.5",
@@ -21140,7 +21160,7 @@ var CATEGORY_MODEL_REQUIREMENTS = {
         variant: "high"
       },
       { providers: ["opencode-go", "vercel"], model: "kimi-k2.6" },
-      { providers: ["opencode-go", "vercel"], model: "glm-5.1" }
+      { providers: ["opencode-go", "vercel"], model: "glm-5.2" }
     ]
   },
   artistry: {
@@ -21157,7 +21177,7 @@ var CATEGORY_MODEL_REQUIREMENTS = {
       },
       { providers: ["openai", "github-copilot", "opencode", "vercel"], model: "gpt-5.5" },
       { providers: ["opencode-go", "vercel"], model: "kimi-k2.6" },
-      { providers: ["opencode-go", "vercel"], model: "glm-5.1" }
+      { providers: ["opencode-go", "vercel"], model: "glm-5.2" }
     ]
   },
   quick: {
@@ -21215,7 +21235,7 @@ var CATEGORY_MODEL_REQUIREMENTS = {
       },
       { providers: ["zai-coding-plan", "opencode", "bailian-coding-plan", "vercel"], model: "glm-5" },
       { providers: ["kimi-for-coding"], model: "k2p5" },
-      { providers: ["opencode-go", "vercel"], model: "glm-5.1" },
+      { providers: ["opencode-go", "vercel"], model: "glm-5.2" },
       { providers: ["opencode", "bailian-coding-plan", "vercel"], model: "kimi-k2.5" },
       {
         providers: [
@@ -22567,6 +22587,22 @@ var SUPPLEMENTAL_MODEL_CAPABILITIES = {
       output: 262144
     }
   },
+  "gpt-5.6-sol": {
+    id: "gpt-5.6-sol",
+    family: "gpt",
+    reasoning: true,
+    temperature: false,
+    toolCall: true,
+    modalities: {
+      input: ["text", "image", "pdf"],
+      output: ["text"]
+    },
+    limit: {
+      context: 1050000,
+      input: 922000,
+      output: 128000
+    }
+  },
   "gpt-5.5": {
     id: "gpt-5.5",
     family: "gpt",
@@ -23696,6 +23732,10 @@ function isGpt5_5Model(model) {
   const modelName = extractModelName2(model).toLowerCase();
   return modelName.includes("gpt-5.5") || modelName.includes("gpt-5-5");
 }
+function isGpt5_6Model(model) {
+  const modelName = extractModelName2(model).toLowerCase();
+  return modelName.includes("gpt-5.6") || modelName.includes("gpt-5-6");
+}
 
 // packages/omo-opencode/src/tools/delegate-task/openai-categories.ts
 var ULTRABRAIN_CATEGORY_PROMPT_APPEND = `<Category_Context>
@@ -23761,7 +23801,7 @@ The orchestrator chose this category because the task benefits from depth over s
 **Status cadence: sparse.** The user is not on the other side of this conversation; the orchestrator is, and they will synthesize your progress. Send commentary only at meaningful phase transitions (starting exploration, starting implementation, starting verification, hitting a genuine blocker). Do not narrate every tool call; silence during focused work is expected.
 </Category_Context>`;
 function resolveDeepCategoryPromptAppend(model) {
-  if (model && isGpt5_5Model(model)) {
+  if (model && (isGpt5_5Model(model) || isGpt5_6Model(model))) {
     return DEEP_CATEGORY_PROMPT_APPEND_GPT_5_5;
   }
   return DEEP_CATEGORY_PROMPT_APPEND;
@@ -23819,13 +23859,13 @@ If your prompt lacks this structure, REWRITE IT before delegating.
 var OPENAI_CATEGORIES = [
   {
     name: "ultrabrain",
-    config: { model: "openai/gpt-5.5", variant: "xhigh" },
+    config: { model: "openai/gpt-5.6-sol", variant: "xhigh" },
     description: "Use ONLY for genuinely hard, logic-heavy tasks. Give clear goals only, not step-by-step instructions.",
     promptAppend: ULTRABRAIN_CATEGORY_PROMPT_APPEND
   },
   {
     name: "deep",
-    config: { model: "openai/gpt-5.5", variant: "medium" },
+    config: { model: "openai/gpt-5.6-sol", variant: "high" },
     description: "Goal-oriented autonomous problem-solving on hairy problems requiring deep research. ONE goal + ONE deliverable per call \u2014 multiple goals must fan out as parallel `deep` calls, never bundled into one.",
     promptAppend: DEEP_CATEGORY_PROMPT_APPEND,
     resolvePromptAppend: resolveDeepCategoryPromptAppend
@@ -78000,6 +78040,7 @@ function injectServerAuthIntoClient(client3) {
 init_logger2();
 var PROBE_TTL_MS = 60000;
 var PROBE_ABORT_MS = 1500;
+var AFFINITY_TTL_MS = 60000;
 var registrations = new Map;
 var lastRegistration;
 var liveParentWakeRoutingDisabled = false;
@@ -78017,7 +78058,9 @@ function initLiveServerRoute(opts) {
     available: undefined,
     probeTimestamp: 0,
     inFlightProbe: undefined,
-    warnedOnce: false
+    warnedOnce: false,
+    sessionAffinity: new Map,
+    inFlightAffinity: new Map
   };
   registrations.set(opts.inProcessClient, registration);
   lastRegistration = registration;
@@ -78071,6 +78114,66 @@ async function probe(registration) {
     return false;
   }
 }
+async function probeSessionAffinity(registration, sessionID) {
+  if (!registration.serverUrl) {
+    return;
+  }
+  const probeUrl = new URL(`/session/${sessionID}`, registration.serverUrl);
+  const authHeader = getServerBasicAuthHeader();
+  const headers = authHeader ? { Authorization: authHeader } : {};
+  try {
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), PROBE_ABORT_MS);
+    let response;
+    try {
+      response = await getFetch()(probeUrl, { headers, signal: controller.signal });
+    } finally {
+      clearTimeout(timeoutId);
+    }
+    if (response.ok) {
+      setSessionAffinity(registration, sessionID, true);
+      return true;
+    }
+    if (response.status === 404) {
+      setSessionAffinity(registration, sessionID, false);
+      log2("[live-server-route] live listener does not own session; falling back to in-process client", { sessionID });
+      return false;
+    }
+    return;
+  } catch {
+    return;
+  }
+}
+function setSessionAffinity(registration, sessionID, owned) {
+  const now = Date.now();
+  for (const [key, entry] of registration.sessionAffinity) {
+    if (now - entry.timestamp >= AFFINITY_TTL_MS) {
+      registration.sessionAffinity.delete(key);
+    }
+  }
+  registration.sessionAffinity.set(sessionID, { owned, timestamp: now });
+}
+function getFreshSessionAffinity(registration, sessionID) {
+  const entry = registration.sessionAffinity.get(sessionID);
+  if (!entry || Date.now() - entry.timestamp >= AFFINITY_TTL_MS) {
+    return;
+  }
+  return entry.owned;
+}
+async function resolveSessionAffinity(registration, sessionID) {
+  const cached = getFreshSessionAffinity(registration, sessionID);
+  if (cached !== undefined) {
+    return cached;
+  }
+  let inFlight = registration.inFlightAffinity.get(sessionID);
+  if (!inFlight) {
+    inFlight = probeSessionAffinity(registration, sessionID).finally(() => {
+      registration.inFlightAffinity.delete(sessionID);
+    });
+    registration.inFlightAffinity.set(sessionID, inFlight);
+  }
+  return inFlight;
+}
 function getFreshProbeAvailability(registration) {
   const available = registration.available;
   if (available === undefined || Date.now() - registration.probeTimestamp >= PROBE_TTL_MS) {
@@ -78123,6 +78226,13 @@ function tryResolveDispatchClientSync2(client3, sessionID) {
   if (!freshAvailability) {
     return { client: client3, route: "in-process", reason: "unavailable" };
   }
+  const cachedAffinity = getFreshSessionAffinity(registration, sessionID);
+  if (cachedAffinity === undefined) {
+    return;
+  }
+  if (!cachedAffinity) {
+    return { client: client3, route: "in-process", reason: "affinity" };
+  }
   const resolvedLiveClient = getOrBuildLiveClient(registration);
   if (!resolvedLiveClient) {
     return { client: client3, route: "in-process", reason: "unavailable" };
@@ -78142,6 +78252,10 @@ async function resolveDispatchClient2(client3, sessionID) {
   if (!isAvailable) {
     return { client: client3, route: "in-process", reason: "unavailable" };
   }
+  const affinity = await resolveSessionAffinity(registration, sessionID);
+  if (affinity === false) {
+    return { client: client3, route: "in-process", reason: "affinity" };
+  }
   const resolvedLiveClient = getOrBuildLiveClient(registration);
   if (!resolvedLiveClient) {
     return { client: client3, route: "in-process", reason: "unavailable" };
@@ -78179,6 +78293,7 @@ function markLiveRouteUnavailable2(reason) {
   for (const registration of registrations.values()) {
     registration.available = false;
     registration.probeTimestamp = Date.now();
+    registration.sessionAffinity.clear();
   }
   log2(`[live-server-route] marked unavailable: ${reason}`);
 }
@@ -89498,7 +89613,7 @@ function getCachedVersion(options = {}) {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "4.16.2",
+  version: "4.16.3",
   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",
@@ -89708,18 +89823,18 @@ var package_default = {
     typescript: "^6.0.3"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "4.16.2",
-    "oh-my-opencode-darwin-x64": "4.16.2",
-    "oh-my-opencode-darwin-x64-baseline": "4.16.2",
-    "oh-my-opencode-linux-arm64": "4.16.2",
-    "oh-my-opencode-linux-arm64-musl": "4.16.2",
-    "oh-my-opencode-linux-x64": "4.16.2",
-    "oh-my-opencode-linux-x64-baseline": "4.16.2",
-    "oh-my-opencode-linux-x64-musl": "4.16.2",
-    "oh-my-opencode-linux-x64-musl-baseline": "4.16.2",
-    "oh-my-opencode-windows-arm64": "4.16.2",
-    "oh-my-opencode-windows-x64": "4.16.2",
-    "oh-my-opencode-windows-x64-baseline": "4.16.2"
+    "oh-my-opencode-darwin-arm64": "4.16.3",
+    "oh-my-opencode-darwin-x64": "4.16.3",
+    "oh-my-opencode-darwin-x64-baseline": "4.16.3",
+    "oh-my-opencode-linux-arm64": "4.16.3",
+    "oh-my-opencode-linux-arm64-musl": "4.16.3",
+    "oh-my-opencode-linux-x64": "4.16.3",
+    "oh-my-opencode-linux-x64-baseline": "4.16.3",
+    "oh-my-opencode-linux-x64-musl": "4.16.3",
+    "oh-my-opencode-linux-x64-musl-baseline": "4.16.3",
+    "oh-my-opencode-windows-arm64": "4.16.3",
+    "oh-my-opencode-windows-x64": "4.16.3",
+    "oh-my-opencode-windows-x64-baseline": "4.16.3"
   },
   overrides: {
     "@earendil-works/pi-agent-core": "0.80.3",
@@ -103685,7 +103800,7 @@ This command includes examples for the OpenCode harness. In Codex, do not call O
 | \`task(subagent_type="oracle", ...)\` | \`multi_agent_v1.spawn_agent({"message":"TASK: act as a rigorous reviewer. ...","agent_type":"lazycodex-gate-reviewer","fork_context":false})\` |
 | \`task(category="...", ...)\` | \`multi_agent_v1.spawn_agent({"message":"TASK: act as an implementation or QA worker. ...","fork_context":false})\` |
 | \`background_output(task_id="...")\` | \`multi_agent_v1.wait_agent(...)\` for mailbox signals |
-| \`team_*(...)\` | Use Codex native subagents via \`multi_agent_v1.spawn_agent\`, \`multi_agent_v1.send_input\`, \`multi_agent_v1.wait_agent\`, and \`multi_agent_v1.close_agent\` |
+| \`team_*(...)\` | Use Codex native subagents via \`multi_agent_v1.spawn_agent\` and \`multi_agent_v1.wait_agent\`; use \`multi_agent_v1.send_input\` and \`multi_agent_v1.close_agent\` only when exposed in the active tools list |
 
 Codex exposes ONE of two subagent tool surfaces per session; check your own tool list and route accordingly. If \`multi_agent_v1.*\` tools exist, use the table above as written. If instead a flat \`spawn_agent\` with a required \`task_name\` exists (\`multi_agent_v2\`), rewrite every \`multi_agent_v1.*\` example: \`multi_agent_v1.spawn_agent({...,"fork_context":false})\` becomes \`spawn_agent({"task_name":"<lowercase_digits_underscores>","message":...,"agent_type":...,"fork_turns":"none"})\` (\`"all"\` only when full parent history is truly required); \`send_input\` becomes \`send_message\`; do not call \`close_agent\`/\`resume_agent\` (finished agents end on their own; \`followup_task\` re-tasks one, \`interrupt_agent\` stops one); \`wait_agent\` takes only \`timeout_ms\` and returns on any child mailbox activity. \`agent_type\` works the same on both surfaces. If a code block below conflicts with this section, this section wins.
 
@@ -104657,7 +104772,7 @@ This command includes examples for the OpenCode harness. In Codex, do not call O
 | \`task(subagent_type="oracle", ...)\` | \`multi_agent_v1.spawn_agent({"message":"TASK: act as a rigorous reviewer. ...","agent_type":"lazycodex-gate-reviewer","fork_context":false})\` |
 | \`task(category="...", ...)\` | \`multi_agent_v1.spawn_agent({"message":"TASK: act as an implementation or QA worker. ...","fork_context":false})\` |
 | \`background_output(task_id="...")\` | \`multi_agent_v1.wait_agent(...)\` for mailbox signals |
-| \`team_*(...)\` | Use Codex native subagents via \`multi_agent_v1.spawn_agent\`, \`multi_agent_v1.send_input\`, \`multi_agent_v1.wait_agent\`, and \`multi_agent_v1.close_agent\` |
+| \`team_*(...)\` | Use Codex native subagents via \`multi_agent_v1.spawn_agent\` and \`multi_agent_v1.wait_agent\`; use \`multi_agent_v1.send_input\` and \`multi_agent_v1.close_agent\` only when exposed in the active tools list |
 
 Codex exposes ONE of two subagent tool surfaces per session; check your own tool list and route accordingly. If \`multi_agent_v1.*\` tools exist, use the table above as written. If instead a flat \`spawn_agent\` with a required \`task_name\` exists (\`multi_agent_v2\`), rewrite every \`multi_agent_v1.*\` example: \`multi_agent_v1.spawn_agent({...,"fork_context":false})\` becomes \`spawn_agent({"task_name":"<lowercase_digits_underscores>","message":...,"agent_type":...,"fork_turns":"none"})\` (\`"all"\` only when full parent history is truly required); \`send_input\` becomes \`send_message\`; do not call \`close_agent\`/\`resume_agent\` (finished agents end on their own; \`followup_task\` re-tasks one, \`interrupt_agent\` stops one); \`wait_agent\` takes only \`timeout_ms\` and returns on any child mailbox activity. \`agent_type\` works the same on both surfaces. If a code block below conflicts with this section, this section wins.
 
@@ -118880,6 +118995,30 @@ function getSessionErrorMessage(properties) {
   const message = errorRaw["message"];
   return typeof message === "string" ? message : undefined;
 }
+var TERMINAL_SESSION_ERROR_PATTERNS = [
+  /no provider available/i,
+  /provider not (available|found|configured)/i,
+  /provider is forbidden/i,
+  /selected provider is forbidden/i,
+  /unknown provider/i,
+  /model not supported/i,
+  /model_not_supported/i,
+  /model[_\s-]*not[_\s-]*found/i,
+  /(?:no|missing)[_\s-]*(?:api|auth(?:entication)?)[_\s-]*key/i,
+  /(?:api|auth(?:entication)?)[_\s-]*key(?:[_\s-]+is)?[_\s-]*(?:missing|not[_\s-]*(?:found|configured)|required)/i,
+  /no models available/i,
+  /no connected providers/i,
+  /all providers (?:are )?(?:unavailable|disconnected|exhausted)/i
+];
+function isTerminalSessionError(errorInfo) {
+  const text = [
+    errorInfo?.name,
+    errorInfo?.message
+  ].filter((value) => typeof value === "string" && value.length > 0).join(" ");
+  if (text.length === 0)
+    return false;
+  return TERMINAL_SESSION_ERROR_PATTERNS.some((pattern) => pattern.test(text));
+}
 
 // packages/omo-opencode/src/tools/background-task/task-result-format.ts
 function getTimeString(value) {
@@ -131527,7 +131666,7 @@ The fallback retry session is now created and can be inspected directly.
     const sessionId = task.sessionId;
     if (sessionId) {
       const sessionStillAlive = await this.verifySessionExists(sessionId);
-      if (sessionStillAlive) {
+      if (sessionStillAlive && !isTerminalSessionError(errorInfo)) {
         this.logger("[background-agent] session.error received but session still alive, treating as transient:", {
           taskId: task.id,
           sessionId,
@@ -131535,6 +131674,14 @@ The fallback retry session is now created and can be inspected directly.
         });
         return;
       }
+      if (sessionStillAlive && isTerminalSessionError(errorInfo)) {
+        this.logger("[background-agent] Finalizing task after terminal session.error (session shell alive but will never produce output):", {
+          taskId: task.id,
+          sessionId,
+          errorName,
+          errorMessage: errorMsg?.slice(0, 200)
+        });
+      }
     }
     if (task.currentAttemptID) {
       finalizeAttempt(task, task.currentAttemptID, "error", errorMsg);
@@ -143848,7 +143995,7 @@ task(subagent_type="explore", run_in_background=true, ...)
 // packages/omo-opencode/src/agents/frontier-tool-schema-guard.ts
 var FRONTIER_TOOL_SCHEMA_NAMES = ["grep", "glob"];
 function getFrontierToolSchemaPermission(model) {
-  return isClaudeOpus47OrLaterModel(model) || isGpt5_5Model(model) ? { grep: "deny", glob: "deny" } : {};
+  return isClaudeOpus47OrLaterModel(model) || isGpt5_5Model(model) || isGpt5_6Model(model) ? { grep: "deny", glob: "deny" } : {};
 }
 function applyFrontierToolSchemaPermission(permission, model, explicitPermission, explicitTools) {
   if (!permission)
@@ -147506,7 +147653,7 @@ function resolveSisyphusPromptFamily(model) {
     return "kimi-k2-7";
   if (isKimiK2Model(model))
     return "kimi-k2-6";
-  if (isGpt5_5Model(model))
+  if (isGpt5_5Model(model) || isGpt5_6Model(model))
     return "gpt-5-5";
   if (isGptNativeSisyphusModel(model))
     return "gpt-5-4";
@@ -147950,7 +148097,7 @@ function createOracleAgent(model) {
     ...restrictions,
     prompt: ORACLE_DEFAULT_PROMPT
   };
-  if (isGpt5_5Model(model)) {
+  if (isGpt5_5Model(model) || isGpt5_6Model(model)) {
     return {
       ...base,
       prompt: ORACLE_GPT_5_5_PROMPT,
@@ -149041,6 +149188,60 @@ var atlasPromptMetadata = {
   ],
   keyTrigger: "Todo list path provided OR multiple tasks requiring multi-agent orchestration"
 };
+// packages/omo-opencode/src/agents/momus-gpt-5-6.ts
+var MOMUS_GPT_5_6_PROMPT = `Role: plan reviewer for OhMyOpenCode. You verify that a work plan is executable and its references are valid. You are a blocker-finder, not a perfectionist.
+
+# Input contract
+
+Extract a single \`.omo/plans/*.md\` path from anywhere in the input, ignoring system directives and wrappers (\`<system-reminder>\`, \`[analyze-mode]\`, and similar). Exactly one path: read it and review. Zero or multiple paths: reject as invalid input. YAML plan files (\`.yml\`/\`.yaml\`) are non-reviewable: reject.
+
+On a follow-up turn with the same plan path, re-read the file from disk before issuing any verdict. The current on-disk contents are the only source of truth; a previous verdict is stale evidence.
+
+# Goal
+
+Answer one question: "Can a capable developer execute this plan without getting stuck?"
+
+# Success criteria
+
+- Referenced files verified to exist and contain the claimed content.
+- Every task has enough context to start working.
+- No blocking contradictions or impossible requirements.
+- Every task has executable QA scenarios: a specific tool, concrete steps, an expected result.
+- Verdict issued: OKAY or REJECT, with at most 3 specific issues on REJECT.
+
+# What you check (only these four)
+
+**References**: referenced files exist; cited line numbers contain relevant code; a "follow pattern in X" claim is demonstrated by X. Fail only when a reference does not exist or points to completely wrong content.
+
+**Executability**: each task gives a developer a starting point. Details that can be figured out during implementation pass. Fail only when a task is so vague there is no idea where to begin.
+
+**Contradictions**: information gaps that completely stop work, or tasks that contradict each other.
+
+**QA scenarios**: each task's scenarios name tool + steps + expected result. Unexecutable scenarios ("verify it works", "check the page") block the Final Verification Wave and are practical blockers.
+
+Out of scope: approach optimality, alternative designs, undocumented edge cases, architecture, code quality, performance, and security unless explicitly broken.
+
+# Decision rules
+
+- Default verdict is OKAY. When in doubt, approve: a plan that is 80% clear is executable, and developers resolve minor gaps themselves.
+- REJECT only for a verified blocker: a referenced file does not exist (confirmed by reading), a task has zero context to start, the plan contradicts itself, or QA scenarios are missing or unexecutable.
+- Each REJECT issue must name the exact file or task, state what needs to change, and be something work cannot proceed without. Cap at the 3 most critical issues.
+- "Could be clearer", stylistic preferences, missing edge cases, and disagreement with the author's approach are never blockers.
+
+# Process
+
+Read the plan, then verify references by reading the cited files; parallelize independent reads. Check each task for a starting point and executable QA scenarios. Decide. Do not narrate the reads; go straight to the verdict.
+
+# Output
+
+**[OKAY]** or **[REJECT]**
+
+**Summary**: 1-2 sentences of prose explaining the verdict.
+
+If REJECT - **Blocking Issues** (max 3): numbered, each naming the exact issue and the change needed.
+
+Keep every fact needed to act on the verdict; trim restatements of the plan, generic advice, and commentary on non-blockers. Match the language of the plan content.`;
+
 // packages/omo-opencode/src/agents/momus.ts
 var MODE8 = "subagent";
 var MOMUS_DEFAULT_PROMPT = `You are a **practical** work plan reviewer. Your goal is simple: verify that the plan is **executable** and **references are valid**.
@@ -149309,6 +149510,14 @@ function createMomusAgent(model) {
     ...restrictions,
     prompt: MOMUS_DEFAULT_PROMPT
   };
+  if (isGpt5_6Model(model)) {
+    return {
+      ...base,
+      prompt: MOMUS_GPT_5_6_PROMPT,
+      reasoningEffort: "xhigh",
+      textVerbosity: "high"
+    };
+  }
   if (isGptModel(model)) {
     return {
       ...base,
@@ -150182,16 +150391,180 @@ function buildGpt55HephaestusPrompt(availableAgents, _availableTools = [], avail
   return HEPHAESTUS_GPT_5_5_TEMPLATE.replace("{{ taskSystemGuide }}", taskSystemGuide).replace("{{ categorySkillsGuide }}", categorySkillsGuide).replace("{{ delegationTable }}", delegationTable).replace("{{ oracleSection }}", oracleSection).replace("{{ frontendGuidance }}", frontendGuidance);
 }
 
+// packages/omo-opencode/src/agents/hephaestus/gpt-5-6.ts
+function buildTaskSystemGuide3(useTaskSystem) {
+  if (useTaskSystem) {
+    return `Create tasks for any non-trivial work (2+ steps, uncertain scope, multiple items). Call \`task_create\` with atomic steps before starting. Mark exactly one item \`in_progress\` at a time via \`task_update\`. Mark items \`completed\` immediately when done; never batch. Update the task list when scope shifts.`;
+  }
+  return `Create todos for any non-trivial work (2+ steps, uncertain scope, multiple items). Call \`todowrite\` with atomic steps before starting. Mark exactly one item \`in_progress\` at a time. Mark items \`completed\` immediately when done; never batch. Update the todo list when scope shifts.`;
+}
+var HEPHAESTUS_GPT_5_6_TEMPLATE = `You are Hephaestus, an autonomous deep worker based on GPT-5.6. You and the user share one workspace. You receive goals, not step-by-step instructions, and execute them end-to-end.
+
+ID contract: background task IDs (\`bg_...\`) use \`background_output(task_id="bg_...")\`; continuation IDs (\`ses_...\`) use \`task(task_id="ses_...")\`.
+
+# Autonomy
+
+User instructions override these defaults; newer instructions override older ones. Safety and type-safety constraints never yield.
+
+Implement, don't propose. Unless the user is explicitly asking a question, brainstorming, or requesting a plan, they want working code, not a description of it. Messages imply action: "how does X work" means understand X to fix or improve it; "why is A broken" means diagnose and fix A. Treat a message as answer-only when the user says so ("just explain", "don't change anything"). State your read in one line before acting - that line commits you to finish the named work this turn.
+
+Make the requested in-scope changes and run non-destructive validation without asking first. Resolve blockers yourself using context and reasonable assumptions; ask only when the missing information would materially change the outcome or the action is destructive - one narrow question, then stop. Never ask permission for obvious work.
+
+If the user's plan or design seems flawed, say so concisely, propose the alternative, and ask whether to proceed with the original or the alternative - do not silently override. Mention high-impact bugs you spot along the way briefly; broaden the task only when it blocks the requested outcome or the user asks.
+
+Status requests are not stop signals: give the update, keep working. The newest non-conflicting message wins; honor every non-conflicting request since your last turn. After compaction, continue from the summary; don't restart.
+
+Unexpected worktree changes you did not make: keep working - the user and other agents work concurrently. Never revert or modify changes you did not make unless explicitly asked. Work around unrelated ones; if a direct conflict with your task is unresolvable, ask one precise question.
+
+# Goal
+
+Resolve the user's task end-to-end in this turn. The goal is not a green build; it is an artifact that **works when used through its surface** (Manual QA Gate). Clean \`lsp_diagnostics\`, green build, passing tests are evidence on the way to that gate, not the gate itself. The user's spec is the spec; "done" means the spec is satisfied in observable behavior.
+
+# Discovery & Retrieval
+
+Never speculate about code you have not read. The worktree is shared: verify with tools and re-read on every hand-off, even when the request feels familiar.
+
+Start broad once: for non-trivial work, fire 2-5 \`explore\` or \`librarian\` sub-agents in parallel with \`run_in_background=true\` plus direct reads of files you already know are relevant - same response. Retrieve again only when the core question is still open, a required fact, path, type, or convention is missing, or a second-order question (callers, error paths, ownership) changes the design. Stop when you can act, sources repeat, or two rounds add nothing new.
+
+When uncertain whether to call a tool, call it. If a finding seems too simple for the complexity of the question, check one more layer of dependencies or callers. Prefer the root fix over the symptom fix. Resolve prerequisite lookups before any action that depends on them.
+
+Once you delegate exploration to background agents, do not search the same thing yourself: do non-overlapping prep or end your response and wait for the completion notification. Do not poll \`background_output\` on running tasks.
+
+# Parallelize
+
+Independent tool calls run in the same response; serial is the exception and requires a real dependency. Each independent shell command is its own tool call - do not chain unrelated steps with \`;\` or \`&&\`. After every file edit, run \`lsp_diagnostics\` on every changed file in parallel.
+
+# Operating Loop
+
+**Explore -> Plan -> Implement -> Verify -> Manually QA.**
+
+- **Explore** per Discovery & Retrieval.
+- **Plan** with \`update_plan\` for non-trivial work: files to modify, specific changes, dependencies. Skip planning for the easiest 25%; never make single-step plans.
+- **Implement** surgically, matching codebase style - naming, indentation, imports, error handling - even when you would write it differently in a greenfield.
+- **Verify** with the most relevant validation available, in parallel where possible: \`lsp_diagnostics\` on changed files, targeted tests for changed behavior, build for affected packages. If validation cannot run, say why and name the next best check.
+- **Manually QA** through the artifact's surface, then write the final message.
+
+# Manual QA Gate
+
+Diagnostics catch type errors, not logic bugs; tests cover only what their authors anticipated. **"Done" requires you have personally used the deliverable through its matching surface and observed it working this turn.**
+
+- **TUI / CLI / shell binary** - launch inside \`interactive_bash\` (tmux): happy path, one bad input, \`--help\`, read the rendered output.
+- **Web / browser-rendered UI** - load the \`playwright\` skill and drive a real browser: click, fill, watch the console.
+- **HTTP API / running service** - hit the live process with \`curl\` or a driver script.
+- **Library / SDK / module** - minimal driver script that imports and executes the new code end-to-end.
+- **No matching surface** - do what a real user would do to discover it works.
+
+"This should work" from reading source does not pass. A defect found in usage is yours to fix this turn.
+
+# Failure Recovery
+
+If an approach fails, try a materially different one - different algorithm, library, or pattern, not a small tweak. Verify after every attempt; stale state is the most common cause of confusing failures.
+
+After three different approaches fail: stop editing, revert to a known-good state, document each attempt and why it failed, consult Oracle synchronously with full failure context, and only if Oracle cannot resolve it, ask the user one precise question.
+
+# Pragmatism & Scope
+
+The best change is usually the smallest correct change. Prefer the approach with fewer new names, helpers, and layers. Keep single-use logic inline; a little duplication beats speculative abstraction. Bug fix != surrounding cleanup. Fix only issues your changes caused; report pre-existing problems in the final message instead of expanding the diff.
+
+Write only what the current correct path needs. No error handlers, fallbacks, retries, or validation for scenarios the current contracts exclude - validate at system boundaries only (user input, external APIs, untrusted I/O). No backward-compatibility shims or alternate paths "in case": preserve old formats only for persisted data, shipped behavior, external consumers, or explicit requirements. Unreleased shapes from the current cycle are drafts, not contracts.
+
+Default to not adding tests. Add one only when the user asks, the change fixes a subtle bug, or it protects an important behavioral boundary existing tests miss. Never add tests to a codebase with no tests.
+
+# Code review requests
+
+When asked for a "review", findings come first, ordered by severity with file references; open questions and assumptions follow; change-summary is secondary. If no findings, say so and name residual risks or testing gaps.
+
+{{ frontendGuidance }}
+
+# AGENTS.md
+
+AGENTS.md files carry directory-scoped conventions. Obey them for files in their scope; deeper files win on conflict; explicit user instructions override.
+
+# Output
+
+**Preamble.** Before the first tool call on a multi-step task, one or two user-visible sentences: acknowledge the request, state the first concrete step.
+
+**During work.** Update only at meaningful phase changes - a discovery that changes the plan, a decision with tradeoffs, a blocker. One sentence each. Do not narrate routine reads.
+
+**Final message.** Lead with the result. Keep every required fact, decision, caveat, and next action; trim introductions, repetition, and generic reassurance first. Group by user-facing outcome, not by file. Include the evidence needed to trust the work - what you verified and what you could not (with the reason) - then stop.
+
+**Formatting.**
+
+- File references: \`src/auth.ts\` or \`src/auth.ts:42\` (1-based, optional line). No \`file://\`, \`vscode://\`, or \`https://\` URIs for local files. No line ranges.
+- Multi-line code in fenced blocks with a language tag.
+- The user does not see command outputs - summarize the key lines.
+- No emojis or em dashes unless the user explicitly requests them.
+- Never output broken inline citations like \`\u3010F:README.md\u2020L5-L14\u3011\` - they break the CLI.
+
+# Tool Use
+
+**File edits.** ${GPT_APPLY_PATCH_GUIDANCE}
+
+**\`task()\`** for research sub-agents and category delegation. Allowed: \`subagent_type="explore"\`, \`"librarian"\`, \`"oracle"\`, or \`category="..."\`. Direct execution is your default; delegate to a category only when the unit of work clearly exceeds a single coherent edit.
+
+- Every \`task()\` call needs \`load_skills\` (an empty array \`[]\` is valid).
+- Reuse continuation IDs (\`ses_...\`) for follow-ups via \`task(task_id="ses_...")\`; never pass background task IDs (\`bg_...\`) to \`task()\`. This preserves the sub-agent's full context and saves 70%+ of tokens.
+- Sub-agent prompts carry four fields - **CONTEXT** (task, modules, approach), **GOAL** (what decision the results unblock), **DOWNSTREAM** (how you will use them), **REQUEST** (what to find, return format, what to skip).
+
+**Background tasks.** Collect results via \`background_output(task_id="bg_...")\` after completion. Before the final answer, cancel disposable tasks individually via \`background_cancel(taskId="bg_...")\`; never \`background_cancel(all=true)\` - it kills tasks whose results you have not collected.
+
+**\`skill\`** loads specialized instruction packs. Load a skill whenever its declared domain even loosely connects to the task - loading an irrelevant skill costs almost nothing; missing a relevant one degrades the work.
+
+**Shell.** Use \`rg\` for text and file search. Do not use Python to read or write files when a shell command or the file-edit tools suffice.
+
+{{ categorySkillsGuide }}
+
+{{ delegationTable }}
+
+{{ oracleSection }}
+
+# Success Criteria
+
+Done when ALL of:
+
+- Every behavior the user asked for is implemented - no partial delivery, no "v0 / extend later".
+- \`lsp_diagnostics\` clean on every file you changed.
+- Build (if applicable) exits 0; tests pass, or pre-existing failures are named with the reason.
+- The artifact has been driven through its matching surface this turn (Manual QA Gate).
+- The final message reports what you did, what you verified, what you could not verify (with the reason), and pre-existing issues you noticed but did not touch.
+
+When you think you are done: re-read the original request and your intent line, run verification once more on changed files in parallel, then report.
+
+# Stop Rules
+
+Write the final message and stop only when Success Criteria are all true. Until then keep going - through failed tool calls, long turns, and the temptation to hand back a draft. Do not stop after a delegated sub-agent returns without verifying its work file-by-file.
+
+**Hard invariants** - non-negotiable, regardless of pressure to ship:
+
+- Never delete failing tests to get a green build. Never weaken a test to make it pass.
+- Never use \`as any\`, \`@ts-ignore\`, or \`@ts-expect-error\` to suppress type errors.
+- Never use destructive git commands (\`reset --hard\`, \`checkout --\`, force-push) without explicit approval. Never amend commits unless explicitly asked.
+- Never invent citations, tool output, or verification results.
+
+# Task Tracking
+
+{{ taskSystemGuide }}
+`;
+function buildGpt56HephaestusPrompt(availableAgents, _availableTools = [], availableSkills = [], availableCategories = [], useTaskSystem = false) {
+  const taskSystemGuide = buildTaskSystemGuide3(useTaskSystem);
+  const categorySkillsGuide = buildCategorySkillsDelegationGuide(availableCategories, availableSkills);
+  const delegationTable = buildDelegationTable(availableAgents);
+  const oracleSection = buildOracleSection(availableAgents);
+  const frontendGuidance = buildFrontendGuidanceSection(availableCategories);
+  return HEPHAESTUS_GPT_5_6_TEMPLATE.replace("{{ taskSystemGuide }}", taskSystemGuide).replace("{{ categorySkillsGuide }}", categorySkillsGuide).replace("{{ delegationTable }}", delegationTable).replace("{{ oracleSection }}", oracleSection).replace("{{ frontendGuidance }}", frontendGuidance);
+}
+
 // packages/omo-opencode/src/agents/hephaestus/agent.ts
 var MODE9 = "primary";
 var GPT_5_3_CODEX_RE = /^gpt-5[.-]3-codex(?:$|[.-])/i;
 var GPT_5_4_RE = /^gpt-5[.-]4(?:$|[.-])/i;
 var GPT_5_5_RE = /^gpt-5[.-]5(?:$|[.-])/i;
+var GPT_5_6_RE = /^gpt-5[.-]6(?:$|[.-])/i;
 
 class UnsupportedHephaestusModelError extends Error {
   model;
   constructor(model) {
-    super(`Hephaestus only supports GPT-5.3 Codex, GPT-5.4, and GPT-5.5 models; received ${model ?? "no model"}.`);
+    super(`Hephaestus only supports GPT-5.3 Codex, GPT-5.4, GPT-5.5, and GPT-5.6 models; received ${model ?? "no model"}.`);
     this.name = "UnsupportedHephaestusModelError";
     this.model = model;
   }
@@ -150203,7 +150576,7 @@ function isHephaestusSupportedModel(model) {
   if (!model)
     return false;
   const modelName = extractModelName3(model);
-  return GPT_5_3_CODEX_RE.test(modelName) || GPT_5_4_RE.test(modelName) || GPT_5_5_RE.test(modelName);
+  return GPT_5_3_CODEX_RE.test(modelName) || GPT_5_4_RE.test(modelName) || GPT_5_5_RE.test(modelName) || GPT_5_6_RE.test(modelName);
 }
 function assertHephaestusSupportedModel(model) {
   if (!isHephaestusSupportedModel(model)) {
@@ -150212,6 +150585,9 @@ function assertHephaestusSupportedModel(model) {
 }
 function getHephaestusPromptSource(model) {
   assertHephaestusSupportedModel(model);
+  if (model && isGpt5_6Model(model)) {
+    return "gpt-5-6";
+  }
   if (model && isGpt5_5Model(model)) {
     return "gpt-5-5";
   }
@@ -150230,6 +150606,9 @@ function buildDynamicHephaestusPrompt(ctx) {
   const source = getHephaestusPromptSource(model);
   let basePrompt;
   switch (source) {
+    case "gpt-5-6":
+      basePrompt = buildGpt56HephaestusPrompt(agents, tools, skills, categories, useTaskSystem);
+      break;
     case "gpt-5-5":
       basePrompt = buildGpt55HephaestusPrompt(agents, tools, skills, categories, useTaskSystem);
       break;
@@ -150885,7 +151264,7 @@ No tasks on multi-step work = INCOMPLETE WORK.`;
 No todos on multi-step work = INCOMPLETE WORK.`;
 }
 // packages/omo-opencode/src/agents/sisyphus-junior/gpt-5-5.ts
-function buildTaskSystemGuide3(useTaskSystem) {
+function buildTaskSystemGuide4(useTaskSystem) {
   if (useTaskSystem) {
     return `Create tasks before any non-trivial work (2+ steps, uncertain scope, multiple items).
 
@@ -151161,7 +151540,7 @@ The block below (injected at runtime by the harness) tells you the specific cate
 `;
 function buildGpt55SisyphusJuniorPrompt(useTaskSystem, promptAppend) {
   const personality = "";
-  const taskSystemGuide = buildTaskSystemGuide3(useTaskSystem);
+  const taskSystemGuide = buildTaskSystemGuide4(useTaskSystem);
   const base = SISYPHUS_JUNIOR_GPT_5_5_TEMPLATE.replace("{{ personality }}", personality).replace("{{ taskSystemGuide }}", taskSystemGuide);
   if (!promptAppend)
     return base;
@@ -151549,7 +151928,7 @@ function getSisyphusJuniorPromptSource(model) {
   if (model && isKimiK2Model(model))
     return "kimi-k2";
   if (model && isGptModel(model)) {
-    if (isGpt5_5Model(model))
+    if (isGpt5_5Model(model) || isGpt5_6Model(model))
       return "gpt-5-5";
     const lower = model.toLowerCase();
     if (lower.includes("gpt-5.4") || lower.includes("gpt-5-4"))