astrocode-workflow 0.3.0 → 0.3.2

package/dist/src/agents/registry.js

@@ -0,0 +1,242 @@
+import { applyModelTuning } from "../shared/model-tuning";
+import { BASE_ORCH_PROMPT, BASE_STAGE_PROMPT, QA_AGENT_PROMPT } from "./prompts";
+function denyAll() {
+    return { "*": "deny" };
+}
+function orchestratorPermissions() {
+    return {
+        "*": "deny",
+        // Common OpenCode tools:
+        "read": "allow",
+        "grep": "allow",
+        "bash": "allow",
+        "edit": "allow",
+        "write": "allow",
+        "question": "allow",
+        // Task delegation:
+        "task": "allow",
+        "delegate_task": "allow",
+        "slashcommand": "allow",
+        // Astro tools:
+        "astro_init": "allow",
+        "astro_status": "allow",
+        "astro_workflow_proceed": "allow",
+        "astro_repair": "allow",
+        "astro_spec_get": "allow",
+        "astro_spec_set": "allow",
+        "astro_story_queue": "allow",
+        "astro_story_approve": "allow",
+        "astro_story_board": "allow",
+        "astro_story_set_state": "allow",
+        "astro_run_get": "allow",
+        "astro_run_abort": "allow",
+        "astro_stage_start": "allow",
+        "astro_stage_complete": "allow",
+        "astro_stage_fail": "allow",
+        "astro_stage_reset": "allow",
+        "astro_artifact_put": "allow",
+        "astro_artifact_list": "allow",
+        "astro_artifact_get": "allow",
+        "astro_inject_put": "allow",
+        "astro_inject_list": "allow",
+        "astro_inject_search": "allow",
+        "astro_inject_get": "allow",
+        // Git helpers (optional)
+        "astro_git_status": "allow",
+        "astro_git_diff": "allow",
+        "astro_git_commit": "ask",
+    };
+}
+function stageReadOnlyPermissions() {
+    return {
+        "*": "deny",
+        "read": "allow",
+        "grep": "allow",
+        "question": "allow",
+        "task": "deny",
+        "delegate_task": "deny",
+        "slashcommand": "deny",
+    };
+}
+function stageImplementPermissions() {
+    return {
+        "*": "deny",
+        "read": "allow",
+        "grep": "allow",
+        "edit": "allow",
+        "write": "allow",
+        "bash": "allow",
+        "question": "allow",
+        "task": "deny",
+        "delegate_task": "deny",
+        "slashcommand": "deny",
+        "astro_artifact_put": "allow",
+        "astro_artifact_list": "allow",
+        "astro_artifact_get": "allow",
+        "astro_git_diff": "allow",
+    };
+}
+function stageVerifyPermissions() {
+    return {
+        "*": "deny",
+        "read": "allow",
+        "grep": "allow",
+        "bash": "allow",
+        "question": "allow",
+        "task": "deny",
+        "delegate_task": "deny",
+        "slashcommand": "deny",
+        "astro_artifact_put": "allow",
+        "astro_artifact_list": "allow",
+        "astro_artifact_get": "allow",
+    };
+}
+export function createAstroAgents(opts) {
+    const { systemDefaultModel, pluginConfig } = opts;
+    // Ensure agents config exists with defaults
+    if (!pluginConfig.agents) {
+        pluginConfig.agents = {
+            orchestrator_name: "Astro",
+            stage_agent_names: {
+                frame: "Frame",
+                plan: "Plan",
+                spec: "Spec",
+                implement: "Implement",
+                review: "Review",
+                verify: "Verify",
+                close: "Close"
+            },
+            librarian_name: "Librarian",
+            explore_name: "Explore",
+            qa_name: "QA",
+            agent_variant_overrides: {}
+        };
+    }
+    const orchestratorName = pluginConfig.agents.orchestrator_name;
+    const modelFor = (agentName) => {
+        const overrides = pluginConfig.agents?.agent_variant_overrides || {};
+        const override = overrides[agentName];
+        return override?.model;
+    };
+    const variantFor = (agentName) => {
+        const overrides = pluginConfig.agents?.agent_variant_overrides || {};
+        const override = overrides[agentName];
+        return override?.variant;
+    };
+    const mk = (name, base, preset) => {
+        const tuned = applyModelTuning(base, preset);
+        // Apply per-agent model/variant overrides from config:
+        const withOverrides = {
+            ...tuned,
+            model: modelFor(name),
+            variant: variantFor(name),
+        };
+        return withOverrides;
+    };
+    const agents = {};
+    agents[orchestratorName] = mk(orchestratorName, {
+        description: "Astrocode vNext orchestrator. DB-driven stage machine with continuation + artifact discipline.",
+        mode: "primary",
+        maxTokens: 32000,
+        prompt: BASE_ORCH_PROMPT,
+        permission: orchestratorPermissions(),
+    }, "orchestrator");
+    // Stage agents (hidden)
+    const stageAgents = pluginConfig.agents.stage_agent_names;
+    agents[stageAgents.frame] = mk(stageAgents.frame, {
+        description: "Stage agent: frame. Produces scope + DoD baton.",
+        mode: "subagent",
+        hidden: true,
+        temperature: 0.1,
+        prompt: BASE_STAGE_PROMPT,
+        permission: stageReadOnlyPermissions(),
+    }, "frame");
+    agents[stageAgents.plan] = mk(stageAgents.plan, {
+        description: "Stage agent: plan. Produces bounded tasks + files + tests.",
+        mode: "subagent",
+        hidden: true,
+        temperature: 0.1,
+        prompt: BASE_STAGE_PROMPT,
+        permission: stageReadOnlyPermissions(),
+    }, "plan");
+    agents[stageAgents.spec] = mk(stageAgents.spec, {
+        description: "Stage agent: spec. Produces implementation contracts (minimal).",
+        mode: "subagent",
+        hidden: true,
+        temperature: 0.1,
+        prompt: BASE_STAGE_PROMPT,
+        permission: stageReadOnlyPermissions(),
+    }, "spec");
+    agents[stageAgents.implement] = mk(stageAgents.implement, {
+        description: "Stage agent: implement. Makes code changes and references diff artifacts.",
+        mode: "subagent",
+        hidden: true,
+        temperature: 0.2,
+        prompt: BASE_STAGE_PROMPT,
+        permission: stageImplementPermissions(),
+    }, "implement");
+    agents[stageAgents.review] = mk(stageAgents.review, {
+        description: "Stage agent: review. Checks spec compliance and risks.",
+        mode: "subagent",
+        hidden: true,
+        temperature: 0.1,
+        prompt: BASE_STAGE_PROMPT,
+        permission: stageReadOnlyPermissions(),
+    }, "review");
+    agents[stageAgents.verify] = mk(stageAgents.verify, {
+        description: "Stage agent: verify. Runs checks and produces evidence artifacts.",
+        mode: "subagent",
+        hidden: true,
+        temperature: 0.1,
+        prompt: BASE_STAGE_PROMPT,
+        permission: stageReadOnlyPermissions(),
+    }, "verify");
+    agents[stageAgents.close] = mk(stageAgents.close, {
+        description: "Stage agent: close. Final run summary + acceptance confirmation.",
+        mode: "subagent",
+        hidden: true,
+        temperature: 0.1,
+        prompt: BASE_STAGE_PROMPT,
+        permission: stageReadOnlyPermissions(),
+    }, "close");
+    // Optional utility agents (hidden) — intentionally minimal prompt; prefer stage directives.
+    agents[pluginConfig.agents.librarian_name] = mk(pluginConfig.agents.librarian_name, {
+        description: "Utility agent: librarian. Fast repo exploration + notes as artifacts.",
+        mode: "subagent",
+        hidden: true,
+        temperature: 0.1,
+        prompt: BASE_STAGE_PROMPT,
+        permission: stageReadOnlyPermissions(),
+    }, "utility");
+    agents[pluginConfig.agents.explore_name] = mk(pluginConfig.agents.explore_name, {
+        description: "Utility agent: explore. Spikes / scans / code search.",
+        mode: "subagent",
+        hidden: true,
+        temperature: 0.1,
+        prompt: BASE_STAGE_PROMPT,
+        permission: stageReadOnlyPermissions(),
+    }, "utility");
+    // QA agent for code review and verification
+    agents[pluginConfig.agents.qa_name] = mk(pluginConfig.agents.qa_name, {
+        description: "QA agent: Global engineering review with canonical rules and severity model.",
+        mode: "subagent",
+        hidden: false, // Make it visible for delegation
+        temperature: 0.1,
+        prompt: QA_AGENT_PROMPT,
+        permission: stageReadOnlyPermissions(), // Read-only for safety
+    }, "utility");
+    // Fallback general agent for delegation failures
+    agents["General"] = mk("General", {
+        description: "General-purpose fallback agent for delegation.",
+        mode: "subagent",
+        hidden: true,
+        temperature: 0.1,
+        prompt: BASE_STAGE_PROMPT,
+        permission: stageReadOnlyPermissions(),
+    }, "utility");
+    // Allow user config to disable certain agents
+    for (const disabled of pluginConfig.disabled_agents) {
+        delete agents[disabled];
+    }
+    return agents;
+}

package/dist/src/agents/types.d.ts

@@ -0,0 +1,14 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+/**
+ * Matches OMO-style heuristics:
+ * - OpenAI provider models: "openai/..."
+ * - GitHub Copilot GPT models: "github-copilot/gpt-..."
+ */
+export declare function isGptModel(model: string): boolean;
+export type AstroAgentName = "Astro (Orchestrator)" | "astro_frame" | "astro_plan" | "astro_spec" | "astro_implement" | "astro_review" | "astro_verify" | "astro_close" | "astro_librarian" | "astro_explore";
+export type PermissionValue = "ask" | "allow" | "deny";
+export type AgentOverrideConfig = Partial<AgentConfig> & {
+    prompt_append?: string;
+    variant?: string;
+};
+export type AgentOverrides = Partial<Record<AstroAgentName, AgentOverrideConfig>>;

package/dist/src/agents/types.js

@@ -0,0 +1,8 @@
+/**
+ * Matches OMO-style heuristics:
+ * - OpenAI provider models: "openai/..."
+ * - GitHub Copilot GPT models: "github-copilot/gpt-..."
+ */
+export function isGptModel(model) {
+    return model.startsWith("openai/") || model.startsWith("github-copilot/gpt-");
+}

package/dist/src/config/config-handler.d.ts

@@ -0,0 +1,4 @@
+import type { AstrocodeConfig } from "./schema";
+export declare function createConfigHandler(opts: {
+    pluginConfig: AstrocodeConfig;
+}): (config: Record<string, any>) => Promise<void>;

package/dist/src/config/config-handler.js

@@ -0,0 +1,46 @@
+import { createAstroAgents } from "../agents/registry";
+import { createAstroCommands } from "../agents/commands";
+/** Best-effort extraction of system default model from an OpenCode config object. */
+function detectSystemDefaultModel(config) {
+    const direct = config?.model;
+    if (typeof direct === "string" && direct.trim())
+        return direct.trim();
+    const agentDefault = config?.agent?.default?.model;
+    if (typeof agentDefault === "string" && agentDefault.trim())
+        return agentDefault.trim();
+    const firstAgent = config?.agent && typeof config.agent === "object" ? Object.values(config.agent)[0] : null;
+    const firstModel = firstAgent?.model;
+    if (typeof firstModel === "string" && firstModel.trim())
+        return firstModel.trim();
+    return "openai/gpt-4o";
+}
+export function createConfigHandler(opts) {
+    const { pluginConfig } = opts;
+    return async function configHandler(config) {
+        try {
+            const systemDefaultModel = detectSystemDefaultModel(config);
+            const agents = createAstroAgents({ systemDefaultModel, pluginConfig });
+            const commands = createAstroCommands({ pluginConfig });
+            // Merge agents (do not override user-defined agent configs with same key; user wins)
+            config.agent = config.agent ?? {};
+            for (const [name, agentCfg] of Object.entries(agents)) {
+                if (pluginConfig.disabled_agents?.includes(name))
+                    continue;
+                if (!config.agent[name])
+                    config.agent[name] = agentCfg;
+            }
+            // Merge commands (user wins)
+            config.command = config.command ?? {};
+            for (const [name, cmd] of Object.entries(commands)) {
+                if (pluginConfig.disabled_commands?.includes(name))
+                    continue;
+                if (!config.command[name])
+                    config.command[name] = cmd;
+            }
+        }
+        catch (e) {
+            console.warn("[astrocode] Config handler failed:", e);
+            // Don't crash OpenCode, just skip config modifications
+        }
+    };
+}

package/dist/src/config/defaults.d.ts

@@ -0,0 +1,3 @@
+import { type AstrocodeConfig } from "./schema";
+/** Concrete defaults object (post-Zod defaults). */
+export declare const DEFAULT_CONFIG: AstrocodeConfig;

package/dist/src/config/defaults.js

@@ -0,0 +1,3 @@
+import { AstrocodeConfigSchema } from "./schema";
+/** Concrete defaults object (post-Zod defaults). */
+export const DEFAULT_CONFIG = AstrocodeConfigSchema.parse({});

package/dist/src/config/loader.d.ts

@@ -0,0 +1,11 @@
+import { type AstrocodeConfig } from "./schema";
+export type ConfigFileDetection = {
+    format: "jsonc" | "json";
+    path: string;
+} | {
+    format: "none";
+    path: string;
+};
+export declare function detectConfigFile(basePathNoExt: string): ConfigFileDetection;
+export declare function loadConfigFromPath(p: string): AstrocodeConfig | null;
+export declare function loadAstrocodeConfig(repoRoot: string): AstrocodeConfig;

package/dist/src/config/loader.js

@@ -0,0 +1,82 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parse as parseJsonc } from "jsonc-parser";
+import { AstrocodeConfigSchema } from "./schema";
+import { deepMerge } from "../shared/deep-merge";
+import { warn } from "../shared/log";
+function validateJsonSerializable(obj, path = "") {
+    if (obj === null || obj === undefined)
+        return;
+    if (typeof obj === "boolean" || typeof obj === "number" || typeof obj === "string")
+        return;
+    if (typeof obj === "bigint") {
+        throw new Error(`Config contains non-JSON-serializable bigint at ${path}`);
+    }
+    if (typeof obj === "symbol") {
+        throw new Error(`Config contains non-JSON-serializable symbol at ${path}`);
+    }
+    if (typeof obj === "function") {
+        throw new Error(`Config contains non-JSON-serializable function at ${path}`);
+    }
+    if (obj instanceof Date) {
+        throw new Error(`Config contains non-JSON-serializable Date at ${path}`);
+    }
+    if (obj instanceof Map || obj instanceof Set) {
+        throw new Error(`Config contains non-JSON-serializable ${obj.constructor.name} at ${path}`);
+    }
+    if (Array.isArray(obj)) {
+        for (let i = 0; i < obj.length; i++) {
+            validateJsonSerializable(obj[i], `${path}[${i}]`);
+        }
+    }
+    else if (typeof obj === "object") {
+        for (const key of Object.keys(obj)) {
+            validateJsonSerializable(obj[key], path ? `${path}.${key}` : key);
+        }
+    }
+}
+export function detectConfigFile(basePathNoExt) {
+    const jsoncPath = basePathNoExt + ".jsonc";
+    if (fs.existsSync(jsoncPath))
+        return { format: "jsonc", path: jsoncPath };
+    const jsonPath = basePathNoExt + ".json";
+    if (fs.existsSync(jsonPath))
+        return { format: "json", path: jsonPath };
+    return { format: "none", path: basePathNoExt + ".jsonc" };
+}
+export function loadConfigFromPath(p) {
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        const raw = fs.readFileSync(p, "utf-8");
+        const parsed = parseJsonc(raw);
+        const cfg = AstrocodeConfigSchema.parse(parsed);
+        return cfg;
+    }
+    catch (e) {
+        warn(`Failed to load astrocode config at ${p}; using defaults`, String(e));
+        return null;
+    }
+}
+export function loadAstrocodeConfig(repoRoot) {
+    // project-level: prefer .astro/astrocode.config.jsonc; fallback astrocode.config.jsonc
+    const projectBase = path.join(repoRoot, ".astro", "astrocode.config");
+    const projectDetected = detectConfigFile(projectBase);
+    const projectCfg = loadConfigFromPath(projectDetected.path);
+    const legacyBase = path.join(repoRoot, "astrocode.config");
+    const legacyDetected = detectConfigFile(legacyBase);
+    const legacyCfg = loadConfigFromPath(legacyDetected.path);
+    // Start with defaults and merge configs
+    let cfg = AstrocodeConfigSchema.parse({});
+    if (legacyCfg)
+        cfg = deepMerge(cfg, legacyCfg);
+    if (projectCfg)
+        cfg = deepMerge(cfg, projectCfg);
+    // Ensure the final config is fully validated with all required defaults
+    cfg = AstrocodeConfigSchema.parse(cfg);
+    // CRITICAL CONTRACT: ensure config is JSON-serializable for recovery mode compatibility
+    // This prevents silent data corruption in cloneConfig's JSON fallback
+    validateJsonSerializable(cfg);
+    // Config loaded successfully (silent)
+    return cfg;
+}

package/dist/src/config/schema.d.ts

@@ -0,0 +1,194 @@
+import { z } from "zod";
+export declare const PermissionValueSchema: z.ZodEnum<{
+    ask: "ask";
+    allow: "allow";
+    deny: "deny";
+}>;
+export type PermissionValue = z.infer<typeof PermissionValueSchema>;
+declare const StageKeySchema: z.ZodEnum<{
+    frame: "frame";
+    plan: "plan";
+    spec: "spec";
+    implement: "implement";
+    review: "review";
+    verify: "verify";
+    close: "close";
+}>;
+export type StageKey = z.infer<typeof StageKeySchema>;
+export declare const AstrocodeConfigSchema: z.ZodDefault<z.ZodObject<{
+    disabled_hooks: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    disabled_agents: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    disabled_commands: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    determinism: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+            off: "off";
+            on: "on";
+        }>>>;
+        strict_stage_order: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    }, z.core.$strip>>>;
+    db: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        path: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        busy_timeout_ms: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        pragmas: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+            journal_mode: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+                WAL: "WAL";
+                DELETE: "DELETE";
+            }>>>;
+            synchronous: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+                NORMAL: "NORMAL";
+                FULL: "FULL";
+                OFF: "OFF";
+            }>>>;
+            foreign_keys: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            temp_store: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+                DEFAULT: "DEFAULT";
+                MEMORY: "MEMORY";
+                FILE: "FILE";
+            }>>>;
+        }, z.core.$strip>>>;
+        schema_version_required: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        allow_auto_migrate: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        fail_on_downgrade: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    }, z.core.$strip>>>;
+    workflow: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        pipeline: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            frame: "frame";
+            plan: "plan";
+            spec: "spec";
+            implement: "implement";
+            review: "review";
+            verify: "verify";
+            close: "close";
+        }>>>>;
+        genesis_planning: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+            off: "off";
+            first_story_only: "first_story_only";
+            always: "always";
+        }>>>;
+        default_mode: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+            step: "step";
+            loop: "loop";
+        }>>>;
+        default_max_steps: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        loop_max_steps_hard_cap: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        plan_max_tasks: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        plan_max_lines: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        baton_summary_max_lines: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        forbid_prompt_narration: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        single_active_run_per_repo: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        lock_timeout_ms: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        role_first_subagents: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        evidence_required: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+            verify: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            implement: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    continuation: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        injection_mode: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+            visible: "visible";
+            silent: "silent";
+        }>>>;
+        inject_on_session_idle: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        session_idle_ms: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        inject_on_tool_done_if_run_active: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        inject_on_message_done_if_run_active: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        dedupe_window_ms: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        max_same_directive_repeats: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        auto_continue: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        auto_continue_delay_ms: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        max_auto_steps_per_session: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    }, z.core.$strip>>>;
+    truncation: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        truncate_all_tool_outputs: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        max_chars_default: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        max_chars_webfetch: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        max_chars_diff: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        persist_truncated_outputs: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    }, z.core.$strip>>>;
+    context_compaction: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        snapshot_after_stage_count: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        snapshot_max_lines: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        baton_summary_max_lines: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        inject_max_chars: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    }, z.core.$strip>>>;
+    artifacts: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        root_dir: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        runs_dir: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        spec_path: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        write_full_baton_md: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        write_baton_summary_md: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        write_baton_output_json: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        baton_filename: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        baton_summary_filename: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        baton_json_filename: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    }, z.core.$strip>>>;
+    agents: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        orchestrator_name: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        stage_agent_names: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+            frame: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+            plan: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+            spec: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+            implement: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+            review: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+            verify: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+            close: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        }, z.core.$strip>>>;
+        librarian_name: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        explore_name: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        qa_name: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        agent_variant_overrides: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            variant: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>>;
+    }, z.core.$strip>>>;
+    permissions: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        enforce_task_tool_restrictions: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        deny_delegate_task_in_subagents: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    }, z.core.$strip>>>;
+    git: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        allow_dirty_start: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        auto_branch: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        branch_prefix: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        auto_commit: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        commit_message_template: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        persist_diff_artifacts: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    }, z.core.$strip>>>;
+    ui: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        toasts: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            throttle_ms: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            show_run_started: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            show_stage_started: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            show_stage_completed: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            show_stage_failed: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            show_run_completed: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            show_auto_continue: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        }, z.core.$strip>>>;
+        continue_prompt: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            mode: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+                toast_button: "toast_button";
+                popup: "popup";
+                chat_only: "chat_only";
+            }>>>;
+            idle_prompt_ms: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    inject: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        scope_allowlist: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        type_allowlist: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        max_per_turn: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    }, z.core.$strip>>>;
+    debug: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        telemetry: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>>;
+export type AstrocodeConfig = z.infer<typeof AstrocodeConfigSchema>;
+export {};