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

package/dist/tools/index.d.ts

@@ -3,5 +3,3 @@ 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 → poll task_status → 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"];
@@ -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"
   }
 ];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-slim",
-  "version": "2.0.0-beta.0",
+  "version": "2.0.0-beta.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",
@@ -46,10 +46,11 @@
     "LICENSE"
   ],
   "scripts": {
+    "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/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",
     "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,92 @@
+---
+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/`;
+- draft a plan before implementation;
+- ask `@oracle` to review the plan and revise it until acceptable;
+- create a phased implementation/delegation plan;
+- ask `@oracle` to review that implementation plan before execution;
+- execute phase by phase with specialist delegation where useful;
+- after each phase, validate, update the deepwork file, ask `@oracle` to review
+  the phase result, fix actionable issues, then continue;
+- ask `@oracle` phase reviews to include simplify/readability feedback alongside
+  correctness, blockers, risks, and plan adherence;
+- 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;
+- assumptions, constraints, and decisions;
+- plan drafts and oracle review notes;
+- implementation phases and status;
+- validation results;
+- unresolved questions, blockers, and follow-ups.
+
+Update this file after major decisions, reviews, phase completions, validation
+results, and scope changes.
+
+## Scheduler Discipline
+
+Use the V2 scheduler model throughout:
+
+- dispatch `@explorer`, `@librarian`, `@fixer`, `@designer`, `@oracle`, or
+  `@council` lanes as background tasks when useful;
+- record task/session IDs and ownership boundaries;
+- poll `task_status` before consuming background results;
+- reconcile terminal results before dependent work;
+- keep write scopes separate when parallelizing;
+- do not advance to the next phase while relevant jobs are running or terminal
+  results are unreconciled.
+
+`@oracle` owns review and risk assessment. It should review plans and completed
+phase outputs, not become the default implementer. For phase reviews, explicitly
+ask oracle to use its simplify skill when available and report readability,
+maintainability, and unnecessary-complexity findings separately from blocking
+correctness issues.
+
+## Lightweight Judgment
+
+Deepwork is meant to prevent chaotic long sessions, not create paperwork. Keep
+the markdown concise, batch small related checks when reasonable, and scale the
+number of review gates to the risk of the work. If the task becomes small and
+obvious, finish simply while preserving validation and the final summary.

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

package/dist/goal/manager.d.ts

@@ -1,41 +0,0 @@
-import type { PluginInput } from '@opencode-ai/plugin';
-import type { GoalConfig } from './types';
-interface MessagePart {
-    type?: string;
-    text?: string;
-    [key: string]: unknown;
-}
-interface ChatTransformMessage {
-    info: {
-        role?: string;
-        agent?: string;
-        sessionID?: string;
-    };
-    parts: MessagePart[];
-}
-export declare function createGoalManager(ctx: PluginInput, config?: GoalConfig): {
-    registerCommand: (opencodeConfig: Record<string, unknown>) => void;
-    handleCommandExecuteBefore: (input: {
-        command: string;
-        sessionID: string;
-        arguments: string;
-    }, output: {
-        parts: Array<{
-            type: string;
-            text?: string;
-        }>;
-    }) => Promise<void>;
-    handleMessagesTransform: (output: {
-        messages: ChatTransformMessage[];
-    }) => Promise<void>;
-    handleEvent: (input: {
-        event: {
-            type: string;
-            properties?: Record<string, unknown>;
-        };
-    }) => Promise<void>;
-    hasActiveGoal: (sessionID: string) => boolean;
-    hasRunningGoal: (sessionID: string) => boolean;
-};
-export type GoalManager = ReturnType<typeof createGoalManager>;
-export {};

package/dist/goal/prompts.d.ts

@@ -1,4 +0,0 @@
-import type { GoalRecord } from './types';
-export declare function buildGoalContext(goal: GoalRecord): string;
-export declare function buildGoalContinuationPrompt(goal: GoalRecord): string;
-export declare function buildGoalStartPrompt(goal: GoalRecord): string;

package/dist/goal/store.d.ts

@@ -1,15 +0,0 @@
-import type { GoalRecord } from './types';
-interface GoalStoreSnapshot {
-    version: 1;
-    goals: GoalRecord[];
-}
-export declare function getGoalStorePath(): string;
-export declare class GoalStore {
-    read(): GoalStoreSnapshot;
-    write(snapshot: GoalStoreSnapshot): void;
-    list(): GoalRecord[];
-    save(goal: GoalRecord): void;
-    findActiveBySession(sessionID: string): GoalRecord | undefined;
-    findLatestByDirectory(directory: string): GoalRecord | undefined;
-}
-export {};

package/dist/goal/types.d.ts

@@ -1,28 +0,0 @@
-export type GoalStatus = 'running' | 'paused' | 'blocked' | 'completed' | 'archived';
-export interface GoalCheckpoint {
-    id: string;
-    createdAt: string;
-    note: string;
-}
-export interface GoalRecord {
-    version: 1;
-    id: string;
-    directory: string;
-    sessionID: string;
-    objective: string;
-    stopCondition?: string;
-    validationCommands: string[];
-    artifacts: string[];
-    status: GoalStatus;
-    createdAt: string;
-    updatedAt: string;
-    maxCycles: number;
-    completedCycles: number;
-    checkpoints: GoalCheckpoint[];
-    lastError?: string;
-}
-export interface GoalConfig {
-    maxCycles?: number;
-    cooldownMs?: number;
-    shouldManageSession?: (sessionID: string) => boolean;
-}

package/dist/integrations/divoom/index.d.ts

@@ -1,3 +0,0 @@
-export * from './status-manager';
-export * from './swift-transport';
-export * from './types';

package/dist/integrations/divoom/status-manager.d.ts

@@ -1,31 +0,0 @@
-import type { DivoomEvent, DivoomStatus, DivoomStatusManagerOptions, DivoomStatusUpdate, DivoomTransport } from './types';
-export declare class DryRunDivoomTransport implements DivoomTransport {
-    sendStatus(update: DivoomStatusUpdate): Promise<void>;
-}
-export declare class DivoomStatusManager {
-    private readonly enabled;
-    private readonly debounceMs;
-    private readonly transport;
-    private readonly now;
-    private readonly schedule;
-    private readonly clearSchedule;
-    private readonly sessions;
-    private currentStatus;
-    private pendingStatus;
-    private pendingReason;
-    private pendingTimer;
-    private quiescentIdleTimer;
-    private readonly beforeExitHandler?;
-    constructor(options?: DivoomStatusManagerOptions);
-    handleEvent(input: {
-        event: DivoomEvent;
-    }): Promise<void>;
-    dispose(): Promise<void>;
-    getStatus(): DivoomStatus;
-    private deriveStatus;
-    private requestStatus;
-    private flushPendingStatus;
-    private scheduleQuiescentIdle;
-    private clearQuiescentIdle;
-}
-export declare function createDivoomStatusManager(options?: DivoomStatusManagerOptions): DivoomStatusManager;

package/dist/integrations/divoom/swift-helper-source.d.ts

@@ -1 +0,0 @@
-export declare const DIVOOM_SWIFT_HELPER_SOURCE: string;

package/dist/integrations/divoom/swift-transport.d.ts

@@ -1,26 +0,0 @@
-import type { DivoomConfig } from '../../config';
-import type { CommandRunner, DivoomStatusUpdate, DivoomTransport } from './types';
-export type SwiftDivoomTransportOptions = {
-    config: DivoomConfig;
-    storageDir?: string;
-    runner?: CommandRunner;
-    platform?: NodeJS.Platform;
-};
-export declare class SwiftDivoomTransport implements DivoomTransport {
-    private readonly deviceAddress;
-    private readonly faces;
-    private readonly storageDir;
-    private readonly runner;
-    private readonly platform;
-    private helperPath;
-    private preparePromise;
-    constructor(options: SwiftDivoomTransportOptions);
-    sendStatus(update: DivoomStatusUpdate): Promise<void>;
-    private prepareHelper;
-    private compileHelper;
-}
-export declare function createDivoomTransport(options: {
-    config?: DivoomConfig;
-    storageDir?: string;
-    runner?: CommandRunner;
-}): DivoomTransport | undefined;