@bohuyeshan/openagent-labforge-core 3.11.2 → 3.11.4

package/dist/cli/install-validators.d.ts

@@ -29,4 +29,5 @@ export declare function detectedToInitialValues(detected: DetectedConfig): {
     opencodeZen: BooleanArg;
     zaiCodingPlan: BooleanArg;
     kimiForCoding: BooleanArg;
+    opencodeGo: BooleanArg;
 };

package/dist/cli/model-fallback-types.d.ts

@@ -8,6 +8,7 @@ export interface ProviderAvailability {
     copilot: boolean;
     zai: boolean;
     kimiForCoding: boolean;
+    opencodeGo: boolean;
     isMaxPlan: boolean;
 }
 export interface AgentConfig {

package/dist/cli/openai-only-model-catalog.d.ts

@@ -0,0 +1,3 @@
+import type { GeneratedOmoConfig, ProviderAvailability } from "./model-fallback-types";
+export declare function isOpenAiOnlyAvailability(availability: ProviderAvailability): boolean;
+export declare function applyOpenAiOnlyModelCatalog(config: GeneratedOmoConfig): GeneratedOmoConfig;

package/dist/cli/run/index.d.ts

@@ -1,5 +1,6 @@
 export { run } from "./runner";
 export { resolveRunAgent } from "./agent-resolver";
+export { resolveRunModel } from "./model-resolver";
 export { createServerConnection } from "./server-connection";
 export { resolveSession } from "./session-resolver";
 export { createJsonOutputManager } from "./json-output";

package/dist/cli/run/model-resolver.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveRunModel(modelString?: string): {
+    providerID: string;
+    modelID: string;
+} | undefined;

package/dist/cli/run/types.d.ts

@@ -3,6 +3,7 @@ export type { OpencodeClient };
 export interface RunOptions {
     message: string;
     agent?: string;
+    model?: string;
     timestamp?: boolean;
     verbose?: boolean;
     directory?: string;

package/dist/cli/types.d.ts

@@ -9,6 +9,7 @@ export interface InstallArgs {
     opencodeZen?: BooleanArg;
     zaiCodingPlan?: BooleanArg;
     kimiForCoding?: BooleanArg;
+    opencodeGo?: BooleanArg;
     skipAuth?: boolean;
 }
 export interface InstallConfig {
@@ -20,6 +21,7 @@ export interface InstallConfig {
     hasOpencodeZen: boolean;
     hasZaiCodingPlan: boolean;
     hasKimiForCoding: boolean;
+    hasOpencodeGo: boolean;
 }
 export interface ConfigMergeResult {
     success: boolean;
@@ -36,4 +38,5 @@ export interface DetectedConfig {
     hasOpencodeZen: boolean;
     hasZaiCodingPlan: boolean;
     hasKimiForCoding: boolean;
+    hasOpencodeGo: boolean;
 }

package/dist/config/schema/agent-names.d.ts

@@ -12,6 +12,7 @@ export declare const BuiltinAgentNameSchema: z.ZodEnum<{
     metis: "metis";
     momus: "momus";
     atlas: "atlas";
+    "sisyphus-junior": "sisyphus-junior";
     prometheus: "prometheus";
 }>;
 export declare const BuiltinSkillNameSchema: z.ZodEnum<{
@@ -40,10 +41,10 @@ export declare const OverridableAgentNameSchema: z.ZodEnum<{
     metis: "metis";
     momus: "momus";
     atlas: "atlas";
+    "sisyphus-junior": "sisyphus-junior";
     build: "build";
     plan: "plan";
     prometheus: "prometheus";
-    "sisyphus-junior": "sisyphus-junior";
     "OpenCode-Builder": "OpenCode-Builder";
 }>;
 export declare const AgentNameSchema: z.ZodEnum<{
@@ -59,6 +60,7 @@ export declare const AgentNameSchema: z.ZodEnum<{
     metis: "metis";
     momus: "momus";
     atlas: "atlas";
+    "sisyphus-junior": "sisyphus-junior";
     prometheus: "prometheus";
 }>;
 export type AgentName = z.infer<typeof AgentNameSchema>;

package/dist/config/schema/background-task.d.ts

@@ -3,6 +3,8 @@ export declare const BackgroundTaskConfigSchema: z.ZodObject<{
     defaultConcurrency: z.ZodOptional<z.ZodNumber>;
     providerConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     modelConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+    maxDescendants: z.ZodOptional<z.ZodNumber>;
     staleTimeoutMs: z.ZodOptional<z.ZodNumber>;
     messageStalenessTimeoutMs: z.ZodOptional<z.ZodNumber>;
     syncPollTimeoutMs: z.ZodOptional<z.ZodNumber>;

package/dist/config/schema/git-env-prefix.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare const GIT_ENV_PREFIX_VALIDATION_MESSAGE = "git_env_prefix must be empty or use shell-safe env assignments like \"GIT_MASTER=1\"";
+export declare function isValidGitEnvPrefix(value: string): boolean;
+export declare function assertValidGitEnvPrefix(value: string): string;
+export declare const GitEnvPrefixSchema: z.ZodDefault<z.ZodString>;

package/dist/config/schema/git-master.d.ts

@@ -2,5 +2,6 @@ import { z } from "zod";
 export declare const GitMasterConfigSchema: z.ZodObject<{
     commit_footer: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
     include_co_authored_by: z.ZodDefault<z.ZodBoolean>;
+    git_env_prefix: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>;
 export type GitMasterConfig = z.infer<typeof GitMasterConfigSchema>;

package/dist/config/schema/hooks.d.ts

@@ -3,6 +3,7 @@ export declare const HookNameSchema: z.ZodEnum<{
     atlas: "atlas";
     "ralph-loop": "ralph-loop";
     "start-work": "start-work";
+    "gpt-permission-continuation": "gpt-permission-continuation";
     "todo-continuation-enforcer": "todo-continuation-enforcer";
     "context-window-monitor": "context-window-monitor";
     "session-recovery": "session-recovery";
@@ -47,5 +48,6 @@ export declare const HookNameSchema: z.ZodEnum<{
     "anthropic-effort": "anthropic-effort";
     "hashline-read-enhancer": "hashline-read-enhancer";
     "read-image-resizer": "read-image-resizer";
+    "delegate-task-english-directive": "delegate-task-english-directive";
 }>;
 export type HookName = z.infer<typeof HookNameSchema>;

package/dist/config/schema/oh-my-opencode-config.d.ts

@@ -52,7 +52,57 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         "web-research": "web-research";
         "data-analysis": "data-analysis";
     }>>>;
-    disabled_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disabled_hooks: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        atlas: "atlas";
+        "ralph-loop": "ralph-loop";
+        "start-work": "start-work";
+        "gpt-permission-continuation": "gpt-permission-continuation";
+        "todo-continuation-enforcer": "todo-continuation-enforcer";
+        "context-window-monitor": "context-window-monitor";
+        "session-recovery": "session-recovery";
+        "session-notification": "session-notification";
+        "comment-checker": "comment-checker";
+        "tool-output-truncator": "tool-output-truncator";
+        "question-label-truncator": "question-label-truncator";
+        "directory-agents-injector": "directory-agents-injector";
+        "directory-readme-injector": "directory-readme-injector";
+        "empty-task-response-detector": "empty-task-response-detector";
+        "think-mode": "think-mode";
+        "model-fallback": "model-fallback";
+        "anthropic-context-window-limit-recovery": "anthropic-context-window-limit-recovery";
+        "preemptive-compaction": "preemptive-compaction";
+        "rules-injector": "rules-injector";
+        "background-notification": "background-notification";
+        "auto-update-checker": "auto-update-checker";
+        "startup-toast": "startup-toast";
+        "keyword-detector": "keyword-detector";
+        "agent-usage-reminder": "agent-usage-reminder";
+        "non-interactive-env": "non-interactive-env";
+        "interactive-bash-session": "interactive-bash-session";
+        "thinking-block-validator": "thinking-block-validator";
+        "category-skill-reminder": "category-skill-reminder";
+        "compaction-context-injector": "compaction-context-injector";
+        "compaction-todo-preserver": "compaction-todo-preserver";
+        "claude-code-hooks": "claude-code-hooks";
+        "auto-slash-command": "auto-slash-command";
+        "edit-error-recovery": "edit-error-recovery";
+        "json-error-recovery": "json-error-recovery";
+        "delegate-task-retry": "delegate-task-retry";
+        "prometheus-md-only": "prometheus-md-only";
+        "sisyphus-junior-notepad": "sisyphus-junior-notepad";
+        "no-sisyphus-gpt": "no-sisyphus-gpt";
+        "no-hephaestus-non-gpt": "no-hephaestus-non-gpt";
+        "unstable-agent-babysitter": "unstable-agent-babysitter";
+        "task-resume-info": "task-resume-info";
+        "stop-continuation-guard": "stop-continuation-guard";
+        "tasks-todowrite-disabler": "tasks-todowrite-disabler";
+        "runtime-fallback": "runtime-fallback";
+        "write-existing-file-guard": "write-existing-file-guard";
+        "anthropic-effort": "anthropic-effort";
+        "hashline-read-enhancer": "hashline-read-enhancer";
+        "read-image-resizer": "read-image-resizer";
+        "delegate-task-english-directive": "delegate-task-english-directive";
+    }>>>;
     disabled_commands: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         "init-deep": "init-deep";
         "ralph-loop": "ralph-loop";
@@ -1384,6 +1434,8 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         defaultConcurrency: z.ZodOptional<z.ZodNumber>;
         providerConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
         modelConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        maxDepth: z.ZodOptional<z.ZodNumber>;
+        maxDescendants: z.ZodOptional<z.ZodNumber>;
         staleTimeoutMs: z.ZodOptional<z.ZodNumber>;
         messageStalenessTimeoutMs: z.ZodOptional<z.ZodNumber>;
         syncPollTimeoutMs: z.ZodOptional<z.ZodNumber>;
@@ -1413,6 +1465,7 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
     git_master: z.ZodOptional<z.ZodObject<{
         commit_footer: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
         include_co_authored_by: z.ZodDefault<z.ZodBoolean>;
+        git_env_prefix: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>>;
     browser_automation_engine: z.ZodOptional<z.ZodObject<{
         provider: z.ZodDefault<z.ZodEnum<{

package/dist/config/schema.d.ts

@@ -10,6 +10,7 @@ export * from "./schema/commands";
 export * from "./schema/dynamic-context-pruning";
 export * from "./schema/experimental";
 export * from "./schema/fallback-models";
+export * from "./schema/git-env-prefix";
 export * from "./schema/git-master";
 export * from "./schema/hooks";
 export * from "./schema/i18n";

package/dist/create-hooks.d.ts

@@ -5,6 +5,15 @@ import type { BackgroundManager } from "./features/background-agent";
 import type { PluginContext } from "./plugin/types";
 import type { ModelCacheState } from "./plugin-state";
 export type CreatedHooks = ReturnType<typeof createHooks>;
+type DisposableHook = {
+    dispose?: () => void;
+} | null | undefined;
+export type DisposableCreatedHooks = {
+    runtimeFallback?: DisposableHook;
+    todoContinuationEnforcer?: DisposableHook;
+    autoSlashCommand?: DisposableHook;
+};
+export declare function disposeCreatedHooks(hooks: DisposableCreatedHooks): void;
 export declare function createHooks(args: {
     ctx: PluginContext;
     pluginConfig: OhMyOpenCodeConfig;
@@ -15,8 +24,10 @@ export declare function createHooks(args: {
     getMergedSkills: () => Promise<LoadedSkill[]>;
     availableSkills: AvailableSkill[];
 }): {
+    disposeHooks: () => void;
     categorySkillReminder: ReturnType<typeof import("./hooks").createCategorySkillReminderHook> | null;
     autoSlashCommand: ReturnType<typeof import("./hooks").createAutoSlashCommandHook> | null;
+    gptPermissionContinuation: ReturnType<typeof import("./hooks").createGptPermissionContinuationHook> | null;
     stopContinuationGuard: ReturnType<typeof import("./hooks").createStopContinuationGuardHook> | null;
     compactionContextInjector: ReturnType<typeof import("./hooks").createCompactionContextInjector> | null;
     compactionTodoPreserver: ReturnType<typeof import("./hooks").createCompactionTodoPreserverHook> | null;
@@ -62,4 +73,6 @@ export declare function createHooks(args: {
     taskResumeInfo: ReturnType<typeof import("./hooks").createTaskResumeInfoHook> | null;
     anthropicEffort: ReturnType<typeof import("./hooks/anthropic-effort").createAnthropicEffortHook> | null;
     runtimeFallback: ReturnType<typeof import("./hooks").createRuntimeFallbackHook> | null;
+    delegateTaskEnglishDirective: ReturnType<typeof import("./hooks").createDelegateTaskEnglishDirectiveHook> | null;
 };
+export {};

package/dist/features/background-agent/compaction-aware-message-resolver.d.ts

@@ -1,3 +1,18 @@
 import type { StoredMessage } from "../hook-message-injector";
+type SessionMessage = {
+    info?: {
+        agent?: string;
+        model?: {
+            providerID?: string;
+            modelID?: string;
+            variant?: string;
+        };
+        providerID?: string;
+        modelID?: string;
+        tools?: StoredMessage["tools"];
+    };
+};
 export declare function isCompactionAgent(agent: string | undefined): boolean;
-export declare function findNearestMessageExcludingCompaction(messageDir: string): StoredMessage | null;
+export declare function resolvePromptContextFromSessionMessages(messages: SessionMessage[], sessionID?: string): StoredMessage | null;
+export declare function findNearestMessageExcludingCompaction(messageDir: string, sessionID?: string): StoredMessage | null;
+export {};

package/dist/features/background-agent/constants.d.ts

@@ -3,7 +3,7 @@ import type { BackgroundTask, LaunchInput } from "./types";
 export declare const TASK_TTL_MS: number;
 export declare const MIN_STABILITY_TIME_MS: number;
 export declare const DEFAULT_STALE_TIMEOUT_MS = 180000;
-export declare const DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS = 600000;
+export declare const DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS = 1800000;
 export declare const MIN_RUNTIME_BEFORE_STALE_MS = 30000;
 export declare const MIN_IDLE_TIME_MS = 5000;
 export declare const POLLING_INTERVAL_MS = 3000;

package/dist/features/background-agent/manager.d.ts

@@ -2,6 +2,7 @@ import type { PluginInput } from "@opencode-ai/plugin";
 import type { BackgroundTask, LaunchInput, ResumeInput } from "./types";
 import { TaskHistory } from "./task-history";
 import type { BackgroundTaskConfig, TmuxConfig } from "../../config/schema";
+import { type SubagentSpawnContext } from "./subagent-spawn-limits";
 interface EventProperties {
     sessionID?: string;
     info?: {
@@ -37,16 +38,31 @@ export declare class BackgroundManager {
     private queuesByKey;
     private processingKeys;
     private completionTimers;
+    private completedTaskSummaries;
     private idleDeferralTimers;
     private notificationQueueByParent;
+    private rootDescendantCounts;
+    private preStartDescendantReservations;
     private enableParentSessionNotifications;
     readonly taskHistory: TaskHistory;
     constructor(ctx: PluginInput, config?: BackgroundTaskConfig, options?: {
         tmuxConfig?: TmuxConfig;
         onSubagentSessionCreated?: OnSubagentSessionCreated;
-        onShutdown?: () => void;
+        onShutdown?: () => void | Promise<void>;
         enableParentSessionNotifications?: boolean;
     });
+    assertCanSpawn(parentSessionID: string): Promise<SubagentSpawnContext>;
+    reserveSubagentSpawn(parentSessionID: string): Promise<{
+        spawnContext: SubagentSpawnContext;
+        descendantCount: number;
+        commit: () => number;
+        rollback: () => void;
+    }>;
+    private registerRootDescendant;
+    private unregisterRootDescendant;
+    private markPreStartDescendantReservation;
+    private settlePreStartDescendantReservation;
+    private rollbackPreStartDescendantReservation;
     launch(input: LaunchInput): Promise<BackgroundTask>;
     private processKey;
     private startTask;
@@ -94,6 +110,8 @@ export declare class BackgroundManager {
      * Cleans up the parent entry if no pending tasks remain.
      */
     private cleanupPendingByParent;
+    private clearTaskHistoryWhenParentTasksGone;
+    private scheduleTaskRemoval;
     cancelTask(taskId: string, options?: {
         source?: string;
         reason?: string;
@@ -123,8 +141,6 @@ export declare class BackgroundManager {
      */
     private tryCompleteTask;
     private notifyParentSession;
-    private formatDuration;
-    private isAbortedSessionError;
     private hasRunningTasks;
     private pruneStaleTasksAndNotifications;
     private checkAndInterruptStaleTasks;
@@ -134,7 +150,7 @@ export declare class BackgroundManager {
      * Cancels all pending concurrency waiters and clears timers.
      * Should be called when the plugin is unloaded.
      */
-    shutdown(): void;
+    shutdown(): Promise<void>;
     private enqueueNotificationForParent;
 }
 export {};

package/dist/features/background-agent/process-cleanup.d.ts

@@ -1,5 +1,5 @@
 interface CleanupTarget {
-    shutdown(): void;
+    shutdown(): void | Promise<void>;
 }
 export declare function registerManagerForCleanup(manager: CleanupTarget): void;
 export declare function unregisterManagerForCleanup(manager: CleanupTarget): void;

package/dist/features/background-agent/remove-task-toast-tracking.d.ts

@@ -0,0 +1 @@
+export declare function removeTaskToastTracking(taskId: string): void;

package/dist/features/background-agent/subagent-spawn-limits.d.ts

@@ -0,0 +1,23 @@
+import type { BackgroundTaskConfig } from "../../config/schema";
+import type { OpencodeClient } from "./constants";
+export declare const DEFAULT_MAX_SUBAGENT_DEPTH = 3;
+export declare const DEFAULT_MAX_ROOT_SESSION_SPAWN_BUDGET = 50;
+export interface SubagentSpawnContext {
+    rootSessionID: string;
+    parentDepth: number;
+    childDepth: number;
+}
+export declare function getMaxSubagentDepth(config?: BackgroundTaskConfig): number;
+export declare function getMaxRootSessionSpawnBudget(config?: BackgroundTaskConfig): number;
+export declare function resolveSubagentSpawnContext(client: OpencodeClient, parentSessionID: string): Promise<SubagentSpawnContext>;
+export declare function createSubagentDepthLimitError(input: {
+    childDepth: number;
+    maxDepth: number;
+    parentSessionID: string;
+    rootSessionID: string;
+}): Error;
+export declare function createSubagentDescendantLimitError(input: {
+    rootSessionID: string;
+    descendantCount: number;
+    maxDescendants: number;
+}): Error;

package/dist/features/background-agent/task-history.d.ts

@@ -14,5 +14,6 @@ export declare class TaskHistory {
     record(parentSessionID: string | undefined, entry: TaskHistoryEntry): void;
     getByParentSession(parentSessionID: string): TaskHistoryEntry[];
     clearSession(parentSessionID: string): void;
+    clearAll(): void;
     formatForCompaction(parentSessionID: string): string | null;
 }

package/dist/features/background-agent/task-poller.d.ts

@@ -17,4 +17,5 @@ export declare function checkAndInterruptStaleTasks(args: {
     concurrencyManager: ConcurrencyManager;
     notifyParentSession: (task: BackgroundTask) => Promise<void>;
     sessionStatuses?: SessionStatusMap;
+    onTaskInterrupted?: (task: BackgroundTask) => void;
 }): Promise<void>;

package/dist/features/background-agent/types.d.ts

@@ -1,4 +1,5 @@
 import type { FallbackEntry } from "../../shared/model-requirements";
+import type { SessionPermissionRule } from "../../shared/question-denied-session-permission";
 export type BackgroundTaskStatus = "pending" | "running" | "completed" | "error" | "cancelled" | "interrupt";
 export interface TaskProgress {
     toolCalls: number;
@@ -10,11 +11,13 @@ export interface TaskProgress {
 export interface BackgroundTask {
     id: string;
     sessionID?: string;
+    rootSessionID?: string;
     parentSessionID: string;
     parentMessageID: string;
     description: string;
     prompt: string;
     agent: string;
+    spawnDepth?: number;
     status: BackgroundTaskStatus;
     queuedAt?: Date;
     startedAt?: Date;
@@ -75,6 +78,7 @@ export interface LaunchInput {
     skills?: string[];
     skillContent?: string;
     category?: string;
+    sessionPermission?: SessionPermissionRule[];
 }
 export interface ResumeInput {
     sessionId: string;

package/dist/features/claude-code-agent-loader/claude-model-mapper.d.ts

@@ -0,0 +1,4 @@
+export declare function mapClaudeModelToOpenCode(model: string | undefined): {
+    providerID: string;
+    modelID: string;
+} | undefined;

package/dist/features/claude-code-agent-loader/loader.d.ts

@@ -1,3 +1,3 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-export declare function loadUserAgents(): Record<string, AgentConfig>;
-export declare function loadProjectAgents(directory?: string): Record<string, AgentConfig>;
+import type { ClaudeCodeAgentConfig } from "./types";
+export declare function loadUserAgents(): Record<string, ClaudeCodeAgentConfig>;
+export declare function loadProjectAgents(directory?: string): Record<string, ClaudeCodeAgentConfig>;

package/dist/features/claude-code-agent-loader/types.d.ts

@@ -1,14 +1,21 @@
 import type { AgentConfig } from "@opencode-ai/sdk";
 export type AgentScope = "user" | "project";
+export type ClaudeCodeAgentConfig = Omit<AgentConfig, "model"> & {
+    model?: string | {
+        providerID: string;
+        modelID: string;
+    };
+};
 export interface AgentFrontmatter {
     name?: string;
     description?: string;
     model?: string;
     tools?: string;
+    mode?: "subagent" | "primary" | "all";
 }
 export interface LoadedAgent {
     name: string;
     path: string;
-    config: AgentConfig;
+    config: ClaudeCodeAgentConfig;
     scope: AgentScope;
 }

package/dist/features/claude-code-plugin-loader/agent-loader.d.ts

@@ -1,3 +1,3 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
+import type { ClaudeCodeAgentConfig } from "../claude-code-agent-loader/types";
 import type { LoadedPlugin } from "./types";
-export declare function loadPluginAgents(plugins: LoadedPlugin[]): Record<string, AgentConfig>;
+export declare function loadPluginAgents(plugins: LoadedPlugin[]): Record<string, ClaudeCodeAgentConfig>;

package/dist/features/claude-code-plugin-loader/loader.d.ts

@@ -1,6 +1,6 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
 import type { CommandDefinition } from "../claude-code-command-loader/types";
 import type { McpServerConfig } from "../claude-code-mcp-loader/types";
+import type { ClaudeCodeAgentConfig } from "../claude-code-agent-loader/types";
 import type { HooksConfig, LoadedPlugin, PluginLoadError, PluginLoaderOptions } from "./types";
 export { discoverInstalledPlugins } from "./discovery";
 export { loadPluginCommands } from "./command-loader";
@@ -11,7 +11,7 @@ export { loadPluginHooksConfigs } from "./hook-loader";
 export interface PluginComponentsResult {
     commands: Record<string, CommandDefinition>;
     skills: Record<string, CommandDefinition>;
-    agents: Record<string, AgentConfig>;
+    agents: Record<string, ClaudeCodeAgentConfig>;
     mcpServers: Record<string, McpServerConfig>;
     hooksConfigs: HooksConfig[];
     plugins: LoadedPlugin[];

package/dist/features/claude-code-plugin-loader/types.d.ts

@@ -186,7 +186,7 @@ export interface ClaudeSettings {
  */
 export interface PluginLoaderOptions {
     /**
-     * Override enabled plugins from oh-my-opencode config.
+     * Override enabled plugins from openagent-labforge config.
      * Key format: "pluginName@marketplace" (e.g., "shell-scripting@claude-code-workflows")
      * Value: true = enabled, false = disabled
      *

package/dist/features/opencode-skill-loader/git-master-template-injection.d.ts

@@ -1,2 +1,2 @@
-import type { GitMasterConfig } from "../../config/schema";
+import { type GitMasterConfig } from "../../config/schema";
 export declare function injectGitMasterConfig(template: string, config?: GitMasterConfig): string;

package/dist/features/skill-mcp-manager/types.d.ts

@@ -41,11 +41,15 @@ export interface ProcessCleanupHandler {
 export interface SkillMcpManagerState {
     clients: Map<string, ManagedClient>;
     pendingConnections: Map<string, Promise<Client>>;
+    disconnectedSessions: Map<string, number>;
     authProviders: Map<string, McpOAuthProvider>;
     cleanupRegistered: boolean;
     cleanupInterval: ReturnType<typeof setInterval> | null;
     cleanupHandlers: ProcessCleanupHandler[];
     idleTimeoutMs: number;
+    shutdownGeneration: number;
+    inFlightConnections: Map<string, number>;
+    disposed: boolean;
 }
 export interface SkillMcpClientConnectionParams {
     state: SkillMcpManagerState;

package/dist/features/tmux-subagent/index.d.ts

@@ -10,6 +10,7 @@ export * from "./session-status-parser";
 export * from "./session-message-count";
 export * from "./session-ready-waiter";
 export * from "./types";
+export * from "./pane-state-parser";
 export * from "./pane-state-querier";
 export * from "./decision-engine";
 export * from "./action-executor";

package/dist/features/tmux-subagent/manager.d.ts

@@ -45,6 +45,11 @@ export declare class TmuxSessionManager {
     private isEnabled;
     private getCapacityConfig;
     private getSessionMappings;
+    private removeTrackedSession;
+    private markSessionClosePending;
+    private queryWindowStateSafely;
+    private tryCloseTrackedSession;
+    private retryPendingCloses;
     private enqueueDeferredSession;
     private removeDeferredSession;
     private startDeferredAttachLoop;

package/dist/features/tmux-subagent/pane-state-parser.d.ts

@@ -0,0 +1,8 @@
+import type { TmuxPaneInfo } from "./types";
+type ParsedPaneState = {
+    windowWidth: number;
+    windowHeight: number;
+    panes: TmuxPaneInfo[];
+};
+export declare function parsePaneStateOutput(stdout: string): ParsedPaneState | null;
+export {};

package/dist/features/tmux-subagent/tracked-session-state.d.ts

@@ -0,0 +1,8 @@
+import type { TrackedSession } from "./types";
+export declare function createTrackedSession(params: {
+    sessionId: string;
+    paneId: string;
+    description: string;
+    now?: Date;
+}): TrackedSession;
+export declare function markTrackedSessionClosePending(tracked: TrackedSession): TrackedSession;

package/dist/features/tmux-subagent/types.d.ts

@@ -4,6 +4,8 @@ export interface TrackedSession {
     description: string;
     createdAt: Date;
     lastSeenAt: Date;
+    closePending: boolean;
+    closeRetryCount: number;
     lastMessageCount?: number;
     stableIdlePolls?: number;
 }

package/dist/hooks/atlas/boulder-session-lineage.d.ts

@@ -0,0 +1,6 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function isSessionInBoulderLineage(input: {
+    client: PluginInput["client"];
+    sessionID: string;
+    boulderSessionIDs: string[];
+}): Promise<boolean>;

package/dist/hooks/atlas/final-wave-approval-gate.d.ts

@@ -0,0 +1,4 @@
+export declare function shouldPauseForFinalWaveApproval(input: {
+    planPath: string;
+    taskOutput: string;
+}): boolean;

package/dist/hooks/atlas/idle-event.d.ts

@@ -0,0 +1,8 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { AtlasHookOptions, SessionState } from "./types";
+export declare function handleAtlasSessionIdle(input: {
+    ctx: PluginInput;
+    options?: AtlasHookOptions;
+    getState: (sessionID: string) => SessionState;
+    sessionID: string;
+}): Promise<void>;

package/dist/hooks/atlas/resolve-active-boulder-session.d.ts

@@ -0,0 +1,11 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { BoulderState, PlanProgress } from "../../features/boulder-state";
+export declare function resolveActiveBoulderSession(input: {
+    client: PluginInput["client"];
+    directory: string;
+    sessionID: string;
+}): Promise<{
+    boulderState: BoulderState;
+    progress: PlanProgress;
+    appendedSession: boolean;
+} | null>;

package/dist/hooks/atlas/tool-execute-after.d.ts

@@ -1,7 +1,9 @@
 import type { PluginInput } from "@opencode-ai/plugin";
+import type { SessionState } from "./types";
 import type { ToolExecuteAfterInput, ToolExecuteAfterOutput } from "./types";
 export declare function createToolExecuteAfterHandler(input: {
     ctx: PluginInput;
     pendingFilePaths: Map<string, string>;
     autoCommit: boolean;
+    getState: (sessionID: string) => SessionState;
 }): (toolInput: ToolExecuteAfterInput, toolOutput: ToolExecuteAfterOutput) => Promise<void>;