@wolfx/oh-my-openagent 3.17.14 → 4.0.0

package/dist/features/team-mode/types.d.ts

@@ -62,12 +62,12 @@ export declare const MemberSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     subagent_type: z.ZodString;
     prompt: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>], "kind">;
-export declare const TeamSpecSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
+export declare const TeamSpecSchema: z.ZodPipe<z.ZodObject<{
+    version: z.ZodDefault<z.ZodLiteral<1>>;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
-    createdAt: z.ZodNumber;
-    leadAgentId: z.ZodString;
+    createdAt: z.ZodDefault<z.ZodNumber>;
+    leadAgentId: z.ZodOptional<z.ZodString>;
     teamAllowedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
     sessionPermission: z.ZodOptional<z.ZodString>;
     members: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -99,7 +99,69 @@ export declare const TeamSpecSchema: z.ZodObject<{
         subagent_type: z.ZodString;
         prompt: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>], "kind">>;
-}, z.core.$strip>;
+}, z.core.$strip>, z.ZodTransform<{
+    version: 1;
+    name: string;
+    createdAt: number;
+    members: ({
+        name: string;
+        backendType: "tmux" | "in-process";
+        isActive: boolean;
+        kind: "category";
+        category: string;
+        prompt: string;
+        cwd?: string | undefined;
+        worktreePath?: string | undefined;
+        subscriptions?: string[] | undefined;
+        color?: string | undefined;
+    } | {
+        name: string;
+        backendType: "tmux" | "in-process";
+        isActive: boolean;
+        kind: "subagent_type";
+        subagent_type: string;
+        cwd?: string | undefined;
+        worktreePath?: string | undefined;
+        subscriptions?: string[] | undefined;
+        color?: string | undefined;
+        prompt?: string | undefined;
+    })[];
+    description?: string | undefined;
+    leadAgentId?: string | undefined;
+    teamAllowedPaths?: string[] | undefined;
+    sessionPermission?: string | undefined;
+}, {
+    version: 1;
+    name: string;
+    createdAt: number;
+    members: ({
+        name: string;
+        backendType: "tmux" | "in-process";
+        isActive: boolean;
+        kind: "category";
+        category: string;
+        prompt: string;
+        cwd?: string | undefined;
+        worktreePath?: string | undefined;
+        subscriptions?: string[] | undefined;
+        color?: string | undefined;
+    } | {
+        name: string;
+        backendType: "tmux" | "in-process";
+        isActive: boolean;
+        kind: "subagent_type";
+        subagent_type: string;
+        cwd?: string | undefined;
+        worktreePath?: string | undefined;
+        subscriptions?: string[] | undefined;
+        color?: string | undefined;
+        prompt?: string | undefined;
+    })[];
+    description?: string | undefined;
+    leadAgentId?: string | undefined;
+    teamAllowedPaths?: string[] | undefined;
+    sessionPermission?: string | undefined;
+}>>;
 export declare const MessageSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     messageId: z.ZodString;
@@ -143,6 +205,46 @@ export declare const TaskSchema: z.ZodObject<{
     updatedAt: z.ZodNumber;
     claimedAt: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
+declare const RuntimeStateMemberSchema: z.ZodObject<{
+    name: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    tmuxPaneId: z.ZodOptional<z.ZodString>;
+    tmuxGridPaneId: z.ZodOptional<z.ZodString>;
+    agentType: z.ZodEnum<{
+        leader: "leader";
+        "general-purpose": "general-purpose";
+    }>;
+    subagent_type: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodObject<{
+        providerID: z.ZodString;
+        modelID: z.ZodString;
+        variant: z.ZodOptional<z.ZodString>;
+        reasoningEffort: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+        thinking: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<{
+                enabled: "enabled";
+                disabled: "disabled";
+            }>;
+            budgetTokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        completed: "completed";
+        running: "running";
+        idle: "idle";
+        shutdown_approved: "shutdown_approved";
+        errored: "errored";
+    }>;
+    color: z.ZodOptional<z.ZodString>;
+    worktreePath: z.ZodOptional<z.ZodString>;
+    lastInjectedTurnMarker: z.ZodOptional<z.ZodString>;
+    pendingInjectedMessageIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
 export declare const RuntimeStateSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     teamRunId: z.ZodString;
@@ -162,14 +264,39 @@ export declare const RuntimeStateSchema: z.ZodObject<{
         orphaned: "orphaned";
     }>;
     leadSessionId: z.ZodOptional<z.ZodString>;
+    tmuxLayout: z.ZodOptional<z.ZodObject<{
+        ownedSession: z.ZodBoolean;
+        targetSessionId: z.ZodString;
+        focusWindowId: z.ZodOptional<z.ZodString>;
+        gridWindowId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
     members: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         sessionId: z.ZodOptional<z.ZodString>;
         tmuxPaneId: z.ZodOptional<z.ZodString>;
+        tmuxGridPaneId: z.ZodOptional<z.ZodString>;
         agentType: z.ZodEnum<{
             leader: "leader";
             "general-purpose": "general-purpose";
         }>;
+        subagent_type: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodObject<{
+            providerID: z.ZodString;
+            modelID: z.ZodString;
+            variant: z.ZodOptional<z.ZodString>;
+            reasoningEffort: z.ZodOptional<z.ZodString>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            thinking: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<{
+                    enabled: "enabled";
+                    disabled: "disabled";
+                }>;
+                budgetTokens: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>>;
         status: z.ZodEnum<{
             pending: "pending";
             completed: "completed";
@@ -185,9 +312,11 @@ export declare const RuntimeStateSchema: z.ZodObject<{
     }, z.core.$strict>>;
     shutdownRequests: z.ZodDefault<z.ZodArray<z.ZodObject<{
         memberId: z.ZodString;
+        requesterName: z.ZodString;
         requestedAt: z.ZodNumber;
         approvedAt: z.ZodOptional<z.ZodNumber>;
         rejectedReason: z.ZodOptional<z.ZodString>;
+        rejectedAt: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>>;
     bounds: z.ZodObject<{
         maxMembers: z.ZodDefault<z.ZodNumber>;
@@ -201,10 +330,13 @@ export declare const AGENT_ELIGIBILITY_REGISTRY: Readonly<Record<string, {
     verdict: "eligible" | "conditional" | "hard-reject";
     rejectionMessage?: string;
 }>>;
+export declare function parseMember(input: unknown): Member;
 export type TeamSpec = z.infer<typeof TeamSpecSchema>;
 export type Member = z.infer<typeof MemberSchema>;
 export type CategoryMember = z.infer<typeof CategoryMemberSchema>;
 export type SubagentMember = z.infer<typeof SubagentMemberSchema>;
 export type Message = z.infer<typeof MessageSchema>;
 export type Task = z.infer<typeof TaskSchema>;
+export type RuntimeStateMember = z.infer<typeof RuntimeStateMemberSchema>;
 export type RuntimeState = z.infer<typeof RuntimeStateSchema>;
+export {};

package/dist/features/tmux-subagent/action-executor-core.d.ts

@@ -8,6 +8,7 @@ export interface ActionResult {
 }
 export interface ExecuteContext {
     config: TmuxConfig;
+    directory: string;
     serverUrl: string;
     windowState: WindowState;
 }

package/dist/features/tmux-subagent/action-executor.d.ts

@@ -12,6 +12,7 @@ export interface ExecuteActionsResult {
 }
 export interface ExecuteContext {
     config: TmuxConfig;
+    directory: string;
     serverUrl: string;
     windowState: WindowState;
     sourcePaneId?: string;

package/dist/features/tmux-subagent/attachable-session-status.d.ts

@@ -0,0 +1,4 @@
+declare const ATTACHABLE_SESSION_STATUSES: readonly ["idle", "running"];
+export type AttachableSessionStatus = (typeof ATTACHABLE_SESSION_STATUSES)[number];
+export declare function isAttachableSessionStatus(status: string | undefined): status is AttachableSessionStatus;
+export {};

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

@@ -1,5 +1,8 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import type { TmuxConfig } from "../../config/schema";
+import type { WindowState } from "./types";
+import * as sharedModule from "../../shared";
+type OpencodeClient = PluginInput["client"];
 interface SessionCreatedEvent {
     type: string;
     properties?: {
@@ -13,14 +16,24 @@ interface SessionCreatedEvent {
 export interface TmuxUtilDeps {
     isInsideTmux: () => boolean;
     getCurrentPaneId: () => string | undefined;
+    queryWindowState: (paneId: string) => Promise<WindowState | null>;
+    waitForSessionReady: (params: {
+        client: OpencodeClient;
+        sessionId: string;
+    }) => Promise<boolean>;
+    log: typeof sharedModule.log;
 }
 export declare class TmuxSessionManager {
     private client;
     private tmuxConfig;
+    private projectDirectory;
     private serverUrl;
     private sourcePaneId;
     private sessions;
     private pendingSessions;
+    private failedReadinessSessions;
+    private closedByPolling;
+    private failedReadinessSweepInterval?;
     private spawnQueue;
     private deferredSessions;
     private deferredQueue;
@@ -34,7 +47,7 @@ export declare class TmuxSessionManager {
     private isolatedContainerNullStateCount;
     private staleSweepCompleted;
     private staleSweepInProgress;
-    constructor(ctx: PluginInput, tmuxConfig: TmuxConfig, deps?: TmuxUtilDeps);
+    constructor(ctx: PluginInput, tmuxConfig: TmuxConfig, deps?: Partial<TmuxUtilDeps>);
     private isEnabled;
     private isIsolated;
     private getEffectiveSourcePaneId;
@@ -42,11 +55,14 @@ export declare class TmuxSessionManager {
     private getCapacityConfig;
     private getSessionMappings;
     getTrackedPaneId(sessionId: string): string | undefined;
+    getServerUrl(): string;
     private removeTrackedSession;
     private reassignIsolatedContainerAnchor;
     private cleanupIsolatedContainerAfterSessionDeletion;
     private markSessionClosePending;
     private queryWindowStateSafely;
+    private windowStateContainsPane;
+    private finalizeForceRemoveCandidate;
     private closeTrackedSessionPane;
     private finalizeTrackedSessionClose;
     private closeTrackedSession;
@@ -55,15 +71,28 @@ export declare class TmuxSessionManager {
     private removeDeferredSession;
     private startDeferredAttachLoop;
     private stopDeferredAttachLoop;
+    private beginPendingSession;
+    private ensureSessionReadyBeforeSpawn;
+    private getSessionStatusType;
+    private rememberFailedReadinessSession;
+    private clearFailedReadinessSession;
+    private startFailedReadinessSweep;
+    private stopFailedReadinessSweep;
+    private isFailedReadinessSessionExpired;
+    private sweepExpiredFailedReadinessSessions;
+    private getFailedReadinessSession;
+    private spawnPendingSession;
+    private getEventSessionId;
+    private retryFailedReadinessSession;
     private tryAttachDeferredSession;
-    private logSessionReadinessInBackground;
-    private waitForSessionReady;
     onSessionCreated(event: SessionCreatedEvent): Promise<void>;
     private enqueueSpawn;
     onSessionDeleted(event: {
         sessionID: string;
     }): Promise<void>;
     private closeSessionById;
+    private closeSessionFromPolling;
+    private shouldSkipRespawnAfterPollingClose;
     onEvent(event: {
         type: string;
         properties?: Record<string, unknown>;

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

@@ -1,2 +1,12 @@
 import type { WindowState } from "./types";
+import { getTmuxPath } from "../../tools/interactive-bash/tmux-path-resolver";
+import { log } from "../../shared";
+import type { TmuxCommandResult } from "../../shared/tmux";
+type QueryWindowStateDeps = {
+    getTmuxPath: typeof getTmuxPath;
+    runTmuxCommand: (tmuxPath: string, args: string[]) => Promise<TmuxCommandResult>;
+    log: typeof log;
+};
+export declare function queryWindowStateWithDeps(sourcePaneId: string, deps: QueryWindowStateDeps): Promise<WindowState | null>;
 export declare function queryWindowState(sourcePaneId: string): Promise<WindowState | null>;
+export {};

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

@@ -12,6 +12,7 @@ export interface SessionPollingController {
 export declare function createSessionPollingController(params: {
     client: OpencodeClient;
     tmuxConfig: TmuxConfig;
+    directory: string;
     serverUrl: string;
     sourcePaneId: string | undefined;
     sessions: Map<string, TrackedSession>;

package/dist/hooks/atlas/atlas-hook.d.ts

@@ -15,5 +15,5 @@ export declare function createAtlasHook(ctx: PluginInput, options?: AtlasHookOpt
         args: Record<string, unknown>;
         message?: string;
     }) => Promise<void>;
-    "tool.execute.after": (toolInput: import("./types").ToolExecuteAfterInput, toolOutput: import("./types").ToolExecuteAfterOutput) => Promise<void>;
+    "tool.execute.after": (toolInput: import("./types").ToolExecuteAfterInput, toolOutput: import("./types").ToolExecuteAfterOutput | undefined) => Promise<void>;
 };

package/dist/hooks/atlas/boulder-continuation-injector.d.ts

@@ -1,6 +1,5 @@
 import type { PluginInput } from "@opencode-ai/plugin";
-import type { BackgroundManager } from "../../features/background-agent";
-import type { SessionState } from "./types";
+import type { BackgroundTaskStatusProvider, SessionState } from "./types";
 export type BoulderContinuationResult = "injected" | "skipped_background_tasks" | "skipped_agent_unavailable" | "failed";
 export declare function injectBoulderContinuation(input: {
     ctx: PluginInput;
@@ -12,6 +11,6 @@ export declare function injectBoulderContinuation(input: {
     worktreePath?: string;
     preferredTaskSessionId?: string;
     preferredTaskTitle?: string;
-    backgroundManager?: BackgroundManager;
+    backgroundManager?: BackgroundTaskStatusProvider;
     sessionState: SessionState;
 }): Promise<BoulderContinuationResult>;

package/dist/hooks/atlas/recent-model-resolver.d.ts

@@ -1,9 +1,17 @@
 import type { PluginInput } from "@opencode-ai/plugin";
+import { findNearestMessageWithFields, findNearestMessageWithFieldsFromSDK } from "../../features/hook-message-injector";
+import { getMessageDir, isSqliteBackend } from "../../shared";
 import type { ModelInfo } from "./types";
 type PromptContext = {
     model?: ModelInfo;
     tools?: Record<string, boolean>;
 };
-export declare function resolveRecentPromptContextForSession(ctx: PluginInput, sessionID: string): Promise<PromptContext>;
+type RecentPromptContextDeps = {
+    isSqliteBackend: typeof isSqliteBackend;
+    getMessageDir: typeof getMessageDir;
+    findNearestMessageWithFields: typeof findNearestMessageWithFields;
+    findNearestMessageWithFieldsFromSDK: typeof findNearestMessageWithFieldsFromSDK;
+};
+export declare function resolveRecentPromptContextForSession(ctx: PluginInput, sessionID: string, deps?: RecentPromptContextDeps): Promise<PromptContext>;
 export declare function resolveRecentModelForSession(ctx: PluginInput, sessionID: string): Promise<ModelInfo | undefined>;
 export {};

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

@@ -7,4 +7,5 @@ export declare function createToolExecuteAfterHandler(input: {
     pendingTaskRefs: Map<string, PendingTaskRef>;
     autoCommit: boolean;
     getState: (sessionID: string) => SessionState;
-}): (toolInput: ToolExecuteAfterInput, toolOutput: ToolExecuteAfterOutput) => Promise<void>;
+    isCallerOrchestrator?: (sessionID: string | undefined) => Promise<boolean>;
+}): (toolInput: ToolExecuteAfterInput, toolOutput: ToolExecuteAfterOutput | undefined) => Promise<void>;

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

@@ -4,6 +4,7 @@ export declare function createToolExecuteBeforeHandler(input: {
     ctx: PluginInput;
     pendingFilePaths: Map<string, string>;
     pendingTaskRefs: Map<string, PendingTaskRef>;
+    isCallerOrchestrator?: (sessionID: string | undefined) => Promise<boolean>;
 }): (toolInput: {
     tool: string;
     sessionID?: string;

package/dist/hooks/atlas/types.d.ts

@@ -1,15 +1,20 @@
 import type { AgentOverrides } from "../../config";
-import type { BackgroundManager } from "../../features/background-agent";
 import type { TopLevelTaskRef } from "../../features/boulder-state";
 export type ModelInfo = {
     providerID: string;
     modelID: string;
     variant?: string;
 };
+export interface BackgroundTaskStatusProvider {
+    getTasksByParentSession: (sessionID: string) => Array<{
+        status: string;
+    }>;
+}
 export interface AtlasHookOptions {
     directory: string;
-    backgroundManager?: BackgroundManager;
+    backgroundManager?: BackgroundTaskStatusProvider;
     isContinuationStopped?: (sessionID: string) => boolean;
+    isCallerOrchestrator?: (sessionID: string | undefined) => Promise<boolean>;
     agentOverrides?: AgentOverrides;
     /** Enable auto-commit after each atomic task completion (default: true) */
     autoCommit?: boolean;
@@ -38,6 +43,7 @@ export type PendingTaskRef = {
 };
 export interface SessionState {
     lastEventWasAbortError?: boolean;
+    skipNextIdleAfterRuntimeErrorRetry?: boolean;
     lastContinuationInjectedAt?: number;
     isInjectingContinuation?: boolean;
     promptFailureCount: number;

package/dist/hooks/index.d.ts

@@ -23,6 +23,8 @@ export { createKeywordDetectorHook } from "./keyword-detector";
 export { createNonInteractiveEnvHook } from "./non-interactive-env";
 export { createInteractiveBashSessionHook } from "./interactive-bash-session";
 export { createThinkingBlockValidatorHook } from "./thinking-block-validator";
+export { createTeamMailboxInjector } from "./team-mailbox-injector";
+export { createTeamModeStatusInjector } from "./team-mode-status-injector";
 export { createToolPairValidatorHook } from "./tool-pair-validator";
 export { createCategorySkillReminderHook } from "./category-skill-reminder";
 export { createRalphLoopHook, type RalphLoopHook } from "./ralph-loop";
@@ -35,6 +37,7 @@ export { createSisyphusJuniorNotepadHook } from "./sisyphus-junior-notepad";
 export { createTaskResumeInfoHook } from "./task-resume-info";
 export { createStartWorkHook } from "./start-work";
 export { createAtlasHook } from "./atlas";
+export { createTeamToolGating } from "./team-tool-gating";
 export { createDelegateTaskRetryHook } from "./delegate-task-retry";
 export { createQuestionLabelTruncatorHook } from "./question-label-truncator";
 export { createStopContinuationGuardHook, type StopContinuationGuard } from "./stop-continuation-guard";

package/dist/hooks/keyword-detector/constants.d.ts

@@ -3,7 +3,13 @@ export declare const INLINE_CODE_PATTERN: RegExp;
 export { isPlannerAgent, isNonOmoAgent, getUltraworkMessage } from "./ultrawork";
 export { SEARCH_PATTERN, SEARCH_MESSAGE } from "./search";
 export { ANALYZE_PATTERN, ANALYZE_MESSAGE } from "./analyze";
+export { TEAM_PATTERN, TEAM_MESSAGE } from "./team";
+export { HYPERPLAN_PATTERN, HYPERPLAN_MESSAGE } from "./hyperplan";
+import type { KeywordType } from "../../config/schema/keyword-detector";
+export declare const HYPERPLAN_ULTRAWORK_PATTERN: RegExp;
+export declare function getHyperplanUltraworkMessage(agentName?: string, modelID?: string): string;
 export type KeywordDetector = {
+    type: KeywordType;
     pattern: RegExp;
     message: string | ((agentName?: string, modelID?: string) => string);
 };

package/dist/hooks/keyword-detector/detector.d.ts

@@ -1,10 +1,12 @@
+import type { KeywordType } from "../../config/schema/keyword-detector";
 export interface DetectedKeyword {
-    type: "ultrawork" | "search" | "analyze";
+    type: KeywordType;
     message: string;
 }
 export declare function removeCodeBlocks(text: string): string;
-export declare function detectKeywords(text: string, agentName?: string, modelID?: string): string[];
-export declare function detectKeywordsWithType(text: string, agentName?: string, modelID?: string): DetectedKeyword[];
+export declare function looksLikeSlashCommand(text: string): boolean;
+export declare function detectKeywords(text: string, agentName?: string, modelID?: string, disabledKeywords?: ReadonlyArray<KeywordType>): string[];
+export declare function detectKeywordsWithType(text: string, agentName?: string, modelID?: string, disabledKeywords?: ReadonlyArray<KeywordType>): DetectedKeyword[];
 export declare function extractPromptText(parts: Array<{
     type: string;
     text?: string;

package/dist/hooks/keyword-detector/hook.d.ts

@@ -1,7 +1,8 @@
 import type { PluginInput } from "@opencode-ai/plugin";
+import type { KeywordDetectorConfig } from "../../config/schema/keyword-detector";
 import type { ContextCollector } from "../../features/context-injector";
 import type { RalphLoopHook } from "../ralph-loop";
-export declare function createKeywordDetectorHook(ctx: PluginInput, _collector?: ContextCollector, _ralphLoop?: Pick<RalphLoopHook, "startLoop">): {
+export declare function createKeywordDetectorHook(ctx: PluginInput, _collector?: ContextCollector, _ralphLoop?: Pick<RalphLoopHook, "startLoop">, config?: KeywordDetectorConfig): {
     "chat.message": (input: {
         sessionID: string;
         agent?: string;

package/dist/hooks/keyword-detector/hyperplan/default.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Hyperplan keyword detector.
+ *
+ * Triggers when the user wants adversarial multi-agent planning via team-mode.
+ *
+ * Triggers (case-insensitive, word-bounded):
+ * - English: hyperplan, hpp
+ *
+ * The detector injects a thin wrapper that loads the `hyperplan` skill, which
+ * carries the full orchestration instructions for the 5-member adversarial team.
+ */
+export declare const HYPERPLAN_PATTERN: RegExp;
+export declare const HYPERPLAN_MESSAGE = "<hyperplan-mode>\n**MANDATORY**: Say \"HYPERPLAN MODE ENABLED!\" as your first response, exactly once.\n\nThe user invoked **hyperplan mode** \u2014 adversarial multi-agent planning via team-mode.\n\nLOAD THE HYPERPLAN SKILL IMMEDIATELY:\n\n```\nskill(name=\"hyperplan\")\n```\n\nAfter loading, follow the skill's full workflow EXACTLY:\n1. Acknowledge and capture the planning request\n2. Spawn the adversarial team via `team_create` with category members `unspecified-low`, `unspecified-high`, `ultrabrain`, and `artistry`; include `deep` only if the category is enabled\n3. Round 1 \u2014 Independent analysis (each member produces findings)\n4. Round 2 \u2014 Cross-attack (each member ruthlessly attacks the other 4's findings)\n5. Round 3 \u2014 Defend, refine, or concede\n6. Distill defensible insights into a structured bundle (Lead does NOT write the plan)\n7. MANDATORY: hand the bundle to the `plan` agent via `task(subagent_type=\"plan\", ...)` \u2014 the plan agent owns sequencing, parallelization, and verification gates\n8. Present the plan agent's output verbatim with provenance line, then clean up the team\n\nDo NOT improvise. Do NOT skip rounds. Do NOT write the plan yourself in step 6 \u2014 the handoff to the plan agent in step 7 is non-negotiable. Be the lead orchestrator and let the adversarial members do the cross-critique.\n\nIf team-mode is unavailable (`team_*` tools missing), instruct the user to set `team_mode.enabled: true` in `~/.config/opencode/oh-my-opencode.jsonc` and restart opencode.\n</hyperplan-mode>";

package/dist/hooks/keyword-detector/hyperplan/index.d.ts

@@ -0,0 +1 @@
+export { HYPERPLAN_PATTERN, HYPERPLAN_MESSAGE } from "./default";

package/dist/hooks/keyword-detector/team/default.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Team mode keyword detector.
+ *
+ * Triggers when the user explicitly invokes team-mode work:
+ * - English: team mode, team-mode, team_mode, teammode (case-insensitive)
+ * - Korean: 팀 모드, 팀모드, 팀으로
+ *
+ * The Korean variants use a negative lookbehind on Hangul syllables (가-힣)
+ * to prevent false positives like "스팀으로" matching "팀으로", or
+ * "스팀모드" matching "팀모드".
+ */
+export declare const TEAM_PATTERN: RegExp;
+export declare const TEAM_MESSAGE = "[team-mode]\nTeam mode reference detected. If user wants team-mode work, MUST orchestrate via team_* tools (team_create -> team_task_create + team_send_message). NEVER substitute with delegate_task - it is not equivalent. If team_* tools are unavailable (team_mode disabled in config), instruct user to set team_mode.enabled=true and restart opencode.";

package/dist/hooks/keyword-detector/team/index.d.ts

@@ -0,0 +1 @@
+export { TEAM_PATTERN, TEAM_MESSAGE } from "./default";

package/dist/hooks/session-recovery/recover-tool-result-missing.d.ts

@@ -1,5 +1,5 @@
 import type { createOpencodeClient } from "@opencode-ai/sdk";
-import type { MessageData } from "./types";
+import type { MessageData, ResumeConfig } from "./types";
 type Client = ReturnType<typeof createOpencodeClient>;
-export declare function recoverToolResultMissing(client: Client, sessionID: string, failedAssistantMsg: MessageData): Promise<boolean>;
+export declare function recoverToolResultMissing(client: Client, sessionID: string, failedAssistantMsg: MessageData, resumeConfig?: ResumeConfig): Promise<boolean>;
 export {};

package/dist/hooks/team-mailbox-injector/hook.d.ts

@@ -0,0 +1,31 @@
+import type { TeamModeConfig } from "../../config/schema/team-mode";
+import type { PluginContext } from "../../plugin/types";
+import type { ExecutorContext } from "../../tools/delegate-task/executor-types";
+type HookContext = ExecutorContext | PluginContext | Record<string, never>;
+type TransformPart = {
+    type: string;
+    text?: string;
+    synthetic?: boolean;
+    [key: string]: unknown;
+};
+type TransformMessageInfo = {
+    role: string;
+    sessionID?: string;
+    [key: string]: unknown;
+};
+type MessageWithParts = {
+    info: TransformMessageInfo;
+    parts: TransformPart[];
+};
+type TeamMailboxInjectorInput = {
+    sessionID?: string;
+    [key: string]: unknown;
+};
+type TeamMailboxInjectorOutput = {
+    messages: MessageWithParts[];
+};
+export type TeamMailboxInjectorHook = {
+    "experimental.chat.messages.transform"?: (input: TeamMailboxInjectorInput, output: TeamMailboxInjectorOutput) => Promise<void>;
+};
+export declare function createTeamMailboxInjector(_ctx: HookContext, config: TeamModeConfig): TeamMailboxInjectorHook;
+export {};

package/dist/hooks/team-mailbox-injector/index.d.ts

@@ -0,0 +1,2 @@
+export { createTeamMailboxInjector } from "./hook";
+export type { TeamMailboxInjectorHook } from "./hook";

package/dist/hooks/team-mode-status-injector/hook.d.ts

@@ -0,0 +1,28 @@
+import type { TeamModeConfig } from "../../config/schema/team-mode";
+type TransformPart = {
+    type: string;
+    text?: string;
+    synthetic?: boolean;
+    [key: string]: unknown;
+};
+type TransformMessageInfo = {
+    role: string;
+    sessionID?: string;
+    [key: string]: unknown;
+};
+type MessageWithParts = {
+    info: TransformMessageInfo;
+    parts: TransformPart[];
+};
+type TeamModeStatusInjectorInput = {
+    sessionID?: string;
+    [key: string]: unknown;
+};
+type TeamModeStatusInjectorOutput = {
+    messages: MessageWithParts[];
+};
+export type TeamModeStatusInjectorHook = {
+    "experimental.chat.messages.transform"?: (input: TeamModeStatusInjectorInput, output: TeamModeStatusInjectorOutput) => Promise<void>;
+};
+export declare function createTeamModeStatusInjector(config: TeamModeConfig): TeamModeStatusInjectorHook;
+export {};

package/dist/hooks/team-mode-status-injector/index.d.ts

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

package/dist/hooks/team-session-events/team-idle-wake-hint.d.ts

@@ -0,0 +1,38 @@
+import type { TeamModeConfig } from "../../config/schema/team-mode";
+type PromptAsyncInput = {
+    path: {
+        id: string;
+    };
+    body: {
+        parts: Array<{
+            type: "text";
+            text: string;
+        }>;
+        agent?: string;
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+        variant?: string;
+    };
+    query: {
+        directory: string;
+    };
+};
+type TeamIdleWakeHintContext = {
+    directory: string;
+    client: {
+        session: {
+            promptAsync?: (input: PromptAsyncInput) => Promise<unknown>;
+        };
+    };
+};
+type HookInput = {
+    event: {
+        type: string;
+        properties?: unknown;
+    };
+};
+export type HookImpl = (input: HookInput) => Promise<void>;
+export declare function createTeamIdleWakeHint(ctx: TeamIdleWakeHintContext, config: TeamModeConfig): HookImpl;
+export {};

package/dist/hooks/team-session-events/team-lead-orphan-handler.d.ts

@@ -0,0 +1,12 @@
+import type { TeamModeConfig } from "../../config/schema/team-mode";
+import type { BackgroundManager } from "../../features/background-agent/manager";
+import type { TmuxSessionManager } from "../../features/tmux-subagent/manager";
+type HookInput = {
+    event: {
+        type: string;
+        properties?: unknown;
+    };
+};
+export type HookImpl = (input: HookInput) => Promise<void>;
+export declare function createTeamLeadOrphanHandler(config: TeamModeConfig, tmuxMgr?: TmuxSessionManager, bgMgr?: BackgroundManager): HookImpl;
+export {};