astrocode-workflow 0.0.1

package/dist/tools/status.js

@@ -0,0 +1,107 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { decideNextAction, getActiveRun, getStageRuns, getStory } from "../workflow/state-machine";
+function statusIcon(status) {
+    switch (status) {
+        case "running":
+            return "🟦";
+        case "completed":
+            return "✅";
+        case "failed":
+            return "⛔";
+        case "aborted":
+            return "🛑";
+        case "created":
+            return "🆕";
+        default:
+            return "⬜";
+    }
+}
+function stageIcon(status) {
+    switch (status) {
+        case "completed":
+            return "✅";
+        case "running":
+            return "🟦";
+        case "failed":
+            return "⛔";
+        case "skipped":
+            return "⏭️";
+        default:
+            return "⬜";
+    }
+}
+export function createAstroStatusTool(opts) {
+    const { config, db } = opts;
+    return tool({
+        description: "Show a compact Astrocode status dashboard: active run/stage, pipeline, story board counts, and next action.",
+        args: {
+            include_board: tool.schema.boolean().default(true),
+            include_recent_events: tool.schema.boolean().default(false),
+        },
+        execute: async ({ include_board, include_recent_events }) => {
+            // Check if database is available
+            if (!db) {
+                return "🔄 Astrocode Status\n\n⚠️ Limited Mode: Database not available\nAstrocode is running with reduced functionality";
+            }
+            const active = getActiveRun(db);
+            const lines = [];
+            lines.push(`# Astrocode Status`);
+            if (!active) {
+                lines.push(`- Active run: *(none)*`);
+                const next = decideNextAction(db, config);
+                if (next.kind === "idle")
+                    lines.push(`- Next: ${next.reason === "no_approved_stories" ? "No approved stories." : "Idle."}`);
+                if (include_board) {
+                    const counts = db
+                        .prepare("SELECT state, COUNT(*) as c FROM stories GROUP BY state ORDER BY state")
+                        .all();
+                    lines.push(``, `## Story board`);
+                    for (const row of counts)
+                        lines.push(`- ${row.state}: ${row.c}`);
+                }
+                return lines.join("\n");
+            }
+            const story = getStory(db, active.story_key);
+            const stageRuns = getStageRuns(db, active.run_id);
+            lines.push(`- Active run: \`${active.run_id}\` ${statusIcon(active.status)} **${active.status}**`);
+            lines.push(`- Story: \`${active.story_key}\` — ${story?.title ?? "(missing)"}  (${story?.state ?? "?"})`);
+            lines.push(`- Current stage: \`${active.current_stage_key ?? "?"}\``);
+            lines.push(``, `## Pipeline`);
+            for (const s of stageRuns) {
+                lines.push(`- ${stageIcon(s.status)} \`${s.stage_key}\` (${s.status})`);
+            }
+            const next = decideNextAction(db, config);
+            lines.push(``, `## Next`);
+            lines.push(`- ${next.kind}`);
+            if (next.kind === "await_stage_completion") {
+                lines.push(`- Awaiting output for stage \`${next.stage_key}\`. When you have it, call **astro_stage_complete** with the stage output text.`);
+            }
+            else if (next.kind === "delegate_stage") {
+                lines.push(`- Need to run stage \`${next.stage_key}\`. Use **astro_workflow_proceed** (or delegate to the matching stage agent).`);
+            }
+            else if (next.kind === "complete_run") {
+                lines.push(`- All stages done. Run can be completed via **astro_workflow_proceed**.`);
+            }
+            else if (next.kind === "failed") {
+                lines.push(`- Run failed at \`${next.stage_key}\`: ${next.error_text}`);
+            }
+            if (include_board) {
+                const counts = db
+                    .prepare("SELECT state, COUNT(*) as c FROM stories GROUP BY state ORDER BY state")
+                    .all();
+                lines.push(``, `## Story board`);
+                for (const row of counts)
+                    lines.push(`- ${row.state}: ${row.c}`);
+            }
+            if (include_recent_events) {
+                const evs = db
+                    .prepare("SELECT created_at, type, run_id, stage_key FROM events ORDER BY created_at DESC LIMIT 10")
+                    .all();
+                lines.push(``, `## Recent events`);
+                for (const e of evs)
+                    lines.push(`- ${e.created_at} — ${e.type}${e.run_id ? ` (run=${e.run_id})` : ""}${e.stage_key ? ` stage=${e.stage_key}` : ""}`);
+            }
+            return lines.join("\n");
+        },
+    });
+}

package/dist/tools/story.d.ts

@@ -0,0 +1,23 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+export declare function createAstroStoryQueueTool(opts: {
+    ctx: any;
+    config: AstrocodeConfig;
+    db: SqliteDb;
+}): ToolDefinition;
+export declare function createAstroStoryApproveTool(opts: {
+    ctx: any;
+    config: AstrocodeConfig;
+    db: SqliteDb;
+}): ToolDefinition;
+export declare function createAstroStoryBoardTool(opts: {
+    ctx: any;
+    config: AstrocodeConfig;
+    db: SqliteDb;
+}): ToolDefinition;
+export declare function createAstroStorySetStateTool(opts: {
+    ctx: any;
+    config: AstrocodeConfig;
+    db: SqliteDb;
+}): ToolDefinition;

package/dist/tools/story.js

@@ -0,0 +1,85 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { withTx } from "../state/db";
+import { nowISO } from "../shared/time";
+import { insertStory } from "../workflow/story-helpers";
+export function createAstroStoryQueueTool(opts) {
+    const { db } = opts;
+    return tool({
+        description: "Create a queued story (ticket) in Astrocode. Returns story_key.",
+        args: {
+            title: tool.schema.string().min(1),
+            body_md: tool.schema.string().default(""),
+            epic_key: tool.schema.string().optional(),
+            priority: tool.schema.number().int().default(0),
+        },
+        execute: async ({ title, body_md, epic_key, priority }) => {
+            const now = nowISO();
+            const story_key = withTx(db, () => {
+                return insertStory(db, { title, body_md, epic_key: epic_key ?? null, priority: priority ?? 0, state: 'queued' });
+            });
+            return `✅ Queued story ${story_key}: ${title}`;
+        },
+    });
+}
+export function createAstroStoryApproveTool(opts) {
+    const { db } = opts;
+    return tool({
+        description: "Approve a story so it becomes eligible to run.",
+        args: {
+            story_key: tool.schema.string().min(1),
+        },
+        execute: async ({ story_key }) => {
+            const now = nowISO();
+            const row = db.prepare("SELECT story_key, state, title FROM stories WHERE story_key=?").get(story_key);
+            if (!row)
+                throw new Error(`Story not found: ${story_key}`);
+            if (row.state === "approved")
+                return `ℹ️ Story ${story_key} already approved.`;
+            db.prepare("UPDATE stories SET state='approved', approved_at=?, updated_at=? WHERE story_key=?").run(now, now, story_key);
+            return `✅ Approved story ${story_key}: ${row.title}`;
+        },
+    });
+}
+export function createAstroStoryBoardTool(opts) {
+    const { db } = opts;
+    return tool({
+        description: "Show stories grouped by state (a compact board).",
+        args: {
+            limit_per_state: tool.schema.number().int().positive().default(20),
+        },
+        execute: async ({ limit_per_state }) => {
+            const states = ["queued", "approved", "in_progress", "blocked", "done", "archived"];
+            const lines = [];
+            lines.push("# Story board");
+            for (const st of states) {
+                const rows = db
+                    .prepare("SELECT story_key, title, priority, created_at FROM stories WHERE state=? ORDER BY priority DESC, created_at ASC LIMIT ?")
+                    .all(st, limit_per_state);
+                lines.push("", `## ${st} (${rows.length})`);
+                for (const r of rows)
+                    lines.push(`- \`${r.story_key}\` (p=${r.priority}) — ${r.title}`);
+            }
+            return lines.join("\n").trim();
+        },
+    });
+}
+export function createAstroStorySetStateTool(opts) {
+    const { db } = opts;
+    return tool({
+        description: "Admin: set story state manually (queued|approved|in_progress|done|blocked|archived). Use carefully.",
+        args: {
+            story_key: tool.schema.string().min(1),
+            state: tool.schema.enum(["queued", "approved", "in_progress", "done", "blocked", "archived"]),
+            note: tool.schema.string().default(""),
+        },
+        execute: async ({ story_key, state, note }) => {
+            const now = nowISO();
+            const row = db.prepare("SELECT story_key, title, state FROM stories WHERE story_key=?").get(story_key);
+            if (!row)
+                throw new Error(`Story not found: ${story_key}`);
+            db.prepare("UPDATE stories SET state=?, updated_at=? WHERE story_key=?").run(state, now, story_key);
+            db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, NULL, NULL, 'story.state_set', ?, ?)").run(`evt_${Date.now()}_${Math.random().toString(16).slice(2)}`, JSON.stringify({ story_key, from: row.state, to: state, note }), now);
+            return `✅ Story ${story_key} state: ${row.state} → ${state}${note ? ` (${note})` : ""}`;
+        },
+    });
+}

package/dist/tools/workflow.d.ts

@@ -0,0 +1,8 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+export declare function createAstroWorkflowProceedTool(opts: {
+    ctx: any;
+    config: AstrocodeConfig;
+    db: SqliteDb;
+}): ToolDefinition;

package/dist/tools/workflow.js

@@ -0,0 +1,197 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { withTx } from "../state/db";
+import { buildContextSnapshot } from "../workflow/context";
+import { decideNextAction, createRunForStory, startStage, completeRun, getActiveRun } from "../workflow/state-machine";
+import { buildStageDirective, directiveHash } from "../workflow/directives";
+import { injectChatPrompt } from "../ui/inject";
+import { nowISO } from "../shared/time";
+import { newEventId } from "../state/ids";
+import { createToastManager } from "../ui/toasts";
+function stageGoal(stage, cfg) {
+    switch (stage) {
+        case "frame":
+            return "Define scope, constraints, and an unambiguous Definition of Done.";
+        case "plan":
+            return `Produce a bounded task plan (<= ${cfg.workflow.plan_max_tasks} tasks) tied to files and tests.`;
+        case "spec":
+            return "Produce minimal spec/contract: interfaces, invariants, acceptance checks.";
+        case "implement":
+            return "Implement the spec with minimal changes, referencing diffs and evidence as artifacts.";
+        case "review":
+            return "Review implementation for correctness, risks, and alignment with spec.";
+        case "verify":
+            return "Run verification commands and produce evidence artifacts.";
+        case "close":
+            return "Summarize outcome and confirm acceptance criteria, leaving clear breadcrumbs.";
+    }
+}
+function stageConstraints(stage, cfg) {
+    const common = [
+        "Do not narrate prompts.",
+        "Keep baton markdown short and structured.",
+        "If blocked: ask exactly ONE question and stop.",
+    ];
+    if (stage === "plan") {
+        common.push(`Hard limit: <= ${cfg.workflow.plan_max_tasks} tasks and <= ${cfg.workflow.plan_max_lines} lines of plan output.`);
+    }
+    if (stage === "verify" && cfg.workflow.evidence_required.verify) {
+        common.push("Evidence required: ASTRO JSON must include evidence[] paths.");
+    }
+    return common;
+}
+function agentNameForStage(stage, cfg) {
+    return cfg.agents.stage_agent_names[stage];
+}
+function buildDelegationPrompt(opts) {
+    const { stageDirective, run_id, stage_key, stage_agent_name } = opts;
+    const stageUpper = stage_key.toUpperCase();
+    return [
+        `[SYSTEM DIRECTIVE: ASTROCODE — DELEGATE_STAGE_${stageUpper}]`,
+        ``,
+        `Do this now, in order:`,
+        `1) Call the **task** tool to delegate to subagent \`${stage_agent_name}\`.`,
+        `   - Pass this exact prompt text to the subagent (copy/paste):`,
+        ``,
+        stageDirective,
+        ``,
+        `2) When the subagent returns, immediately call **astro_stage_complete** with:`,
+        `   - run_id = "${run_id}"`,
+        `   - stage_key = "${stage_key}"`,
+        `   - output_text = (the FULL subagent response text)`,
+        ``,
+        `3) Then call **astro_workflow_proceed** again (mode=step).`,
+        ``,
+        `Important: do NOT do any stage work yourself in orchestrator mode.`,
+    ].join("\n").trim();
+}
+export function createAstroWorkflowProceedTool(opts) {
+    const { ctx, config, db } = opts;
+    const toasts = createToastManager({ ctx, throttleMs: config.ui.toasts.throttle_ms });
+    return tool({
+        description: "Deterministic harness: advances the DB-driven pipeline by one step (or loops bounded). Stops when LLM work is required (delegation/await).",
+        args: {
+            mode: tool.schema.enum(["step", "loop"]).default(config.workflow.default_mode),
+            max_steps: tool.schema.number().int().positive().default(config.workflow.default_max_steps),
+        },
+        execute: async ({ mode, max_steps }) => {
+            const sessionId = ctx.sessionID;
+            const steps = Math.min(max_steps, config.workflow.loop_max_steps_hard_cap);
+            const actions = [];
+            const startedAt = nowISO();
+            for (let i = 0; i < steps; i++) {
+                const next = decideNextAction(db, config);
+                if (next.kind === "idle") {
+                    actions.push("idle: no approved stories");
+                    break;
+                }
+                if (next.kind === "start_run") {
+                    const { run_id } = withTx(db, () => createRunForStory(db, config, next.story_key));
+                    actions.push(`started run ${run_id} for story ${next.story_key}`);
+                    if (config.ui.toasts.enabled && config.ui.toasts.show_run_started) {
+                        await toasts.show({ title: "Astrocode", message: `Run started (${run_id})`, variant: "success" });
+                    }
+                    if (mode === "step")
+                        break;
+                    continue;
+                }
+                if (next.kind === "complete_run") {
+                    withTx(db, () => completeRun(db, next.run_id));
+                    actions.push(`completed run ${next.run_id}`);
+                    if (config.ui.toasts.enabled && config.ui.toasts.show_run_completed) {
+                        await toasts.show({ title: "Astrocode", message: `Run completed (${next.run_id})`, variant: "success" });
+                    }
+                    if (mode === "step")
+                        break;
+                    continue;
+                }
+                if (next.kind === "delegate_stage") {
+                    const active = getActiveRun(db);
+                    if (!active)
+                        throw new Error("Invariant: delegate_stage but no active run.");
+                    const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(active.run_id);
+                    const story = db.prepare("SELECT * FROM stories WHERE story_key=?").get(run.story_key);
+                    // Mark stage started + set subagent_type to the stage agent.
+                    const agentName = agentNameForStage(next.stage_key, config);
+                    withTx(db, () => {
+                        startStage(db, active.run_id, next.stage_key, { subagent_type: agentName });
+                    });
+                    if (config.ui.toasts.enabled && config.ui.toasts.show_stage_started) {
+                        await toasts.show({ title: "Astrocode", message: `Stage started: ${next.stage_key}`, variant: "info" });
+                    }
+                    const context = buildContextSnapshot({ db, config, run_id: active.run_id, next_action: `delegate stage ${next.stage_key}` });
+                    const stageDirective = buildStageDirective({
+                        config,
+                        stage_key: next.stage_key,
+                        run_id: active.run_id,
+                        story_key: run.story_key,
+                        story_title: story?.title ?? "(missing)",
+                        stage_agent_name: agentName,
+                        stage_goal: stageGoal(next.stage_key, config),
+                        stage_constraints: stageConstraints(next.stage_key, config),
+                        context_snapshot_md: context,
+                    }).body;
+                    const delegatePrompt = buildDelegationPrompt({
+                        stageDirective,
+                        run_id: active.run_id,
+                        stage_key: next.stage_key,
+                        stage_agent_name: agentName,
+                    });
+                    // Record in continuations as a stage directive (dedupe by hash)
+                    const h = directiveHash(delegatePrompt);
+                    const now = nowISO();
+                    if (sessionId) {
+                        db.prepare("INSERT INTO continuations (session_id, run_id, directive_hash, kind, reason, created_at) VALUES (?, ?, ?, 'stage', ?, ?)").run(sessionId, active.run_id, h, `delegate ${next.stage_key}`, now);
+                    }
+                    // Visible injection so user can see state
+                    if (sessionId) {
+                        await injectChatPrompt({ ctx, sessionId, text: delegatePrompt });
+                    }
+                    actions.push(`delegated stage ${next.stage_key} via ${agentName}`);
+                    // Stop here; subagent needs to run.
+                    break;
+                }
+                if (next.kind === "await_stage_completion") {
+                    actions.push(`await stage completion: ${next.stage_key}`);
+                    // Optionally nudge with a short directive
+                    if (sessionId) {
+                        const context = buildContextSnapshot({ db, config, run_id: next.run_id, next_action: `complete stage ${next.stage_key}` });
+                        const prompt = [
+                            `[SYSTEM DIRECTIVE: ASTROCODE — AWAIT_STAGE_OUTPUT]`,
+                            ``,
+                            `Run ${next.run_id} is waiting for stage ${next.stage_key} output.`,
+                            `If you have the subagent output, call astro_stage_complete with output_text=the FULL output.`,
+                            ``,
+                            `Context snapshot:`,
+                            context,
+                        ].join("\n").trim();
+                        const h = directiveHash(prompt);
+                        const now = nowISO();
+                        db.prepare("INSERT INTO continuations (session_id, run_id, directive_hash, kind, reason, created_at) VALUES (?, ?, ?, 'continue', ?, ?)").run(sessionId, next.run_id, h, `await ${next.stage_key}`, now);
+                        await injectChatPrompt({ ctx, sessionId, text: prompt });
+                    }
+                    break;
+                }
+                if (next.kind === "failed") {
+                    actions.push(`failed: ${next.stage_key} — ${next.error_text}`);
+                    break;
+                }
+                // safety
+                actions.push(`unhandled next action: ${next.kind}`);
+                break;
+            }
+            // Housekeeping event
+            db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, NULL, NULL, 'workflow.proceed', ?, ?)").run(newEventId(), JSON.stringify({ started_at: startedAt, mode, max_steps: steps, actions }), nowISO());
+            const active = getActiveRun(db);
+            const lines = [];
+            lines.push(`# astro_workflow_proceed`);
+            lines.push(`- mode: ${mode}`);
+            lines.push(`- steps requested: ${max_steps} (cap=${steps})`);
+            if (active)
+                lines.push(`- active run: \`${active.run_id}\` (stage=${active.current_stage_key ?? "?"})`);
+            lines.push(``, `## Actions`);
+            for (const a of actions)
+                lines.push(`- ${a}`);
+            return lines.join("\n").trim();
+        },
+    });
+}

package/dist/ui/inject.d.ts

@@ -0,0 +1,5 @@
+export declare function injectChatPrompt(opts: {
+    ctx: any;
+    sessionId: string;
+    text: string;
+}): Promise<void>;

package/dist/ui/inject.js

@@ -0,0 +1,9 @@
+export async function injectChatPrompt(opts) {
+    const { ctx, sessionId, text } = opts;
+    await ctx.client.session.prompt({
+        path: { id: sessionId },
+        body: {
+            parts: [{ type: "text", text }],
+        },
+    });
+}

package/dist/ui/toasts.d.ts

@@ -0,0 +1,13 @@
+export type ToastVariant = "info" | "success" | "warning" | "error";
+export type ToastOptions = {
+    title: string;
+    message: string;
+    variant?: ToastVariant;
+    durationMs?: number;
+};
+export declare function createToastManager(opts: {
+    ctx: any;
+    throttleMs: number;
+}): {
+    show: (toast: ToastOptions) => Promise<void>;
+};

package/dist/ui/toasts.js

@@ -0,0 +1,39 @@
+export function createToastManager(opts) {
+    const { ctx, throttleMs } = opts;
+    let lastAt = 0;
+    async function show(toast) {
+        const now = Date.now();
+        if (now - lastAt < throttleMs)
+            return;
+        lastAt = now;
+        const tui = ctx?.client?.tui;
+        if (tui?.showToast) {
+            try {
+                await tui.showToast({
+                    title: toast.title,
+                    message: toast.message,
+                    variant: toast.variant ?? "info",
+                    durationMs: toast.durationMs ?? 2500,
+                });
+                return;
+            }
+            catch {
+                // fall through
+            }
+        }
+        // Fallback: visible chat prompt
+        try {
+            const sessionId = ctx?.sessionID;
+            if (!sessionId)
+                return;
+            await ctx.client.session.prompt({
+                path: { id: sessionId },
+                body: { parts: [{ type: "text", text: `[ASTRO TOAST] ${toast.title}: ${toast.message}` }] },
+            });
+        }
+        catch {
+            // ignore
+        }
+    }
+    return { show };
+}

package/dist/workflow/artifacts.d.ts

@@ -0,0 +1,24 @@
+import type { SqliteDb } from "../state/db";
+export type ArtifactType = "baton" | "summary" | "evidence" | "diff" | "log" | "commit" | "tool_output" | "snapshot" | "spec";
+export type PutArtifactOpts = {
+    repoRoot: string;
+    db: SqliteDb;
+    run_id?: string | null;
+    stage_key?: string | null;
+    type: ArtifactType | string;
+    rel_path: string;
+    content: string | Buffer;
+    meta?: Record<string, unknown>;
+};
+export declare function writeFileSafe(repoRoot: string, relPath: string, content: string | Buffer): void;
+export declare function putArtifact(opts: PutArtifactOpts): {
+    artifact_id: string;
+    sha256: string;
+    abs_path: string;
+};
+export declare function listArtifacts(db: SqliteDb, filters?: {
+    run_id?: string;
+    stage_key?: string;
+    type?: string;
+}): any[];
+export declare function getArtifact(db: SqliteDb, artifact_id: string): any | null;

package/dist/workflow/artifacts.js

@@ -0,0 +1,45 @@
+import fs from "node:fs";
+import path from "node:path";
+import { newArtifactId } from "../state/ids";
+import { nowISO } from "../shared/time";
+import { sha256Hex } from "../shared/hash";
+import { assertInsideAstro, ensureDir, toPosix } from "../shared/paths";
+export function writeFileSafe(repoRoot, relPath, content) {
+    const abs = path.join(repoRoot, relPath);
+    assertInsideAstro(repoRoot, abs);
+    ensureDir(path.dirname(abs));
+    fs.writeFileSync(abs, content);
+}
+export function putArtifact(opts) {
+    const { repoRoot, db, run_id = null, stage_key = null, type, rel_path, content } = opts;
+    const artifact_id = newArtifactId();
+    const abs_path = path.join(repoRoot, rel_path);
+    writeFileSafe(repoRoot, rel_path, content);
+    const sha256 = sha256Hex(content instanceof Buffer ? content : Buffer.from(content, "utf-8"));
+    const created_at = nowISO();
+    const meta_json = JSON.stringify(opts.meta ?? {});
+    db.prepare("INSERT INTO artifacts (artifact_id, run_id, stage_key, type, path, sha256, meta_json, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(artifact_id, run_id, stage_key, type, toPosix(rel_path), sha256, meta_json, created_at);
+    return { artifact_id, sha256, abs_path };
+}
+export function listArtifacts(db, filters) {
+    const where = [];
+    const params = [];
+    if (filters?.run_id) {
+        where.push("run_id = ?");
+        params.push(filters.run_id);
+    }
+    if (filters?.stage_key) {
+        where.push("stage_key = ?");
+        params.push(filters.stage_key);
+    }
+    if (filters?.type) {
+        where.push("type = ?");
+        params.push(filters.type);
+    }
+    const sql = `SELECT * FROM artifacts ${where.length ? "WHERE " + where.join(" AND ") : ""} ORDER BY created_at DESC LIMIT 200`;
+    return db.prepare(sql).all(...params);
+}
+export function getArtifact(db, artifact_id) {
+    const row = db.prepare("SELECT * FROM artifacts WHERE artifact_id = ?").get(artifact_id);
+    return row ?? null;
+}

package/dist/workflow/baton.d.ts

@@ -0,0 +1,66 @@
+import type { AstrocodeConfig } from "../config/schema";
+import { z } from "zod";
+export declare const ASTRO_JSON_BEGIN = "<!-- ASTRO_JSON_BEGIN -->";
+export declare const ASTRO_JSON_END = "<!-- ASTRO_JSON_END -->";
+export declare const StageKeySchema: z.ZodEnum<{
+    frame: "frame";
+    plan: "plan";
+    spec: "spec";
+    implement: "implement";
+    review: "review";
+    verify: "verify";
+    close: "close";
+}>;
+export declare const AstroJsonSchema: z.ZodObject<{
+    schema_version: z.ZodDefault<z.ZodNumber>;
+    run_id: z.ZodOptional<z.ZodString>;
+    story_key: z.ZodOptional<z.ZodString>;
+    stage_key: z.ZodEnum<{
+        frame: "frame";
+        plan: "plan";
+        spec: "spec";
+        implement: "implement";
+        review: "review";
+        verify: "verify";
+        close: "close";
+    }>;
+    status: z.ZodDefault<z.ZodEnum<{
+        blocked: "blocked";
+        failed: "failed";
+        ok: "ok";
+    }>>;
+    summary: z.ZodDefault<z.ZodString>;
+    decisions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    next_actions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    files: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        kind: z.ZodDefault<z.ZodString>;
+        notes: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        kind: z.ZodDefault<z.ZodString>;
+        notes: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    new_stories: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        body_md: z.ZodOptional<z.ZodString>;
+        priority: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    questions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    metrics: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+}, z.core.$strip>;
+export type AstroJson = z.infer<typeof AstroJsonSchema>;
+export type ParsedStageOutput = {
+    baton_md: string;
+    astro_json: AstroJson | null;
+    astro_json_raw: string | null;
+    error: string | null;
+};
+export declare function parseStageOutputText(text: string): ParsedStageOutput;
+export declare function buildBatonSummary(opts: {
+    config: AstrocodeConfig;
+    stage_key: string;
+    astro_json: AstroJson | null;
+    baton_md: string;
+}): string;