astrocode-workflow 0.1.59 → 0.2.0

package/dist/tools/injects.js

@@ -2,28 +2,41 @@ import { tool } from "@opencode-ai/plugin/tool";
 import { withTx } from "../state/db";
 import { nowISO } from "../shared/time";
 import { sha256Hex } from "../shared/hash";
-const VALID_INJECT_TYPES = ['note', 'policy', 'reminder', 'debug'];
+const VALID_INJECT_TYPES = ["note", "policy", "reminder", "debug"];
 function validateInjectType(type) {
     if (!VALID_INJECT_TYPES.includes(type)) {
-        throw new Error(`Invalid inject type "${type}". Must be one of: ${VALID_INJECT_TYPES.join(', ')}`);
+        throw new Error(`Invalid inject type "${type}". Must be one of: ${VALID_INJECT_TYPES.join(", ")}`);
     }
     return type;
 }
 function validateTimestamp(timestamp) {
     if (!timestamp)
         return null;
-    // Check if it's a valid ISO 8601 timestamp with Z suffix
+    // Strict ISO 8601 UTC with Z suffix, sortable as string.
     const isoRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/;
     if (!isoRegex.test(timestamp)) {
         throw new Error(`Invalid timestamp format. Expected ISO 8601 UTC with Z suffix (e.g., "2026-01-23T13:05:19.000Z"), got: "${timestamp}"`);
     }
-    // Additional validation: ensure it's parseable and represents a valid date
-    const parsed = new Date(timestamp);
-    if (isNaN(parsed.getTime())) {
+    const parsed = Date.parse(timestamp);
+    if (!Number.isFinite(parsed)) {
         throw new Error(`Invalid timestamp: "${timestamp}" does not represent a valid date`);
     }
     return timestamp;
 }
+function parseJsonStringArray(name, raw) {
+    let v;
+    try {
+        v = JSON.parse(raw);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`${name} must be valid JSON. Parse error: ${msg}`);
+    }
+    if (!Array.isArray(v) || !v.every((x) => typeof x === "string")) {
+        throw new Error(`${name} must be a JSON array of strings`);
+    }
+    return v;
+}
 function newInjectId() {
     return `inj_${Date.now()}_${Math.random().toString(16).slice(2)}`;
 }
@@ -46,15 +59,34 @@ export function createAstroInjectPutTool(opts) {
             const id = inject_id ?? newInjectId();
             const now = nowISO();
             const sha = sha256Hex(body_md);
-            // Validate inputs
             const validatedType = validateInjectType(type);
             const validatedExpiresAt = validateTimestamp(expires_at);
+            // Ensure tags_json is at least valid JSON (we do not enforce schema here beyond validity).
+            try {
+                JSON.parse(tags_json);
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                throw new Error(`tags_json must be valid JSON. Parse error: ${msg}`);
+            }
             return withTx(db, () => {
                 const existing = db.prepare("SELECT inject_id FROM injects WHERE inject_id=?").get(id);
                 if (existing) {
-                    // Use INSERT ... ON CONFLICT for atomic updates
                     db.prepare(`
-            INSERT INTO injects (inject_id, type, title, body_md, tags_json, scope, source, priority, expires_at, sha256, created_at, updated_at)
+            INSERT INTO injects (
+              inject_id,
+              type,
+              title,
+              body_md,
+              tags_json,
+              scope,
+              source,
+              priority,
+              expires_at,
+              sha256,
+              created_at,
+              updated_at
+            )
             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
             ON CONFLICT(inject_id) DO UPDATE SET
               type=excluded.type,
@@ -67,7 +99,7 @@ export function createAstroInjectPutTool(opts) {
               expires_at=excluded.expires_at,
               sha256=excluded.sha256,
               updated_at=excluded.updated_at
-          `).run(id, type, title, body_md, tags_json, scope, source, priority, validatedExpiresAt, sha, now, now);
+          `).run(id, validatedType, title, body_md, tags_json, scope, source, priority, validatedExpiresAt, sha, now, now);
                     return `✅ Updated inject ${id}: ${title}`;
                 }
                 db.prepare("INSERT INTO injects (inject_id, type, title, body_md, tags_json, scope, source, priority, expires_at, sha256, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)").run(id, validatedType, title, body_md, tags_json, scope, source, priority, validatedExpiresAt, sha, now, now);
@@ -93,10 +125,18 @@ export function createAstroInjectListTool(opts) {
                 params.push(scope);
             }
             if (type) {
+                // Keep list tool permissive (debugging), but still prevents obvious garbage if used.
+                validateInjectType(type);
                 where.push("type = ?");
                 params.push(type);
             }
-            const sql = `SELECT inject_id, type, title, scope, priority, created_at, updated_at FROM injects ${where.length ? "WHERE " + where.join(" AND ") : ""} ORDER BY priority DESC, updated_at DESC LIMIT ?`;
+            const sql = `
+        SELECT inject_id, type, title, scope, priority, created_at, updated_at
+        FROM injects
+        ${where.length ? "WHERE " + where.join(" AND ") : ""}
+        ORDER BY priority DESC, updated_at DESC
+        LIMIT ?
+      `;
             const rows = db.prepare(sql).all(...params, limit);
             return JSON.stringify(rows, null, 2);
         },
@@ -134,7 +174,13 @@ export function createAstroInjectSearchTool(opts) {
                 where.push("scope = ?");
                 params.push(scope);
             }
-            const sql = `SELECT inject_id, type, title, scope, priority, updated_at FROM injects WHERE ${where.join(" AND ")} ORDER BY priority DESC, updated_at DESC LIMIT ?`;
+            const sql = `
+        SELECT inject_id, type, title, scope, priority, updated_at
+        FROM injects
+        WHERE ${where.join(" AND ")}
+        ORDER BY priority DESC, updated_at DESC
+        LIMIT ?
+      `;
             const rows = db.prepare(sql).all(...params, limit);
             return JSON.stringify(rows, null, 2);
         },
@@ -142,7 +188,13 @@ export function createAstroInjectSearchTool(opts) {
 }
 export function selectEligibleInjects(db, opts) {
     const { nowIso, scopeAllowlist, typeAllowlist, limit = 50 } = opts;
-    // Build placeholders safely
+    if (!Array.isArray(scopeAllowlist) || scopeAllowlist.length === 0) {
+        throw new Error("selectEligibleInjects: scopeAllowlist must be a non-empty array");
+    }
+    if (!Array.isArray(typeAllowlist) || typeAllowlist.length === 0) {
+        throw new Error("selectEligibleInjects: typeAllowlist must be a non-empty array");
+    }
+    // Build placeholders safely (guaranteed non-empty).
     const scopeQs = scopeAllowlist.map(() => "?").join(", ");
     const typeQs = typeAllowlist.map(() => "?").join(", ");
     const sql = `
@@ -168,8 +220,11 @@ export function createAstroInjectEligibleTool(opts) {
         },
         execute: async ({ scopes_json, types_json, limit }) => {
             const now = nowISO();
-            const scopes = JSON.parse(scopes_json);
-            const types = JSON.parse(types_json);
+            const scopes = parseJsonStringArray("scopes_json", scopes_json);
+            const types = parseJsonStringArray("types_json", types_json);
+            // Validate types against the known set to keep selection sane.
+            for (const t of types)
+                validateInjectType(t);
             const rows = selectEligibleInjects(db, {
                 nowIso: now,
                 scopeAllowlist: scopes,
@@ -190,30 +245,38 @@ export function createAstroInjectDebugDueTool(opts) {
         },
         execute: async ({ scopes_json, types_json }) => {
             const now = nowISO();
-            const scopes = JSON.parse(scopes_json);
-            const types = JSON.parse(types_json);
-            // Get ALL injects to analyze filtering
+            const nowMs = Date.parse(now);
+            const scopes = parseJsonStringArray("scopes_json", scopes_json);
+            const types = parseJsonStringArray("types_json", types_json);
+            for (const t of types)
+                validateInjectType(t);
             const allInjects = db.prepare("SELECT * FROM injects").all();
             let total = allInjects.length;
             let selected = 0;
             let skippedExpired = 0;
             let skippedScope = 0;
             let skippedType = 0;
+            let skippedUnparseableExpiresAt = 0;
             const excludedReasons = [];
             const selectedInjects = [];
             for (const inject of allInjects) {
                 const reasons = [];
-                // Check expiration
-                if (inject.expires_at && inject.expires_at <= now) {
-                    reasons.push("expired");
-                    skippedExpired++;
+                // Expiration: parse to ms for correctness across legacy rows.
+                if (inject.expires_at) {
+                    const expMs = Date.parse(String(inject.expires_at));
+                    if (!Number.isFinite(expMs)) {
+                        reasons.push("expires_at_unparseable");
+                        skippedUnparseableExpiresAt++;
+                    }
+                    else if (expMs <= nowMs) {
+                        reasons.push("expired");
+                        skippedExpired++;
+                    }
                 }
-                // Check scope
                 if (!scopes.includes(inject.scope)) {
                     reasons.push("scope");
                     skippedScope++;
                 }
-                // Check type
                 if (!types.includes(inject.type)) {
                     reasons.push("type");
                     skippedType++;
@@ -222,7 +285,7 @@ export function createAstroInjectDebugDueTool(opts) {
                     excludedReasons.push({
                         inject_id: inject.inject_id,
                         title: inject.title,
-                        reasons: reasons,
+                        reasons,
                         scope: inject.scope,
                         type: inject.type,
                         expires_at: inject.expires_at,
@@ -249,9 +312,10 @@ export function createAstroInjectDebugDueTool(opts) {
                     excluded_total: total - selected,
                     skipped_breakdown: {
                         expired: skippedExpired,
+                        expires_at_unparseable: skippedUnparseableExpiresAt,
                         scope: skippedScope,
                         type: skippedType,
-                    }
+                    },
                 },
                 selected_injects: selectedInjects,
                 excluded_injects: excludedReasons,

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/state-machine.d.ts

@@ -1,6 +1,7 @@
 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";
@@ -10,23 +11,28 @@ export declare const EVENT_TYPES: {
     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
  * ----------------------
- * Old behavior: mutate an approved story into a planning/decomposition instruction.
- * New behavior: NEVER mutate story title/body.
- *
- * Planning-first is a run-scoped directive stored in `injects` (scope = run:<run_id>).
- *
- * Deterministic trigger (config-driven):
- * - config.workflow.genesis_planning:
- *    - "off"             => never attach directive
- *    - "first_story_only"=> attach only when story_key === "S-0001"
- *    - "always"          => attach for every run
- *
- * Contract: DB is already initialized before workflow is used:
- * - schema tables exist
- * - repo_state singleton row (id=1) exists
+ * - 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";
@@ -61,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;