goatcode-sh 0.0.1 → 0.1.3

package/dist/config/schema.d.ts

@@ -0,0 +1,273 @@
+import { z } from "zod";
+export declare const AgentOverrideConfigSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    variant: z.ZodOptional<z.ZodString>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    top_p: z.ZodOptional<z.ZodNumber>;
+    prompt_append: z.ZodOptional<z.ZodString>;
+    denied_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disable: z.ZodOptional<z.ZodBoolean>;
+    fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+}, z.core.$strip>;
+export declare const CategoryConfigSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    variant: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    prompt_append: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const AgentOverridesSchema: z.ZodObject<{
+    orchestrator: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        prompt_append: z.ZodOptional<z.ZodString>;
+        denied_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        disable: z.ZodOptional<z.ZodBoolean>;
+        fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strip>>;
+    "deep-worker": z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        prompt_append: z.ZodOptional<z.ZodString>;
+        denied_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        disable: z.ZodOptional<z.ZodBoolean>;
+        fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strip>>;
+    planner: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        prompt_append: z.ZodOptional<z.ZodString>;
+        denied_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        disable: z.ZodOptional<z.ZodBoolean>;
+        fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strip>>;
+    advisor: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        prompt_append: z.ZodOptional<z.ZodString>;
+        denied_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        disable: z.ZodOptional<z.ZodBoolean>;
+        fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strip>>;
+    researcher: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        prompt_append: z.ZodOptional<z.ZodString>;
+        denied_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        disable: z.ZodOptional<z.ZodBoolean>;
+        fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strip>>;
+    explorer: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        prompt_append: z.ZodOptional<z.ZodString>;
+        denied_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        disable: z.ZodOptional<z.ZodBoolean>;
+        fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strip>>;
+    worker: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        prompt_append: z.ZodOptional<z.ZodString>;
+        denied_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        disable: z.ZodOptional<z.ZodBoolean>;
+        fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const CategoryOverridesSchema: z.ZodObject<{
+    "visual-engineering": z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        prompt_append: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    ultrabrain: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        prompt_append: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    deep: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        prompt_append: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    artistry: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        prompt_append: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    quick: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        prompt_append: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    "unspecified-low": z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        prompt_append: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    "unspecified-high": z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        prompt_append: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    writing: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        prompt_append: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const GoatCodeConfigSchema: z.ZodObject<{
+    agents: z.ZodOptional<z.ZodObject<{
+        orchestrator: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            prompt_append: z.ZodOptional<z.ZodString>;
+            denied_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            disable: z.ZodOptional<z.ZodBoolean>;
+            fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>;
+        "deep-worker": z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            prompt_append: z.ZodOptional<z.ZodString>;
+            denied_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            disable: z.ZodOptional<z.ZodBoolean>;
+            fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>;
+        planner: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            prompt_append: z.ZodOptional<z.ZodString>;
+            denied_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            disable: z.ZodOptional<z.ZodBoolean>;
+            fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>;
+        advisor: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            prompt_append: z.ZodOptional<z.ZodString>;
+            denied_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            disable: z.ZodOptional<z.ZodBoolean>;
+            fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>;
+        researcher: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            prompt_append: z.ZodOptional<z.ZodString>;
+            denied_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            disable: z.ZodOptional<z.ZodBoolean>;
+            fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>;
+        explorer: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            prompt_append: z.ZodOptional<z.ZodString>;
+            denied_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            disable: z.ZodOptional<z.ZodBoolean>;
+            fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>;
+        worker: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            prompt_append: z.ZodOptional<z.ZodString>;
+            denied_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            disable: z.ZodOptional<z.ZodBoolean>;
+            fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    categories: z.ZodOptional<z.ZodObject<{
+        "visual-engineering": z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            prompt_append: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        ultrabrain: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            prompt_append: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        deep: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            prompt_append: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        artistry: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            prompt_append: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        quick: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            prompt_append: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        "unspecified-low": z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            prompt_append: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        "unspecified-high": z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            prompt_append: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        writing: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            prompt_append: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    default_temperature: z.ZodDefault<z.ZodNumber>;
+    default_provider: z.ZodOptional<z.ZodString>;
+    provider_priority: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    disabled_agents: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    disabled_hooks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    disabled_tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    disabled_skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    auto_update: z.ZodDefault<z.ZodBoolean>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type GoatCodeConfigInput = z.input<typeof GoatCodeConfigSchema>;

package/dist/config/validator.d.ts

@@ -0,0 +1,9 @@
+import type { GoatCodeConfig } from "../types/config";
+export type ValidationResult = {
+    success: true;
+    config: GoatCodeConfig;
+} | {
+    success: false;
+    errors: string[];
+};
+export declare function validateConfig(raw: unknown): ValidationResult;

package/dist/features/auto-update/index.d.ts

@@ -0,0 +1,3 @@
+export { checkForUpdate } from "./update-checker";
+export type { UpdateCheckResult } from "./update-checker";
+export { createAutoUpdatePlugin } from "./plugin";

package/dist/features/auto-update/plugin.d.ts

@@ -0,0 +1,2 @@
+import type { PluginDefinition } from "../../types/plugin";
+export declare function createAutoUpdatePlugin(): PluginDefinition;

package/dist/features/auto-update/update-checker.d.ts

@@ -0,0 +1,7 @@
+export interface UpdateCheckResult {
+    updateAvailable: boolean;
+    latest: string;
+    current: string;
+    error: boolean;
+}
+export declare function checkForUpdate(currentVersion: string, fetchFn?: typeof fetch): Promise<UpdateCheckResult>;

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

@@ -0,0 +1,10 @@
+export declare class ConcurrencyManager {
+    private readonly limit;
+    private counts;
+    private queues;
+    constructor(limit?: number);
+    acquire(key: string): Promise<void>;
+    release(key: string): void;
+    getCount(key: string): number;
+    getQueueLength(key: string): number;
+}

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

@@ -0,0 +1,6 @@
+export type { BackgroundTask, BackgroundTaskStatus, LaunchInput } from "./types";
+export { ConcurrencyManager } from "./concurrency";
+export { POLLING_INTERVAL_MS, STABILITY_REQUIRED_POLLS, createPollState, checkStability, pollUntilStable, } from "./poller";
+export { spawnBackgroundSession } from "./spawner";
+export { BackgroundAgentManager } from "./manager";
+export { initBackgroundAgent, getBackgroundAgent, resetBackgroundAgent } from "./singleton";

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

@@ -0,0 +1,18 @@
+import type { OpenCodeContext } from "../../types/plugin";
+import type { BackgroundTask, LaunchInput } from "./types";
+export declare class BackgroundAgentManager {
+    private readonly tasks;
+    private readonly concurrency;
+    private readonly abortControllers;
+    constructor(concurrencyLimit?: number);
+    launch(ctx: OpenCodeContext, input: LaunchInput): Promise<BackgroundTask>;
+    private runLifecycle;
+    dispose(): void;
+    complete(id: string, result: string): void;
+    fail(id: string, error: string): void;
+    cancel(ctx: OpenCodeContext, id: string): Promise<void>;
+    private cleanupSession;
+    private evictStaleTasks;
+    get(id: string): BackgroundTask | undefined;
+    getAll(): BackgroundTask[];
+}

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

@@ -0,0 +1,17 @@
+export declare const POLLING_INTERVAL_MS = 3000;
+export declare const STABILITY_REQUIRED_POLLS = 2;
+export type PollState = {
+    lastMessageCount: number;
+    stablePolls: number;
+};
+export type PollSnapshot = {
+    messageCount: number;
+    isIdle: boolean;
+    result?: string;
+};
+export declare function createPollState(): PollState;
+export declare function checkStability(state: PollState, currentMessageCount: number, isIdle: boolean): {
+    stable: boolean;
+    nextState: PollState;
+};
+export declare function pollUntilStable(fetchSnapshot: () => Promise<PollSnapshot>, maxPolls?: number, signal?: AbortSignal): Promise<PollSnapshot>;

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

@@ -0,0 +1,7 @@
+import { BackgroundAgentManager } from "./manager";
+export type BackgroundAgentContext = {
+    manager: BackgroundAgentManager;
+};
+export declare function initBackgroundAgent(): BackgroundAgentContext;
+export declare function getBackgroundAgent(): BackgroundAgentContext;
+export declare function resetBackgroundAgent(): void;

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

@@ -0,0 +1,6 @@
+import type { OpenCodeContext } from "../../types/plugin";
+import type { LaunchInput } from "./types";
+export type SpawnResult = {
+    sessionId: string;
+};
+export declare function spawnBackgroundSession(ctx: OpenCodeContext, input: LaunchInput): Promise<SpawnResult>;

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

@@ -0,0 +1,18 @@
+export type BackgroundTaskStatus = "queued" | "running" | "completed" | "failed" | "cancelled";
+export interface BackgroundTask {
+    id: string;
+    sessionId?: string;
+    status: BackgroundTaskStatus;
+    prompt: string;
+    model: string;
+    createdAt: number;
+    startedAt?: number;
+    completedAt?: number;
+    result?: string;
+    error?: string;
+}
+export interface LaunchInput {
+    id: string;
+    prompt: string;
+    model: string;
+}

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

@@ -0,0 +1,2 @@
+import type { PluginDefinition } from "../types/plugin";
+export declare const BUILTIN_FEATURE_PLUGINS: PluginDefinition[];

package/dist/features/categories/category-config.d.ts

@@ -0,0 +1,9 @@
+import type { BuiltinCategoryName, CategoryConfig } from "../../types/category";
+export type CategoryName = BuiltinCategoryName;
+export interface CategoryDefinition extends Required<Pick<CategoryConfig, "description">> {
+    model: string;
+    variant?: string;
+    promptAppend?: string;
+}
+export declare const DEFAULT_CATEGORY_DEFINITIONS: Record<CategoryName, CategoryDefinition>;
+export declare const DEFAULT_CATEGORIES: Record<CategoryName, CategoryConfig>;

package/dist/features/categories/category-resolver.d.ts

@@ -0,0 +1,6 @@
+import type { BuiltinCategoryName, CategoryConfig } from "../../types/category";
+export type CategoryOverrides = Partial<Record<BuiltinCategoryName, CategoryConfig>>;
+export declare class CategoryResolver {
+    resolve(name: string, configOverrides?: CategoryOverrides): CategoryConfig | undefined;
+}
+export declare function resolveCategory(name: string, configOverrides?: CategoryOverrides): CategoryConfig | undefined;

package/dist/features/categories/index.d.ts

@@ -0,0 +1,3 @@
+export { CATEGORY_PROMPT_APPENDS } from "./prompt-appends";
+export { DEFAULT_CATEGORIES, DEFAULT_CATEGORY_DEFINITIONS, type CategoryDefinition, type CategoryName, } from "./category-config";
+export { CategoryResolver, resolveCategory, type CategoryOverrides } from "./category-resolver";

package/dist/features/categories/prompt-appends.d.ts

@@ -0,0 +1,10 @@
+export declare const CATEGORY_PROMPT_APPENDS: {
+    readonly "visual-engineering": "<Category_Context>\nYou are working on VISUAL/UI tasks.\n\nFollow the project's design system first. Prefer existing UI patterns, tokens, and reusable components.\n</Category_Context>";
+    readonly ultrabrain: "<Category_Context>\nYou are working on DEEP LOGICAL REASONING / COMPLEX ARCHITECTURE tasks.\n\nPrioritize clear recommendations, tradeoffs, and maintainable implementation strategy.\n</Category_Context>";
+    readonly deep: "<Category_Context>\nYou are working on GOAL-ORIENTED AUTONOMOUS tasks.\n\nResearch thoroughly before making changes and execute with minimal supervision.\n</Category_Context>";
+    readonly artistry: "<Category_Context>\nYou are working on HIGHLY CREATIVE / ARTISTIC tasks.\n\nExplore unconventional approaches while keeping outcomes coherent.\n</Category_Context>";
+    readonly quick: "<Category_Context>\nYou are working on SMALL / QUICK tasks.\n\nUse minimal overhead and solve directly without over-engineering.\n</Category_Context>";
+    readonly "unspecified-low": "<Category_Context>\nYou are working on moderate-effort tasks that do not fit specialized categories.\n</Category_Context>";
+    readonly "unspecified-high": "<Category_Context>\nYou are working on substantial-effort tasks that do not fit specialized categories.\n</Category_Context>";
+    readonly writing: "<Category_Context>\nYou are working on WRITING / PROSE tasks.\n\nFavor clear, natural language and avoid AI-slop phrasing.\n</Category_Context>";
+};

package/dist/features/loops/file-store.d.ts

@@ -0,0 +1,22 @@
+import { type LoopOptions, type LoopState, type LoopStore } from "./state";
+interface FileLoopStoreOptions {
+    stateFilePath?: string;
+}
+export declare class FileLoopStore implements LoopStore {
+    private stateFilePath;
+    private loadedFromDisk;
+    private readonly loopStates;
+    constructor(options?: FileLoopStoreOptions);
+    startLoop(sessionId: string, options?: LoopOptions): void;
+    stopLoop(sessionId: string): void;
+    isActive(sessionId: string): boolean;
+    getLoopState(sessionId: string): LoopState | undefined;
+    incrementIteration(sessionId: string): void;
+    markCompletionDetected(sessionId: string): void;
+    setStateFilePathForTests(filePath: string): void;
+    loadPersistedStateForTests(): void;
+    clearAllForTests(clearPersistedFile?: boolean): void;
+    private ensureLoadedFromDisk;
+    private persist;
+}
+export {};

package/dist/features/loops/handler.d.ts

@@ -0,0 +1,9 @@
+import { type HookEvent } from "./shared/event-utils";
+import { type LoopState, type LoopStore } from "./state";
+export interface LoopHandlerOptions {
+    completionPromise?: string;
+    detectCompletion?: (event: HookEvent, state: LoopState) => boolean;
+    sendContinuationMessage?: (sessionId: string, message: string) => Promise<void> | void;
+}
+export declare function buildLoopContinuationMessage(state: LoopState, completionPromise: string): string;
+export declare function createLoopHandler(store: LoopStore, options?: LoopHandlerOptions): (input: unknown) => Promise<void>;

package/dist/features/loops/index.d.ts

@@ -0,0 +1,5 @@
+export { DEFAULT_MAX_ITERATIONS, UNBOUNDED_MAX_ITERATIONS, type LoopOptions, type LoopState, type LoopStore, } from "./state";
+export { MemoryLoopStore } from "./memory-store";
+export { FileLoopStore } from "./file-store";
+export { buildLoopContinuationMessage, createLoopHandler, type LoopHandlerOptions, } from "./handler";
+export { clearLoopStateForTests, configureLoopStateFilePathForTests, createLoopPlugin, defaultLoopStore, fileLoopStore, getLoopState, isLoopActive, loadPersistedLoopStateForTests, loopPlugin, memoryLoopStore, startLoop, stopLoop, } from "./plugin";

package/dist/features/loops/memory-store.d.ts

@@ -0,0 +1,11 @@
+import { type LoopOptions, type LoopState, type LoopStore } from "./state";
+export declare class MemoryLoopStore implements LoopStore {
+    private readonly loopStates;
+    startLoop(sessionId: string, options?: LoopOptions): void;
+    stopLoop(sessionId: string): void;
+    isActive(sessionId: string): boolean;
+    getLoopState(sessionId: string): LoopState | undefined;
+    incrementIteration(sessionId: string): void;
+    markCompletionDetected(sessionId: string): void;
+    clearAllForTests(): void;
+}

package/dist/features/loops/plugin.d.ts

@@ -0,0 +1,34 @@
+import { FileLoopStore } from "./file-store";
+import { type LoopHandlerOptions } from "./handler";
+import { MemoryLoopStore } from "./memory-store";
+import { type LoopOptions, type LoopState, type LoopStore } from "./state";
+declare class RoutedLoopStore implements LoopStore {
+    private readonly memoryStore;
+    private readonly fileStore;
+    constructor(memoryStore: MemoryLoopStore, fileStore: FileLoopStore);
+    startLoop(sessionId: string, options?: LoopOptions): void;
+    stopLoop(sessionId: string): void;
+    isActive(sessionId: string): boolean;
+    getLoopState(sessionId: string): LoopState | undefined;
+    incrementIteration(sessionId: string): void;
+    markCompletionDetected(sessionId: string): void;
+    clearForTests(clearPersistedFile?: boolean): void;
+    configureFilePathForTests(filePath: string): void;
+    loadPersistedForTests(): void;
+}
+export declare const memoryLoopStore: MemoryLoopStore;
+export declare const fileLoopStore: FileLoopStore;
+export declare const defaultLoopStore: RoutedLoopStore;
+export declare function startLoop(sessionId: string, options?: LoopOptions): void;
+export declare function stopLoop(sessionId: string): void;
+export declare function isLoopActive(sessionId: string): boolean;
+export declare function getLoopState(sessionId: string): LoopState | undefined;
+export declare function clearLoopStateForTests(clearPersistedFile?: boolean): void;
+export declare function configureLoopStateFilePathForTests(filePath: string): void;
+export declare function loadPersistedLoopStateForTests(): void;
+export declare function createLoopPlugin(options?: LoopHandlerOptions): import("../../plugin-api").PluginDefinition;
+/**
+ * Default plugin registration. The host injects sendContinuationMessage at runtime via createLoopPlugin().
+ */
+export declare const loopPlugin: import("../../plugin-api").PluginDefinition;
+export {};

package/dist/features/loops/shared/event-utils.d.ts

@@ -0,0 +1,7 @@
+export interface HookEvent {
+    type?: unknown;
+    properties?: unknown;
+}
+export declare function asEvent(input: unknown): HookEvent | null;
+export declare function getSessionId(properties: unknown): string | null;
+export declare function defaultCompletionDetector(event: HookEvent, completionPromise: string): boolean;

package/dist/features/loops/state.d.ts

@@ -0,0 +1,22 @@
+export interface LoopOptions {
+    persist?: boolean;
+    maxIterations?: number;
+}
+export interface LoopState {
+    active: boolean;
+    iteration: number;
+    maxIterations: number;
+    completionDetected: boolean;
+    persist: boolean;
+}
+export interface LoopStore {
+    startLoop(sessionId: string, options?: LoopOptions): void;
+    stopLoop(sessionId: string): void;
+    isActive(sessionId: string): boolean;
+    getLoopState(sessionId: string): LoopState | undefined;
+    incrementIteration(sessionId: string): void;
+    markCompletionDetected(sessionId: string): void;
+}
+export declare const DEFAULT_MAX_ITERATIONS = 100;
+export declare const UNBOUNDED_MAX_ITERATIONS = 1000;
+export declare function createInitialLoopState(options?: LoopOptions): LoopState;

package/dist/features/prompt-builder/agent-table-builder.d.ts

@@ -0,0 +1,6 @@
+export interface AgentTableEntry {
+    name: string;
+    description: string;
+    whenToUse: string;
+}
+export declare function buildAgentTable(agents: AgentTableEntry[]): string;

package/dist/features/prompt-builder/category-section-builder.d.ts

@@ -0,0 +1,2 @@
+import type { AvailableCategory } from "../../types/category";
+export declare function buildCategoriesSection(categories: AvailableCategory[]): string;

package/dist/features/prompt-builder/dynamic-prompt-builder.d.ts

@@ -0,0 +1,9 @@
+import type { AvailableCategory } from "../../types/category";
+import type { AgentTableEntry } from "./agent-table-builder";
+import type { SkillEntry } from "./skill-section-builder";
+export interface DynamicPromptInput {
+    agents: AgentTableEntry[];
+    skills: SkillEntry[];
+    categories: AvailableCategory[];
+}
+export declare function buildDynamicPrompt(input: DynamicPromptInput): string;

package/dist/features/prompt-builder/index.d.ts

@@ -0,0 +1,7 @@
+export type { AgentTableEntry } from "./agent-table-builder";
+export { buildAgentTable } from "./agent-table-builder";
+export type { SkillEntry } from "./skill-section-builder";
+export { buildSkillsSection } from "./skill-section-builder";
+export { buildCategoriesSection } from "./category-section-builder";
+export type { DynamicPromptInput } from "./dynamic-prompt-builder";
+export { buildDynamicPrompt } from "./dynamic-prompt-builder";

package/dist/features/prompt-builder/skill-section-builder.d.ts

@@ -0,0 +1,5 @@
+export interface SkillEntry {
+    name: string;
+    description: string;
+}
+export declare function buildSkillsSection(skills: SkillEntry[]): string;

package/dist/features/session-state/index.d.ts

@@ -0,0 +1,5 @@
+export { setSessionState, getSessionState, deleteSessionState, clearSessionStore, } from "./session-store";
+export type { SessionState } from "./session-store";
+export { consumeNewMessages, resetMessageCursor } from "./session-cursor";
+export type { CursorMessage } from "./session-cursor";
+export { setSessionTools, getSessionTools, deleteSessionTools, clearSessionTools, } from "./session-tools-store";

package/dist/features/session-state/session-cursor.d.ts

@@ -0,0 +1,13 @@
+type MessageTime = {
+    created?: number | string;
+} | number | string | undefined;
+type MessageInfo = {
+    id?: string;
+    time?: MessageTime;
+};
+export type CursorMessage = {
+    info?: MessageInfo;
+};
+export declare function consumeNewMessages<T extends CursorMessage>(sessionId: string | undefined, messages: T[]): T[];
+export declare function resetMessageCursor(sessionId?: string): void;
+export {};

package/dist/features/session-state/session-store.d.ts

@@ -0,0 +1,12 @@
+export interface SessionState {
+    sessionId: string;
+    model?: string;
+    agent?: string;
+    status?: "active" | "idle" | "completed";
+    createdAt: number;
+    updatedAt: number;
+}
+export declare function setSessionState(sessionId: string, state: Partial<Omit<SessionState, "sessionId" | "createdAt">>): void;
+export declare function getSessionState(sessionId: string): SessionState | undefined;
+export declare function deleteSessionState(sessionId: string): void;
+export declare function clearSessionStore(): void;

package/dist/features/session-state/session-tools-store.d.ts

@@ -0,0 +1,4 @@
+export declare function setSessionTools(sessionId: string, tools: Record<string, boolean>): void;
+export declare function getSessionTools(sessionId: string): Record<string, boolean> | undefined;
+export declare function deleteSessionTools(sessionId: string): void;
+export declare function clearSessionTools(): void;

package/dist/features/skills/builtin/git-master.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from "../skill-loader";
+export declare const gitMasterSkill: Skill;