astrocode-workflow 0.1.58 → 0.2.0

package/dist/ui/inject.d.ts

@@ -1,6 +1,20 @@
-export declare function injectChatPrompt(opts: {
+type QueueItem = {
     ctx: any;
     sessionId: string;
     text: string;
     agent?: string;
-}): Promise<void>;
+};
+/**
+ * Enqueue an injection and ensure the worker is running.
+ * Does NOT wait for delivery — use `flushChatPrompts()` to wait.
+ */
+export declare function enqueueChatPrompt(opts: QueueItem): void;
+/**
+ * Wait until all queued injections have been processed (sent or exhausted retries).
+ */
+export declare function flushChatPrompts(): Promise<void>;
+/**
+ * Deterministic helper: enqueue + flush (recommended for stage boundaries).
+ */
+export declare function injectChatPrompt(opts: QueueItem): Promise<void>;
+export {};

package/dist/ui/inject.js

@@ -1,47 +1,118 @@
-let isInjecting = false;
+// src/ui/inject.ts
+//
+// Deterministic chat injection:
+// - Always enqueue
+// - Process sequentially (per-process single worker)
+// - Retries with backoff
+// - flush() lets callers wait until injections are actually sent
+//
+// IMPORTANT: Callers who need reliability must `await injectChatPrompt(...)`
+// or `await flushChatPrompts()` after enqueueing.
 const injectionQueue = [];
-async function processQueue() {
-    if (isInjecting || injectionQueue.length === 0)
+let workerRunning = false;
+// Used to let callers await "queue drained"
+let drainWaiters = [];
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function resolveDrainWaitersIfIdle() {
+    if (workerRunning)
         return;
-    isInjecting = true;
-    const opts = injectionQueue.shift();
-    if (!opts) {
-        isInjecting = false;
+    if (injectionQueue.length !== 0)
+        return;
+    const waiters = drainWaiters;
+    drainWaiters = [];
+    for (const w of waiters)
+        w();
+}
+function getPromptApi(ctx) {
+    const fn = ctx?.client?.session?.prompt;
+    return typeof fn === "function" ? fn.bind(ctx.client.session) : null;
+}
+async function sendWithRetries(opts) {
+    const { ctx, sessionId, text } = opts;
+    const agent = opts.agent ?? "Astro";
+    const prefixedText = `[${agent}]\n\n${text}`;
+    if (!sessionId) {
+        console.warn("[Astrocode] Injection skipped: missing sessionId");
         return;
     }
-    try {
-        const { ctx, sessionId, text, agent = "Astro" } = opts;
-        const prefixedText = `[${agent}]\n\n${text}`;
-        // Basic validation
-        if (!sessionId) {
-            console.warn("[Astrocode] Skipping injection: No sessionId provided");
+    const prompt = getPromptApi(ctx);
+    if (!prompt) {
+        console.warn("[Astrocode] Injection skipped: ctx.client.session.prompt unavailable");
+        return;
+    }
+    const maxAttempts = 3;
+    let attempt = 0;
+    while (attempt < maxAttempts) {
+        attempt += 1;
+        try {
+            await prompt({
+                path: { id: sessionId },
+                body: {
+                    parts: [{ type: "text", text: prefixedText }],
+                    agent,
+                },
+            });
             return;
         }
-        if (!ctx?.client?.session?.prompt) {
-            console.warn("[Astrocode] Skipping injection: API not available (ctx.client.session.prompt)");
-            return;
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            const isLast = attempt >= maxAttempts;
+            if (isLast) {
+                console.warn(`[Astrocode] Injection failed (final): ${msg}`);
+                return;
+            }
+            // Exponential backoff + jitter
+            const base = 150 * Math.pow(2, attempt - 1); // 150, 300, 600
+            const jitter = Math.floor(Math.random() * 120);
+            await sleep(base + jitter);
         }
-        await ctx.client.session.prompt({
-            path: { id: sessionId },
-            body: {
-                parts: [{ type: "text", text: prefixedText }],
-                // Pass agent context for systems that support it
-                agent: agent,
-            },
-        });
     }
-    catch (error) {
-        console.warn(`[Astrocode] Injection failed: ${error}`);
+}
+async function runWorkerLoop() {
+    if (workerRunning)
+        return;
+    workerRunning = true;
+    try {
+        // Drain sequentially to preserve ordering
+        while (injectionQueue.length > 0) {
+            const item = injectionQueue.shift();
+            if (!item)
+                continue;
+            await sendWithRetries(item);
+        }
     }
     finally {
-        isInjecting = false;
-        // Process next item immediately
-        if (injectionQueue.length > 0) {
-            setImmediate(processQueue);
-        }
+        workerRunning = false;
+        resolveDrainWaitersIfIdle();
     }
 }
-export async function injectChatPrompt(opts) {
+/**
+ * Enqueue an injection and ensure the worker is running.
+ * Does NOT wait for delivery — use `flushChatPrompts()` to wait.
+ */
+export function enqueueChatPrompt(opts) {
     injectionQueue.push(opts);
-    processQueue();
+    // Kick worker
+    void runWorkerLoop();
+}
+/**
+ * Wait until all queued injections have been processed (sent or exhausted retries).
+ */
+export function flushChatPrompts() {
+    if (!workerRunning && injectionQueue.length === 0)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        drainWaiters.push(resolve);
+        // Ensure worker is running (in case someone enqueued without kick)
+        void runWorkerLoop();
+    });
+}
+/**
+ * Deterministic helper: enqueue + flush (recommended for stage boundaries).
+ */
+export async function injectChatPrompt(opts) {
+    enqueueChatPrompt(opts);
+    await flushChatPrompts();
 }

package/dist/workflow/directives.d.ts

@@ -16,12 +16,14 @@ export declare function buildContinueDirective(opts: {
     context_snapshot_md: string;
 }): BuiltDirective;
 export declare function buildBlockedDirective(opts: {
+    config?: AstrocodeConfig;
     run_id: string;
     stage_key: string;
     question: string;
     context_snapshot_md: string;
 }): BuiltDirective;
 export declare function buildRepairDirective(opts: {
+    config?: AstrocodeConfig;
     report_md: string;
 }): BuiltDirective;
 export declare function buildStageDirective(opts: {

package/dist/workflow/directives.js

@@ -1,13 +1,25 @@
 import { sha256Hex } from "../shared/hash";
 import { clampChars, normalizeNewlines } from "../shared/text";
+function getInjectMaxChars(config) {
+    // Deterministic fallback for older configs.
+    const v = config?.context_compaction?.inject_max_chars;
+    return typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 12000;
+}
 export function directiveHash(body) {
     // Stable hash to dedupe: normalize newlines + trim
     const norm = normalizeNewlines(body).trim();
     return sha256Hex(norm);
 }
+function finalizeBody(body, maxChars) {
+    // Normalize first, clamp second, trim last => hash/body match exactly.
+    const norm = normalizeNewlines(body);
+    const clamped = clampChars(norm, maxChars);
+    return clamped.trim();
+}
 export function buildContinueDirective(opts) {
     const { config, run_id, stage_key, next_action, context_snapshot_md } = opts;
-    const body = clampChars(normalizeNewlines([
+    const maxChars = getInjectMaxChars(config);
+    const body = finalizeBody([
         `[SYSTEM DIRECTIVE: ASTROCODE — CONTINUE]`,
         ``,
         `This directive is injected by the Astro agent to continue the workflow.`,
@@ -22,8 +34,8 @@ export function buildContinueDirective(opts) {
         `- If blocked, ask exactly ONE question and stop.`,
         ``,
         `Context snapshot:`,
-        context_snapshot_md.trim(),
-    ].join("\n")), config.context_compaction.inject_max_chars);
+        (context_snapshot_md ?? "").trim(),
+    ].join("\n"), maxChars);
     return {
         kind: "continue",
         title: "ASTROCODE — CONTINUE",
@@ -32,8 +44,9 @@ export function buildContinueDirective(opts) {
     };
 }
 export function buildBlockedDirective(opts) {
-    const { run_id, stage_key, question, context_snapshot_md } = opts;
-    const body = normalizeNewlines([
+    const { config, run_id, stage_key, question, context_snapshot_md } = opts;
+    const maxChars = getInjectMaxChars(config);
+    const body = finalizeBody([
         `[SYSTEM DIRECTIVE: ASTROCODE — BLOCKED]`,
         ``,
         `This directive is injected by the Astro agent indicating the workflow is blocked.`,
@@ -45,8 +58,8 @@ export function buildBlockedDirective(opts) {
         `Question: ${question}`,
         ``,
         `Context snapshot:`,
-        context_snapshot_md.trim(),
-    ].join("\n")).trim();
+        (context_snapshot_md ?? "").trim(),
+    ].join("\n"), maxChars);
     return {
         kind: "blocked",
         title: "ASTROCODE — BLOCKED",
@@ -55,7 +68,8 @@ export function buildBlockedDirective(opts) {
     };
 }
 export function buildRepairDirective(opts) {
-    const body = normalizeNewlines([
+    const maxChars = getInjectMaxChars(opts.config);
+    const body = finalizeBody([
         `[SYSTEM DIRECTIVE: ASTROCODE — REPAIR]`,
         ``,
         `This directive is injected by the Astro agent after performing a repair pass.`,
@@ -63,8 +77,8 @@ export function buildRepairDirective(opts) {
         `Astrocode performed a repair pass. Summarize in <= 10 lines and continue.`,
         ``,
         `Repair report:`,
-        opts.report_md.trim(),
-    ].join("\n")).trim();
+        (opts.report_md ?? "").trim(),
+    ].join("\n"), maxChars);
     return {
         kind: "repair",
         title: "ASTROCODE — REPAIR",
@@ -73,12 +87,13 @@ export function buildRepairDirective(opts) {
     };
 }
 export function buildStageDirective(opts) {
-    const { config, stage_key, run_id, story_key, story_title, stage_agent_name, stage_goal, stage_constraints, context_snapshot_md } = opts;
-    const stageKeyUpper = stage_key.toUpperCase();
-    const constraintsBlock = stage_constraints.length
+    const { config, stage_key, run_id, story_key, story_title, stage_agent_name, stage_goal, stage_constraints, context_snapshot_md, } = opts;
+    const maxChars = getInjectMaxChars(config);
+    const stageKeyUpper = String(stage_key).toUpperCase();
+    const constraintsBlock = Array.isArray(stage_constraints) && stage_constraints.length
         ? ["", "Constraints:", ...stage_constraints.map((c) => `- ${c}`)].join("\n")
         : "";
-    const body = clampChars(normalizeNewlines([
+    const body = finalizeBody([
         `[SYSTEM DIRECTIVE: ASTROCODE — STAGE_${stageKeyUpper}]`,
         ``,
         `This directive is injected by the Astro agent to delegate the stage task.`,
@@ -93,14 +108,14 @@ export function buildStageDirective(opts) {
         `Output contract (strict):`,
         `1) Baton markdown (short, structured)`,
         `2) ASTRO JSON between markers:`,
-        `   ${"<!-- ASTRO_JSON_BEGIN -->"}`,
+        `   <!-- ASTRO_JSON_BEGIN -->`,
         `   {`,
         `     "schema_version": 1,`,
         `     "stage_key": "${stage_key}",`,
         `     "status": "ok",`,
-        `     ...`,
+        `     "...": "..."`,
         `   }`,
-        `   ${"<!-- ASTRO_JSON_END -->"}`,
+        `   <!-- ASTRO_JSON_END -->`,
         ``,
         `ASTRO JSON requirements:`,
         `- stage_key must be "${stage_key}"`,
@@ -111,8 +126,8 @@ export function buildStageDirective(opts) {
         `If blocked: ask exactly ONE question and stop.`,
         ``,
         `Context snapshot:`,
-        context_snapshot_md.trim(),
-    ].join("\n")), config.context_compaction.inject_max_chars);
+        (context_snapshot_md ?? "").trim(),
+    ].join("\n"), maxChars);
     return {
         kind: "stage",
         title: `ASTROCODE — STAGE_${stageKeyUpper}`,

package/dist/workflow/state-machine.d.ts

@@ -1,6 +1,39 @@
 import type { AstrocodeConfig } from "../config/schema";
 import type { SqliteDb } from "../state/db";
 import type { RunRow, StageKey, StageRunRow, StoryRow } from "../state/types";
+import type { ToastOptions } from "../ui/toasts";
+export declare const EVENT_TYPES: {
+    readonly RUN_STARTED: "run.started";
+    readonly RUN_COMPLETED: "run.completed";
+    readonly RUN_FAILED: "run.failed";
+    readonly RUN_ABORTED: "run.aborted";
+    readonly RUN_GENESIS_PLANNING_ATTACHED: "run.genesis_planning_attached";
+    readonly STAGE_STARTED: "stage.started";
+    readonly WORKFLOW_PROCEED: "workflow.proceed";
+};
+/**
+ * UI HOOKS
+ * --------
+ * This workflow module is DB-first. UI emission is optional and happens AFTER the DB tx commits.
+ *
+ * Contract:
+ * - If you pass ui.ctx + ui.sessionId, we will inject a visible chat message deterministically.
+ * - If you pass ui.toast, we will also toast (throttling is handled by the toast manager).
+ */
+export type WorkflowUi = {
+    ctx: any;
+    sessionId: string;
+    agentName?: string;
+    toast?: (t: ToastOptions) => Promise<void>;
+};
+/**
+ * PLANNING-FIRST REDESIGN
+ * ----------------------
+ * - Never mutate story title/body.
+ * - Planning-first becomes a run-scoped inject stored in `injects` (scope = run:<run_id>).
+ * - Trigger is deterministic via config.workflow.genesis_planning:
+ *    - "off" | "first_story_only" | "always"
+ */
 export type NextAction = {
     kind: "idle";
     reason: "no_approved_stories";
@@ -34,10 +67,20 @@ export declare function decideNextAction(db: SqliteDb, config: AstrocodeConfig):
 export declare function createRunForStory(db: SqliteDb, config: AstrocodeConfig, storyKey: string): {
     run_id: string;
 };
+/**
+ * STAGE MOVEMENT (START) — now async so UI injection is deterministic.
+ */
 export declare function startStage(db: SqliteDb, runId: string, stageKey: StageKey, meta?: {
     subagent_type?: string;
     subagent_session_id?: string;
-}): void;
-export declare function completeRun(db: SqliteDb, runId: string): void;
-export declare function failRun(db: SqliteDb, runId: string, stageKey: StageKey, errorText: string): void;
+    ui?: WorkflowUi;
+}): Promise<void>;
+/**
+ * STAGE CLOSED (RUN COMPLETED) — now async so UI injection is deterministic.
+ */
+export declare function completeRun(db: SqliteDb, runId: string, ui?: WorkflowUi): Promise<void>;
+/**
+ * STAGE CLOSED (RUN FAILED) — now async so UI injection is deterministic.
+ */
+export declare function failRun(db: SqliteDb, runId: string, stageKey: StageKey, errorText: string, ui?: WorkflowUi): Promise<void>;
 export declare function abortRun(db: SqliteDb, runId: string, reason: string): void;