oh-my-opencode-slim 2.2.2 → 2.2.3

package/dist/index.js

@@ -18495,7 +18495,6 @@ var DEFAULT_MODELS = {
 };
 var POLL_INTERVAL_BACKGROUND_MS = 2000;
 var MAX_POLL_TIME_MS = 5 * 60 * 1000;
-var DEFAULT_MAX_SUBAGENT_DEPTH = 3;
 var PHASE_REMINDER_TEXT = `!IMPORTANT! Scheduler workflow: First choose the lightest workflow that fits the work. If direct execution is justified, complete it and verify proportionately. Otherwise: plan lanes/dependencies → dispatch background specialists → track task IDs → wait for hook-driven completion → reconcile terminal results → verify. Do not poll running jobs, consume running-job output, or advance dependent work. !END!`;
 function formatSystemReminder(text) {
   return `<system-reminder>
@@ -18746,6 +18745,7 @@ var MultiplexerTypeSchema = z2.enum([
   "tmux",
   "zellij",
   "herdr",
+  "kitty",
   "cmux",
   "none"
 ]);
@@ -19188,7 +19188,7 @@ async function promptWithTimeout(client, args, timeoutMs, signal) {
     }
     await Promise.race(racers);
   } catch (error) {
-    if (error instanceof OperationTimeoutError) {
+    if (isPromptCancellationError(error)) {
       try {
         await abortSessionWithTimeout(client, sessionId);
       } catch {}
@@ -19200,6 +19200,11 @@ async function promptWithTimeout(client, args, timeoutMs, signal) {
       signal?.removeEventListener("abort", onAbort);
   }
 }
+function isPromptCancellationError(error) {
+  if (error instanceof OperationTimeoutError)
+    return true;
+  return error instanceof Error && error.message === "Prompt cancelled";
+}
 async function extractSessionResult(client, sessionId, options) {
   const includeReasoning = options?.includeReasoning ?? true;
   const messagesResult = await client.session.messages({
@@ -21287,17 +21292,15 @@ class CouncilManager {
   client;
   directory;
   config;
-  depthTracker;
   tmuxEnabled;
   deprecatedFields;
   legacyMasterModel;
-  constructor(ctx, config, depthTracker, tmuxEnabled = false) {
+  constructor(ctx, config, tmuxEnabled = false) {
     this.client = ctx.client;
     this.directory = ctx.directory;
     this.config = config;
     this.deprecatedFields = config?.council?._deprecated;
     this.legacyMasterModel = config?.council?._legacyMasterModel;
-    this.depthTracker = depthTracker;
     this.tmuxEnabled = tmuxEnabled;
   }
   getDeprecatedFields() {
@@ -21307,21 +21310,6 @@ class CouncilManager {
     return this.legacyMasterModel;
   }
   async runCouncil(prompt, presetName, parentSessionId) {
-    if (this.depthTracker) {
-      const parentDepth = this.depthTracker.getDepth(parentSessionId);
-      if (parentDepth + 1 > this.depthTracker.maxDepth) {
-        log("[council-manager] spawn blocked: max depth exceeded", {
-          parentSessionId,
-          parentDepth,
-          maxDepth: this.depthTracker.maxDepth
-        });
-        return {
-          success: false,
-          error: "Subagent depth exceeded",
-          councillorResults: []
-        };
-      }
-    }
     const councilConfig = this.config?.council;
     if (!councilConfig) {
       log("[council-manager] Council configuration not found");
@@ -21413,12 +21401,6 @@ class CouncilManager {
         throw new Error("Failed to create session");
       }
       sessionId = session.data.id;
-      if (this.depthTracker) {
-        const registered = this.depthTracker.registerChild(options.parentSessionId, sessionId);
-        if (!registered) {
-          throw new Error("Subagent depth exceeded");
-        }
-      }
       if (this.tmuxEnabled) {
         await new Promise((r) => setTimeout(r, TMUX_SPAWN_DELAY_MS));
       }
@@ -21457,9 +21439,6 @@ class CouncilManager {
     } finally {
       if (sessionId) {
         this.client.session.abort({ path: { id: sessionId } }).catch(() => {});
-        if (this.depthTracker) {
-          this.depthTracker.cleanup(sessionId);
-        }
       }
     }
   }
@@ -25434,6 +25413,7 @@ function activationPrompt(task2) {
     "Deepwork requirements:",
     "- before planning, delegation, or creating state, inspect existing `.gitignore` and `.ignore`; add only missing entries without duplicates: `.gitignore` must contain `.slim/deepwork/`, and `.ignore` must contain `!.slim/deepwork/` and `!.slim/deepwork/**`; this keeps state git-local yet OpenCode-readable;",
     "- create/update a `.slim/deepwork/` progress file;",
+    "- save code/doc deliverables to project paths (e.g. `src/`, `docs/`); reserve `.slim/deepwork/` strictly for progress files;",
     "- keep OpenCode todos synced with the current phase;",
     "- draft a plan and get `@oracle` review before implementation;",
     "- create and review a phased implementation/delegation plan;",
@@ -26421,23 +26401,21 @@ function createPhaseReminderHook(options = {}) {
       if (agent !== "orchestrator" || !sessionID || options.shouldInject && !options.shouldInject(sessionID)) {
         return;
       }
-      const textPartIndex = lastUserMessage.parts.findIndex((p) => p.type === "text" && p.text !== undefined);
-      if (textPartIndex === -1) {
-        return;
-      }
-      const originalPart = lastUserMessage.parts[textPartIndex];
-      if (isInternalInitiatorPart(originalPart)) {
-        return;
-      }
-      if (lastUserMessage.parts.some(hasPhaseReminder)) {
-        return;
+      for (const message of messages) {
+        if (!isUserMessageWithParts(message) || message.info.agent !== "orchestrator" || message.info.sessionID !== sessionID) {
+          continue;
+        }
+        const textPart = message.parts.find((part) => part.type === "text" && part.text !== undefined);
+        if (!textPart || isInternalInitiatorPart(textPart) || message.parts.some(hasPhaseReminder)) {
+          continue;
+        }
+        message.parts.push({
+          type: "text",
+          synthetic: true,
+          text: PHASE_REMINDER,
+          metadata: { [PHASE_REMINDER_METADATA_KEY]: true }
+        });
       }
-      lastUserMessage.parts.push({
-        type: "text",
-        synthetic: true,
-        text: PHASE_REMINDER,
-        metadata: { [PHASE_REMINDER_METADATA_KEY]: true }
-      });
     }
   };
 }
@@ -26611,6 +26589,13 @@ function createPendingCallTracker() {
       pendingCalls.delete(callId);
       return pending;
     },
+    peekByParent(parentSessionId) {
+      for (const call of pendingCalls.values()) {
+        if (call.parentSessionId === parentSessionId)
+          return call;
+      }
+      return;
+    },
     clearSession(sessionId) {
       for (const [callId, pending] of pendingCalls.entries()) {
         if (pending.parentSessionId === sessionId) {
@@ -26706,7 +26691,7 @@ var BACKGROUND_COMPLETION_FAILED = /^Background task failed: /;
 var MAX_PROCESSED_INJECTED_COMPLETIONS = 500;
 var RAW_SESSION_ID_PATTERN = /^ses_[A-Za-z0-9_-]+$/;
 var IDLE_RECONCILE_DELAY_MS = 2000;
-var idleReconcileTimers = new Map;
+var CONTINUATION_NUDGE = "Continue coordinating the remaining incomplete todos. Do not finalize while work remains.";
 function djb2Hash(str) {
   let hash = 5381;
   for (let i = 0;i < str.length; i++) {
@@ -26747,8 +26732,137 @@ function createTaskSessionManagerHook(_ctx, options) {
   const processedInjectedCompletions = new Set;
   const processedInjectedCompletionOrder = [];
   const terminalJobsInjectedByParent = new Map;
+  const idleReconcileTimers = new Map;
+  const continuationSessionTokens = new Map;
+  const activeContinuationEvaluations = new Map;
+  const continuationConsumed = new Set;
+  const idleReconcileDelayMs = options.idleReconcileDelayMs ?? IDLE_RECONCILE_DELAY_MS;
+  const sessionSdk = _ctx.client.session;
+  function getContinuationSessionToken(sessionID) {
+    const existing = continuationSessionTokens.get(sessionID);
+    if (existing)
+      return existing;
+    const token = Symbol(sessionID);
+    continuationSessionTokens.set(sessionID, token);
+    return token;
+  }
+  function isCurrentContinuation(sessionID, sessionToken, evaluationToken) {
+    return continuationSessionTokens.get(sessionID) === sessionToken && (evaluationToken === undefined || activeContinuationEvaluations.get(sessionID)?.has(evaluationToken) === true);
+  }
+  function invalidateContinuation(sessionID) {
+    const timer = idleReconcileTimers.get(sessionID);
+    if (timer) {
+      clearTimeout(timer);
+      idleReconcileTimers.delete(sessionID);
+    }
+    continuationSessionTokens.delete(sessionID);
+    activeContinuationEvaluations.delete(sessionID);
+  }
+  function clearContinuation(sessionID) {
+    invalidateContinuation(sessionID);
+    continuationConsumed.delete(sessionID);
+  }
+  function isActiveStatus(status, sessionID) {
+    return Object.hasOwn(status, sessionID);
+  }
+  async function evaluateContinuation(parentSessionID, sessionToken) {
+    const evaluationToken = Symbol(parentSessionID);
+    const activeEvaluations = activeContinuationEvaluations.get(parentSessionID) ?? new Set;
+    activeEvaluations.add(evaluationToken);
+    activeContinuationEvaluations.set(parentSessionID, activeEvaluations);
+    if (continuationConsumed.has(parentSessionID) || !isCurrentContinuation(parentSessionID, sessionToken, evaluationToken) || options.isFallbackInProgress?.(parentSessionID) || backgroundJobBoard.hasTerminalUnreconciled(parentSessionID) || !sessionSdk?.todo || !sessionSdk.children || !sessionSdk.status || !sessionSdk.promptAsync) {
+      activeEvaluations.delete(evaluationToken);
+      if (activeEvaluations.size === 0) {
+        activeContinuationEvaluations.delete(parentSessionID);
+      }
+      return;
+    }
+    try {
+      const [todoResponse, childrenResponse, statusResponse] = await Promise.all([
+        sessionSdk.todo({
+          path: { id: parentSessionID },
+          throwOnError: true
+        }),
+        sessionSdk.children({
+          path: { id: parentSessionID },
+          throwOnError: true
+        }),
+        sessionSdk.status({ throwOnError: true })
+      ]);
+      if (!Array.isArray(todoResponse.data) || !Array.isArray(childrenResponse.data) || !isRecord2(statusResponse.data)) {
+        return;
+      }
+      const todos = todoResponse.data;
+      const children = childrenResponse.data;
+      const status = statusResponse.data;
+      if (!todos.every((todo) => isRecord2(todo) && typeof todo.status === "string") || !children.every((child) => isRecord2(child) && typeof child.id === "string")) {
+        return;
+      }
+      if (!todos.some((todo) => todo.status !== "completed" && todo.status !== "cancelled")) {
+        return;
+      }
+      const childIDs = children.map((child) => child.id);
+      if (isActiveStatus(status, parentSessionID) || childIDs.some((childID) => isActiveStatus(status, childID))) {
+        return;
+      }
+      const [latestChildrenResponse, latestStatusResponse] = await Promise.all([
+        sessionSdk.children({
+          path: { id: parentSessionID },
+          throwOnError: true
+        }),
+        sessionSdk.status({ throwOnError: true })
+      ]);
+      if (!Array.isArray(latestChildrenResponse.data) || !isRecord2(latestStatusResponse.data) || !latestChildrenResponse.data.every((child) => isRecord2(child) && typeof child.id === "string") || continuationConsumed.has(parentSessionID) || !isCurrentContinuation(parentSessionID, sessionToken, evaluationToken) || options.isFallbackInProgress?.(parentSessionID) || backgroundJobBoard.hasTerminalUnreconciled(parentSessionID)) {
+        return;
+      }
+      const latestChildIDs = latestChildrenResponse.data.map((child) => child.id);
+      const latestStatus = latestStatusResponse.data;
+      if (isActiveStatus(latestStatus, parentSessionID) || latestChildIDs.some((childID) => isActiveStatus(latestStatus, childID))) {
+        return;
+      }
+      if (continuationConsumed.has(parentSessionID) || !isCurrentContinuation(parentSessionID, sessionToken, evaluationToken) || options.isFallbackInProgress?.(parentSessionID) || backgroundJobBoard.hasTerminalUnreconciled(parentSessionID)) {
+        return;
+      }
+      continuationConsumed.add(parentSessionID);
+      await sessionSdk.promptAsync({
+        path: { id: parentSessionID },
+        body: { parts: [createInternalAgentTextPart(CONTINUATION_NUDGE)] },
+        throwOnError: true
+      });
+    } catch (error) {
+      log("[task-session-manager] continuation nudge suppressed after SDK error", {
+        parentSessionID,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      const evaluations = activeContinuationEvaluations.get(parentSessionID);
+      evaluations?.delete(evaluationToken);
+      if (evaluations?.size === 0) {
+        activeContinuationEvaluations.delete(parentSessionID);
+      }
+    }
+  }
+  function scheduleIdleReconciliation(parentSessionID) {
+    if (idleReconcileTimers.has(parentSessionID) || options.isFallbackInProgress?.(parentSessionID)) {
+      return;
+    }
+    const sessionToken = getContinuationSessionToken(parentSessionID);
+    const timer = setTimeout(() => {
+      idleReconcileTimers.delete(parentSessionID);
+      if (!isCurrentContinuation(parentSessionID, sessionToken)) {
+        return;
+      }
+      const hadTerminalUnreconciled = backgroundJobBoard.hasTerminalUnreconciled(parentSessionID);
+      reconcileInjectedTerminalJobs(parentSessionID);
+      if (!hadTerminalUnreconciled) {
+        evaluateContinuation(parentSessionID, sessionToken);
+      }
+    }, idleReconcileDelayMs).unref?.();
+    idleReconcileTimers.set(parentSessionID, timer);
+  }
   if (options.coordinator) {
     options.coordinator.onSessionDeleted((sessionId) => {
+      clearContinuation(sessionId);
       if (!options.isFallbackInProgress?.(sessionId)) {
         backgroundJobBoard.drop(sessionId);
         backgroundJobBoard.clearParent(sessionId);
@@ -26908,6 +27022,18 @@ function createTaskSessionManagerHook(_ctx, options) {
     terminalJobsInjectedByParent.delete(parentSessionID);
   }
   return {
+    observeChatMessage: (input, output) => {
+      const inputMessage = isRecord2(input) ? input : undefined;
+      const outputRecord = isRecord2(output) ? output : undefined;
+      const outputMessage = isRecord2(outputRecord?.message) ? outputRecord.message : undefined;
+      const sessionID = typeof outputMessage?.sessionID === "string" ? outputMessage.sessionID : typeof inputMessage?.sessionID === "string" ? inputMessage.sessionID : undefined;
+      const parts = Array.isArray(outputRecord?.parts) ? outputRecord.parts : inputMessage?.parts;
+      if (!sessionID || typeof outputMessage?.role === "string" && outputMessage.role !== "user" || !options.shouldManageSession(sessionID) || !Array.isArray(parts) || !parts.some((part) => isRecord2(part) && part.type === "text" && typeof part.text === "string" && part.synthetic !== true && !isInternalInitiatorPart(part))) {
+        return;
+      }
+      invalidateContinuation(sessionID);
+      continuationConsumed.delete(sessionID);
+    },
     "tool.execute.before": async (input, output) => {
       const toolName = input.tool.toLowerCase();
       if (toolName !== "task")
@@ -27133,6 +27259,34 @@ function createTaskSessionManagerHook(_ctx, options) {
         });
         if (info?.id && info.parentID && options.shouldManageSession(info.parentID)) {
           taskContextTracker.pendingManagedTaskIds.add(info.id);
+          const pending = pendingCallTracker.peekByParent(info.parentID);
+          if (pending && !pending.resumedTaskId && !backgroundJobBoard.get(info.id)) {
+            const record = backgroundJobBoard.registerLaunch({
+              taskID: info.id,
+              parentSessionID: pending.parentSessionId,
+              agent: pending.agentType,
+              description: pending.label,
+              objective: pending.label
+            });
+            log("[task-session-manager] early board registration from session.created", {
+              taskID: record.taskID,
+              alias: record.alias,
+              parentSessionID: record.parentSessionID,
+              agent: record.agent
+            });
+          }
+        }
+        return;
+      }
+      if (input.event.type === "server.instance.disposed") {
+        const continuationSessionIDs = new Set([
+          ...idleReconcileTimers.keys(),
+          ...continuationSessionTokens.keys(),
+          ...activeContinuationEvaluations.keys(),
+          ...continuationConsumed
+        ]);
+        for (const sessionID of continuationSessionIDs) {
+          clearContinuation(sessionID);
         }
         return;
       }
@@ -27146,11 +27300,7 @@ function createTaskSessionManagerHook(_ctx, options) {
           runningJobForSession: job?.state === "running" || false
         });
         if (sessionId2 && options.shouldManageSession(sessionId2)) {
-          const timer2 = setTimeout(() => {
-            idleReconcileTimers.delete(sessionId2);
-            reconcileInjectedTerminalJobs(sessionId2);
-          }, IDLE_RECONCILE_DELAY_MS).unref?.();
-          idleReconcileTimers.set(sessionId2, timer2);
+          scheduleIdleReconciliation(sessionId2);
         }
         if (job && sessionId2 && job.state === "running" && !options.isFallbackInProgress?.(sessionId2)) {
           log("[task-session-manager] reconciled running job from idle", {
@@ -27172,13 +27322,8 @@ function createTaskSessionManagerHook(_ctx, options) {
       }
       if (input.event.type === "session.error") {
         const sessionId2 = input.event.properties?.info?.id || input.event.properties?.sessionID;
-        if (sessionId2) {
-          const timer2 = idleReconcileTimers.get(sessionId2);
-          if (timer2) {
-            clearTimeout(timer2);
-            idleReconcileTimers.delete(sessionId2);
-          }
-        }
+        if (sessionId2)
+          invalidateContinuation(sessionId2);
         if (sessionId2 && options.shouldManageSession(sessionId2)) {
           const props = input.event.properties;
           if (!props?.error || !isFailoverError(props.error)) {
@@ -27187,14 +27332,13 @@ function createTaskSessionManagerHook(_ctx, options) {
         }
         return;
       }
-      if (input.event.type === "session.status" && input.event.properties?.status?.type === "busy") {
+      if (input.event.type === "session.status") {
         const sessionId2 = input.event.properties?.info?.id || input.event.properties?.sessionID;
-        if (sessionId2) {
-          const timer2 = idleReconcileTimers.get(sessionId2);
-          if (timer2) {
-            clearTimeout(timer2);
-            idleReconcileTimers.delete(sessionId2);
-          }
+        const statusType = input.event.properties?.status?.type;
+        if (sessionId2)
+          invalidateContinuation(sessionId2);
+        if (statusType !== "busy") {
+          return;
         }
         const before = sessionId2 ? backgroundJobBoard.get(sessionId2) : undefined;
         const updated = sessionId2 ? backgroundJobBoard.markRunningFromLiveSession(sessionId2) : undefined;
@@ -27225,11 +27369,7 @@ function createTaskSessionManagerHook(_ctx, options) {
       const sessionId = input.event.properties?.info?.id || input.event.properties?.sessionID;
       if (!sessionId)
         return;
-      const timer = idleReconcileTimers.get(sessionId);
-      if (timer) {
-        clearTimeout(timer);
-        idleReconcileTimers.delete(sessionId);
-      }
+      clearContinuation(sessionId);
       log("[task-session-manager] session.deleted observed", {
         sessionID: sessionId
       });
@@ -27275,6 +27415,15 @@ function formatCancelledTaskStatusOutput(taskID, summary = "cancelled") {
   ].join(`
 `);
 }
+// src/index-event.ts
+async function handleTaskSessionEvent(input, invalidateTaskSessions, handleMultiplexerEvent, cleanupInstance) {
+  await invalidateTaskSessions(input);
+  await handleMultiplexerEvent();
+  if (input.event.type === "server.instance.disposed") {
+    await cleanupInstance();
+  }
+}
+
 // src/interview/dashboard.ts
 import crypto2 from "node:crypto";
 import * as fsSync2 from "node:fs";
@@ -32317,6 +32466,42 @@ function buildOpencodeAttachCommand(sessionId, serverUrl, directory, executable
     quoteShellArg(attachDir)
   ].join(" ");
 }
+function resolveOpencodeExecutable() {
+  return resolveHostOpencodeBinary() ?? "opencode";
+}
+function buildShellLaunchArgs(command) {
+  const shell = process.env.SHELL || "/bin/sh";
+  const name = (shell.split(/[/\\]/).at(-1) ?? "sh").replace(/\.(exe|EXE)$/, "");
+  if (name === "nu" || name === "fish") {
+    return [shell, "-c", command];
+  }
+  if (name === "zsh") {
+    return [
+      shell,
+      "-l",
+      "-c",
+      `[[ -f "\${ZDOTDIR:-$HOME}/.zshrc" ]] && source "\${ZDOTDIR:-$HOME}/.zshrc" >/dev/null 2>&1
+${command}`
+    ];
+  }
+  if (name === "bash") {
+    return [
+      shell,
+      "-l",
+      "-c",
+      `shopt -s expand_aliases
+[[ -f ~/.bashrc ]] && source ~/.bashrc >/dev/null 2>&1 || true
+${command}`
+    ];
+  }
+  if (name === "cmd") {
+    return [shell, "/c", command];
+  }
+  if (name === "pwsh" || name === "powershell") {
+    return [shell, "-NoProfile", "-Command", command];
+  }
+  return [shell, "-c", command];
+}
 function resolveHostOpencodeBinary(options = {}) {
   const pathExists = options.pathExists ?? existsSync9;
   for (const candidate of [
@@ -32393,13 +32578,15 @@ async function gracefulClosePane(binary, paneId, options) {
   try {
     const ctrlCProc = crossSpawn([binary, ...options.ctrlC], {
       stdout: "ignore",
-      stderr: "ignore"
+      stderr: "ignore",
+      env: options.env
     });
     await ctrlCProc.exited;
     await new Promise((r) => setTimeout(r, GRACEFUL_SHUTDOWN_DELAY_MS));
     const proc = crossSpawn([binary, ...options.close], {
       stdout: "ignore",
-      stderr: "ignore"
+      stderr: "ignore",
+      env: options.env
     });
     const exitCode = await proc.exited;
     if (exitCode === 0)
@@ -33130,6 +33317,189 @@ function getPaneDirection(layout) {
   }
 }
 
+// src/multiplexer/kitty/index.ts
+init_compat();
+class KittyMultiplexer {
+  type = "kitty";
+  binaryPath = null;
+  hasChecked = false;
+  storedLayout;
+  appliedLayout = null;
+  constructor(layout = "main-vertical", mainPaneSize = 60) {
+    this.storedLayout = layout;
+  }
+  async isAvailable() {
+    if (this.hasChecked) {
+      return this.binaryPath !== null;
+    }
+    this.binaryPath = await findBinary("kitten") ?? await findBinary("kitty");
+    this.hasChecked = true;
+    return this.binaryPath !== null;
+  }
+  isInsideSession() {
+    return !!process.env.KITTY_PID || !!process.env.KITTY_WINDOW_ID;
+  }
+  hasListenOn() {
+    return !!process.env.KITTY_LISTEN_ON;
+  }
+  async spawnPane(sessionId, description, serverUrl, directory) {
+    const kitten = await this.getBinary();
+    if (!kitten) {
+      log("[kitty] spawnPane: kitten/kitty binary not found");
+      return { success: false };
+    }
+    if (!this.isInsideSession()) {
+      log("[kitty] spawnPane: OpenCode is not running inside a kitty session; " + "set multiplexer.type to a different backend or run OpenCode inside kitty");
+      return { success: false };
+    }
+    if (!this.hasListenOn()) {
+      log("[kitty] spawnPane: KITTY_LISTEN_ON is not set. Add `listen_on " + "unix:/tmp/kitty-rc-$(USER)` to kitty.conf and restart kitty so the " + "plugin can drive kitty via the socket.");
+      return { success: false };
+    }
+    const { kittyLayout, location } = getKittyLayoutConfig(this.storedLayout);
+    await this.ensureLayout(kittyLayout);
+    try {
+      const opencodeCmd = buildOpencodeAttachCommand(sessionId, serverUrl, directory, resolveOpencodeExecutable());
+      const attachDir = normalizePathForShell(directory);
+      const shellArgs = buildShellLaunchArgs(opencodeCmd);
+      const args = [
+        "@",
+        "launch",
+        "--type=window",
+        `--location=${location}`,
+        `--title=${description.slice(0, 60)}`,
+        `--cwd=${attachDir}`,
+        "--keep-focus",
+        "--",
+        ...shellArgs
+      ];
+      log("[kitty] spawnPane: executing", { kitten, args });
+      const proc = crossSpawn([kitten, ...args], {
+        stdout: "pipe",
+        stderr: "pipe",
+        env: this.kittyEnv()
+      });
+      const exitCode = await proc.exited;
+      const stdout = await proc.stdout();
+      const stderr = await proc.stderr();
+      const lines = stdout.trim().split(`
+`).map((l) => l.trim()).filter(Boolean);
+      const windowId = lines.length > 0 ? lines[lines.length - 1] : "";
+      log("[kitty] spawnPane: result", {
+        exitCode,
+        windowId,
+        stderr: stderr.trim()
+      });
+      if (exitCode === 0 && windowId) {
+        log("[kitty] spawnPane: SUCCESS", { windowId });
+        return { success: true, paneId: windowId };
+      }
+      return { success: false };
+    } catch (err) {
+      log("[kitty] spawnPane: exception", { error: String(err) });
+      return { success: false };
+    }
+  }
+  async closePane(paneId) {
+    if (!this.isInsideSession()) {
+      log("[kitty] closePane: OpenCode is not running inside a kitty session; " + "cannot target a kitty instance");
+      return false;
+    }
+    if (!this.hasListenOn()) {
+      log("[kitty] closePane: KITTY_LISTEN_ON is not set; cannot target kitty. " + "Add `listen_on` to kitty.conf and restart kitty.");
+      return false;
+    }
+    const kitten = await this.getBinary();
+    return await gracefulClosePane(kitten, paneId, {
+      ctrlC: ["@", "send-key", "--match", `id:${paneId}`, "ctrl+c"],
+      close: ["@", "close-window", "--match", `id:${paneId}`],
+      acceptExitCode1: true,
+      emptyPaneReturnsTrue: true,
+      env: this.kittyEnv()
+    });
+  }
+  async applyLayout(layout, mainPaneSize) {
+    if (!this.isInsideSession()) {
+      log("[kitty] applyLayout: OpenCode is not running inside a kitty session; " + "cannot target a kitty instance");
+      return;
+    }
+    if (!this.hasListenOn()) {
+      log("[kitty] applyLayout: KITTY_LISTEN_ON is not set; cannot target kitty. " + "Add `listen_on` to kitty.conf and restart kitty.");
+      return;
+    }
+    this.storedLayout = layout;
+    const { kittyLayout } = getKittyLayoutConfig(layout);
+    await this.ensureLayout(kittyLayout);
+  }
+  async runKitty(kitten, args) {
+    const proc = crossSpawn([kitten, ...args], {
+      stdout: "pipe",
+      stderr: "pipe",
+      env: this.kittyEnv()
+    });
+    const [exitCode, , stderr] = await Promise.all([
+      proc.exited,
+      proc.stdout(),
+      proc.stderr()
+    ]);
+    if (exitCode !== 0) {
+      log("[kitty] command failed", {
+        command: args[1],
+        args: [kitten, ...args],
+        exitCode,
+        stderr: stderr.trim()
+      });
+    }
+    return exitCode;
+  }
+  async ensureLayout(kittyLayout) {
+    if (this.appliedLayout === kittyLayout)
+      return;
+    const kitten = await this.getBinary();
+    if (!kitten)
+      return;
+    try {
+      const exitCode = await this.runKitty(kitten, [
+        "@",
+        "goto-layout",
+        kittyLayout
+      ]);
+      if (exitCode === 0)
+        this.appliedLayout = kittyLayout;
+    } catch (err) {
+      log("[kitty] ensureLayout: exception", { error: String(err) });
+    }
+  }
+  async getBinary() {
+    await this.isAvailable();
+    return this.binaryPath;
+  }
+  kittyEnv() {
+    const listenOn = process.env.KITTY_LISTEN_ON;
+    if (!listenOn)
+      return;
+    return { ...process.env, KITTY_LISTEN_ON: listenOn };
+  }
+}
+function getKittyLayoutConfig(layout) {
+  switch (layout) {
+    case "main-vertical":
+      return { kittyLayout: "tall", location: "after" };
+    case "main-horizontal":
+      return { kittyLayout: "fat", location: "after" };
+    case "tiled":
+      return { kittyLayout: "grid", location: "after" };
+    case "even-horizontal":
+      return { kittyLayout: "horizontal", location: "after" };
+    case "even-vertical":
+      return { kittyLayout: "vertical", location: "after" };
+    default: {
+      const _exhaustive = layout;
+      return _exhaustive;
+    }
+  }
+}
+
 // src/multiplexer/tmux/index.ts
 init_compat();
 var TMUX_LAYOUT_DEBOUNCE_MS = 150;
@@ -33677,6 +34047,10 @@ function getMultiplexer(config) {
       multiplexer = new CmuxMultiplexer;
       actualType = "cmux";
       break;
+    case "kitty":
+      multiplexer = new KittyMultiplexer(config.layout, config.main_pane_size);
+      actualType = "kitty";
+      break;
     case "auto": {
       if (process.env.CMUX_SOCKET_PATH && process.env.CMUX_WORKSPACE_ID && process.env.CMUX_SURFACE_ID) {
         multiplexer = new CmuxMultiplexer;
@@ -33690,6 +34064,9 @@ function getMultiplexer(config) {
       } else if (process.env.HERDR_ENV || process.env.HERDR_PANE_ID) {
         multiplexer = new HerdrMultiplexer(config.layout, config.main_pane_size);
         actualType = "herdr";
+      } else if (process.env.KITTY_PID || process.env.KITTY_WINDOW_ID) {
+        multiplexer = new KittyMultiplexer(config.layout, config.main_pane_size);
+        actualType = "kitty";
       } else {
         log("[multiplexer] auto: not inside any session, disabling");
         return null;
@@ -38834,47 +39211,6 @@ function isPluginDisabledByEnv(env = process.env) {
   return isTruthyEnvValue(env[PLUGIN_DISABLE_ENV]);
 }
 
-// src/utils/subagent-depth.ts
-class SubagentDepthTracker {
-  depthBySession = new Map;
-  _maxDepth;
-  constructor(maxDepth = DEFAULT_MAX_SUBAGENT_DEPTH) {
-    this._maxDepth = maxDepth;
-  }
-  get maxDepth() {
-    return this._maxDepth;
-  }
-  getDepth(sessionId) {
-    return this.depthBySession.get(sessionId) ?? 0;
-  }
-  registerChild(parentSessionId, childSessionId) {
-    const parentDepth = this.getDepth(parentSessionId);
-    const childDepth = parentDepth + 1;
-    if (childDepth > this.maxDepth) {
-      log("[subagent-depth] spawn blocked: max depth exceeded", {
-        parentSessionId,
-        parentDepth,
-        childDepth,
-        maxDepth: this.maxDepth
-      });
-      return false;
-    }
-    this.depthBySession.set(childSessionId, childDepth);
-    log("[subagent-depth] child registered", {
-      parentSessionId,
-      childSessionId,
-      childDepth
-    });
-    return true;
-  }
-  cleanup(sessionId) {
-    this.depthBySession.delete(sessionId);
-  }
-  cleanupAll() {
-    this.depthBySession.clear();
-  }
-}
-
 // src/utils/system-collapse.ts
 function collapseSystemInPlace(system2) {
   if (system2.length === 0) {
@@ -38938,7 +39274,6 @@ var OhMyOpenCodeLite = async (ctx) => {
   let runtimeChains;
   let multiplexerConfig;
   let multiplexerEnabled;
-  let depthTracker;
   let multiplexerSessionManager;
   let autoUpdateChecker;
   let sessionAgentMap;
@@ -39010,8 +39345,7 @@ var OhMyOpenCodeLite = async (ctx) => {
     if (multiplexerEnabled) {
       startAvailabilityCheck(multiplexerConfig);
     }
-    depthTracker = new SubagentDepthTracker;
-    councilTools = config.council ? createCouncilTool(ctx, new CouncilManager(ctx, config, depthTracker, multiplexerEnabled)) : {};
+    councilTools = config.council ? createCouncilTool(ctx, new CouncilManager(ctx, config, multiplexerEnabled)) : {};
     mcps = createBuiltinMcps(config.disabled_mcps, config.websearch);
     acpRunTools = Object.keys(config.acpAgents ?? {}).length > 0 ? { acp_run: createAcpRunTool(config.acpAgents) } : {};
     webfetch = createWebfetchTool(ctx);
@@ -39383,27 +39717,22 @@ var OhMyOpenCodeLite = async (ctx) => {
         }
       }
       if (event.type === "session.created") {
-        const childSessionId = event.properties?.info?.id;
-        const parentSessionId = event.properties?.info?.parentID;
-        if (depthTracker && childSessionId && parentSessionId) {
-          depthTracker.registerChild(parentSessionId, childSessionId);
-        }
         const createdSessionId = event.properties?.info?.id;
         const createdSessionDir = event.properties?.info?.directory;
         if (createdSessionId && createdSessionDir) {
           sessionDirectories.set(createdSessionId, createdSessionDir);
         }
       }
-      await multiplexerSessionManager.onSessionCreated(event);
-      await multiplexerSessionManager.onSessionStatus(event);
-      await multiplexerSessionManager.onSessionDeleted(event);
-      if (event.type === "server.instance.disposed") {
+      await handleTaskSessionEvent(input, taskSessionManagerHook.event, async () => {
+        await multiplexerSessionManager.onSessionCreated(event);
+        await multiplexerSessionManager.onSessionStatus(event);
+        await multiplexerSessionManager.onSessionDeleted(event);
+      }, async () => {
         await multiplexerSessionManager.cleanupOnInstanceDisposed();
-      }
+      });
       await foregroundFallback.handleEvent(input.event);
       await autoUpdateChecker.event(input);
       await interviewManager.handleEvent(input);
-      await taskSessionManagerHook.event(input);
       if (event.type === "permission.asked" || event.type === "question.asked") {
         companionManager.onWaitingInput();
       }
@@ -39426,9 +39755,6 @@ var OhMyOpenCodeLite = async (ctx) => {
           sessionLifecycle.dispatchSessionDeleted(sessionID);
         }
         companionManager.onSessionDeleted(sessionID);
-        if (depthTracker && sessionID) {
-          depthTracker.cleanup(sessionID);
-        }
         if (sessionID) {
           sessionAgentMap.delete(sessionID);
           sessionDirectories.delete(sessionID);
@@ -39462,6 +39788,7 @@ var OhMyOpenCodeLite = async (ctx) => {
           status: "busy"
         });
       }
+      taskSessionManagerHook.observeChatMessage(input, output);
     },
     "experimental.chat.system.transform": async (input, output) => {
       const agentName = input.sessionID ? sessionAgentMap.get(input.sessionID) : undefined;