oh-my-opencode-slim 1.1.1 → 1.1.2

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,16 @@
+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;
+    verifyAbortMs?: number;
+    abortRetryIntervalMs?: number;
+    stableStoppedMs?: number;
+    deleteTimeoutMs?: number;
+    deleteVerifyMs?: number;
+    deleteStableStoppedMs?: number;
+}
+export declare function createCancelTaskTool(options: CancelTaskToolOptions): Record<string, ToolDefinition>;
+export {};

package/dist/tools/preset-manager.d.ts

@@ -3,13 +3,12 @@ import type { PluginConfig } from '../config';
 /**
  * Creates a preset manager for the /preset slash command.
  *
- * Uses the OpenCode SDK's client.config.update() to change agent models
- * and temperatures without restarting. The server invalidates its agent
- * cache and re-reads config on the next prompt.
- *
- * Note: activePreset is tracked in-memory only and resets on plugin reload.
- * If the user manually edits config or another mechanism changes agents,
- * this tracker may become stale until the next /preset call.
+ * Stores the requested runtime preset in plugin memory and updates the
+ * plugin-facing TUI snapshot. It deliberately does not call OpenCode's
+ * client.config.update() or instance.dispose() from command hooks because
+ * OpenCode continues the same command into the prompt loop after
+ * command.execute.before, which can break the active conversation while
+ * the agent registry is changing.
  */
 export declare function createPresetManager(ctx: PluginInput, config: PluginConfig): {
     handleCommandExecuteBefore: (input: {

package/dist/tools/subtask/tools.d.ts

@@ -9,12 +9,17 @@ import type { PluginInput, ToolDefinition } from '@opencode-ai/plugin';
 import type { SubagentDepthTracker } from '../../utils/subagent-depth';
 import type { SubtaskState } from './state';
 export type OpencodeClient = PluginInput['client'];
+export declare const DEFAULT_SUBTASK_TIMEOUT_MS: number;
+export interface CreateSubtaskToolOptions {
+    /** Worker timeout in ms. 0 disables the timeout. */
+    timeoutMs?: number;
+}
 /**
  * Create the subtask tool.
  *
  * Takes the OpenCode client as a dependency for TUI and session operations.
  */
-export declare function createSubtaskTool(ctx: PluginInput, state: SubtaskState, depthTracker?: SubagentDepthTracker): ToolDefinition;
+export declare function createSubtaskTool(ctx: PluginInput, state: SubtaskState, depthTracker?: SubagentDepthTracker, options?: CreateSubtaskToolOptions): ToolDefinition;
 /**
  * Create the read_session tool.
  *

package/dist/tui.js

@@ -140,6 +140,13 @@ function getCustomOpenCodeConfigDir() {
   const configDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   return configDir || undefined;
 }
+function getConfigDir() {
+  const customConfigDir = getCustomOpenCodeConfigDir();
+  if (customConfigDir) {
+    return customConfigDir;
+  }
+  return getDefaultOpenCodeConfigDir();
+}
 function getConfigSearchDirs() {
   const dirs = [getCustomOpenCodeConfigDir(), getDefaultOpenCodeConfigDir()];
   return dirs.filter((dir, index) => {
@@ -147,7 +154,7 @@ function getConfigSearchDirs() {
   });
 }
 function getOpenCodeConfigPaths() {
-  const configDir = getDefaultOpenCodeConfigDir();
+  const configDir = getConfigDir();
   return [join(configDir, "opencode.json"), join(configDir, "opencode.jsonc")];
 }
 // src/config/council-schema.ts
@@ -330,6 +337,9 @@ var TodoContinuationConfigSchema = z2.object({
   autoEnable: z2.boolean().default(false).describe("Automatically enable auto-continue when the orchestrator session has enough todos"),
   autoEnableThreshold: z2.number().int().min(1).max(50).default(4).describe("Number of todos that triggers auto-enable (only used when autoEnable is true)")
 });
+var SubtaskConfigSchema = z2.object({
+  timeoutMs: z2.number().int().min(0).max(24 * 60 * 60 * 1000).optional().describe("Subtask worker timeout in ms. 0 disables the timeout. Defaults to 300000 (5 minutes).")
+});
 var FailoverConfigSchema = z2.object({
   enabled: z2.boolean().default(true),
   timeoutMs: z2.number().min(0).default(15000),
@@ -377,6 +387,7 @@ var PluginConfigSchema = z2.object({
   sessionManager: SessionManagerConfigSchema.optional(),
   divoom: DivoomConfigSchema.optional(),
   todoContinuation: TodoContinuationConfigSchema.optional(),
+  subtask: SubtaskConfigSchema.optional(),
   fallback: FailoverConfigSchema.optional(),
   council: CouncilConfigSchema.optional()
 }).superRefine((value, ctx) => {
@@ -460,65 +471,6 @@ var CUSTOM_SKILLS = [
   }
 ];
 
-// src/cli/skills.ts
-var RECOMMENDED_SKILLS = [
-  {
-    name: "agent-browser",
-    repo: "https://github.com/vercel-labs/agent-browser",
-    skillName: "agent-browser",
-    allowedAgents: ["designer"],
-    description: "High-performance browser automation",
-    postInstallCommands: [
-      "npm install -g agent-browser",
-      "agent-browser install"
-    ]
-  }
-];
-var PERMISSION_ONLY_SKILLS = [
-  {
-    name: "requesting-code-review",
-    allowedAgents: ["oracle"],
-    description: "Code review template for reviewer subagents in multi-step workflows"
-  }
-];
-function getSkillPermissionsForAgent(agentName, skillList) {
-  const permissions = {
-    "*": agentName === "orchestrator" ? "allow" : "deny"
-  };
-  if (skillList) {
-    permissions["*"] = "deny";
-    for (const name of skillList) {
-      if (name === "*") {
-        permissions["*"] = "allow";
-      } else if (name.startsWith("!")) {
-        permissions[name.slice(1)] = "deny";
-      } else {
-        permissions[name] = "allow";
-      }
-    }
-    return permissions;
-  }
-  for (const skill of RECOMMENDED_SKILLS) {
-    const isAllowed = skill.allowedAgents.includes("*") || skill.allowedAgents.includes(agentName);
-    if (isAllowed) {
-      permissions[skill.skillName] = "allow";
-    }
-  }
-  for (const skill of CUSTOM_SKILLS) {
-    const isAllowed = skill.allowedAgents.includes("*") || skill.allowedAgents.includes(agentName);
-    if (isAllowed) {
-      permissions[skill.name] = "allow";
-    }
-  }
-  for (const skill of PERMISSION_ONLY_SKILLS) {
-    const isAllowed = skill.allowedAgents.includes("*") || skill.allowedAgents.includes(agentName);
-    if (isAllowed) {
-      permissions[skill.name] = "allow";
-    }
-  }
-  return permissions;
-}
-
 // src/cli/config-io.ts
 function stripJsonComments(json) {
   const commentPattern = /\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g;
@@ -533,7 +485,9 @@ function loadConfigFromPath(configPath, options) {
     const content = fs.readFileSync(configPath, "utf-8");
     let rawConfig;
     try {
-      rawConfig = JSON.parse(stripJsonComments(content));
+      const stripped = stripJsonComments(content);
+      const interpolated = stripped.replace(/\{env:([^}]+)\}/g, (_, varName) => process.env[varName] ?? "");
+      rawConfig = JSON.parse(interpolated);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       options?.onWarning?.({
@@ -612,7 +566,8 @@ function mergePluginConfigs(base, override) {
     sessionManager: deepMerge(base.sessionManager, override.sessionManager),
     divoom: deepMerge(base.divoom, override.divoom),
     fallback: deepMerge(base.fallback, override.fallback),
-    council: deepMerge(base.council, override.council)
+    council: deepMerge(base.council, override.council),
+    subtask: deepMerge(base.subtask, override.subtask)
   };
 }
 function deepMerge(base, override) {

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

@@ -0,0 +1,90 @@
+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;
+    parentSessionID: string;
+    agent: string;
+    description: string;
+    objective?: string;
+    state: BackgroundJobState;
+    timedOut: boolean;
+    statusUncertain: boolean;
+    cancellationRequested: boolean;
+    terminalUnreconciled: boolean;
+    launchedAt: number;
+    lastLaunchedAt: number;
+    updatedAt: number;
+    lastLiveBusyAt?: number;
+    completedAt?: number;
+    resultSummary?: string;
+    lastStatusError?: string;
+    alias: string;
+    lastUsedAt: number;
+    terminalState?: TaskOutputState;
+    contextFiles: ContextFile[];
+}
+export interface BackgroundJobBoardOptions {
+    maxReusablePerAgent?: number;
+    readContextMinLines?: number;
+    readContextMaxFiles?: number;
+}
+export interface BackgroundJobLaunchInput {
+    taskID: string;
+    parentSessionID: string;
+    agent: string;
+    description?: string;
+    objective?: string;
+    now?: number;
+}
+export interface BackgroundJobStatusInput {
+    taskID: string;
+    state: TaskOutputState;
+    timedOut?: boolean;
+    statusUncertain?: boolean;
+    resultSummary?: string;
+    lastStatusError?: string;
+    now?: number;
+}
+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;
+    markRunningFromLiveSession(taskID: string, now?: number): BackgroundJobRecord | undefined;
+    markReconciled(taskID: string, now?: number): BackgroundJobRecord | undefined;
+    markCancelled(taskID: string, reason?: string, now?: number, options?: {
+        force?: boolean;
+    }): 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, 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/oh-my-opencode-slim.schema.json

@@ -599,6 +599,17 @@
         }
       }
     },
+    "subtask": {
+      "type": "object",
+      "properties": {
+        "timeoutMs": {
+          "description": "Subtask worker timeout in ms. 0 disables the timeout. Defaults to 300000 (5 minutes).",
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 86400000
+        }
+      }
+    },
     "fallback": {
       "type": "object",
       "properties": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-slim",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "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,11 +43,14 @@
     "src/skills",
     "oh-my-opencode-slim.schema.json",
     "README.md",
+    "README.zh-CN.md",
+    "README.ja-JP.md",
+    "README.ko-KR.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",
+    "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",
     "prepare": "bun run build",

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>;

package/dist/goal/index.d.ts

@@ -1,3 +0,0 @@
-export { createGoalManager, type GoalManager } from './manager';
-export { GoalStore, getGoalStorePath } from './store';
-export type { GoalCheckpoint, GoalConfig, GoalRecord, GoalStatus, } from './types';