evil-omo 3.17.0 → 3.17.5

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

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

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

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

package/dist/cli/provider-model-id-transform.d.ts

@@ -1 +1 @@
-export { transformModelForProvider } from "../shared/provider-model-id-transform";
+export declare function transformModelForProvider(provider: string, model: string): string;

package/dist/cli/types.d.ts

@@ -10,6 +10,7 @@ export interface InstallArgs {
     zaiCodingPlan?: BooleanArg;
     kimiForCoding?: BooleanArg;
     opencodeGo?: BooleanArg;
+    vercelAiGateway?: BooleanArg;
     skipAuth?: boolean;
 }
 export interface InstallConfig {
@@ -22,6 +23,7 @@ export interface InstallConfig {
     hasZaiCodingPlan: boolean;
     hasKimiForCoding: boolean;
     hasOpencodeGo: boolean;
+    hasVercelAiGateway: boolean;
 }
 export interface ConfigMergeResult {
     success: boolean;
@@ -40,4 +42,5 @@ export interface DetectedConfig {
     hasZaiCodingPlan: boolean;
     hasKimiForCoding: boolean;
     hasOpencodeGo: boolean;
+    hasVercelAiGateway: boolean;
 }

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

@@ -0,0 +1,3 @@
+import { z } from "zod";
+export declare const AgentDefinitionPathSchema: z.ZodString;
+export declare const AgentDefinitionsConfigSchema: z.ZodOptional<z.ZodArray<z.ZodString>>;

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

@@ -4,7 +4,6 @@ export declare const BackgroundTaskConfigSchema: z.ZodObject<{
     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>;
     taskTtlMs: z.ZodOptional<z.ZodNumber>;

package/dist/config/schema/evil-omo-config.d.ts

@@ -3,9 +3,18 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
     $schema: z.ZodOptional<z.ZodString>;
     new_task_system_enabled: z.ZodOptional<z.ZodBoolean>;
     default_run_agent: z.ZodOptional<z.ZodString>;
+    agent_definitions: z.ZodOptional<z.ZodArray<z.ZodString>>;
     disabled_mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
     disabled_agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    disabled_skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disabled_skills: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        playwright: "playwright";
+        "agent-browser": "agent-browser";
+        "dev-browser": "dev-browser";
+        "frontend-ui-ux": "frontend-ui-ux";
+        "git-master": "git-master";
+        "review-work": "review-work";
+        "ai-slop-remover": "ai-slop-remover";
+    }>>>;
     disabled_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
     disabled_commands: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         "init-deep": "init-deep";
@@ -1987,7 +1996,6 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         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>;
         taskTtlMs: z.ZodOptional<z.ZodNumber>;
@@ -2043,7 +2051,7 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
     babysitting: z.ZodOptional<z.ZodObject<{
         timeout_ms: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
-    git_master: z.ZodOptional<z.ZodObject<{
+    git_master: z.ZodDefault<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>;

package/dist/create-hooks.d.ts

@@ -2,6 +2,7 @@ import type { AvailableSkill } from "./agents/dynamic-agent-prompt-builder";
 import type { HookName, OhMyOpenCodeConfig } from "./config";
 import type { LoadedSkill } from "./features/opencode-skill-loader/types";
 import type { BackgroundManager } from "./features/background-agent";
+import type { ModelFallbackControllerAccessor } from "./hooks/model-fallback";
 import type { PluginContext } from "./plugin/types";
 import type { ModelCacheState } from "./plugin-state";
 export type CreatedHooks = ReturnType<typeof createHooks>;
@@ -22,6 +23,7 @@ export declare function createHooks(args: {
     pluginConfig: OhMyOpenCodeConfig;
     modelCacheState: ModelCacheState;
     backgroundManager: BackgroundManager;
+    modelFallbackControllerAccessor?: ModelFallbackControllerAccessor;
     isHookEnabled: (hookName: HookName) => boolean;
     safeHookEnabled: boolean;
     mergedSkills: LoadedSkill[];

package/dist/create-managers.d.ts

@@ -8,6 +8,7 @@ import { TmuxSessionManager } from "./features/tmux-subagent";
 import { registerManagerForCleanup } from "./features/background-agent/process-cleanup";
 import { createConfigHandler } from "./plugin-handlers";
 import { markServerRunningInProcess } from "./shared/tmux/tmux-utils/server-health";
+import type { ModelFallbackControllerAccessor } from "./hooks/model-fallback";
 type CreateManagersDeps = {
     BackgroundManagerClass: typeof BackgroundManager;
     SkillMcpManagerClass: typeof SkillMcpManager;
@@ -22,6 +23,7 @@ export type Managers = {
     backgroundManager: BackgroundManager;
     skillMcpManager: SkillMcpManager;
     configHandler: ReturnType<typeof createConfigHandler>;
+    modelFallbackControllerAccessor: ModelFallbackControllerAccessor;
 };
 export declare function createManagers(args: {
     ctx: PluginContext;

package/dist/create-tools.d.ts

@@ -4,7 +4,7 @@ import type { BrowserAutomationProvider } from "./config/schema/browser-automati
 import type { LoadedSkill } from "./features/opencode-skill-loader/types";
 import type { PluginContext, ToolsRecord } from "./plugin/types";
 import type { Managers } from "./create-managers";
-export type CreateToolsResult = {
+type CreateToolsResult = {
     filteredTools: ToolsRecord;
     mergedSkills: LoadedSkill[];
     availableSkills: AvailableSkill[];
@@ -16,5 +16,6 @@ export type CreateToolsResult = {
 export declare function createTools(args: {
     ctx: PluginContext;
     pluginConfig: OhMyOpenCodeConfig;
-    managers: Pick<Managers, "backgroundManager" | "tmuxSessionManager" | "skillMcpManager">;
+    managers: Pick<Managers, "backgroundManager" | "tmuxSessionManager" | "skillMcpManager" | "modelFallbackControllerAccessor">;
 }): Promise<CreateToolsResult>;
+export {};

package/dist/evil-omo.schema.json

@@ -14,6 +14,13 @@
     "default_run_agent": {
       "type": "string"
     },
+    "agent_definitions": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "minLength": 1
+      }
+    },
     "disabled_mcps": {
       "type": "array",
       "items": {
@@ -32,7 +39,15 @@
       "type": "array",
       "items": {
         "type": "string",
-        "minLength": 1
+        "enum": [
+          "playwright",
+          "agent-browser",
+          "dev-browser",
+          "frontend-ui-ux",
+          "git-master",
+          "review-work",
+          "ai-slop-remover"
+        ]
       }
     },
     "disabled_hooks": {
@@ -5623,11 +5638,6 @@
           "minimum": 1,
           "maximum": 9007199254740991
         },
-        "maxDescendants": {
-          "type": "integer",
-          "minimum": 1,
-          "maximum": 9007199254740991
-        },
         "staleTimeoutMs": {
           "type": "number",
           "minimum": 60000
@@ -5860,6 +5870,11 @@
       "additionalProperties": false
     },
     "git_master": {
+      "default": {
+        "commit_footer": true,
+        "include_co_authored_by": true,
+        "git_env_prefix": "GIT_MASTER=1"
+      },
       "type": "object",
       "properties": {
         "commit_footer": {
@@ -6058,5 +6073,8 @@
       }
     }
   },
+  "required": [
+    "git_master"
+  ],
   "additionalProperties": false
 }

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

@@ -1,2 +1,4 @@
 export * from "./types";
 export { BackgroundManager, type SubagentSessionCreatedEvent, type OnSubagentSessionCreated } from "./manager";
+export { waitForTaskSessionID } from "./wait-for-task-session";
+export type { WaitForTaskSessionIDOptions } from "./wait-for-task-session";

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

@@ -0,0 +1,4 @@
+type ProcessCleanupEvent = NodeJS.Signals | "beforeExit" | "exit" | "uncaughtException" | "unhandledRejection";
+export declare function getNewListener(signal: ProcessCleanupEvent, existingListeners: Function[]): () => void;
+export declare function flushMicrotasks(): Promise<void>;
+export {};

package/dist/features/background-agent/session-existence.d.ts

@@ -1,3 +1,3 @@
 import type { OpencodeClient } from "./opencode-client";
 export declare const MIN_SESSION_GONE_POLLS = 3;
-export declare function verifySessionExists(client: OpencodeClient, sessionID: string): Promise<boolean>;
+export declare function verifySessionExists(client: OpencodeClient, sessionID: string, directory?: string): Promise<boolean>;

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

@@ -1,23 +1,16 @@
 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 resolveSubagentSpawnContext(client: OpencodeClient, parentSessionID: string, directory?: 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-poller.d.ts

@@ -14,6 +14,7 @@ export type SessionStatusMap = Record<string, {
 export declare function checkAndInterruptStaleTasks(args: {
     tasks: Iterable<BackgroundTask>;
     client: OpencodeClient;
+    directory?: string;
     config: BackgroundTaskConfig | undefined;
     concurrencyManager: ConcurrencyManager;
     notifyParentSession: (task: BackgroundTask) => Promise<void>;

package/dist/features/background-agent/wait-for-task-session.d.ts

@@ -0,0 +1,17 @@
+import type { BackgroundTaskStatus } from "./types";
+type AbortSignalLike = {
+    aborted: boolean;
+};
+interface TaskReader {
+    getTask(taskID: string): {
+        sessionID?: string;
+        status?: BackgroundTaskStatus;
+    } | undefined;
+}
+export interface WaitForTaskSessionIDOptions {
+    timeoutMs?: number;
+    intervalMs?: number;
+    signal?: AbortSignalLike;
+}
+export declare function waitForTaskSessionID(manager: TaskReader, taskID: string, options?: WaitForTaskSessionIDOptions): Promise<string | undefined>;
+export {};

package/dist/features/builtin-commands/commands.d.ts

@@ -1,5 +1,6 @@
 import type { BuiltinCommandName, BuiltinCommands } from "./types";
-export interface LoadBuiltinCommandsOptions {
+interface LoadBuiltinCommandsOptions {
     useRegisteredAgents?: boolean;
 }
 export declare function loadBuiltinCommands(disabledCommands?: BuiltinCommandName[], options?: LoadBuiltinCommandsOptions): BuiltinCommands;
+export {};

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

@@ -0,0 +1,3 @@
+import type { AgentScope, ClaudeCodeAgentConfig, LoadedAgent } from "./types";
+export declare function parseMarkdownAgentFile(filePath: string, scope: AgentScope): LoadedAgent | null;
+export declare function loadAgentDefinitions(paths: string[], scope: AgentScope): Record<string, ClaudeCodeAgentConfig>;

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

@@ -1,2 +1,5 @@
 export * from "./types";
 export * from "./loader";
+export * from "./agent-definitions-loader";
+export * from "./opencode-config-agents-reader";
+export * from "./json-agent-loader";

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

@@ -0,0 +1,2 @@
+import type { AgentScope, LoadedAgent } from "./types";
+export declare function parseJsonAgentFile(filePath: string, scope: AgentScope): LoadedAgent | null;

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

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

package/dist/features/claude-code-agent-loader/opencode-config-agents-reader.d.ts

@@ -0,0 +1,2 @@
+import type { ClaudeCodeAgentConfig } from "./types";
+export declare function readOpencodeConfigAgents(directory: string): Record<string, ClaudeCodeAgentConfig>;

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

@@ -1,5 +1,5 @@
 import type { AgentConfig } from "@opencode-ai/sdk";
-export type AgentScope = "user" | "project";
+export type AgentScope = "user" | "project" | "opencode" | "opencode-project" | "definition-file" | "opencode-config";
 export type ClaudeCodeAgentConfig = Omit<AgentConfig, "model"> & {
     model?: string | {
         providerID: string;
@@ -13,6 +13,14 @@ export interface AgentFrontmatter {
     tools?: string;
     mode?: "subagent" | "primary" | "all";
 }
+export interface AgentJsonDefinition {
+    name: string;
+    description?: string;
+    model?: string;
+    tools?: string | string[];
+    mode?: "subagent" | "primary" | "all";
+    prompt: string;
+}
 export interface LoadedAgent {
     name: string;
     path: string;

package/dist/features/claude-code-command-loader/loader-cache.d.ts

@@ -0,0 +1,6 @@
+import type { CommandDefinition } from "./types";
+export declare function getCommandLoaderCacheKey(directory?: string): Promise<string>;
+export declare function getCachedCommands(cacheKey: string): Promise<Record<string, CommandDefinition>> | undefined;
+export declare function setCachedCommands(cacheKey: string, commands: Promise<Record<string, CommandDefinition>>): void;
+export declare function deleteCachedCommands(cacheKey: string): void;
+export declare function clearCommandLoaderCache(): void;

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

@@ -1,4 +1,6 @@
+import { clearCommandLoaderCache } from "./loader-cache";
 import type { CommandDefinition } from "./types";
+export { clearCommandLoaderCache };
 export declare function loadUserCommands(): Promise<Record<string, CommandDefinition>>;
 export declare function loadProjectCommands(directory?: string): Promise<Record<string, CommandDefinition>>;
 export declare function loadOpencodeGlobalCommands(): Promise<Record<string, CommandDefinition>>;

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

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./team-worktree";

package/dist/features/team-mode/team-layout-tmux/index.d.ts

@@ -0,0 +1 @@
+export { canVisualize, createTeamLayout, removeTeamLayout } from "./layout";

package/dist/features/team-mode/team-layout-tmux/layout.d.ts

@@ -0,0 +1,15 @@
+import type { TmuxSessionManager } from "../../tmux-subagent/manager";
+type TeamLayoutMember = {
+    name: string;
+    sessionId: string;
+    color?: string;
+};
+type TeamLayoutResult = {
+    focusWindowId: string;
+    gridWindowId: string;
+    panesByMember: Record<string, string>;
+};
+export declare function canVisualize(): boolean;
+export declare function createTeamLayout(teamRunId: string, members: Array<TeamLayoutMember>, tmuxMgr: TmuxSessionManager): Promise<TeamLayoutResult | null>;
+export declare function removeTeamLayout(teamRunId: string, tmuxMgr: TmuxSessionManager): Promise<void>;
+export {};

package/dist/features/team-mode/team-worktree/cleanup.d.ts

@@ -0,0 +1,3 @@
+import type { TeamModeConfig } from "./manager";
+export declare function removeWorktree(worktreePath: string): Promise<void>;
+export declare function findOrphanWorktrees(baseDir: string, _config: TeamModeConfig): Promise<string[]>;

package/dist/features/team-mode/team-worktree/index.d.ts

@@ -0,0 +1,2 @@
+export { GitUnavailableError, createWorktree, isGitAvailable, validateWorktreeSpec } from "./manager";
+export { findOrphanWorktrees, removeWorktree } from "./cleanup";

package/dist/features/team-mode/team-worktree/manager.d.ts

@@ -0,0 +1,15 @@
+export type TeamModeConfig = {
+    worktreeBaseDir?: string;
+};
+export declare class GitUnavailableError extends Error {
+    constructor();
+}
+declare function runGit(args: string[], cwd?: string): Promise<{
+    code: number;
+    stderr: string;
+}>;
+export declare function setGitCommandRunnerForTests(runner: typeof runGit): void;
+export declare function isGitAvailable(): Promise<boolean>;
+export declare function validateWorktreeSpec(spec: string): void;
+export declare function createWorktree(repoRoot: string, _teamRunId: string, _memberName: string, worktreePath: string, _config: TeamModeConfig): Promise<string>;
+export {};

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

@@ -0,0 +1,210 @@
+import { z } from "zod";
+export declare const MESSAGE_KINDS: readonly ["message", "shutdown_request", "shutdown_approved", "shutdown_rejected", "announcement"];
+export declare const MEMBER_KINDS: readonly ["category", "subagent_type"];
+export declare const TASK_STATUSES: readonly ["pending", "claimed", "in_progress", "completed", "deleted"];
+export declare const RUNTIME_STATUSES: readonly ["creating", "active", "shutdown_requested", "deleting", "deleted", "failed", "orphaned"];
+export declare const CategoryMemberSchema: z.ZodObject<{
+    name: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    worktreePath: z.ZodOptional<z.ZodString>;
+    subscriptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    backendType: z.ZodDefault<z.ZodEnum<{
+        tmux: "tmux";
+        "in-process": "in-process";
+    }>>;
+    color: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+    kind: z.ZodLiteral<"category">;
+    category: z.ZodString;
+    prompt: z.ZodString;
+}, z.core.$strict>;
+export declare const SubagentMemberSchema: z.ZodObject<{
+    name: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    worktreePath: z.ZodOptional<z.ZodString>;
+    subscriptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    backendType: z.ZodDefault<z.ZodEnum<{
+        tmux: "tmux";
+        "in-process": "in-process";
+    }>>;
+    color: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+    kind: z.ZodLiteral<"subagent_type">;
+    subagent_type: z.ZodString;
+    prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const MemberSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    name: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    worktreePath: z.ZodOptional<z.ZodString>;
+    subscriptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    backendType: z.ZodDefault<z.ZodEnum<{
+        tmux: "tmux";
+        "in-process": "in-process";
+    }>>;
+    color: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+    kind: z.ZodLiteral<"category">;
+    category: z.ZodString;
+    prompt: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    name: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    worktreePath: z.ZodOptional<z.ZodString>;
+    subscriptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    backendType: z.ZodDefault<z.ZodEnum<{
+        tmux: "tmux";
+        "in-process": "in-process";
+    }>>;
+    color: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+    kind: z.ZodLiteral<"subagent_type">;
+    subagent_type: z.ZodString;
+    prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], "kind">;
+export declare const TeamSpecSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+    leadAgentId: z.ZodString;
+    teamAllowedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sessionPermission: z.ZodOptional<z.ZodString>;
+    members: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        name: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        worktreePath: z.ZodOptional<z.ZodString>;
+        subscriptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        backendType: z.ZodDefault<z.ZodEnum<{
+            tmux: "tmux";
+            "in-process": "in-process";
+        }>>;
+        color: z.ZodOptional<z.ZodString>;
+        isActive: z.ZodDefault<z.ZodBoolean>;
+        kind: z.ZodLiteral<"category">;
+        category: z.ZodString;
+        prompt: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        name: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        worktreePath: z.ZodOptional<z.ZodString>;
+        subscriptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        backendType: z.ZodDefault<z.ZodEnum<{
+            tmux: "tmux";
+            "in-process": "in-process";
+        }>>;
+        color: z.ZodOptional<z.ZodString>;
+        isActive: z.ZodDefault<z.ZodBoolean>;
+        kind: z.ZodLiteral<"subagent_type">;
+        subagent_type: z.ZodString;
+        prompt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strip>;
+export declare const MessageSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    messageId: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodString;
+    kind: z.ZodEnum<{
+        message: "message";
+        shutdown_request: "shutdown_request";
+        shutdown_approved: "shutdown_approved";
+        shutdown_rejected: "shutdown_rejected";
+        announcement: "announcement";
+    }>;
+    body: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    references: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    timestamp: z.ZodNumber;
+    correlationId: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const TaskSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    id: z.ZodString;
+    subject: z.ZodString;
+    description: z.ZodString;
+    activeForm: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        in_progress: "in_progress";
+        completed: "completed";
+        deleted: "deleted";
+        claimed: "claimed";
+    }>;
+    owner: z.ZodOptional<z.ZodString>;
+    blocks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    blockedBy: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    claimedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const RuntimeStateSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    teamRunId: z.ZodString;
+    teamName: z.ZodString;
+    specSource: z.ZodEnum<{
+        user: "user";
+        project: "project";
+    }>;
+    createdAt: z.ZodNumber;
+    status: z.ZodEnum<{
+        deleted: "deleted";
+        failed: "failed";
+        active: "active";
+        creating: "creating";
+        shutdown_requested: "shutdown_requested";
+        deleting: "deleting";
+        orphaned: "orphaned";
+    }>;
+    leadSessionId: z.ZodOptional<z.ZodString>;
+    members: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        sessionId: z.ZodOptional<z.ZodString>;
+        tmuxPaneId: z.ZodOptional<z.ZodString>;
+        agentType: z.ZodEnum<{
+            leader: "leader";
+            "general-purpose": "general-purpose";
+        }>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            completed: "completed";
+            running: "running";
+            idle: "idle";
+            errored: "errored";
+            shutdown_approved: "shutdown_approved";
+        }>;
+        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>>;
+    shutdownRequests: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        memberId: z.ZodString;
+        requestedAt: z.ZodNumber;
+        approvedAt: z.ZodOptional<z.ZodNumber>;
+        rejectedReason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    bounds: z.ZodObject<{
+        maxMembers: z.ZodDefault<z.ZodNumber>;
+        maxParallelMembers: z.ZodDefault<z.ZodNumber>;
+        maxMessagesPerRun: z.ZodDefault<z.ZodNumber>;
+        maxWallClockMinutes: z.ZodDefault<z.ZodNumber>;
+        maxMemberTurns: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+export declare const AGENT_ELIGIBILITY_REGISTRY: Readonly<Record<string, {
+    verdict: "eligible" | "conditional" | "hard-reject";
+    rejectionMessage?: string;
+}>>;
+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 RuntimeState = z.infer<typeof RuntimeStateSchema>;

package/dist/features/tmux-subagent/event-handlers.d.ts

@@ -1,6 +1,2 @@
 export { coerceSessionCreatedEvent } from "./session-created-event";
 export type { SessionCreatedEvent } from "./session-created-event";
-export { handleSessionCreated } from "./session-created-handler";
-export type { SessionCreatedHandlerDeps } from "./session-created-handler";
-export { handleSessionDeleted } from "./session-deleted-handler";
-export type { SessionDeletedHandlerDeps } from "./session-deleted-handler";

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

@@ -1,10 +1,7 @@
 export * from "./manager";
 export * from "./event-handlers";
 export * from "./polling";
-export * from "./cleanup";
 export * from "./session-created-event";
-export * from "./session-created-handler";
-export * from "./session-deleted-handler";
 export * from "./polling-constants";
 export * from "./session-status-parser";
 export * from "./session-message-count";