oh-my-opencode-slim 2.2.1 → 2.2.3

package/dist/multiplexer/index.d.ts

@@ -5,6 +5,7 @@ export type { CmuxClient, CommandRunner } from './cmux';
 export { CliCmuxClient, CmuxMultiplexer } from './cmux';
 export { getMultiplexer, startAvailabilityCheck, } from './factory';
 export { HerdrMultiplexer } from './herdr';
+export { KittyMultiplexer } from './kitty';
 export { MultiplexerSessionManager, TmuxSessionManager, } from './session-manager';
 export { TmuxMultiplexer } from './tmux';
 export type { Multiplexer, PaneResult } from './types';

package/dist/multiplexer/kitty/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Kitty multiplexer implementation
+ *
+ * Uses kitty's remote-control CLI (`kitten @`) to manage windows.
+ * A kitty WINDOW is the 1:1 equivalent of a tmux pane (full PTY).
+ *
+ * Requires `allow_remote_control` **and** `listen_on` in kitty.conf. When
+ * `listen_on` is set, kitty exports `KITTY_LISTEN_ON` to its child processes
+ * (including OpenCode). The plugin passes that env through to `kitten @` so
+ * remote control goes via the socket instead of the controlling terminal,
+ * because OpenCode spawns subagent commands in a process detached from the
+ * kitty window's tty, where the tty-based remote-control path does not work.
+ *
+ * Layout mapping:
+ * - main-vertical → tall layout (full-height main pane on left, side panes stacked on right)
+ * - main-horizontal → fat layout (full-width main pane on top, side panes tiled below)
+ * - tiled → grid layout (equal-sized cells)
+ * - even-horizontal → horizontal layout (all panes side-by-side)
+ * - even-vertical → vertical layout (all panes stacked)
+ *
+ * Maps each plugin layout to the closest kitty built-in layout. kitty has no
+ * per-window layout API, so the chosen layout is applied as a global change to
+ * the active tab (overriding whatever layout was active there).
+ */
+import type { MultiplexerLayout } from '../../config/schema';
+import type { Multiplexer, PaneResult } from '../types';
+export declare class KittyMultiplexer implements Multiplexer {
+    readonly type: "kitty";
+    private binaryPath;
+    private hasChecked;
+    private storedLayout;
+    private appliedLayout;
+    constructor(layout?: MultiplexerLayout, mainPaneSize?: number);
+    isAvailable(): Promise<boolean>;
+    isInsideSession(): boolean;
+    /**
+     * The kitty multiplexer needs `listen_on` configured in kitty.conf so kitty
+     * exports `KITTY_LISTEN_ON` to its children. Without it, `kitten @` cannot
+     * reach kitty from OpenCode's detached subagent processes (the tty path does
+     * not work). Returns true when the socket env is present.
+     */
+    private hasListenOn;
+    spawnPane(sessionId: string, description: string, serverUrl: string, directory: string): Promise<PaneResult>;
+    closePane(paneId: string): Promise<boolean>;
+    applyLayout(layout: MultiplexerLayout, mainPaneSize: number): Promise<void>;
+    private runKitty;
+    private ensureLayout;
+    private getBinary;
+    /**
+     * Build the env for `kitten @` invocations. When kitty's `listen_on` socket
+     * is configured, kitty sets `KITTY_LISTEN_ON` in its child processes (which
+     * includes OpenCode). We pass that env through so remote control goes via the
+     * socket instead of the controlling terminal (required for the plugin's
+     * detached subagent processes). When the var is absent we return undefined
+     * and `kitten @` falls back to the tty path.
+     */
+    private kittyEnv;
+}

package/dist/multiplexer/shared.d.ts

@@ -8,6 +8,32 @@ export declare function quoteShellArg(value: string): string;
 /** Normalize Windows backslashes to / so sh -lc (MSYS2/Git Bash) doesn't treat them as escape chars. */
 export declare function normalizePathForShell(directory: string): string;
 export declare function buildOpencodeAttachCommand(sessionId: string, serverUrl: string, directory: string, executable?: string): string;
+/**
+ * Resolve the absolute path to the running OpenCode binary so child shells
+ * (e.g. a kitty-launched window) don't need `opencode` on their PATH. Falls
+ * back to the bare `opencode` name when no absolute path can be determined.
+ */
+export declare function resolveOpencodeExecutable(): string;
+/**
+ * Build the `[shell, ...shellArgs, command]` array for launching a command in
+ * the user's interactive shell. OpenCode respects the user's shell when running
+ * commands; multiplexer panes must do the same, otherwise a hardcoded `sh -c`
+ * breaks under non-POSIX shells (fish, nu, powershell, ...) or misses login
+ * startup files (where `opencode` may be on PATH).
+ *
+ * Mirrors OpenCode's own `Shell.args()` resolution:
+ * - nu / fish: `<shell> -c <command>` (no login mode)
+ * - zsh: login mode; zsh sources ~/.zshenv automatically, then we source
+ *   .zshrc before running the command
+ * - bash: login mode, sources bashrc, then runs command
+ * - cmd: `cmd /c <command>`
+ * - powershell: `pwsh -NoProfile -Command <command>`
+ * - default (sh/dash/elvish/xonsh/...): `<shell> -c <command>`
+ *
+ * Note: the working directory is supplied by the launcher (e.g. kitty's
+ * `--cwd`), not by a `cd` inside the shell command.
+ */
+export declare function buildShellLaunchArgs(command: string): string[];
 export declare function resolveHostOpencodeBinary(options?: {
     override?: string;
     envOverride?: string;
@@ -27,5 +53,7 @@ export interface GracefulClosePaneOptions {
     acceptExitCode1?: boolean;
     /** Return true for empty/unknown paneId instead of false (zellij/herdr behavior). */
     emptyPaneReturnsTrue?: boolean;
+    /** Env to pass to the kitten/kitty invocations (e.g. KITTY_LISTEN_ON). */
+    env?: Record<string, string | undefined>;
 }
 export declare function gracefulClosePane(binary: string | null, paneId: string, options: GracefulClosePaneOptions): Promise<boolean>;

package/dist/multiplexer/types.d.ts

@@ -14,10 +14,10 @@ export interface PaneResult {
 /**
  * Core multiplexer interface
  * Implementations: TmuxMultiplexer, ZellijMultiplexer, HerdrMultiplexer,
- * CmuxMultiplexer
+ * CmuxMultiplexer, KittyMultiplexer
  */
 export interface Multiplexer {
-    readonly type: 'tmux' | 'zellij' | 'herdr' | 'cmux';
+    readonly type: 'tmux' | 'zellij' | 'herdr' | 'cmux' | 'kitty';
     /**
      * Check if the multiplexer binary is available on the system
      */

package/dist/tui.js

@@ -129,7 +129,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>
@@ -367,6 +366,7 @@ var MultiplexerTypeSchema = z2.enum([
   "tmux",
   "zellij",
   "herdr",
+  "kitty",
   "cmux",
   "none"
 ]);

package/dist/utils/background-job-board.d.ts

@@ -95,7 +95,7 @@ export declare class BackgroundJobBoard implements BackgroundJobStore {
     hasRunning(parentSessionID: string): boolean;
     hasTerminalUnreconciled(parentSessionID: string): boolean;
     hasConvergenceSignals(taskID: string, threshold?: number): boolean;
-    formatForPrompt(parentSessionID: string, now?: number): string | undefined;
+    formatForPrompt(parentSessionID: string, _now?: number): string | undefined;
     clearParent(parentSessionID: string): void;
     drop(taskID: string): void;
     deferIfRunning(_sessionId: string): boolean;

package/oh-my-opencode-slim.schema.json

@@ -941,6 +941,7 @@
             "tmux",
             "zellij",
             "herdr",
+            "kitty",
             "cmux",
             "none"
           ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-slim",
-  "version": "2.2.1",
+  "version": "2.2.3",
   "description": "Lightweight agent orchestration plugin for OpenCode - a slimmed-down fork of oh-my-opencode",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -61,6 +61,7 @@
     "generate-schema": "bun run scripts/generate-schema.ts",
     "verify:release": "bun run scripts/verify-release-artifact.ts",
     "verify:host-smoke": "bun run scripts/verify-opencode-host-smoke.ts",
+    "verify:cache-stability": "bun run scripts/verify-opencode-cache-stability.ts",
     "typecheck": "tsc --noEmit",
     "test": "bun test",
     "lint": "biome lint .",

package/src/skills/deepwork/SKILL.md

@@ -27,6 +27,8 @@ Required behavior:
   `!.slim/deepwork/` and `!.slim/deepwork/**`;
 - keep OpenCode todos aligned with the active deepwork phase;
 - create and maintain a local markdown progress file under `.slim/deepwork/`;
+- save code/doc deliverables to project paths (e.g. `src/`, `docs/`); reserve
+  `.slim/deepwork/` strictly for progress files;
 - write valuable research findings into that file as confirmed research context
   when they are received and reconciled;
 - draft a plan before implementation;

package/dist/utils/subagent-depth.d.ts

@@ -1,35 +0,0 @@
-/**
- * Tracks subagent spawn depth to prevent excessive nesting.
- *
- * Depth 0 = root session (user's main conversation)
- * Depth 1 = agent spawned by root (e.g., explorer, council)
- * Depth 2 = agent spawned by depth-1 agent (e.g., councillor spawned by council)
- * Depth 3 = agent spawned by depth-2 agent (max depth by default)
- *
- * When max depth is exceeded, the spawn is blocked.
- */
-export declare class SubagentDepthTracker {
-    private depthBySession;
-    private readonly _maxDepth;
-    constructor(maxDepth?: number);
-    /** Maximum allowed depth. */
-    get maxDepth(): number;
-    /**
-     * Get the current depth of a session.
-     * Root sessions (not tracked) have depth 0.
-     */
-    getDepth(sessionId: string): number;
-    /**
-     * Register a child session and check if the spawn is allowed.
-     * @returns true if allowed, false if max depth exceeded
-     */
-    registerChild(parentSessionId: string, childSessionId: string): boolean;
-    /**
-     * Clean up session tracking when a session is deleted.
-     */
-    cleanup(sessionId: string): void;
-    /**
-     * Clean up all tracking data.
-     */
-    cleanupAll(): void;
-}