oh-my-opencode-slim 2.1.0 → 2.2.0

package/dist/interview/document.d.ts

@@ -1,3 +1,4 @@
+import { parseFrontmatter as sharedParseFrontmatter } from '../utils/frontmatter';
 import type { InterviewAnswer, InterviewQuestion, InterviewRecord, SpecBlock } from './types';
 export declare const DEFAULT_OUTPUT_FOLDER = "interview";
 export declare function normalizeOutputFolder(outputFolder: string): string;
@@ -20,7 +21,7 @@ export declare function buildInterviewDocument(idea: string, summary: string, hi
     tags?: string[];
 }): string;
 /** Parse frontmatter from a .md file. Returns null if no frontmatter. */
-export declare function parseFrontmatter(content: string): Record<string, string> | null;
+export declare const parseFrontmatter: typeof sharedParseFrontmatter;
 export declare function ensureInterviewFile(record: InterviewRecord): Promise<void>;
 export declare function readInterviewDocument(record: InterviewRecord): Promise<string>;
 export declare function rewriteInterviewDocument(record: InterviewRecord, summary: string): Promise<string>;

package/dist/interview/service.d.ts

@@ -25,6 +25,8 @@ export declare function createInterviewService(ctx: PluginInput, config?: Interv
         parts: Array<{
             type: string;
             text?: string;
+            synthetic?: boolean;
+            metadata?: Record<string, unknown>;
         }>;
     }) => Promise<void>;
     handleEvent: (input: {

package/dist/interview/ui.d.ts

@@ -6,7 +6,6 @@ interface DashboardInterviewItem extends InterviewListItem {
     sessionID?: string;
     directory?: string;
 }
-export declare function escapeHtml(value: string): string;
 export declare function renderDashboardPage(interviews: DashboardInterviewItem[], files: InterviewFileItem[], outputFolder: string): string;
 export declare function renderInterviewPage(interviewId: string, resumeSlug: string): string;
 export {};

package/dist/multiplexer/cmux/close-policy.d.ts

@@ -0,0 +1,20 @@
+export type CmuxCloseReason = 'idle' | 'deleted' | 'cleanup';
+export interface CmuxCloseIntent {
+    reason: CmuxCloseReason;
+    expectedActivityVersion: number;
+    attempts: number;
+    deadline: number;
+    phase: 'pending' | 'cooldown';
+    nextAttemptAt: number;
+    cooldowns: number;
+}
+export declare class CmuxClosePolicy {
+    private readonly budgetMs;
+    private readonly maxAttempts;
+    constructor(budgetMs?: number, maxAttempts?: number);
+    request(reason: CmuxCloseReason, version: number, now: number, current?: CmuxCloseIntent): CmuxCloseIntent;
+    activity(intent?: CmuxCloseIntent): CmuxCloseIntent | undefined;
+    failed(intent: CmuxCloseIntent, now: number): CmuxCloseIntent;
+    resume(intent: CmuxCloseIntent, now: number): CmuxCloseIntent;
+    complete(): undefined;
+}

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

@@ -0,0 +1,102 @@
+import type { MultiplexerLayout } from '../../config/schema';
+import { crossSpawn } from '../../utils/compat';
+import type { Multiplexer, PaneResult } from '../types';
+export interface CmuxReadinessOptions {
+    checkSessionReady?: (url: URL, sessionId: string, signal: AbortSignal) => Promise<boolean>;
+    delay?: (milliseconds: number) => Promise<void>;
+    readinessAttemptTimeoutMs?: number;
+    opencodeBinary?: string;
+    pathExists?: (path: string) => boolean;
+}
+export interface CommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export interface CommandRunner {
+    run(argv: string[]): Promise<CommandResult>;
+}
+export interface CmuxIdentity {
+    workspaceId: string;
+    paneId: string;
+    surfaceId: string;
+    socketPath: string;
+}
+export interface CmuxClient {
+    version(): Promise<string | null>;
+    getVersionError?(): 'unavailable' | 'hard';
+    identify(): Promise<CmuxIdentity | null>;
+    getIdentifyError?(): 'unavailable' | 'hard';
+    createSurface(input: {
+        workspaceId: string;
+        targetSurfaceId: string;
+        direction: 'right' | 'down';
+        focus: false;
+    }, socketPath?: string): Promise<{
+        paneId: string;
+        surfaceId: string;
+    } | null>;
+    getCreateError?(): 'not_found' | 'unavailable' | 'invalid_state' | 'hard';
+    respawnSurface(workspaceId: string, surfaceId: string, command: string, socketPath?: string): Promise<boolean>;
+    closeSurface(workspaceId: string, surfaceId: string, socketPath?: string): Promise<'closed' | 'not_found' | 'failed'>;
+    equalizeSplits(params: {
+        workspace_id: string;
+        orientation: 'vertical';
+    }, socketPath?: string): Promise<boolean>;
+}
+export declare class CmuxMultiplexer implements Multiplexer {
+    private readonly client;
+    readonly type: "cmux";
+    private versionAvailable;
+    private availabilityError;
+    private readonly checkSessionReady;
+    private readonly delay;
+    private readonly readinessAttemptTimeoutMs;
+    private readonly opencodeBinary;
+    constructor(client?: CmuxClient, options?: CmuxReadinessOptions);
+    isAvailable(): Promise<boolean>;
+    isInsideSession(): boolean;
+    spawnPane(sessionId: string, _description: string, serverUrl: string, directory: string): Promise<PaneResult>;
+    closePane(paneId: string): Promise<boolean>;
+    applyLayout(_layout: MultiplexerLayout, _mainPaneSize: number): Promise<void>;
+    private cleanupPane;
+    private waitForSession;
+    private equalize;
+}
+export declare class SpawnCommandRunner implements CommandRunner {
+    private readonly timeoutMs;
+    private readonly spawn;
+    constructor(timeoutMs?: number, spawn?: typeof crossSpawn);
+    run(argv: string[]): Promise<CommandResult>;
+}
+export declare class CliCmuxClient implements CmuxClient {
+    private readonly runner;
+    private binary;
+    private versionError;
+    private identifyError;
+    private lastRunThrew;
+    private createError;
+    constructor(runner?: CommandRunner, binary?: string);
+    version(): Promise<string | null>;
+    getVersionError(): 'unavailable' | 'hard';
+    identify(): Promise<CmuxIdentity | null>;
+    getIdentifyError(): 'unavailable' | 'hard';
+    createSurface(input: {
+        workspaceId: string;
+        targetSurfaceId: string;
+        direction: 'right' | 'down';
+        focus: false;
+    }, socketPath?: string): Promise<{
+        paneId: string;
+        surfaceId: string;
+    } | null>;
+    getCreateError(): 'not_found' | 'unavailable' | 'invalid_state' | 'hard';
+    respawnSurface(workspaceId: string, surfaceId: string, command: string, socketPath?: string): Promise<boolean>;
+    closeSurface(workspaceId: string, surfaceId: string, socketPath?: string): Promise<'closed' | 'not_found' | 'failed'>;
+    equalizeSplits(params: {
+        workspace_id: string;
+        orientation: 'vertical';
+    }, socketPath?: string): Promise<boolean>;
+    private run;
+}
+export declare function resetCmuxStateForTests(): void;

package/dist/multiplexer/cmux/session-lifecycle.d.ts

@@ -0,0 +1,92 @@
+import type { Multiplexer } from '../types';
+export interface CmuxSessionEvent {
+    type: string;
+    properties?: {
+        info?: {
+            id?: string;
+            parentID?: string;
+            title?: string;
+            directory?: string;
+            sessionID?: string;
+        };
+        part?: {
+            sessionID?: string;
+        };
+        sessionID?: string;
+        status?: {
+            type: string;
+        };
+    };
+}
+interface BackgroundJobs {
+    deferIfRunning(session: string): boolean;
+    clearDeferredClose(session: string): void;
+}
+export interface CmuxSessionLifecycleOptions {
+    now?: () => number;
+    delay?: (milliseconds: number) => Promise<void>;
+    deferredRetryMs?: number;
+    deferredTtlMs?: number;
+    missingGraceMs?: number;
+    closeRetryMs?: number;
+    closeRetryTtlMs?: number;
+    closeRetryMaxAttempts?: number;
+    orphanCooldownMs?: number;
+    shutdownTimeoutMs?: number;
+    isServerRunning?: (url: string) => Promise<boolean>;
+    fetchStatuses?: () => Promise<Record<string, {
+        type: string;
+    }>>;
+}
+export declare class CmuxSessionLifecycle {
+    private readonly owner;
+    private readonly multiplexer;
+    private readonly resolveServerUrl;
+    private readonly defaultDirectory;
+    private readonly backgroundJobs?;
+    private readonly store;
+    private readonly policy;
+    private readonly now;
+    private readonly delay;
+    private readonly injectedDelay;
+    private readonly deferredRetryMs;
+    private readonly deferredTtlMs;
+    private readonly missingGraceMs;
+    private readonly closeRetryMs;
+    private readonly shutdownTimeoutMs;
+    private readonly serverCheck;
+    private readonly fetchStatuses;
+    private pollTimer?;
+    private polling;
+    private cleanupPromise?;
+    private disposed;
+    private spawnGeneration;
+    constructor(owner: string, multiplexer: Multiplexer, resolveServerUrl: () => string | null, defaultDirectory: string, backgroundJobs?: BackgroundJobs | undefined, options?: CmuxSessionLifecycleOptions);
+    onSessionCreated(event: CmuxSessionEvent): Promise<void>;
+    onSessionStatus(event: CmuxSessionEvent): Promise<void>;
+    onSessionDeleted(event: CmuxSessionEvent): Promise<void>;
+    closeSessionFromCoordinator(session: string): Promise<void>;
+    cleanup(): Promise<void>;
+    /** Runs one status pass; exposed for deterministic lifecycle tests. */
+    pollOnce(): Promise<void>;
+    private spawn;
+    private spawnOperation;
+    private deferSpawn;
+    private cancelDeferred;
+    private activity;
+    private requestClose;
+    private attemptClose;
+    private scheduleCooldown;
+    private poll;
+    private startPolling;
+    private updatePolling;
+    private runCleanup;
+    private attemptCloseWithoutTimer;
+    private adoptAndClose;
+    private closeLatePane;
+    private trackStalePane;
+    private eventSession;
+    private timer;
+    private loadStatuses;
+}
+export {};

package/dist/multiplexer/cmux/session-state.d.ts

@@ -0,0 +1,45 @@
+import type { PaneResult } from '../types';
+import type { CmuxCloseIntent } from './close-policy';
+export type CmuxSpawnState = 'known' | 'spawning' | 'attached' | 'failed';
+export type CmuxLifecycleState = 'active' | 'deleted' | 'orphaned';
+export interface CmuxDeferredSpawn {
+    deadline: number;
+    generation: number;
+    timer?: {
+        cancel(): void;
+    };
+}
+export interface CmuxSessionRecord {
+    session: string;
+    owner: string;
+    parent: string;
+    title: string;
+    directory: string;
+    paneId?: string;
+    spawnState: CmuxSpawnState;
+    lifecycle: CmuxLifecycleState;
+    attachedAt?: number;
+    lastActivityAt: number;
+    activityVersion: number;
+    idleConsecutive: number;
+    statusMissingSince?: number;
+    deferredSpawn?: CmuxDeferredSpawn;
+    closeIntent?: CmuxCloseIntent;
+    closeTimer?: {
+        cancel(): void;
+    };
+    spawnPromise?: Promise<PaneResult>;
+}
+export declare class CmuxSessionStore {
+    claimCreated(record: CmuxSessionRecord): boolean;
+    get(session: string): CmuxSessionRecord | undefined;
+    ownedBy(owner: string): CmuxSessionRecord[];
+    claimOrphans(owner: string, directory: string): CmuxSessionRecord[];
+    markAttached(session: string, paneId: string, now: number): void;
+    markActivity(session: string, now: number): void;
+    markDeleted(session: string): void;
+    markOrphaned(session: string): void;
+    removeAfterConfirmedClose(session: string): boolean;
+    removeWithoutPane(session: string): boolean;
+    resetForTests(): void;
+}

package/dist/multiplexer/factory.d.ts

@@ -11,15 +11,6 @@ import type { Multiplexer } from './types';
  * be captured fresh for each plugin context.
  */
 export declare function getMultiplexer(config: MultiplexerConfig): Multiplexer | null;
-/**
- * Clear the multiplexer cache (useful for testing)
- */
-export declare function clearMultiplexerCache(): void;
-/**
- * Get the effective multiplexer type for auto mode
- * Returns the actual type that would be used (tmux/zellij/herdr/none)
- */
-export declare function getAutoMultiplexerType(): 'tmux' | 'zellij' | 'herdr' | 'none';
 /**
  * Start background availability check for a multiplexer
  */

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

@@ -18,14 +18,18 @@ export declare class HerdrMultiplexer implements Multiplexer {
     private binaryPath;
     private hasChecked;
     private readonly parentPaneId;
-    private readonly paneDirection;
+    private layout;
+    private paneDirection;
+    private agentAreaPaneId;
+    private spawnMutex;
     constructor(layout?: MultiplexerLayout, mainPaneSize?: number);
     isAvailable(): Promise<boolean>;
     isInsideSession(): boolean;
     spawnPane(sessionId: string, description: string, serverUrl: string, directory: string): Promise<PaneResult>;
+    private doSpawn;
     closePane(paneId: string): Promise<boolean>;
-    applyLayout(_layout: MultiplexerLayout, _mainPaneSize: number): Promise<void>;
+    applyLayout(layout: MultiplexerLayout, _mainPaneSize: number): Promise<void>;
+    private runSplit;
     private targetPaneArg;
     private getBinary;
-    private findBinary;
 }

package/dist/multiplexer/index.d.ts

@@ -1,7 +1,9 @@
 /**
  * Multiplexer module exports
  */
-export { clearMultiplexerCache, getMultiplexer, startAvailabilityCheck, } from './factory';
+export type { CmuxClient, CommandRunner } from './cmux';
+export { CliCmuxClient, CmuxMultiplexer } from './cmux';
+export { getMultiplexer, startAvailabilityCheck, } from './factory';
 export { HerdrMultiplexer } from './herdr';
 export { MultiplexerSessionManager, TmuxSessionManager, } from './session-manager';
 export { TmuxMultiplexer } from './tmux';

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

@@ -1,6 +1,8 @@
 import type { PluginInput } from '@opencode-ai/plugin';
 import type { MultiplexerConfig } from '../config/schema';
-import type { BackgroundJobBoard } from '../utils/background-job-board';
+import type { BackgroundJobStore } from '../utils/background-job-store';
+import { type CmuxSessionLifecycleOptions } from './cmux/session-lifecycle';
+type BackgroundJobReader = Pick<BackgroundJobStore, 'getState' | 'deferIfRunning' | 'clearDeferredClose'>;
 interface SessionEvent {
     type: string;
     properties?: {
@@ -9,6 +11,10 @@ interface SessionEvent {
             parentID?: string;
             title?: string;
             directory?: string;
+            sessionID?: string;
+        };
+        part?: {
+            sessionID?: string;
         };
         sessionID?: string;
         status?: {
@@ -17,6 +23,7 @@ interface SessionEvent {
     };
 }
 export declare function resetMultiplexerSessionManagerState(): void;
+export type MultiplexerSessionManagerOptions = CmuxSessionLifecycleOptions;
 /**
  * Tracks child sessions and spawns/closes multiplexer panes for them.
  *
@@ -26,17 +33,17 @@ export declare function resetMultiplexerSessionManagerState(): void;
 export declare class MultiplexerSessionManager {
     private readonly backgroundJobBoard?;
     private instanceId;
-    private serverUrl;
+    private readonly resolveServerUrl;
     private directory;
     private multiplexer;
     private sessions;
     private knownSessions;
     private spawningSessions;
     private closingSessions;
-    private deferredIdleCloses;
     private pollInterval?;
     private enabled;
-    constructor(ctx: PluginInput, config: MultiplexerConfig, backgroundJobBoard?: BackgroundJobBoard | undefined);
+    private cmuxLifecycle?;
+    constructor(ctx: PluginInput, config: MultiplexerConfig, backgroundJobBoard?: BackgroundJobReader | undefined, options?: MultiplexerSessionManagerOptions);
     onSessionCreated(event: SessionEvent): Promise<void>;
     onSessionStatus(event: SessionEvent): Promise<void>;
     onSessionDeleted(event: SessionEvent): Promise<void>;
@@ -50,9 +57,10 @@ export declare class MultiplexerSessionManager {
     private updatePolling;
     private getSessionId;
     private backgroundJobState;
-    private isRunningBackgroundJob;
-    retryDeferredIdleClose(sessionId: string): Promise<void>;
+    private shouldCloseNow;
+    closeSessionFromCoordinator(sessionId: string): Promise<void>;
     cleanup(): Promise<void>;
+    cleanupOnInstanceDisposed(): Promise<void>;
 }
 /**
  * @deprecated Use MultiplexerSessionManager instead

package/dist/multiplexer/shared.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared multiplexer infrastructure
+ *
+ * Functions used across tmux, zellij, and herdr backend adapters.
+ * Extracted to eliminate copy-paste duplication and prevent drift.
+ */
+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;
+export declare function resolveHostOpencodeBinary(options?: {
+    override?: string;
+    envOverride?: string;
+    execPath?: string;
+    argv0?: string;
+    pathExists?: (path: string) => boolean;
+}): string | null;
+export declare function findBinary(binaryName: string, options?: {
+    verify?: boolean;
+}): Promise<string | null>;
+export interface GracefulClosePaneOptions {
+    /** Backend-specific Ctrl+C command args (binary prepended by caller). */
+    ctrlC: string[];
+    /** Backend-specific close/kill command args (binary prepended by caller). */
+    close: string[];
+    /** Accept exit code 1 as success (zellij/herdr treat "already closed" as 1). */
+    acceptExitCode1?: boolean;
+    /** Return true for empty/unknown paneId instead of false (zellij/herdr behavior). */
+    emptyPaneReturnsTrue?: boolean;
+}
+export declare function gracefulClosePane(binary: string | null, paneId: string, options: GracefulClosePaneOptions): Promise<boolean>;

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

@@ -23,5 +23,4 @@ export declare class TmuxMultiplexer implements Multiplexer {
     private runTmux;
     private getBinary;
     private targetArgs;
-    private findBinary;
 }

package/dist/multiplexer/types.d.ts

@@ -8,13 +8,16 @@ import type { MultiplexerConfig, MultiplexerLayout } from '../config/schema';
 export interface PaneResult {
     success: boolean;
     paneId?: string;
+    orphanPaneId?: string;
+    error?: 'unavailable' | 'not_found' | 'invalid_state' | 'hard';
 }
 /**
  * Core multiplexer interface
- * Implementations: TmuxMultiplexer, ZellijMultiplexer, HerdrMultiplexer
+ * Implementations: TmuxMultiplexer, ZellijMultiplexer, HerdrMultiplexer,
+ * CmuxMultiplexer
  */
 export interface Multiplexer {
-    readonly type: 'tmux' | 'zellij' | 'herdr';
+    readonly type: 'tmux' | 'zellij' | 'herdr' | 'cmux';
     /**
      * Check if the multiplexer binary is available on the system
      */

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

@@ -44,5 +44,4 @@ export declare class ZellijMultiplexer implements Multiplexer {
     private getParentTabId;
     private findTabIdForPane;
     private getBinary;
-    private findBinary;
 }

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

@@ -1,8 +1,8 @@
 import { type PluginInput, type ToolDefinition } from '@opencode-ai/plugin';
-import type { BackgroundJobBoard } from '../utils/background-job-board';
+import type { BackgroundJobStore } from '../utils/background-job-store';
 interface CancelTaskToolOptions {
     client: PluginInput['client'];
-    backgroundJobBoard: BackgroundJobBoard;
+    backgroundJobBoard: BackgroundJobStore;
     shouldManageSession: (sessionID: string) => boolean;
     abortTimeoutMs?: number;
     verifyAbortMs?: number;

package/dist/tools/smartfetch/utils.d.ts

@@ -1,11 +1,13 @@
+import { escapeHtml } from '../../utils/escape-html';
+import { parseFrontmatter } from '../../utils/frontmatter';
 import type { CachedFetch, ExtractedContent } from './types';
+export { escapeHtml, parseFrontmatter };
 export declare function wordCount(text: string): number;
 export declare function frontmatter(metadata: Record<string, unknown>): string;
 export declare function trimBlankRuns(input: string): string;
 export declare function cleanHeadingText(input: string): string;
 export declare function cleanFetchedMarkdown(input: string): string;
 export declare function cleanFetchedText(input: string): string;
-export declare function escapeHtml(input: string): string;
 export declare function withTruncationMarker(content: string, format: 'text' | 'markdown' | 'html', truncated: boolean): string;
 export declare function joinRenderedContent(metadata: string, content: string, format: 'text' | 'markdown' | 'html'): string;
 export declare function renderMessageForFormat(content: string, format: 'text' | 'markdown' | 'html'): string;

package/dist/tui-state.d.ts

@@ -4,15 +4,15 @@ export interface TuiSnapshot {
     agentModels: Record<string, string>;
     agentVariants: Record<string, string>;
 }
-export declare function getTuiStatePath(): string;
-export declare function readTuiSnapshot(): TuiSnapshot;
-export declare function readTuiSnapshotAsync(): Promise<TuiSnapshot>;
+export declare function getTuiStatePath(projectDir: string): string;
+export declare function readTuiSnapshot(projectDir: string): TuiSnapshot;
+export declare function readTuiSnapshotAsync(projectDir: string): Promise<TuiSnapshot>;
 export declare function recordTuiAgentModels(input: {
     agentModels: Record<string, string>;
     agentVariants?: Record<string, string>;
-}): void;
+}, projectDir: string): void;
 export declare function recordTuiAgentModel(input: {
     agentName: string;
     model: string;
     variant?: string | null;
-}): void;
+}, projectDir: string): void;

package/dist/tui.d.ts

@@ -6,6 +6,7 @@ export declare function splitSidebarModelId(model: string): {
 };
 export declare function getSidebarAgentNames(snapshot: TuiSnapshot): string[];
 export declare function readConfigInvalid(directory: string): boolean;
+export declare function readCompactSidebar(directory: string): boolean;
 declare const plugin: TuiPluginModule & {
     id: string;
 };