astrocode-workflow 0.1.58 → 0.2.0

package/src/ui/inject.ts

@@ -1,62 +1,136 @@
-let isInjecting = false;
-const injectionQueue: Array<{
+// 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.
+
+type QueueItem = {
   ctx: any;
   sessionId: string;
   text: string;
   agent?: string;
-}> = [];
+};
+
+const injectionQueue: QueueItem[] = [];
+
+let workerRunning = false;
+
+// Used to let callers await "queue drained"
+let drainWaiters: Array<() => void> = [];
+
+function sleep(ms: number) {
+  return new Promise<void>((resolve) => setTimeout(resolve, ms));
+}
+
+function resolveDrainWaitersIfIdle() {
+  if (workerRunning) return;
+  if (injectionQueue.length !== 0) return;
+
+  const waiters = drainWaiters;
+  drainWaiters = [];
+  for (const w of waiters) w();
+}
 
-async function processQueue() {
-  if (isInjecting || injectionQueue.length === 0) return;
+function getPromptApi(ctx: any) {
+  const fn = ctx?.client?.session?.prompt;
+  return typeof fn === "function" ? fn.bind(ctx.client.session) : null;
+}
 
-  isInjecting = true;
-  const opts = injectionQueue.shift();
+async function sendWithRetries(opts: QueueItem): Promise<void> {
+  const { ctx, sessionId, text } = opts;
+  const agent = opts.agent ?? "Astro";
+  const prefixedText = `[${agent}]\n\n${text}`;
 
-  if (!opts) {
-    isInjecting = false;
+  if (!sessionId) {
+    console.warn("[Astrocode] Injection skipped: missing sessionId");
     return;
   }
 
-  try {
-    const { ctx, sessionId, text, agent = "Astro" } = opts;
-    const prefixedText = `[${agent}]\n\n${text}`;
+  const prompt = getPromptApi(ctx);
+  if (!prompt) {
+    console.warn("[Astrocode] Injection skipped: ctx.client.session.prompt unavailable");
+    return;
+  }
 
-    // Basic validation
-    if (!sessionId) {
-      console.warn("[Astrocode] Skipping injection: No sessionId provided");
-      return;
-    }
+  const maxAttempts = 3;
+  let attempt = 0;
 
-    if (!ctx?.client?.session?.prompt) {
-      console.warn("[Astrocode] Skipping injection: API not available (ctx.client.session.prompt)");
+  while (attempt < maxAttempts) {
+    attempt += 1;
+    try {
+      await prompt({
+        path: { id: sessionId },
+        body: {
+          parts: [{ type: "text", text: prefixedText }],
+          agent,
+        },
+      });
       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}`);
-  } finally {
-    isInjecting = false;
-    // Process next item immediately
-    if (injectionQueue.length > 0) {
-      setImmediate(processQueue);
+async function runWorkerLoop(): Promise<void> {
+  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 {
+    workerRunning = false;
+    resolveDrainWaitersIfIdle();
   }
 }
 
-export async function injectChatPrompt(opts: {
-  ctx: any;
-  sessionId: string;
-  text: string;
-  agent?: string;
-}) {
+/**
+ * Enqueue an injection and ensure the worker is running.
+ * Does NOT wait for delivery — use `flushChatPrompts()` to wait.
+ */
+export function enqueueChatPrompt(opts: QueueItem) {
   injectionQueue.push(opts);
-  processQueue();
+  // Kick worker
+  void runWorkerLoop();
+}
+
+/**
+ * Wait until all queued injections have been processed (sent or exhausted retries).
+ */
+export function flushChatPrompts(): Promise<void> {
+  if (!workerRunning && injectionQueue.length === 0) return Promise.resolve();
+  return new Promise<void>((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: QueueItem): Promise<void> {
+  enqueueChatPrompt(opts);
+  await flushChatPrompts();
 }

package/src/workflow/directives.ts

@@ -1,8 +1,8 @@
+// src/workflow/directives.ts
 import type { AstrocodeConfig } from "../config/schema";
 import { sha256Hex } from "../shared/hash";
 import { clampChars, normalizeNewlines } from "../shared/text";
 import type { StageKey } from "../state/types";
-import { addStalenessIndicator } from "./context";
 
 export type DirectiveKind = "continue" | "stage" | "blocked" | "repair";
 
@@ -13,12 +13,25 @@ export type BuiltDirective = {
   hash: string;
 };
 
+function getInjectMaxChars(config?: AstrocodeConfig): number {
+  // Deterministic fallback for older configs.
+  const v = (config as any)?.context_compaction?.inject_max_chars;
+  return typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 12000;
+}
+
 export function directiveHash(body: string): string {
   // Stable hash to dedupe: normalize newlines + trim
   const norm = normalizeNewlines(body).trim();
   return sha256Hex(norm);
 }
 
+function finalizeBody(body: string, maxChars: number): string {
+  // 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: {
   config: AstrocodeConfig;
   run_id: string;
@@ -27,28 +40,27 @@ export function buildContinueDirective(opts: {
   context_snapshot_md: string;
 }): BuiltDirective {
   const { config, run_id, stage_key, next_action, context_snapshot_md } = opts;
+  const maxChars = getInjectMaxChars(config);
 
-  const body = clampChars(
-    normalizeNewlines(
-      [
-        `[SYSTEM DIRECTIVE: ASTROCODE — CONTINUE]`,
-        ``,
-        `This directive is injected by the Astro agent to continue the workflow.`,
-        ``,
-        `Run: \`${run_id}\`${stage_key ? `  Stage: \`${stage_key}\`` : ""}`,
-        ``,
-        `Next action: ${next_action}`,
-        ``,
-        `Rules:`,
-        `- Do not stop early. Keep going until the run is completed, failed, or blocked.`,
-        `- Prefer tools over prose.`,
-        `- If blocked, ask exactly ONE question and stop.`,
-        ``,
-        `Context snapshot:`,
-        context_snapshot_md.trim(),
-      ].join("\n")
-    ),
-    config.context_compaction.inject_max_chars
+  const body = finalizeBody(
+    [
+      `[SYSTEM DIRECTIVE: ASTROCODE — CONTINUE]`,
+      ``,
+      `This directive is injected by the Astro agent to continue the workflow.`,
+      ``,
+      `Run: \`${run_id}\`${stage_key ? `  Stage: \`${stage_key}\`` : ""}`,
+      ``,
+      `Next action: ${next_action}`,
+      ``,
+      `Rules:`,
+      `- Do not stop early. Keep going until the run is completed, failed, or blocked.`,
+      `- Prefer tools over prose.`,
+      `- If blocked, ask exactly ONE question and stop.`,
+      ``,
+      `Context snapshot:`,
+      (context_snapshot_md ?? "").trim(),
+    ].join("\n"),
+    maxChars
   );
 
   return {
@@ -60,13 +72,16 @@ export function buildContinueDirective(opts: {
 }
 
 export function buildBlockedDirective(opts: {
+  config?: AstrocodeConfig;
   run_id: string;
   stage_key: string;
   question: string;
   context_snapshot_md: string;
 }): BuiltDirective {
-  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]`,
       ``,
@@ -78,10 +93,11 @@ export function buildBlockedDirective(opts: {
       ``,
       `Question: ${question}`,
       ``,
-        `Context snapshot:`,
-        context_snapshot_md.trim(),
-    ].join("\n")
-  ).trim();
+      `Context snapshot:`,
+      (context_snapshot_md ?? "").trim(),
+    ].join("\n"),
+    maxChars
+  );
 
   return {
     kind: "blocked",
@@ -91,8 +107,10 @@ export function buildBlockedDirective(opts: {
   };
 }
 
-export function buildRepairDirective(opts: { report_md: string }): BuiltDirective {
-  const body = normalizeNewlines(
+export function buildRepairDirective(opts: { config?: AstrocodeConfig; report_md: string }): BuiltDirective {
+  const maxChars = getInjectMaxChars(opts.config);
+
+  const body = finalizeBody(
     [
       `[SYSTEM DIRECTIVE: ASTROCODE — REPAIR]`,
       ``,
@@ -101,9 +119,10 @@ export function buildRepairDirective(opts: { report_md: string }): BuiltDirectiv
       `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",
@@ -124,53 +143,62 @@ export function buildStageDirective(opts: {
   stage_constraints: string[];
   context_snapshot_md: string;
 }): BuiltDirective {
-  const { config, stage_key, run_id, story_key, story_title, stage_agent_name, stage_goal, stage_constraints, context_snapshot_md } = 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 maxChars = getInjectMaxChars(config);
+  const stageKeyUpper = String(stage_key).toUpperCase();
 
-  const constraintsBlock = stage_constraints.length
+  const constraintsBlock = Array.isArray(stage_constraints) && stage_constraints.length
     ? ["", "Constraints:", ...stage_constraints.map((c) => `- ${c}`)].join("\n")
     : "";
 
-  const body = clampChars(
-    normalizeNewlines(
-      [
-        `[SYSTEM DIRECTIVE: ASTROCODE — STAGE_${stageKeyUpper}]`,
-        ``,
-        `This directive is injected by the Astro agent to delegate the stage task.`,
-        ``,
-        `You are: \`${stage_agent_name}\``,
-        `Run: \`${run_id}\``,
-        `Story: \`${story_key}\` — ${story_title}`,
-        ``,
-        `Stage goal: ${stage_goal}`,
-        constraintsBlock,
-        ``,
-        `Output contract (strict):`,
-        `1) Baton markdown (short, structured)`,
-        `2) ASTRO JSON between markers:`,
-        `   ${"<!-- ASTRO_JSON_BEGIN -->"}`,
-        `   {`,
-        `     "schema_version": 1,`,
-        `     "stage_key": "${stage_key}",`,
-        `     "status": "ok",`,
-        `     ...`,
-        `   }`,
-        `   ${"<!-- ASTRO_JSON_END -->"}`,
-        ``,
-        `ASTRO JSON requirements:`,
-        `- stage_key must be "${stage_key}"`,
-        `- status must be "ok" | "blocked" | "failed"`,
-        `- include summary + next_actions`,
-        `- include files/evidence paths when relevant`,
-        ``,
-        `If blocked: ask exactly ONE question and stop.`,
-        ``,
-        `Context snapshot:`,
-        context_snapshot_md.trim(),
-      ].join("\n")
-    ),
-    config.context_compaction.inject_max_chars
+  const body = finalizeBody(
+    [
+      `[SYSTEM DIRECTIVE: ASTROCODE — STAGE_${stageKeyUpper}]`,
+      ``,
+      `This directive is injected by the Astro agent to delegate the stage task.`,
+      ``,
+      `You are: \`${stage_agent_name}\``,
+      `Run: \`${run_id}\``,
+      `Story: \`${story_key}\` — ${story_title}`,
+      ``,
+      `Stage goal: ${stage_goal}`,
+      constraintsBlock,
+      ``,
+      `Output contract (strict):`,
+      `1) Baton markdown (short, structured)`,
+      `2) ASTRO JSON between markers:`,
+      `   <!-- ASTRO_JSON_BEGIN -->`,
+      `   {`,
+      `     "schema_version": 1,`,
+      `     "stage_key": "${stage_key}",`,
+      `     "status": "ok",`,
+      `     "...": "..."`,
+      `   }`,
+      `   <!-- ASTRO_JSON_END -->`,
+      ``,
+      `ASTRO JSON requirements:`,
+      `- stage_key must be "${stage_key}"`,
+      `- status must be "ok" | "blocked" | "failed"`,
+      `- include summary + next_actions`,
+      `- include files/evidence paths when relevant`,
+      ``,
+      `If blocked: ask exactly ONE question and stop.`,
+      ``,
+      `Context snapshot:`,
+      (context_snapshot_md ?? "").trim(),
+    ].join("\n"),
+    maxChars
   );
 
   return {