oh-my-opencode-slim 2.0.4 → 2.1.0

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/dashboard.d.ts

@@ -45,6 +45,11 @@ export declare function createDashboardServer(config: DashboardConfig): {
         answer: string;
     }> | null;
     consumeNudgeAction: (interviewId: string) => 'more-questions' | 'confirm-complete' | null;
+    consumeBlockComment: (interviewId: string) => {
+        section: string;
+        comment: string;
+    } | null;
+    consumeChatMessage: (interviewId: string) => string | null;
     authToken: string;
     discoverSessionDirectories: () => Promise<void>;
     addManualFolder: (dir: string) => void;

package/dist/interview/document.d.ts

@@ -1,4 +1,4 @@
-import type { InterviewAnswer, InterviewQuestion, InterviewRecord } from './types';
+import type { InterviewAnswer, InterviewQuestion, InterviewRecord, SpecBlock } from './types';
 export declare const DEFAULT_OUTPUT_FOLDER = "interview";
 export declare function normalizeOutputFolder(outputFolder: string): string;
 export declare function createInterviewDirectoryPath(directory: string, outputFolder: string): string;
@@ -16,6 +16,8 @@ export declare function extractTitle(document: string): string;
 export declare function buildInterviewDocument(idea: string, summary: string, history: string, meta?: {
     sessionID?: string;
     baseMessageCount?: number;
+    owner?: string;
+    tags?: string[];
 }): string;
 /** Parse frontmatter from a .md file. Returns null if no frontmatter. */
 export declare function parseFrontmatter(content: string): Record<string, string> | null;
@@ -23,3 +25,4 @@ export declare function ensureInterviewFile(record: InterviewRecord): Promise<vo
 export declare function readInterviewDocument(record: InterviewRecord): Promise<string>;
 export declare function rewriteInterviewDocument(record: InterviewRecord, summary: string): Promise<string>;
 export declare function appendInterviewAnswers(record: InterviewRecord, questions: InterviewQuestion[], answers: InterviewAnswer[]): Promise<void>;
+export declare function parseSpecBlocks(markdown: string): SpecBlock[];

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/server.d.ts

@@ -4,6 +4,8 @@ export declare function createInterviewServer(deps: {
     listInterviewFiles: () => Promise<InterviewFileItem[]>;
     listInterviews: () => InterviewListItem[];
     submitAnswers: (interviewId: string, answers: InterviewAnswer[]) => Promise<void>;
+    submitBlockComment: (interviewId: string, section: string, comment: string) => Promise<void>;
+    submitChat: (interviewId: string, message: string) => Promise<void>;
     handleNudgeAction: (interviewId: string, action: 'more-questions' | 'confirm-complete') => Promise<void>;
     outputFolder: string;
     port: number;

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;
@@ -30,5 +37,7 @@ export declare function createInterviewService(ctx: PluginInput, config?: Interv
     listInterviewFiles: () => Promise<InterviewFileItem[]>;
     listInterviews: () => InterviewListItem[];
     submitAnswers: (interviewId: string, answers: InterviewAnswer[]) => Promise<void>;
+    submitBlockComment: (interviewId: string, section: string, comment: string) => Promise<void>;
+    submitChat: (interviewId: string, message: string) => Promise<void>;
     handleNudgeAction: (interviewId: string, action: 'more-questions' | 'confirm-complete') => Promise<void>;
 };

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;
 }
@@ -61,6 +63,11 @@ export interface InterviewFileItem {
     sessionID?: string;
     directory?: string;
 }
+export interface SpecBlock {
+    id: string;
+    title: string;
+    content: string;
+}
 export interface InterviewState {
     interview: InterviewRecord;
     url: string;
@@ -71,6 +78,7 @@ export interface InterviewState {
     summary: string;
     questions: InterviewQuestion[];
     document: string;
+    blocks: SpecBlock[];
 }
 /** Wire format for dashboard state cache entries. */
 export interface InterviewStateEntry {
@@ -93,4 +101,11 @@ export interface InterviewStateEntry {
     lastUpdatedAt: number;
     filePath: string;
     nudgeAction: 'more-questions' | 'confirm-complete' | null;
+    pendingBlockComment: {
+        section: string;
+        comment: string;
+    } | null;
+    pendingChatMessage: string | null;
+    document?: string;
+    blocks?: SpecBlock[];
 }

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,31 @@
+/**
+ * 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 readonly paneDirection;
+    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 targetPaneArg;
+    private getBinary;
+    private findBinary;
+}

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

@@ -33,6 +33,7 @@ export declare class MultiplexerSessionManager {
     private knownSessions;
     private spawningSessions;
     private closingSessions;
+    private deferredIdleCloses;
     private pollInterval?;
     private enabled;
     constructor(ctx: PluginInput, config: MultiplexerConfig, backgroundJobBoard?: BackgroundJobBoard | undefined);
@@ -48,7 +49,9 @@ export declare class MultiplexerSessionManager {
     private isTrackedOrSpawning;
     private updatePolling;
     private getSessionId;
+    private backgroundJobState;
     private isRunningBackgroundJob;
+    retryDeferredIdleClose(sessionId: string): Promise<void>;
     cleanup(): Promise<void>;
 }
 /**

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/tools/acp-run.d.ts

@@ -1,3 +1,3 @@
 import { type ToolDefinition } from '@opencode-ai/plugin';
-import type { AcpAgentsConfig } from '../config';
+import { type AcpAgentsConfig } from '../config';
 export declare function createAcpRunTool(agents?: AcpAgentsConfig): ToolDefinition;

package/dist/tui-state.d.ts

@@ -2,14 +2,17 @@ export interface TuiSnapshot {
     version: 1;
     updatedAt: number;
     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 recordTuiAgentModels(input: {
     agentModels: Record<string, string>;
+    agentVariants?: Record<string, string>;
 }): void;
 export declare function recordTuiAgentModel(input: {
     agentName: string;
     model: string;
+    variant?: string | null;
 }): void;

package/dist/tui.d.ts

@@ -1,6 +1,9 @@
 import type { TuiPluginModule } from '@opencode-ai/plugin/tui';
 import { type TuiSnapshot } from './tui-state';
-export declare function formatSidebarModelName(model: string): string;
+export declare function splitSidebarModelId(model: string): {
+    provider?: string;
+    model: string;
+};
 export declare function getSidebarAgentNames(snapshot: TuiSnapshot): string[];
 export declare function readConfigInvalid(directory: string): boolean;
 declare const plugin: TuiPluginModule & {