oh-my-opencode-slim 2.0.5 → 2.1.1

package/dist/interview/dashboard-manager.d.ts

@@ -0,0 +1,21 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { PluginConfig } from '../config';
+export declare function createDashboardManager(ctx: PluginInput, config: PluginConfig, dashboardPort: number, outputFolder: string): {
+    registerCommand: (config: Record<string, unknown>) => void;
+    handleCommandExecuteBefore: (input: {
+        command: string;
+        sessionID: string;
+        arguments: string;
+    }, output: {
+        parts: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+    handleEvent: (input: {
+        event: {
+            type: string;
+            properties?: Record<string, unknown>;
+        };
+    }) => Promise<void>;
+};

package/dist/interview/manager.d.ts

@@ -1,19 +1,5 @@
 import type { PluginInput } from '@opencode-ai/plugin';
 import type { PluginConfig } from '../config';
-/**
- * Interview Manager — Composition root.
- *
- * Two modes:
- *
- * 1. **Dashboard mode** (dashboard:true or port>0):
- *    First process to bind the port becomes the dashboard (dumb aggregator).
- *    Other processes register as sessions and push state to it.
- *    Sessions drive LLM interaction locally, dashboard just serves the web UI.
- *
- * 2. **Per-session mode** (default, port=0, dashboard:false):
- *    Upstream behavior. Each process runs its own interview server on a random
- *    port. Lazy startup on first /interview command.
- */
 export declare function createInterviewManager(ctx: PluginInput, config: PluginConfig): {
     registerCommand: (config: Record<string, unknown>) => void;
     handleCommandExecuteBefore: (input: {

package/dist/interview/service.d.ts

@@ -1,6 +1,13 @@
 import type { PluginInput } from '@opencode-ai/plugin';
 import type { InterviewConfig } from '../config';
 import type { InterviewAnswer, InterviewFileItem, InterviewListItem, InterviewRecord, InterviewState } from './types';
+/**
+ * Cap on retained abandoned interview records. Abandoned interviews are kept
+ * briefly so a still-open browser tab can render their final state, but
+ * without a bound the `interviewsById` and `browserOpened` collections grow
+ * for the life of a long-running session/dashboard process.
+ */
+export declare const MAX_RETAINED_ABANDONED = 50;
 export declare function createInterviewService(ctx: PluginInput, config?: InterviewConfig, deps?: {
     openBrowser?: (url: string) => void;
     env?: NodeJS.ProcessEnv;
@@ -18,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/session-server.d.ts

@@ -0,0 +1,21 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { InterviewConfig } from '../config';
+export declare function createPerSessionInterviewServer(ctx: PluginInput, interviewConfig: InterviewConfig | undefined, outputFolder: string): {
+    registerCommand: (config: Record<string, unknown>) => void;
+    handleCommandExecuteBefore: (input: {
+        command: string;
+        sessionID: string;
+        arguments: string;
+    }, output: {
+        parts: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+    handleEvent: (input: {
+        event: {
+            type: string;
+            properties?: Record<string, unknown>;
+        };
+    }) => Promise<void>;
+};

package/dist/interview/types.d.ts

@@ -14,7 +14,7 @@ export interface InterviewAssistantState {
     title?: string;
     questions: InterviewQuestion[];
 }
-/** Raw question object from LLM output — loose, everything optional. */
+/** Raw question object from LLM output - loose, everything optional. */
 export declare const RawQuestionSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     question: z.ZodOptional<z.ZodString>;
@@ -33,6 +33,8 @@ export interface InterviewRecord {
     idea: string;
     markdownPath: string;
     createdAt: string;
+    abandonedAt?: string;
+    abandonedOrder?: number;
     status: 'active' | 'abandoned';
     baseMessageCount: number;
 }

package/dist/loop/loop-session.d.ts

@@ -0,0 +1,64 @@
+export declare function loopDirname(loopID: string, goal: string): string;
+export type LoopPhase = 'executing' | 'verifying' | 'done' | 'escalated' | 'cancelled';
+export type ExecuteAgent = 'fixer' | 'designer' | 'explorer' | 'librarian';
+export type VerifyAgent = 'oracle' | 'observer' | 'test';
+export type SuccessCriterion = {
+    type: 'test';
+    command: string;
+} | {
+    type: 'build';
+    command: string;
+} | {
+    type: 'lint';
+    command: string;
+} | {
+    type: 'fileExists';
+    path: string;
+} | {
+    type: 'command';
+    command: string;
+    expectExitCode?: number;
+} | {
+    type: 'oracle';
+} | {
+    type: 'observer';
+} | {
+    type: 'manual';
+};
+export interface LoopDefinition {
+    goal: string;
+    successCriteria: string;
+    success: SuccessCriterion;
+    maxAttempts: number;
+    executeAgent: ExecuteAgent;
+    verifyAgent: VerifyAgent;
+    contextFiles?: string[];
+    parentSessionID?: string;
+}
+export type VerificationResult = {
+    passed: true;
+    reason: string;
+} | {
+    passed: false;
+    reason: string;
+    suggestedFix?: string;
+};
+export interface AttemptRecord {
+    attemptNumber: number;
+    executionResult: string;
+    verificationResult: VerificationResult;
+    artifactPaths?: string[];
+}
+export interface LoopSession {
+    loopID: string;
+    definition: LoopDefinition;
+    currentPhase: LoopPhase;
+    attempts: number;
+    activeJobID?: string;
+    history: AttemptRecord[];
+    historyDir: string;
+    manualReviewPending: boolean;
+}
+export declare function createLoopSession(definition: LoopDefinition, loopID: string): LoopSession;
+export declare function compactAttempt(attempt: AttemptRecord): string;
+export declare function writeHistoryFile(session: LoopSession): void;

package/dist/multiplexer/factory.d.ts

@@ -6,9 +6,9 @@ import type { Multiplexer } from './types';
 /**
  * Create a multiplexer instance based on config.
  *
- * Do not cache instances: tmux/zellij integrations may depend on
- * per-process environment like TMUX_PANE/ZELLIJ, which should be captured
- * fresh for each plugin context.
+ * Do not cache instances: tmux/zellij/herdr integrations may depend on
+ * per-process environment like TMUX_PANE/ZELLIJ/HERDR_PANE_ID, which should
+ * be captured fresh for each plugin context.
  */
 export declare function getMultiplexer(config: MultiplexerConfig): Multiplexer | null;
 /**
@@ -17,9 +17,9 @@ export declare function getMultiplexer(config: MultiplexerConfig): Multiplexer |
 export declare function clearMultiplexerCache(): void;
 /**
  * Get the effective multiplexer type for auto mode
- * Returns the actual type that would be used (tmux/zellij/none)
+ * Returns the actual type that would be used (tmux/zellij/herdr/none)
  */
-export declare function getAutoMultiplexerType(): 'tmux' | 'zellij' | 'none';
+export declare function getAutoMultiplexerType(): 'tmux' | 'zellij' | 'herdr' | 'none';
 /**
  * Start background availability check for a multiplexer
  */

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

@@ -0,0 +1,33 @@
+/**
+ * Herdr multiplexer implementation
+ *
+ * Splits panes for sub-agent sessions in Herdr.
+ *
+ * Herdr is an agent-aware terminal multiplexer (workspaces → tabs → panes).
+ * Pane IDs use the format `w<workspace>:p<pane>`. The CLI outputs
+ * newline-delimited JSON; `pane split` returns a `pane_info` result whose
+ * `pane.pane_id` field is the new pane's ID.
+ *
+ * Environment detection: Herdr injects `HERDR_ENV=1` and `HERDR_PANE_ID`
+ * into every pane it manages.
+ */
+import type { MultiplexerLayout } from '../../config/schema';
+import type { Multiplexer, PaneResult } from '../types';
+export declare class HerdrMultiplexer implements Multiplexer {
+    readonly type: "herdr";
+    private binaryPath;
+    private hasChecked;
+    private readonly parentPaneId;
+    private layout;
+    private paneDirection;
+    private agentAreaPaneId;
+    constructor(layout?: MultiplexerLayout, mainPaneSize?: number);
+    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 runSplit;
+    private targetPaneArg;
+    private getBinary;
+}

package/dist/multiplexer/index.d.ts

@@ -2,6 +2,7 @@
  * Multiplexer module exports
  */
 export { clearMultiplexerCache, getMultiplexer, startAvailabilityCheck, } from './factory';
+export { HerdrMultiplexer } from './herdr';
 export { MultiplexerSessionManager, TmuxSessionManager, } from './session-manager';
 export { TmuxMultiplexer } from './tmux';
 export type { Multiplexer, PaneResult } from './types';

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

@@ -1,6 +1,7 @@
 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';
+type BackgroundJobReader = Pick<BackgroundJobStore, 'getState' | 'deferIfRunning' | 'clearDeferredClose'>;
 interface SessionEvent {
     type: string;
     properties?: {
@@ -33,10 +34,9 @@ export declare class MultiplexerSessionManager {
     private knownSessions;
     private spawningSessions;
     private closingSessions;
-    private deferredIdleCloses;
     private pollInterval?;
     private enabled;
-    constructor(ctx: PluginInput, config: MultiplexerConfig, backgroundJobBoard?: BackgroundJobBoard | undefined);
+    constructor(ctx: PluginInput, config: MultiplexerConfig, backgroundJobBoard?: BackgroundJobReader | undefined);
     onSessionCreated(event: SessionEvent): Promise<void>;
     onSessionStatus(event: SessionEvent): Promise<void>;
     onSessionDeleted(event: SessionEvent): Promise<void>;
@@ -49,8 +49,9 @@ export declare class MultiplexerSessionManager {
     private isTrackedOrSpawning;
     private updatePolling;
     private getSessionId;
-    private isRunningBackgroundJob;
-    retryDeferredIdleClose(sessionId: string): Promise<void>;
+    private backgroundJobState;
+    private shouldCloseNow;
+    closeSessionFromCoordinator(sessionId: string): Promise<void>;
     cleanup(): Promise<void>;
 }
 /**

package/dist/multiplexer/shared.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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): string;
+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

@@ -1,8 +1,8 @@
 /**
  * Multiplexer abstraction layer
  *
- * Provides a unified interface for terminal multiplexers (tmux, zellij, etc.)
- * to spawn and manage panes for child agent sessions.
+ * Provides a unified interface for terminal multiplexers (tmux, zellij,
+ * herdr, etc.) to spawn and manage panes for child agent sessions.
  */
 import type { MultiplexerConfig, MultiplexerLayout } from '../config/schema';
 export interface PaneResult {
@@ -11,10 +11,10 @@ export interface PaneResult {
 }
 /**
  * Core multiplexer interface
- * Implementations: TmuxMultiplexer, ZellijMultiplexer
+ * Implementations: TmuxMultiplexer, ZellijMultiplexer, HerdrMultiplexer
  */
 export interface Multiplexer {
-    readonly type: 'tmux' | 'zellij';
+    readonly type: 'tmux' | 'zellij' | 'herdr';
     /**
      * 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/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;
 };