chore: include pre-built dist for github install

dist/config/index.d.ts

@@ -0,0 +1,2 @@
+export { OhMyOpenCodeConfigSchema, } from "./schema";
+export type { OhMyOpenCodeConfig, AgentOverrideConfig, AgentOverrides, McpName, AgentName, HookName, BuiltinCommandName, SisyphusAgentConfig, ExperimentalConfig, DynamicContextPruningConfig, RalphLoopConfig, TmuxConfig, TmuxLayout, SisyphusConfig, SisyphusTasksConfig, RuntimeFallbackConfig, FallbackModels, } from "./schema";

dist/config/schema.d.ts

@@ -0,0 +1,25 @@
+export * from "./schema/agent-names";
+export * from "./schema/agent-overrides";
+export * from "./schema/babysitting";
+export * from "./schema/background-task";
+export * from "./schema/browser-automation";
+export * from "./schema/categories";
+export * from "./schema/claude-code";
+export * from "./schema/comment-checker";
+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/notification";
+export * from "./schema/oh-my-opencode-config";
+export * from "./schema/ralph-loop";
+export * from "./schema/runtime-fallback";
+export * from "./schema/skills";
+export * from "./schema/sisyphus";
+export * from "./schema/sisyphus-agent";
+export * from "./schema/tmux";
+export * from "./schema/websearch";
+export { AnyMcpNameSchema, type AnyMcpName, McpNameSchema, type McpName } from "../mcp/types";

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

@@ -0,0 +1,52 @@
+import { z } from "zod";
+export declare const BuiltinAgentNameSchema: z.ZodEnum<{
+    sisyphus: "sisyphus";
+    hephaestus: "hephaestus";
+    oracle: "oracle";
+    librarian: "librarian";
+    explore: "explore";
+    "multimodal-looker": "multimodal-looker";
+    metis: "metis";
+    momus: "momus";
+    atlas: "atlas";
+    "sisyphus-junior": "sisyphus-junior";
+    prometheus: "prometheus";
+}>;
+export declare const BuiltinSkillNameSchema: z.ZodEnum<{
+    playwright: "playwright";
+    "agent-browser": "agent-browser";
+    "dev-browser": "dev-browser";
+    "frontend-ui-ux": "frontend-ui-ux";
+    "git-master": "git-master";
+}>;
+export declare const OverridableAgentNameSchema: z.ZodEnum<{
+    sisyphus: "sisyphus";
+    hephaestus: "hephaestus";
+    oracle: "oracle";
+    librarian: "librarian";
+    explore: "explore";
+    "multimodal-looker": "multimodal-looker";
+    metis: "metis";
+    momus: "momus";
+    atlas: "atlas";
+    "sisyphus-junior": "sisyphus-junior";
+    build: "build";
+    plan: "plan";
+    prometheus: "prometheus";
+    "OpenCode-Builder": "OpenCode-Builder";
+}>;
+export declare const AgentNameSchema: z.ZodEnum<{
+    sisyphus: "sisyphus";
+    hephaestus: "hephaestus";
+    oracle: "oracle";
+    librarian: "librarian";
+    explore: "explore";
+    "multimodal-looker": "multimodal-looker";
+    metis: "metis";
+    momus: "momus";
+    atlas: "atlas";
+    "sisyphus-junior": "sisyphus-junior";
+    prometheus: "prometheus";
+}>;
+export type AgentName = z.infer<typeof AgentNameSchema>;
+export type BuiltinSkillName = z.infer<typeof BuiltinSkillNameSchema>;

dist/config/schema/babysitting.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare const BabysittingConfigSchema: z.ZodObject<{
+    timeout_ms: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type BabysittingConfig = z.infer<typeof BabysittingConfigSchema>;

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

@@ -0,0 +1,12 @@
+import { z } from "zod";
+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>;
+}, z.core.$strip>;
+export type BackgroundTaskConfig = z.infer<typeof BackgroundTaskConfigSchema>;

dist/config/schema/browser-automation.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export declare const BrowserAutomationProviderSchema: z.ZodEnum<{
+    playwright: "playwright";
+    "agent-browser": "agent-browser";
+    "dev-browser": "dev-browser";
+    "playwright-cli": "playwright-cli";
+}>;
+export declare const BrowserAutomationConfigSchema: z.ZodObject<{
+    provider: z.ZodDefault<z.ZodEnum<{
+        playwright: "playwright";
+        "agent-browser": "agent-browser";
+        "dev-browser": "dev-browser";
+        "playwright-cli": "playwright-cli";
+    }>>;
+}, z.core.$strip>;
+export type BrowserAutomationProvider = z.infer<typeof BrowserAutomationProviderSchema>;
+export type BrowserAutomationConfig = z.infer<typeof BrowserAutomationConfigSchema>;

dist/config/schema/categories.d.ts

@@ -0,0 +1,78 @@
+import { z } from "zod";
+export declare const CategoryConfigSchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    variant: 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>>;
+    reasoningEffort: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+    }>>;
+    textVerbosity: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+    tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    prompt_append: z.ZodOptional<z.ZodString>;
+    max_prompt_tokens: z.ZodOptional<z.ZodNumber>;
+    is_unstable_agent: z.ZodOptional<z.ZodBoolean>;
+    disable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const BuiltinCategoryNameSchema: z.ZodEnum<{
+    deep: "deep";
+    "unspecified-high": "unspecified-high";
+    "visual-engineering": "visual-engineering";
+    ultrabrain: "ultrabrain";
+    artistry: "artistry";
+    quick: "quick";
+    "unspecified-low": "unspecified-low";
+    writing: "writing";
+}>;
+export declare const CategoriesConfigSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    variant: 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>>;
+    reasoningEffort: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+    }>>;
+    textVerbosity: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+    tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    prompt_append: z.ZodOptional<z.ZodString>;
+    max_prompt_tokens: z.ZodOptional<z.ZodNumber>;
+    is_unstable_agent: z.ZodOptional<z.ZodBoolean>;
+    disable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>;
+export type CategoryConfig = z.infer<typeof CategoryConfigSchema>;
+export type CategoriesConfig = z.infer<typeof CategoriesConfigSchema>;
+export type BuiltinCategoryName = z.infer<typeof BuiltinCategoryNameSchema>;

dist/config/schema/claude-code.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const ClaudeCodeConfigSchema: z.ZodObject<{
+    mcp: z.ZodOptional<z.ZodBoolean>;
+    commands: z.ZodOptional<z.ZodBoolean>;
+    skills: z.ZodOptional<z.ZodBoolean>;
+    agents: z.ZodOptional<z.ZodBoolean>;
+    hooks: z.ZodOptional<z.ZodBoolean>;
+    plugins: z.ZodOptional<z.ZodBoolean>;
+    plugins_override: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+}, z.core.$strip>;
+export type ClaudeCodeConfig = z.infer<typeof ClaudeCodeConfigSchema>;

dist/config/schema/commands.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const BuiltinCommandNameSchema: z.ZodEnum<{
+    "init-deep": "init-deep";
+    "ralph-loop": "ralph-loop";
+    "ulw-loop": "ulw-loop";
+    "cancel-ralph": "cancel-ralph";
+    refactor: "refactor";
+    "start-work": "start-work";
+    "stop-continuation": "stop-continuation";
+}>;
+export type BuiltinCommandName = z.infer<typeof BuiltinCommandNameSchema>;

dist/config/schema/comment-checker.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare const CommentCheckerConfigSchema: z.ZodObject<{
+    custom_prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CommentCheckerConfig = z.infer<typeof CommentCheckerConfigSchema>;

dist/config/schema/dynamic-context-pruning.d.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+export declare const DynamicContextPruningConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    notification: z.ZodDefault<z.ZodEnum<{
+        off: "off";
+        minimal: "minimal";
+        detailed: "detailed";
+    }>>;
+    turn_protection: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        turns: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    protected_tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    strategies: z.ZodOptional<z.ZodObject<{
+        deduplication: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        supersede_writes: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            aggressive: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        purge_errors: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            turns: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DynamicContextPruningConfig = z.infer<typeof DynamicContextPruningConfigSchema>;

dist/config/schema/experimental.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+export declare const ExperimentalConfigSchema: z.ZodObject<{
+    aggressive_truncation: z.ZodOptional<z.ZodBoolean>;
+    auto_resume: z.ZodOptional<z.ZodBoolean>;
+    preemptive_compaction: z.ZodOptional<z.ZodBoolean>;
+    truncate_all_tool_outputs: z.ZodOptional<z.ZodBoolean>;
+    dynamic_context_pruning: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        notification: z.ZodDefault<z.ZodEnum<{
+            off: "off";
+            minimal: "minimal";
+            detailed: "detailed";
+        }>>;
+        turn_protection: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            turns: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        protected_tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        strategies: z.ZodOptional<z.ZodObject<{
+            deduplication: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            supersede_writes: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                aggressive: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            purge_errors: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                turns: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    task_system: z.ZodOptional<z.ZodBoolean>;
+    plugin_load_timeout_ms: z.ZodOptional<z.ZodNumber>;
+    safe_hook_creation: z.ZodOptional<z.ZodBoolean>;
+    disable_omo_env: z.ZodOptional<z.ZodBoolean>;
+    hashline_edit: z.ZodOptional<z.ZodBoolean>;
+    model_fallback_title: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ExperimentalConfig = z.infer<typeof ExperimentalConfigSchema>;

dist/config/schema/fallback-models.d.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+export declare const FallbackModelsSchema: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+export type FallbackModels = z.infer<typeof FallbackModelsSchema>;

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>;

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

@@ -0,0 +1,7 @@
+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>;

dist/config/schema/hooks.d.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+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";
+    "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";
+}>;
+export type HookName = z.infer<typeof HookNameSchema>;

dist/config/schema/internal/permission.d.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+export declare const PermissionValueSchema: z.ZodEnum<{
+    ask: "ask";
+    allow: "allow";
+    deny: "deny";
+}>;
+export type PermissionValue = z.infer<typeof PermissionValueSchema>;
+export declare const AgentPermissionSchema: z.ZodObject<{
+    edit: z.ZodOptional<z.ZodEnum<{
+        ask: "ask";
+        allow: "allow";
+        deny: "deny";
+    }>>;
+    bash: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        ask: "ask";
+        allow: "allow";
+        deny: "deny";
+    }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+        ask: "ask";
+        allow: "allow";
+        deny: "deny";
+    }>>]>>;
+    webfetch: z.ZodOptional<z.ZodEnum<{
+        ask: "ask";
+        allow: "allow";
+        deny: "deny";
+    }>>;
+    task: z.ZodOptional<z.ZodEnum<{
+        ask: "ask";
+        allow: "allow";
+        deny: "deny";
+    }>>;
+    doom_loop: z.ZodOptional<z.ZodEnum<{
+        ask: "ask";
+        allow: "allow";
+        deny: "deny";
+    }>>;
+    external_directory: z.ZodOptional<z.ZodEnum<{
+        ask: "ask";
+        allow: "allow";
+        deny: "deny";
+    }>>;
+}, z.core.$strip>;
+export type AgentPermission = z.infer<typeof AgentPermissionSchema>;

dist/config/schema/notification.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare const NotificationConfigSchema: z.ZodObject<{
+    force_enable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type NotificationConfig = z.infer<typeof NotificationConfigSchema>;

dist/config/schema/ralph-loop.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const RalphLoopConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    default_max_iterations: z.ZodDefault<z.ZodNumber>;
+    state_dir: z.ZodOptional<z.ZodString>;
+    default_strategy: z.ZodDefault<z.ZodEnum<{
+        reset: "reset";
+        continue: "continue";
+    }>>;
+}, z.core.$strip>;
+export type RalphLoopConfig = z.infer<typeof RalphLoopConfigSchema>;

dist/config/schema/runtime-fallback.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export declare const RuntimeFallbackConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    retry_on_errors: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    max_fallback_attempts: z.ZodOptional<z.ZodNumber>;
+    cooldown_seconds: z.ZodOptional<z.ZodNumber>;
+    timeout_seconds: z.ZodOptional<z.ZodNumber>;
+    notify_on_fallback: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type RuntimeFallbackConfig = z.infer<typeof RuntimeFallbackConfigSchema>;

dist/config/schema/sisyphus-agent.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const SisyphusAgentConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    default_builder_enabled: z.ZodOptional<z.ZodBoolean>;
+    planner_enabled: z.ZodOptional<z.ZodBoolean>;
+    replace_plan: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SisyphusAgentConfig = z.infer<typeof SisyphusAgentConfigSchema>;

dist/config/schema/sisyphus.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const SisyphusTasksConfigSchema: z.ZodObject<{
+    storage_path: z.ZodOptional<z.ZodString>;
+    task_list_id: z.ZodOptional<z.ZodString>;
+    claude_code_compat: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const SisyphusConfigSchema: z.ZodObject<{
+    tasks: z.ZodOptional<z.ZodObject<{
+        storage_path: z.ZodOptional<z.ZodString>;
+        task_list_id: z.ZodOptional<z.ZodString>;
+        claude_code_compat: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SisyphusTasksConfig = z.infer<typeof SisyphusTasksConfigSchema>;
+export type SisyphusConfig = z.infer<typeof SisyphusConfigSchema>;

dist/config/schema/skills.d.ts

@@ -0,0 +1,58 @@
+import { z } from "zod";
+export declare const SkillSourceSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    path: z.ZodString;
+    recursive: z.ZodOptional<z.ZodBoolean>;
+    glob: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+export declare const SkillDefinitionSchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    template: z.ZodOptional<z.ZodString>;
+    from: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    agent: z.ZodOptional<z.ZodString>;
+    subtask: z.ZodOptional<z.ZodBoolean>;
+    "argument-hint": z.ZodOptional<z.ZodString>;
+    license: z.ZodOptional<z.ZodString>;
+    compatibility: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    "allowed-tools": z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const SkillEntrySchema: z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    template: z.ZodOptional<z.ZodString>;
+    from: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    agent: z.ZodOptional<z.ZodString>;
+    subtask: z.ZodOptional<z.ZodBoolean>;
+    "argument-hint": z.ZodOptional<z.ZodString>;
+    license: z.ZodOptional<z.ZodString>;
+    compatibility: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    "allowed-tools": z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>]>;
+export declare const SkillsConfigSchema: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+    sources: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        path: z.ZodString;
+        recursive: z.ZodOptional<z.ZodBoolean>;
+        glob: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>>;
+    enable: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disable: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$catchall<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    template: z.ZodOptional<z.ZodString>;
+    from: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    agent: z.ZodOptional<z.ZodString>;
+    subtask: z.ZodOptional<z.ZodBoolean>;
+    "argument-hint": z.ZodOptional<z.ZodString>;
+    license: z.ZodOptional<z.ZodString>;
+    compatibility: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    "allowed-tools": z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>]>>>]>;
+export type SkillsConfig = z.infer<typeof SkillsConfigSchema>;
+export type SkillDefinition = z.infer<typeof SkillDefinitionSchema>;

dist/config/schema/start-work.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare const StartWorkConfigSchema: z.ZodObject<{
+    auto_commit: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type StartWorkConfig = z.infer<typeof StartWorkConfigSchema>;

dist/config/schema/tmux.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export declare const TmuxLayoutSchema: z.ZodEnum<{
+    "main-horizontal": "main-horizontal";
+    "main-vertical": "main-vertical";
+    tiled: "tiled";
+    "even-horizontal": "even-horizontal";
+    "even-vertical": "even-vertical";
+}>;
+export declare const TmuxConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    layout: z.ZodDefault<z.ZodEnum<{
+        "main-horizontal": "main-horizontal";
+        "main-vertical": "main-vertical";
+        tiled: "tiled";
+        "even-horizontal": "even-horizontal";
+        "even-vertical": "even-vertical";
+    }>>;
+    main_pane_size: z.ZodDefault<z.ZodNumber>;
+    main_pane_min_width: z.ZodDefault<z.ZodNumber>;
+    agent_pane_min_width: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type TmuxConfig = z.infer<typeof TmuxConfigSchema>;
+export type TmuxLayout = z.infer<typeof TmuxLayoutSchema>;

dist/config/schema/websearch.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const WebsearchProviderSchema: z.ZodEnum<{
+    exa: "exa";
+    tavily: "tavily";
+}>;
+export declare const WebsearchConfigSchema: z.ZodObject<{
+    provider: z.ZodOptional<z.ZodEnum<{
+        exa: "exa";
+        tavily: "tavily";
+    }>>;
+}, z.core.$strip>;
+export type WebsearchProvider = z.infer<typeof WebsearchProviderSchema>;
+export type WebsearchConfig = z.infer<typeof WebsearchConfigSchema>;