oh-my-opencode-slim 2.0.0-beta.0 → 2.0.0-beta.10

package/dist/multiplexer/session-manager.d.ts

@@ -1,5 +1,6 @@
 import type { PluginInput } from '@opencode-ai/plugin';
 import type { MultiplexerConfig } from '../config/schema';
+import type { BackgroundJobBoard } from '../utils/background-job-board';
 interface SessionEvent {
     type: string;
     properties?: {
@@ -23,6 +24,7 @@ export declare function resetMultiplexerSessionManagerState(): void;
  * with polling kept as a fallback for reliability.
  */
 export declare class MultiplexerSessionManager {
+    private readonly backgroundJobBoard?;
     private instanceId;
     private serverUrl;
     private directory;
@@ -33,7 +35,7 @@ export declare class MultiplexerSessionManager {
     private closingSessions;
     private pollInterval?;
     private enabled;
-    constructor(ctx: PluginInput, config: MultiplexerConfig);
+    constructor(ctx: PluginInput, config: MultiplexerConfig, backgroundJobBoard?: BackgroundJobBoard | undefined);
     onSessionCreated(event: SessionEvent): Promise<void>;
     onSessionStatus(event: SessionEvent): Promise<void>;
     onSessionDeleted(event: SessionEvent): Promise<void>;
@@ -46,6 +48,7 @@ export declare class MultiplexerSessionManager {
     private isTrackedOrSpawning;
     private updatePolling;
     private getSessionId;
+    private isRunningBackgroundJob;
     cleanup(): Promise<void>;
 }
 /**

package/dist/tools/ast-grep/tools.d.ts

@@ -1,3 +1,3 @@
-import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+import { type ToolDefinition } from '@opencode-ai/plugin';
 export declare const ast_grep_search: ToolDefinition;
 export declare const ast_grep_replace: ToolDefinition;

package/dist/tools/cancel-task.d.ts

@@ -0,0 +1,10 @@
+import { type PluginInput, type ToolDefinition } from '@opencode-ai/plugin';
+import type { BackgroundJobBoard } from '../utils/background-job-board';
+interface CancelTaskToolOptions {
+    client: PluginInput['client'];
+    backgroundJobBoard: BackgroundJobBoard;
+    shouldManageSession: (sessionID: string) => boolean;
+    abortTimeoutMs?: number;
+}
+export declare function createCancelTaskTool(options: CancelTaskToolOptions): Record<string, ToolDefinition>;
+export {};

package/dist/tools/index.d.ts

@@ -1,7 +1,6 @@
 export { ast_grep_replace, ast_grep_search } from './ast-grep';
+export { createCancelTaskTool } from './cancel-task';
 export { createCouncilTool } from './council';
 export type { PresetManager } from './preset-manager';
 export { createPresetManager } from './preset-manager';
 export { createWebfetchTool } from './smartfetch';
-export type { SubtaskCommandManager } from './subtask';
-export { createReadSessionTool, createSubtaskCommandManager, createSubtaskState, createSubtaskTool, } from './subtask';

package/dist/tui.js

@@ -68,9 +68,7 @@ var POLL_INTERVAL_BACKGROUND_MS = 2000;
 var DEFAULT_TIMEOUT_MS = 2 * 60 * 1000;
 var MAX_POLL_TIME_MS = 5 * 60 * 1000;
 var DEFAULT_MAX_SUBAGENT_DEPTH = 3;
-var PHASE_REMINDER_TEXT = `!IMPORTANT! Recall the workflow rules:
-Understand → build a short work graph with independent lanes, dependencies, and advisory ownership → dispatch independent specialists as background tasks → record task/session IDs → continue orchestration → poll task_status for terminal results → reconcile → verify.
-Only consume outputs or advance dependent work when background results are terminal. !END!`;
+var PHASE_REMINDER_TEXT = `!IMPORTANT! Scheduler workflow: plan lanes/dependencies → dispatch background specialists → track task IDs → wait for hook-driven completion or use task_status only when needed → reconcile terminal results → verify. Do not consume running-job output or advance dependent work. !END!`;
 var TMUX_SPAWN_DELAY_MS = 500;
 var COUNCILLOR_STAGGER_MS = 250;
 var DEFAULT_DISABLED_AGENTS = ["observer"];
@@ -308,7 +306,7 @@ var InterviewConfigSchema = z2.object({
   port: z2.number().int().min(0).max(65535).default(0),
   dashboard: z2.boolean().default(false)
 });
-var SessionManagerConfigSchema = z2.object({
+var BackgroundJobsConfigSchema = z2.object({
   maxSessionsPerAgent: z2.number().int().min(1).max(10).default(2),
   readContextMinLines: z2.number().int().min(0).max(1000).default(10),
   readContextMaxFiles: z2.number().int().min(0).max(50).default(8)
@@ -374,7 +372,7 @@ var PluginConfigSchema = z2.object({
   tmux: TmuxConfigSchema.optional(),
   websearch: WebsearchConfigSchema.optional(),
   interview: InterviewConfigSchema.optional(),
-  sessionManager: SessionManagerConfigSchema.optional(),
+  backgroundJobs: BackgroundJobsConfigSchema.optional(),
   divoom: DivoomConfigSchema.optional(),
   todoContinuation: TodoContinuationConfigSchema.optional(),
   fallback: FailoverConfigSchema.optional(),
@@ -457,6 +455,12 @@ var CUSTOM_SKILLS = [
     description: "Clone important dependency source for local inspection",
     allowedAgents: ["orchestrator"],
     sourcePath: "src/skills/clonedeps"
+  },
+  {
+    name: "deepwork",
+    description: "Heavy/complex coding sessions and large modifications workflow",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/deepwork"
   }
 ];
 
@@ -552,7 +556,7 @@ function mergePluginConfigs(base, override) {
     tmux: deepMerge(base.tmux, override.tmux),
     multiplexer: deepMerge(base.multiplexer, override.multiplexer),
     interview: deepMerge(base.interview, override.interview),
-    sessionManager: deepMerge(base.sessionManager, override.sessionManager),
+    backgroundJobs: deepMerge(base.backgroundJobs, override.backgroundJobs),
     divoom: deepMerge(base.divoom, override.divoom),
     fallback: deepMerge(base.fallback, override.fallback),
     council: deepMerge(base.council, override.council)

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

@@ -1,4 +1,10 @@
 import { type TaskOutputState } from './task';
+export interface ContextFile {
+    path: string;
+    lineCount: number;
+    lineNumbers?: number[];
+    lastReadAt: number;
+}
 export type BackgroundJobState = TaskOutputState | 'reconciled';
 export interface BackgroundJobRecord {
     taskID: string;
@@ -10,10 +16,19 @@ export interface BackgroundJobRecord {
     timedOut: boolean;
     terminalUnreconciled: boolean;
     launchedAt: number;
+    lastLaunchedAt: number;
     updatedAt: number;
     completedAt?: number;
     resultSummary?: string;
     alias: string;
+    lastUsedAt: number;
+    terminalState?: TaskOutputState;
+    contextFiles: ContextFile[];
+}
+export interface BackgroundJobBoardOptions {
+    maxReusablePerAgent?: number;
+    readContextMinLines?: number;
+    readContextMaxFiles?: number;
 }
 export interface BackgroundJobLaunchInput {
     taskID: string;
@@ -33,16 +48,34 @@ export interface BackgroundJobStatusInput {
 export declare class BackgroundJobBoard {
     private readonly jobs;
     private readonly counters;
+    private readonly maxReusablePerAgent;
+    private readonly readContextMinLines;
+    private readonly readContextMaxFiles;
+    constructor(options?: BackgroundJobBoardOptions);
     registerLaunch(input: BackgroundJobLaunchInput): BackgroundJobRecord;
     updateStatus(input: BackgroundJobStatusInput): BackgroundJobRecord | undefined;
     updateFromStatusOutput(output: string): BackgroundJobRecord | undefined;
     markReconciled(taskID: string, now?: number): BackgroundJobRecord | undefined;
+    markCancelled(taskID: string, reason?: string, now?: number): BackgroundJobRecord | undefined;
     get(taskID: string): BackgroundJobRecord | undefined;
+    resolve(parentSessionID: string, taskIDOrAlias: string): BackgroundJobRecord | undefined;
+    resolveForStatus(parentSessionID: string, taskIDOrAlias: string): BackgroundJobRecord | undefined;
+    resolveReusable(parentSessionID: string, taskIDOrAlias: string, agent?: string): BackgroundJobRecord | undefined;
+    markUsed(parentSessionID: string, key: string, now?: number): void;
+    taskIDs(): Set<string>;
+    addContext(taskID: string, files: ContextFile[]): void;
     list(parentSessionID?: string): BackgroundJobRecord[];
     hasRunning(parentSessionID: string): boolean;
     hasTerminalUnreconciled(parentSessionID: string): boolean;
-    formatForPrompt(parentSessionID: string): string | undefined;
+    formatForPrompt(parentSessionID: string, now?: number): string | undefined;
     clearParent(parentSessionID: string): void;
     drop(taskID: string): void;
+    private trimReusable;
+    private formatReusableJob;
     private nextAlias;
 }
+export declare function deriveTaskSessionLabel(input: {
+    description?: string;
+    prompt?: string;
+    agentType: string;
+}): string;

package/dist/utils/index.d.ts

@@ -5,6 +5,5 @@ export * from './internal-initiator';
 export { getLogDir, initLogger, log, resetLogger } from './logger';
 export * from './polling';
 export * from './session';
-export * from './session-manager';
 export * from './task';
 export { extractZip } from './zip-extractor';

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

@@ -486,7 +486,7 @@
         }
       }
     },
-    "sessionManager": {
+    "backgroundJobs": {
       "type": "object",
       "properties": {
         "maxSessionsPerAgent": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-slim",
-  "version": "2.0.0-beta.0",
+  "version": "2.0.0-beta.10",
   "description": "Lightweight agent orchestration plugin for OpenCode - a slimmed-down fork of oh-my-opencode",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -43,13 +43,15 @@
     "src/skills",
     "oh-my-opencode-slim.schema.json",
     "README.md",
+    "README.zh-CN.md",
     "LICENSE"
   ],
   "scripts": {
-    "build:plugin": "bun build src/index.ts src/tui.ts --outdir dist --target node --format esm --external @ast-grep/napi --external @opencode-ai/plugin --external @opencode-ai/sdk --external @opentui/core --external @opentui/solid --external jsdom --external zod",
-    "build:cli": "bun build src/cli/index.ts --outdir dist/cli --target node --format esm --external @ast-grep/napi --external @opencode-ai/plugin --external @opencode-ai/sdk --external jsdom --external zod",
+    "clean:dist": "bun -e \"import { rmSync } from 'node:fs'; rmSync('dist', { recursive: true, force: true })\"",
+    "build:plugin": "bun build src/index.ts src/tui.ts --outdir dist --target node --format esm --external @ast-grep/napi --external @opencode-ai/plugin --external @opencode-ai/plugin/* --external @opencode-ai/sdk --external @opencode-ai/sdk/* --external @opentui/core --external @opentui/solid --external jsdom --external zod",
+    "build:cli": "bun build src/cli/index.ts --outdir dist/cli --target node --format esm --external @ast-grep/napi --external @opencode-ai/plugin --external @opencode-ai/plugin/* --external @opencode-ai/sdk --external @opencode-ai/sdk/* --external jsdom --external zod",
     "copy:divoom-assets": "bun run scripts/copy-divoom-assets.ts",
-    "build": "bun run build:plugin && bun run build:cli && bun run copy:divoom-assets && tsc --emitDeclarationOnly && bun run generate-schema",
+    "build": "bun run clean:dist && bun run build:plugin && bun run build:cli && bun run copy:divoom-assets && tsc --emitDeclarationOnly && bun run generate-schema",
     "prepare": "bun run build",
     "contributors:add": "all-contributors add",
     "contributors:check": "all-contributors check",

package/src/skills/codemap.md

@@ -18,6 +18,7 @@
   - `src/skills/codemap/` (command-style repository mapping skill)
   - `src/skills/clonedeps/` (workflow skill for dependency source mirroring)
   - `src/skills/simplify/` (readability/refactor guidance skill)
+  - `src/skills/deepwork/` (orchestrator-only workflow for heavy coding sessions)
 - Files are considered static runtime payload. No plugin TS module in `src/` imports these files directly; they
   are loaded by OpenCode via filesystem installation.
 
@@ -38,6 +39,6 @@
   bundled skills when agent policy is derived from built-in recommendations.
 - `verify-release-artifact.ts` enforces artifact completeness by asserting key
   bundled skill payloads such as `src/skills/simplify/SKILL.md`,
-  `src/skills/codemap/SKILL.md`, and `src/skills/clonedeps/SKILL.md` are present
-  in the tarball.
+  `src/skills/codemap/SKILL.md`, `src/skills/clonedeps/SKILL.md`, and
+  `src/skills/deepwork/SKILL.md` are present in the tarball.
 - `package.json` scripts (`verify:release`, `build`) rely on these assets to ensure install-time skill availability.

package/src/skills/deepwork/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: deepwork
+description: Orchestrator-only workflow for heavy coding sessions, multi-phase implementation, and risky refactors. Use for complex work that needs planning, review gates, and persistent progress tracking.
+---
+
+# Deepwork
+
+Deepwork is an orchestrator workflow for heavy coding sessions. Use it when the
+work is broad, risky, multi-file, or likely to span several implementation
+phases. Do not use it for trivial edits, quick docs changes, or simple bug fixes.
+
+## Core Contract
+
+When deepwork is active, the orchestrator must manage the work as a scheduler,
+not as the default implementation worker.
+
+Required behavior:
+
+- keep OpenCode todos aligned with the active deepwork phase;
+- create and maintain a local markdown progress file under `.slim/deepwork/`;
+- write valuable research findings into that file as confirmed research context
+  when they are received and reconciled;
+- draft a plan before implementation;
+- ask `@oracle` to review the plan and revise it until acceptable;
+- create a phased implementation/delegation plan;
+- before oracle reviews, add relevant confirmed research findings and file
+  references to the deepwork file so oracle can review the plan or phase from
+  accepted context instead of redoing discovery;
+- ask `@oracle` to review that implementation plan before execution;
+- after oracle review and before each implementation phase, decide the execution
+  path: what can run in parallel, what must be sequential, which specialists to
+  delegate to, and whether to split the same agent into multiple bounded lanes;
+- after each phase, validate, update the deepwork file, prepare the plan file
+  for oracle review and ask `@oracle` to review the phase result, fix
+  actionable issues, then continue;
+- finish with final validation and a concise summary.
+
+## Deepwork File
+
+Create a task-specific file such as:
+
+```text
+.slim/deepwork/<short-task-slug>.md
+```
+
+Keep `.slim/deepwork/` out of git, but make it readable to OpenCode. Ensure the
+project ignore files include:
+
+```gitignore
+# .gitignore
+.slim/deepwork/
+```
+
+```gitignore
+# .ignore
+!.slim/deepwork/
+!.slim/deepwork/**
+```
+
+Do not follow a rigid template. Choose whatever markdown structure best fits the
+work. The file only needs to remain useful as persistent session state and should
+capture, as applicable:
+
+- current goal and understanding;
+- researched, factual context from `@librarian` to avoid oracle doing its own
+  research;
+- plan drafts and oracle review notes;
+- implementation phases and status;
+- validation results;
+- unresolved questions, blockers, and follow-ups.
+
+Update this file after major decisions, valuable specialist research, reviews,
+phase completions, validation results, and scope changes.
+When `@librarian` docs, code reads, or external references produce useful
+information, reconcile the result and record the accepted findings here so later
+planning and reviews share the same context instead of rediscovering it.
+Don't put actual contents of local files, reference them by path only.
+
+## Scheduler Discipline
+
+Use the scheduler model throughout:
+
+- follow Orchestrator delegations rules
+- record task/session IDs and ownership boundaries;
+- poll `task_status` before consuming background results;
+- avoid blocking Orchestrator lane too long; prefer shorter periodic task waits
+  rather than one long wait;
+- do not advance to the next phase while relevant jobs are running or terminal
+  results are unreconciled.

package/dist/agents/council-master.d.ts

@@ -1,2 +0,0 @@
-import { type AgentDefinition } from './orchestrator';
-export declare function createCouncilMasterAgent(model: string, customPrompt?: string, customAppendPrompt?: string): AgentDefinition;

package/dist/background/background-manager.d.ts

@@ -1,203 +0,0 @@
-/**
- * Background Task Manager
- *
- * Manages long-running AI agent tasks that execute in separate sessions.
- * Background tasks run independently from the main conversation flow, allowing
- * the user to continue working while tasks complete asynchronously.
- *
- * Key features:
- * - Fire-and-forget launch (returns task_id immediately)
- * - Creates isolated sessions for background work
- * - Event-driven completion detection via session.status
- * - Start queue with configurable concurrency limit
- * - Supports task cancellation and result retrieval
- */
-import type { PluginInput } from '@opencode-ai/plugin';
-import type { BackgroundTaskConfig, PluginConfig } from '../config';
-import type { MultiplexerConfig } from '../config/schema';
-import { SubagentDepthTracker } from './subagent-depth';
-export declare function loadPersistedTask(taskId: string): BackgroundTask | null;
-/**
- * Represents a background task running in an isolated session.
- * Tasks are tracked from creation through completion or failure.
- */
-export interface BackgroundTask {
-    id: string;
-    sessionId?: string;
-    description: string;
-    agent: string;
-    status: 'pending' | 'starting' | 'running' | 'completed' | 'failed' | 'cancelled';
-    result?: string;
-    error?: string;
-    config: BackgroundTaskConfig;
-    parentSessionId: string;
-    startedAt: Date;
-    completedAt?: Date;
-    prompt: string;
-    questions: string[];
-}
-/**
- * Options for launching a new background task.
- */
-export interface LaunchOptions {
-    agent: string;
-    prompt: string;
-    description: string;
-    parentSessionId: string;
-}
-export declare class BackgroundTaskManager {
-    private tasks;
-    private tasksBySessionId;
-    private agentBySessionId;
-    private depthTracker;
-    private client;
-    private directory;
-    private tmuxEnabled;
-    private config?;
-    private backgroundConfig;
-    private disabledAgents;
-    private startQueue;
-    private activeStarts;
-    private maxConcurrentStarts;
-    private completionResolvers;
-    constructor(ctx: PluginInput, multiplexerConfig?: MultiplexerConfig, config?: PluginConfig);
-    /**
-     * Look up the delegation rules for an agent type.
-     * Unknown agent types default to explorer-only access, making it easy
-     * to add new background agent types without updating SUBAGENT_DELEGATION_RULES.
-     */
-    private getSubagentRules;
-    /**
-     * Resolve the agent associated with a session.
-     * Untracked sessions are treated as orchestrator sessions by default.
-     */
-    private getSessionAgent;
-    /**
-     * Check if a parent session is allowed to delegate to a specific agent type.
-     * @param parentSessionId - The session ID of the parent
-     * @param requestedAgent - The agent type being requested
-     * @returns true if allowed, false if not
-     */
-    isAgentAllowed(parentSessionId: string, requestedAgent: string): boolean;
-    /**
-     * Get the list of allowed subagents for a parent session.
-     * @param parentSessionId - The session ID of the parent
-     * @returns Array of allowed agent names, empty if none
-     */
-    getAllowedSubagents(parentSessionId: string): readonly string[];
-    /**
-     * Launch a new background task (fire-and-forget).
-     *
-     * Phase A (sync): Creates task record and returns immediately.
-     * Phase B (async): Session creation and prompt sending happen in background.
-     *
-     * @param opts - Task configuration options
-     * @returns The created background task with pending status
-     */
-    launch(opts: LaunchOptions): BackgroundTask;
-    /**
-     * Enqueue task for background start.
-     */
-    private enqueueStart;
-    /**
-     * Process start queue with concurrency limit.
-     */
-    private processQueue;
-    private resolveFallbackChain;
-    /**
-     * Calculate tool permissions for a spawned agent based on its own delegation rules.
-     * Agents that cannot delegate (leaf nodes) get delegation tools disabled entirely,
-     * preventing models from even seeing tools they can never use.
-     *
-     * @param agentName - The agent type being spawned
-     * @returns Tool permissions object with background_task and task enabled/disabled
-     */
-    private calculateToolPermissions;
-    /**
-     * Start a task in the background (Phase B).
-     */
-    private startTask;
-    /**
-     * Handle session.status events for completion detection.
-     * Uses session.status instead of deprecated session.idle.
-     */
-    handleSessionStatus(event: {
-        type: string;
-        properties?: {
-            sessionID?: string;
-            status?: {
-                type: string;
-            };
-        };
-    }): Promise<void>;
-    /**
-     * Handle session.deleted events for cleanup.
-     * When a session is deleted, cancel associated tasks and clean up.
-     */
-    handleSessionDeleted(event: {
-        type: string;
-        properties?: {
-            info?: {
-                id?: string;
-            };
-            sessionID?: string;
-        };
-    }): Promise<void>;
-    /**
-     * Extract task result and mark complete.
-     * When retry_on_empty is enabled (default), empty responses are
-     * treated as failures so the fallback chain can retry.
-     * When disabled, empty responses succeed with an empty string result.
-     */
-    private extractAndCompleteTask;
-    /**
-     * Complete a task and notify waiting callers.
-     */
-    private completeTask;
-    /**
-     * Send completion notification to parent session.
-     */
-    private sendCompletionNotification;
-    /**
-     * Retrieve the current state of a background task.
-     *
-     * Checks in-memory first. If not found (e.g. after plugin reinitialization
-     * caused by context compaction), falls back to the persisted state on disk.
-     *
-     * @param taskId - The task ID to retrieve
-     * @returns The task object, or null if not found in memory or on disk
-     */
-    getResult(taskId: string): BackgroundTask | null;
-    /**
-     * Add a question relayed from a background subagent via ask_orchestrator.
-     * Resolves the task from the session ID in toolContext.
-     * Returns true if the question was recorded, false if the task wasn't found
-     * or is no longer active (completed/failed/cancelled).
-     *
-     * Questions are persisted to disk immediately for crash safety.
-     */
-    addQuestion(sessionId: string, question: string): 'recorded' | 'not-found' | 'terminal' | 'cap-reached';
-    /**
-     * Wait for a task to complete.
-     *
-     * @param taskId - The task ID to wait for
-     * @param timeout - Maximum time to wait in milliseconds (0 = no timeout)
-     * @returns The completed task, or null if not found/timeout
-     */
-    waitForCompletion(taskId: string, timeout?: number): Promise<BackgroundTask | null>;
-    /**
-     * Cancel one or all running background tasks.
-     *
-     * @param taskId - Optional task ID to cancel. If omitted, cancels all pending/running tasks.
-     * @returns Number of tasks cancelled
-     */
-    cancel(taskId?: string): number;
-    /**
-     * Clean up all tasks.
-     */
-    cleanup(): void;
-    /**
-     * Get the depth tracker instance for use by other managers.
-     */
-    getDepthTracker(): SubagentDepthTracker;
-}

package/dist/background/index.d.ts

@@ -1,3 +0,0 @@
-export { type BackgroundTask, BackgroundTaskManager, type LaunchOptions, loadPersistedTask, } from './background-manager';
-export { MultiplexerSessionManager, TmuxSessionManager, } from './multiplexer-session-manager';
-export { SubagentDepthTracker } from './subagent-depth';

package/dist/background/multiplexer-session-manager.d.ts

@@ -1,70 +0,0 @@
-import type { PluginInput } from '@opencode-ai/plugin';
-import type { MultiplexerConfig } from '../config/schema';
-/**
- * Event shape for session events
- */
-interface SessionEvent {
-    type: string;
-    properties?: {
-        info?: {
-            id?: string;
-            parentID?: string;
-            title?: string;
-            directory?: string;
-        };
-        sessionID?: string;
-        status?: {
-            type: string;
-        };
-    };
-}
-/**
- * MultiplexerSessionManager tracks child sessions and spawns/closes multiplexer panes for them.
- *
- * Uses session.status events for completion detection instead of polling.
- * Supports both tmux and zellij multiplexers.
- */
-export declare class MultiplexerSessionManager {
-    private client;
-    private serverUrl;
-    private directory;
-    private multiplexer;
-    private sessions;
-    private pollInterval?;
-    private enabled;
-    constructor(ctx: PluginInput, config: MultiplexerConfig);
-    /**
-     * Handle session.created events.
-     * Spawns a multiplexer pane for child sessions (those with parentID).
-     */
-    onSessionCreated(event: SessionEvent): Promise<void>;
-    /**
-     * Handle session.status events for completion detection.
-     * Uses session.status instead of deprecated session.idle.
-     *
-     * When a session becomes idle (completed), close its pane.
-     */
-    onSessionStatus(event: SessionEvent): Promise<void>;
-    /**
-     * Handle session.deleted events.
-     * When a session is deleted, close its multiplexer pane immediately.
-     */
-    onSessionDeleted(event: SessionEvent): Promise<void>;
-    private startPolling;
-    private stopPolling;
-    /**
-     * Poll sessions for status updates (fallback for reliability).
-     * Also handles timeout and missing session detection.
-     */
-    private pollSessions;
-    private closeSession;
-    /**
-     * Clean up all tracked sessions.
-     */
-    cleanup(): Promise<void>;
-}
-/**
- * @deprecated Use MultiplexerSessionManager instead
- */
-export declare const TmuxSessionManager: typeof MultiplexerSessionManager;
-export {};

package/dist/background/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;
-}

package/dist/cli/divoom.d.ts

@@ -1,23 +0,0 @@
-import type { DivoomStatus } from '../integrations/divoom/types';
-export type DivoomCliResult = {
-    exitCode: number;
-    message?: string;
-    error?: string;
-};
-export type DivoomCliOptions = {
-    cwd?: string;
-    dryRun?: boolean;
-    detector?: () => Promise<string | null>;
-    transportFactory?: (config: {
-        status: DivoomStatus;
-        directory: string;
-    }) => {
-        sendStatus(update: {
-            status: DivoomStatus;
-            reason: string;
-            timestamp: number;
-        }): Promise<void>;
-    };
-};
-export declare function runDivoomCli(args: string[], options?: DivoomCliOptions): Promise<DivoomCliResult>;
-export declare function detectDivoomAddress(): Promise<string | null>;