oh-my-opencode-lite 0.1.0

package/dist/cli/install.d.ts

@@ -0,0 +1,3 @@
+import type { InstallArgs, InstallConfig } from './types';
+export declare function createInstallConfig(args: InstallArgs): InstallConfig;
+export declare function install(args: InstallArgs): Promise<number>;

package/dist/cli/model-key-normalization.d.ts

@@ -0,0 +1 @@
+export declare function buildModelKeyAliases(input: string): string[];

package/dist/cli/paths.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Get the OpenCode plugin config directory.
+ *
+ * Resolution order:
+ * 1. OPENCODE_CONFIG_DIR (custom OpenCode directory)
+ * 2. XDG_CONFIG_HOME/opencode
+ * 3. ~/.config/opencode
+ */
+export declare function getConfigDir(): string;
+export declare function getOpenCodeConfigPaths(): string[];
+export declare function getConfigJson(): string;
+export declare function getConfigJsonc(): string;
+export declare function getLiteConfig(): string;
+export declare function getLiteConfigJsonc(): string;
+export declare function getExistingLiteConfigPath(): string;
+export declare function getExistingConfigPath(): string;
+export declare function ensureConfigDir(): void;
+/**
+ * Ensure the directory for OpenCode's main config file exists.
+ */
+export declare function ensureOpenCodeConfigDir(): void;

package/dist/cli/providers.d.ts

@@ -0,0 +1,120 @@
+import type { InstallConfig } from './types';
+export declare const MODEL_MAPPINGS: {
+    readonly openai: {
+        readonly orchestrator: {
+            readonly model: "openai/gpt-5.4";
+        };
+        readonly oracle: {
+            readonly model: "openai/gpt-5.4";
+            readonly variant: "high";
+        };
+        readonly librarian: {
+            readonly model: "openai/gpt-5.4-mini";
+            readonly variant: "low";
+        };
+        readonly explorer: {
+            readonly model: "openai/gpt-5.4-mini";
+            readonly variant: "low";
+        };
+        readonly designer: {
+            readonly model: "openai/gpt-5.4-mini";
+            readonly variant: "medium";
+        };
+        readonly quick: {
+            readonly model: "openai/gpt-5.4-mini";
+            readonly variant: "low";
+        };
+        readonly deep: {
+            readonly model: "openai/gpt-5.4";
+            readonly variant: "high";
+        };
+    };
+    readonly kimi: {
+        readonly orchestrator: {
+            readonly model: "kimi-for-coding/k2p5";
+        };
+        readonly oracle: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "high";
+        };
+        readonly librarian: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "low";
+        };
+        readonly explorer: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "low";
+        };
+        readonly designer: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "medium";
+        };
+        readonly quick: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "low";
+        };
+        readonly deep: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "high";
+        };
+    };
+    readonly copilot: {
+        readonly orchestrator: {
+            readonly model: "github-copilot/claude-opus-4.6";
+        };
+        readonly oracle: {
+            readonly model: "github-copilot/claude-opus-4.6";
+            readonly variant: "high";
+        };
+        readonly librarian: {
+            readonly model: "github-copilot/grok-code-fast-1";
+            readonly variant: "low";
+        };
+        readonly explorer: {
+            readonly model: "github-copilot/grok-code-fast-1";
+            readonly variant: "low";
+        };
+        readonly designer: {
+            readonly model: "github-copilot/gemini-3.1-pro-preview";
+            readonly variant: "medium";
+        };
+        readonly quick: {
+            readonly model: "github-copilot/claude-sonnet-4.6";
+            readonly variant: "low";
+        };
+        readonly deep: {
+            readonly model: "github-copilot/claude-opus-4.6";
+            readonly variant: "high";
+        };
+    };
+    readonly 'zai-plan': {
+        readonly orchestrator: {
+            readonly model: "zai-coding-plan/glm-5";
+        };
+        readonly oracle: {
+            readonly model: "zai-coding-plan/glm-5";
+            readonly variant: "high";
+        };
+        readonly librarian: {
+            readonly model: "zai-coding-plan/glm-5";
+            readonly variant: "low";
+        };
+        readonly explorer: {
+            readonly model: "zai-coding-plan/glm-5";
+            readonly variant: "low";
+        };
+        readonly designer: {
+            readonly model: "zai-coding-plan/glm-5";
+            readonly variant: "medium";
+        };
+        readonly quick: {
+            readonly model: "zai-coding-plan/glm-5";
+            readonly variant: "low";
+        };
+        readonly deep: {
+            readonly model: "zai-coding-plan/glm-5";
+            readonly variant: "high";
+        };
+    };
+};
+export declare function generateLiteConfig(installConfig: InstallConfig): Record<string, unknown>;

package/dist/cli/skill-manifest.d.ts

@@ -0,0 +1,32 @@
+import type { CustomSkill } from './custom-skills';
+export interface SkillManifestEntry {
+    hash: string;
+    installedAt: string;
+}
+export interface SkillManifest {
+    pluginVersion: string;
+    skills: Record<string, SkillManifestEntry>;
+    sharedHash: string;
+}
+export type SkillUpdateReason = 'manifest-missing' | 'version-change' | 'shared-hash-mismatch' | 'new-skill' | 'hash-mismatch' | 'missing-install';
+export interface SkillUpdateEntry {
+    skill: CustomSkill;
+    sourceHash: string;
+    targetPath: string;
+    reasons: SkillUpdateReason[];
+}
+export interface SkillUpdateCheck {
+    pluginVersion: string;
+    sharedHash: string;
+    manifest: SkillManifest | null;
+    versionChanged: boolean;
+    sharedChanged: boolean;
+    needsUpdate: boolean;
+    skillsNeedingUpdate: SkillUpdateEntry[];
+    removedSkills: string[];
+}
+export declare function readManifest(): SkillManifest | null;
+export declare function writeManifest(manifest: SkillManifest): void;
+export declare function computeSkillHash(skillDirPath: string): string;
+export declare function findRemovedSkills(manifest: SkillManifest): string[];
+export declare function checkSkillsNeedUpdate(packageRoot: string): SkillUpdateCheck;

package/dist/cli/skills.d.ts

@@ -0,0 +1,26 @@
+/**
+ * A recommended skill to install via `npx skills add`.
+ */
+export interface RecommendedSkill {
+    /** Human-readable name for prompts */
+    name: string;
+    /** GitHub repo URL for `npx skills add` */
+    repo: string;
+    /** Skill name within the repo (--skill flag) */
+    skillName: string;
+    /** Description shown to user during install */
+    description: string;
+    /** Optional commands to run after the skill is added */
+    postInstallCommands?: string[];
+}
+/**
+ * List of recommended skills.
+ * Add new skills here to include them in the installation flow.
+ */
+export declare const RECOMMENDED_SKILLS: RecommendedSkill[];
+/**
+ * Install a skill using `npx skills add`.
+ * @param skill - The skill to install
+ * @returns True if installation succeeded, false otherwise
+ */
+export declare function installSkill(skill: RecommendedSkill): boolean;

package/dist/cli/system.d.ts

@@ -0,0 +1,6 @@
+export declare function resolveOpenCodePath(): string;
+export declare function isOpenCodeInstalled(): Promise<boolean>;
+export declare function isTmuxInstalled(): Promise<boolean>;
+export declare function getOpenCodeVersion(): Promise<string | null>;
+export declare function getOpenCodePath(): string | null;
+export declare function fetchLatestVersion(packageName: string): Promise<string | null>;

package/dist/cli/types.d.ts

@@ -0,0 +1,38 @@
+export type BooleanArg = 'yes' | 'no';
+export interface InstallArgs {
+    tui: boolean;
+    tmux?: BooleanArg;
+    skills?: BooleanArg;
+    dryRun?: boolean;
+    reset?: boolean;
+}
+export interface OpenCodeConfig {
+    plugin?: string[];
+    provider?: Record<string, unknown>;
+    agent?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface InstallConfig {
+    hasTmux: boolean;
+    installSkills: boolean;
+    installCustomSkills: boolean;
+    dryRun?: boolean;
+    reset: boolean;
+}
+export interface ConfigMergeResult {
+    success: boolean;
+    configPath: string;
+    error?: string;
+}
+export interface DetectedConfig {
+    isInstalled: boolean;
+    hasKimi: boolean;
+    hasOpenAI: boolean;
+    hasAnthropic?: boolean;
+    hasCopilot?: boolean;
+    hasZaiPlan?: boolean;
+    hasAntigravity: boolean;
+    hasChutes?: boolean;
+    hasOpencodeZen: boolean;
+    hasTmux: boolean;
+}

package/dist/config/constants.d.ts

@@ -0,0 +1,19 @@
+export declare const AGENT_ALIASES: Record<string, string>;
+type BuiltinAgentName = 'orchestrator' | 'explorer' | 'librarian' | 'oracle' | 'designer' | 'quick' | 'deep';
+export type AgentName = BuiltinAgentName | (string & {});
+export declare const SUBAGENT_NAMES: readonly string[];
+export declare const ORCHESTRATOR_NAME: "orchestrator";
+export declare const ALL_AGENT_NAMES: readonly BuiltinAgentName[];
+export declare const SUBAGENT_DELEGATION_RULES: Record<AgentName, readonly string[]>;
+export declare const DEFAULT_MODELS: Record<AgentName, string | undefined>;
+export declare const POLL_INTERVAL_MS = 500;
+export declare const POLL_INTERVAL_SLOW_MS = 1000;
+export declare const POLL_INTERVAL_BACKGROUND_MS = 2000;
+export declare const DEFAULT_TIMEOUT_MS: number;
+export declare const MAX_POLL_TIME_MS: number;
+export declare const BACKGROUND_TASK_TIMEOUT_MS = 300000;
+export declare const FALLBACK_FAILOVER_TIMEOUT_MS = 15000;
+export declare const DEFAULT_DELEGATION_TIMEOUT = 900000;
+export declare const DEFAULT_THOTH_COMMAND: string[];
+export declare const STABLE_POLLS_THRESHOLD = 3;
+export {};

package/dist/config/index.d.ts

@@ -0,0 +1,5 @@
+export * from './constants';
+export { loadAgentPrompt, loadPluginConfig } from './loader';
+export type { DelegationConfig, ThothConfig } from './schema';
+export * from './schema';
+export { getAgentOverride } from './utils';

package/dist/config/loader.d.ts

@@ -0,0 +1,33 @@
+import { type PluginConfig } from './schema';
+/**
+ * Load plugin configuration from user and project config files, merging them appropriately.
+ *
+ * Configuration is loaded from two locations:
+ * 1. User config: $OPENCODE_CONFIG_DIR/oh-my-opencode-lite.jsonc or .json,
+ *    or ~/.config/opencode/oh-my-opencode-lite.jsonc or .json (or $XDG_CONFIG_HOME)
+ * 2. Project config: <directory>/.opencode/oh-my-opencode-lite.jsonc or .json
+ *
+ * JSONC format is preferred over JSON (allows comments and trailing commas).
+ * Project config takes precedence over user config. Nested objects (agents,
+ * tmux, background, fallback, thoth, delegation, clarificationGate,
+ * artifactStore) are deep-merged, while top-level arrays are replaced entirely
+ * by project config.
+ *
+ * @param directory - Project directory to search for .opencode config
+ * @returns Merged plugin configuration (empty object if no configs found)
+ */
+export declare function loadPluginConfig(directory: string): PluginConfig;
+/**
+ * Load custom prompt for an agent from the prompts directory.
+ * Checks for {agent}.md (replaces default) and {agent}_append.md (appends to default).
+ * If preset is provided and safe for paths, it first checks {preset}/ subdirectory,
+ * then falls back to the root prompts directory.
+ *
+ * @param agentName - Name of the agent (e.g., "orchestrator", "explorer")
+ * @param preset - Optional preset name for preset-scoped prompt lookup
+ * @returns Object with prompt and/or appendPrompt if files exist
+ */
+export declare function loadAgentPrompt(agentName: string, preset?: string): {
+    prompt?: string;
+    appendPrompt?: string;
+};

package/dist/config/schema.d.ts

@@ -0,0 +1,313 @@
+import { z } from 'zod';
+declare const FALLBACK_AGENT_NAMES: readonly ["orchestrator", "oracle", "designer", "explorer", "librarian", "quick", "deep"];
+declare const MANUAL_AGENT_NAMES: readonly ["orchestrator", "oracle", "designer", "explorer", "librarian", "quick", "deep"];
+export declare const ManualAgentPlanSchema: z.ZodObject<{
+    primary: z.ZodString;
+    fallback1: z.ZodString;
+    fallback2: z.ZodString;
+    fallback3: z.ZodString;
+}, z.core.$strip>;
+export declare const ManualPlanSchema: z.ZodObject<{
+    orchestrator: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    oracle: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    designer: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    explorer: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    librarian: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    quick: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    deep: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+export type ManualAgentName = (typeof MANUAL_AGENT_NAMES)[number];
+export type ManualAgentPlan = z.infer<typeof ManualAgentPlanSchema>;
+export type ManualPlan = z.infer<typeof ManualPlanSchema>;
+export type FallbackAgentName = (typeof FALLBACK_AGENT_NAMES)[number];
+export declare const AgentOverrideConfigSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        variant: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const TmuxLayoutSchema: z.ZodEnum<{
+    "main-vertical": "main-vertical";
+    "main-horizontal": "main-horizontal";
+    tiled: "tiled";
+    "even-horizontal": "even-horizontal";
+    "even-vertical": "even-vertical";
+}>;
+export type TmuxLayout = z.infer<typeof TmuxLayoutSchema>;
+export declare const TmuxConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    layout: z.ZodDefault<z.ZodEnum<{
+        "main-vertical": "main-vertical";
+        "main-horizontal": "main-horizontal";
+        tiled: "tiled";
+        "even-horizontal": "even-horizontal";
+        "even-vertical": "even-vertical";
+    }>>;
+    main_pane_size: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type TmuxConfig = z.infer<typeof TmuxConfigSchema>;
+export type AgentOverrideConfig = z.infer<typeof AgentOverrideConfigSchema>;
+/** Normalized model entry with optional per-model variant. */
+export type ModelEntry = {
+    id: string;
+    variant?: string;
+};
+export declare const PresetSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        variant: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>>;
+export type Preset = z.infer<typeof PresetSchema>;
+export declare const AgentNameSchema: z.ZodEnum<{
+    explorer: "explorer";
+    designer: "designer";
+    orchestrator: "orchestrator";
+    librarian: "librarian";
+    oracle: "oracle";
+    quick: "quick";
+    deep: "deep";
+}>;
+export declare const McpNameSchema: z.ZodEnum<{
+    websearch: "websearch";
+    context7: "context7";
+    grep_app: "grep_app";
+    thoth_mem: "thoth_mem";
+}>;
+export type McpName = string;
+export declare const ThothConfigSchema: z.ZodObject<{
+    command: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    data_dir: z.ZodOptional<z.ZodString>;
+    environment: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    http_port: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ThothConfig = z.infer<typeof ThothConfigSchema>;
+export declare const DelegationConfigSchema: z.ZodObject<{
+    storage_dir: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+export type DelegationConfig = z.infer<typeof DelegationConfigSchema>;
+export declare const ClarificationGateModeSchema: z.ZodEnum<{
+    off: "off";
+    "explicit-only": "explicit-only";
+    auto: "auto";
+    "auto-for-planning": "auto-for-planning";
+}>;
+export declare const ClarificationGateConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        off: "off";
+        "explicit-only": "explicit-only";
+        auto: "auto";
+        "auto-for-planning": "auto-for-planning";
+    }>>;
+    min_scope_signals: z.ZodDefault<z.ZodNumber>;
+    hard_complex_signal_threshold: z.ZodDefault<z.ZodNumber>;
+    explicit_keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    planning_keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type ClarificationGateConfig = z.infer<typeof ClarificationGateConfigSchema>;
+export declare const ArtifactStoreModeSchema: z.ZodEnum<{
+    "thoth-mem": "thoth-mem";
+    openspec: "openspec";
+    hybrid: "hybrid";
+}>;
+export declare const ArtifactStoreConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        "thoth-mem": "thoth-mem";
+        openspec: "openspec";
+        hybrid: "hybrid";
+    }>>;
+}, z.core.$strip>;
+export type ArtifactStoreConfig = z.infer<typeof ArtifactStoreConfigSchema>;
+export declare const BackgroundTaskConfigSchema: z.ZodObject<{
+    maxConcurrentStarts: z.ZodDefault<z.ZodNumber>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type BackgroundTaskConfig = z.infer<typeof BackgroundTaskConfigSchema>;
+export declare const FailoverConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+    retryDelayMs: z.ZodDefault<z.ZodNumber>;
+    chains: z.ZodDefault<z.ZodObject<{
+        orchestrator: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        oracle: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        designer: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        explorer: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        librarian: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        quick: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        deep: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$catchall<z.ZodArray<z.ZodString>>>>;
+}, z.core.$strip>;
+export type FailoverConfig = z.infer<typeof FailoverConfigSchema>;
+export declare const PluginConfigSchema: z.ZodObject<{
+    preset: z.ZodOptional<z.ZodString>;
+    setDefaultAgent: z.ZodOptional<z.ZodBoolean>;
+    scoringEngineVersion: z.ZodOptional<z.ZodEnum<{
+        v1: "v1";
+        "v2-shadow": "v2-shadow";
+        v2: "v2";
+    }>>;
+    balanceProviderUsage: z.ZodOptional<z.ZodBoolean>;
+    manualPlan: z.ZodOptional<z.ZodObject<{
+        orchestrator: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        oracle: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        designer: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        explorer: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        librarian: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        quick: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        deep: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strict>>;
+    presets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            variant: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>]>>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>>>;
+    agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            variant: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>]>>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>>;
+    disabled_mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tmux: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        layout: z.ZodDefault<z.ZodEnum<{
+            "main-vertical": "main-vertical";
+            "main-horizontal": "main-horizontal";
+            tiled: "tiled";
+            "even-horizontal": "even-horizontal";
+            "even-vertical": "even-vertical";
+        }>>;
+        main_pane_size: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    background: z.ZodOptional<z.ZodObject<{
+        maxConcurrentStarts: z.ZodDefault<z.ZodNumber>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    fallback: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        retryDelayMs: z.ZodDefault<z.ZodNumber>;
+        chains: z.ZodDefault<z.ZodObject<{
+            orchestrator: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            oracle: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            designer: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            explorer: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            librarian: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            quick: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            deep: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$catchall<z.ZodArray<z.ZodString>>>>;
+    }, z.core.$strip>>;
+    thoth: z.ZodOptional<z.ZodObject<{
+        command: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        data_dir: z.ZodOptional<z.ZodString>;
+        environment: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+        http_port: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    delegation: z.ZodOptional<z.ZodObject<{
+        storage_dir: z.ZodOptional<z.ZodString>;
+        timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    clarificationGate: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            off: "off";
+            "explicit-only": "explicit-only";
+            auto: "auto";
+            "auto-for-planning": "auto-for-planning";
+        }>>;
+        min_scope_signals: z.ZodDefault<z.ZodNumber>;
+        hard_complex_signal_threshold: z.ZodDefault<z.ZodNumber>;
+        explicit_keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        planning_keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    artifactStore: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            "thoth-mem": "thoth-mem";
+            openspec: "openspec";
+            hybrid: "hybrid";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PluginConfig = z.infer<typeof PluginConfigSchema>;
+export type { AgentName } from './constants';

package/dist/config/utils.d.ts

@@ -0,0 +1,10 @@
+import type { AgentOverrideConfig, PluginConfig } from './schema';
+/**
+ * Get agent override config by name, supporting backward-compatible aliases.
+ * Checks both the current name and any legacy alias names.
+ *
+ * @param config - The plugin configuration
+ * @param name - The current agent name
+ * @returns The agent-specific override configuration if found
+ */
+export declare function getAgentOverride(config: PluginConfig | undefined, name: string): AgentOverrideConfig | undefined;

package/dist/delegation/delegation-manager.d.ts

@@ -0,0 +1,25 @@
+import type { DelegationConfig } from '../config';
+import { type DelegationListEntry, type DelegationRecord, type PersistedDelegationRecord } from './types';
+export interface DelegationManagerOptions {
+    directory: string;
+    config?: DelegationConfig;
+    getActiveTaskIds?: (rootSessionId: string) => Iterable<string>;
+}
+export interface PersistDelegationInput {
+    rootSessionId: string;
+    record: DelegationRecord;
+}
+export declare class DelegationManager {
+    private readonly directory;
+    private readonly config?;
+    private readonly getActiveTaskIds?;
+    constructor(options: DelegationManagerOptions);
+    resolveProjectId(directory?: string): Promise<string | null>;
+    createTaskId(rootSessionId: string): Promise<string>;
+    persist(input: PersistDelegationInput): Promise<PersistedDelegationRecord | null>;
+    read(taskId: string, rootSessionId: string): Promise<PersistedDelegationRecord | null>;
+    list(rootSessionId: string): Promise<DelegationListEntry[]>;
+    listCompleted(rootSessionId: string): Promise<DelegationListEntry[]>;
+    summarizeForInjection(rootSessionId: string, limit?: number): Promise<string | null>;
+    private getReservedTaskIds;
+}

package/dist/delegation/index.d.ts

@@ -0,0 +1,4 @@
+export { DelegationManager, type DelegationManagerOptions, } from './delegation-manager';
+export { resolvePaths, resolveStorageDir } from './paths';
+export { getProjectId } from './project-id';
+export * from './types';