@bohuyeshan/openagent-labforge-core 3.11.0

package/dist/hooks/todo-continuation-enforcer/continuation-injection.d.ts

@@ -0,0 +1,13 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { BackgroundManager } from "../../features/background-agent";
+import type { ResolvedMessageInfo } from "./types";
+import type { SessionStateStore } from "./session-state";
+export declare function injectContinuation(args: {
+    ctx: PluginInput;
+    sessionID: string;
+    backgroundManager?: BackgroundManager;
+    skipAgents?: string[];
+    resolvedInfo?: ResolvedMessageInfo;
+    sessionStateStore: SessionStateStore;
+    isContinuationStopped?: (sessionID: string) => boolean;
+}): Promise<void>;

package/dist/hooks/todo-continuation-enforcer/countdown.d.ts

@@ -0,0 +1,15 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { BackgroundManager } from "../../features/background-agent";
+import type { ResolvedMessageInfo } from "./types";
+import type { SessionStateStore } from "./session-state";
+export declare function startCountdown(args: {
+    ctx: PluginInput;
+    sessionID: string;
+    incompleteCount: number;
+    total: number;
+    resolvedInfo?: ResolvedMessageInfo;
+    backgroundManager?: BackgroundManager;
+    skipAgents: string[];
+    sessionStateStore: SessionStateStore;
+    isContinuationStopped?: (sessionID: string) => boolean;
+}): void;

package/dist/hooks/todo-continuation-enforcer/handler.d.ts

@@ -0,0 +1,15 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { BackgroundManager } from "../../features/background-agent";
+import type { SessionStateStore } from "./session-state";
+export declare function createTodoContinuationHandler(args: {
+    ctx: PluginInput;
+    sessionStateStore: SessionStateStore;
+    backgroundManager?: BackgroundManager;
+    skipAgents?: string[];
+    isContinuationStopped?: (sessionID: string) => boolean;
+}): (input: {
+    event: {
+        type: string;
+        properties?: unknown;
+    };
+}) => Promise<void>;

package/dist/hooks/todo-continuation-enforcer/idle-event.d.ts

@@ -0,0 +1,11 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { BackgroundManager } from "../../features/background-agent";
+import type { SessionStateStore } from "./session-state";
+export declare function handleSessionIdle(args: {
+    ctx: PluginInput;
+    sessionID: string;
+    sessionStateStore: SessionStateStore;
+    backgroundManager?: BackgroundManager;
+    skipAgents?: string[];
+    isContinuationStopped?: (sessionID: string) => boolean;
+}): Promise<void>;

package/dist/hooks/todo-continuation-enforcer/index.d.ts

@@ -0,0 +1,4 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { TodoContinuationEnforcer, TodoContinuationEnforcerOptions } from "./types";
+export type { TodoContinuationEnforcer, TodoContinuationEnforcerOptions } from "./types";
+export declare function createTodoContinuationEnforcer(ctx: PluginInput, options?: TodoContinuationEnforcerOptions): TodoContinuationEnforcer;

package/dist/hooks/todo-continuation-enforcer/message-directory.d.ts

@@ -0,0 +1 @@
+export { getMessageDir } from "../../shared/opencode-message-dir";

package/dist/hooks/todo-continuation-enforcer/non-idle-events.d.ts

@@ -0,0 +1,6 @@
+import type { SessionStateStore } from "./session-state";
+export declare function handleNonIdleEvent(args: {
+    eventType: string;
+    properties: Record<string, unknown> | undefined;
+    sessionStateStore: SessionStateStore;
+}): void;

package/dist/hooks/todo-continuation-enforcer/pending-question-detection.d.ts

@@ -0,0 +1,15 @@
+interface MessagePart {
+    type: string;
+    name?: string;
+    toolName?: string;
+    text?: string;
+}
+interface Message {
+    info?: {
+        role?: string;
+    };
+    role?: string;
+    parts?: MessagePart[];
+}
+export declare function hasUnansweredQuestion(messages: Message[]): boolean;
+export {};

package/dist/hooks/todo-continuation-enforcer/session-state.d.ts

@@ -0,0 +1,10 @@
+import type { SessionState } from "./types";
+export interface SessionStateStore {
+    getState: (sessionID: string) => SessionState;
+    getExistingState: (sessionID: string) => SessionState | undefined;
+    cancelCountdown: (sessionID: string) => void;
+    cleanup: (sessionID: string) => void;
+    cancelAllCountdowns: () => void;
+    shutdown: () => void;
+}
+export declare function createSessionStateStore(): SessionStateStore;

package/dist/hooks/todo-continuation-enforcer/todo.d.ts

@@ -0,0 +1,2 @@
+import type { Todo } from "./types";
+export declare function getIncompleteCount(todos: Todo[]): number;

package/dist/hooks/todo-continuation-enforcer/types.d.ts

@@ -0,0 +1,59 @@
+import type { BackgroundManager } from "../../features/background-agent";
+import type { ToolPermission } from "../../features/hook-message-injector";
+export interface TodoContinuationEnforcerOptions {
+    backgroundManager?: BackgroundManager;
+    skipAgents?: string[];
+    isContinuationStopped?: (sessionID: string) => boolean;
+}
+export interface TodoContinuationEnforcer {
+    handler: (input: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+    markRecovering: (sessionID: string) => void;
+    markRecoveryComplete: (sessionID: string) => void;
+    cancelAllCountdowns: () => void;
+}
+export interface Todo {
+    content: string;
+    status: string;
+    priority: string;
+    id?: string;
+}
+export interface SessionState {
+    countdownTimer?: ReturnType<typeof setTimeout>;
+    countdownInterval?: ReturnType<typeof setInterval>;
+    isRecovering?: boolean;
+    countdownStartedAt?: number;
+    idleStrikeCount?: number;
+    abortDetectedAt?: number;
+    lastInjectedAt?: number;
+    inFlight?: boolean;
+    consecutiveFailures: number;
+}
+export interface MessageInfo {
+    id?: string;
+    role?: string;
+    error?: {
+        name?: string;
+        data?: unknown;
+    };
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    providerID?: string;
+    modelID?: string;
+    tools?: Record<string, ToolPermission>;
+}
+export interface ResolvedMessageInfo {
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    tools?: Record<string, ToolPermission>;
+}

package/dist/hooks/tool-output-truncator.d.ts

@@ -0,0 +1,20 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { ExperimentalConfig } from "../config/schema";
+interface ToolOutputTruncatorOptions {
+    modelCacheState?: {
+        anthropicContext1MEnabled: boolean;
+    };
+    experimental?: ExperimentalConfig;
+}
+export declare function createToolOutputTruncatorHook(ctx: PluginInput, options?: ToolOutputTruncatorOptions): {
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+};
+export {};

package/dist/hooks/unstable-agent-babysitter/index.d.ts

@@ -0,0 +1,2 @@
+export { createUnstableAgentBabysitterHook } from "./unstable-agent-babysitter-hook";
+export { buildReminder, extractMessages, getMessageInfo, getMessageParts, isUnstableTask, THINKING_SUMMARY_MAX_CHARS, } from "./task-message-analyzer";

package/dist/hooks/unstable-agent-babysitter/task-message-analyzer.d.ts

@@ -0,0 +1,24 @@
+import type { BackgroundTask } from "../../features/background-agent";
+export declare const THINKING_SUMMARY_MAX_CHARS: 500;
+type MessageInfo = {
+    role?: string;
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    providerID?: string;
+    modelID?: string;
+    tools?: Record<string, boolean | "allow" | "deny" | "ask">;
+};
+type MessagePart = {
+    type?: string;
+    text?: string;
+    thinking?: string;
+};
+export declare function getMessageInfo(value: unknown): MessageInfo | undefined;
+export declare function getMessageParts(value: unknown): MessagePart[];
+export declare function extractMessages(value: unknown): unknown[];
+export declare function isUnstableTask(task: BackgroundTask): boolean;
+export declare function buildReminder(task: BackgroundTask, summary: string | null, idleMs: number): string;
+export {};

package/dist/hooks/unstable-agent-babysitter/unstable-agent-babysitter-hook.d.ts

@@ -0,0 +1,71 @@
+import type { BackgroundManager } from "../../features/background-agent";
+type BabysittingConfig = {
+    timeout_ms?: number;
+};
+type BabysitterContext = {
+    directory: string;
+    client: {
+        session: {
+            messages: (args: {
+                path: {
+                    id: string;
+                };
+            }) => Promise<{
+                data?: unknown;
+            } | unknown[]>;
+            prompt: (args: {
+                path: {
+                    id: string;
+                };
+                body: {
+                    parts: Array<{
+                        type: "text";
+                        text: string;
+                    }>;
+                    agent?: string;
+                    model?: {
+                        providerID: string;
+                        modelID: string;
+                    };
+                    tools?: Record<string, boolean>;
+                };
+                query?: {
+                    directory?: string;
+                };
+            }) => Promise<unknown>;
+            promptAsync: (args: {
+                path: {
+                    id: string;
+                };
+                body: {
+                    parts: Array<{
+                        type: "text";
+                        text: string;
+                    }>;
+                    agent?: string;
+                    model?: {
+                        providerID: string;
+                        modelID: string;
+                    };
+                    tools?: Record<string, boolean>;
+                };
+                query?: {
+                    directory?: string;
+                };
+            }) => Promise<unknown>;
+        };
+    };
+};
+type BabysitterOptions = {
+    backgroundManager: Pick<BackgroundManager, "getTasksByParentSession">;
+    config?: BabysittingConfig;
+};
+export declare function createUnstableAgentBabysitterHook(ctx: BabysitterContext, options: BabysitterOptions): {
+    event: ({ event }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+};
+export {};

package/dist/hooks/write-existing-file-guard/hook.d.ts

@@ -0,0 +1,3 @@
+import type { Hooks, PluginInput } from "@opencode-ai/plugin";
+export declare const MAX_TRACKED_PATHS_PER_SESSION = 1024;
+export declare function createWriteExistingFileGuardHook(ctx: PluginInput): Hooks;

package/dist/hooks/write-existing-file-guard/index.d.ts

@@ -0,0 +1 @@
+export { createWriteExistingFileGuardHook } from "./hook";

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from "@opencode-ai/plugin";
+declare const OhMyOpenCodePlugin: Plugin;
+export default OhMyOpenCodePlugin;
+export type { OhMyOpenCodeConfig, AgentName, AgentOverrideConfig, AgentOverrides, McpName, HookName, BuiltinCommandName, } from "./config";
+export type { ConfigLoadError } from "./shared/config-errors";