astrocode-workflow 0.1.59 → 0.2.0

package/dist/workflow/state-machine.js

@@ -3,6 +3,8 @@ import { nowISO } from "../shared/time";
 import { newEventId, newRunId, newStageRunId } from "../state/ids";
 import { warn } from "../shared/log";
 import { sha256Hex } from "../shared/hash";
+import { SCHEMA_VERSION } from "../state/schema";
+import { injectChatPrompt } from "../ui/inject";
 export const EVENT_TYPES = {
     RUN_STARTED: "run.started",
     RUN_COMPLETED: "run.completed",
@@ -12,6 +14,42 @@ export const EVENT_TYPES = {
     STAGE_STARTED: "stage.started",
     WORKFLOW_PROCEED: "workflow.proceed",
 };
+async function emitUi(ui, text, toast) {
+    if (!ui)
+        return;
+    // Prefer toast (if provided) AND also inject chat (for audit trail / visibility).
+    // If you want toast-only, pass a toast function and omit ctx/sessionId.
+    if (toast && ui.toast) {
+        try {
+            await ui.toast(toast);
+        }
+        catch {
+            // non-fatal
+        }
+    }
+    try {
+        await injectChatPrompt({
+            ctx: ui.ctx,
+            sessionId: ui.sessionId,
+            text,
+            agent: ui.agentName ?? "Astro",
+        });
+    }
+    catch {
+        // non-fatal (workflow correctness is DB-based)
+    }
+}
+function tableExists(db, tableName) {
+    try {
+        const row = db
+            .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?")
+            .get(tableName);
+        return row?.name === tableName;
+    }
+    catch {
+        return false;
+    }
+}
 export function getActiveRun(db) {
     const row = db
         .prepare("SELECT * FROM runs WHERE status = 'running' ORDER BY started_at DESC, created_at DESC LIMIT 1")
@@ -52,7 +90,7 @@ export function decideNextAction(db, config) {
     if (current.status === "failed") {
         return { kind: "failed", run_id: activeRun.run_id, stage_key: current.stage_key, error_text: current.error_text ?? "stage failed" };
     }
-    warn("Unexpected stage status in decideNextAction", { status: current.status, stage_key: current.stage_key });
+    warn("Unexpected stage status in decideNextAction", { status: current.status, stage_key: current.status });
     return { kind: "await_stage_completion", run_id: activeRun.run_id, stage_key: current.stage_key, stage_run_id: current.stage_run_id };
 }
 function getPipelineFromConfig(config) {
@@ -66,8 +104,7 @@ function getGenesisPlanningMode(config) {
     const raw = config?.workflow?.genesis_planning;
     if (raw === "off" || raw === "first_story_only" || raw === "always")
         return raw;
-    if (raw != null)
-        warn(`Invalid workflow.genesis_planning config: ${String(raw)}. Using default "first_story_only".`);
+    warn(`Invalid genesis_planning config: ${String(raw)}. Using default "first_story_only".`);
     return "first_story_only";
 }
 function shouldAttachPlanningDirective(config, story) {
@@ -79,6 +116,8 @@ function shouldAttachPlanningDirective(config, story) {
     return story.story_key === "S-0001";
 }
 function attachRunPlanningDirective(db, runId, story, pipeline) {
+    if (!tableExists(db, "injects"))
+        return;
     const now = nowISO();
     const injectId = `inj_${runId}_genesis_plan`;
     const body = [
@@ -96,16 +135,8 @@ function attachRunPlanningDirective(db, runId, story, pipeline) {
         `- Pipeline: ${pipeline.join(" → ")}`,
         ``,
     ].join("\n");
-    let hash = null;
+    const hash = sha256Hex(body);
     try {
-        hash = sha256Hex(body);
-    }
-    catch {
-        // Hash is optional; directive must never be blocked by hashing.
-        hash = null;
-    }
-    try {
-        // Do not clobber user edits. If it exists, we leave it.
         db.prepare(`
       INSERT OR IGNORE INTO injects (
         inject_id, type, title, body_md, tags_json, scope, source, priority,
@@ -118,26 +149,9 @@ function attachRunPlanningDirective(db, runId, story, pipeline) {
         db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, NULL, ?, ?, ?)").run(newEventId(), runId, EVENT_TYPES.RUN_GENESIS_PLANNING_ATTACHED, JSON.stringify({ story_key: story.story_key, inject_id: injectId }), now);
     }
     catch (e) {
-        // Helpful, never required for correctness.
         warn("Failed to attach genesis planning inject", { run_id: runId, story_key: story.story_key, err: e });
     }
 }
-function updateRepoStateLastEvent(db, now, fields) {
-    // Contract: repo_state row exists. If not, fail deterministically (don’t “bootstrap” here).
-    const res = db
-        .prepare(`
-      UPDATE repo_state
-      SET last_run_id = COALESCE(?, last_run_id),
-          last_story_key = COALESCE(?, last_story_key),
-          last_event_at = ?,
-          updated_at = ?
-      WHERE id = 1
-    `)
-        .run(fields.last_run_id ?? null, fields.last_story_key ?? null, now, now);
-    if (!res || res.changes === 0) {
-        throw new Error("repo_state missing (id=1). Database not initialized; run init must be performed before workflow.");
-    }
-}
 export function createRunForStory(db, config, storyKey) {
     return withTx(db, () => {
         const story = getStory(db, storyKey);
@@ -158,12 +172,24 @@ export function createRunForStory(db, config, storyKey) {
         if (shouldAttachPlanningDirective(config, story)) {
             attachRunPlanningDirective(db, run_id, story, pipeline);
         }
-        updateRepoStateLastEvent(db, now, { last_run_id: run_id, last_story_key: storyKey });
+        db.prepare(`
+      INSERT INTO repo_state (id, schema_version, created_at, updated_at, last_run_id, last_story_key, last_event_at)
+      VALUES (1, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        last_run_id=excluded.last_run_id,
+        last_story_key=excluded.last_story_key,
+        last_event_at=excluded.last_event_at,
+        updated_at=excluded.updated_at
+    `).run(SCHEMA_VERSION, now, now, run_id, storyKey, now);
         return { run_id };
     });
 }
-export function startStage(db, runId, stageKey, meta) {
-    return withTx(db, () => {
+/**
+ * STAGE MOVEMENT (START) — now async so UI injection is deterministic.
+ */
+export async function startStage(db, runId, stageKey, meta) {
+    // Do DB work inside tx, capture what we need for UI outside.
+    const payload = withTx(db, () => {
         const now = nowISO();
         const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId);
         if (!run)
@@ -178,11 +204,32 @@ export function startStage(db, runId, stageKey, meta) {
         db.prepare("UPDATE stage_runs SET status='running', started_at=?, updated_at=?, subagent_type=COALESCE(?, subagent_type), subagent_session_id=COALESCE(?, subagent_session_id) WHERE stage_run_id=?").run(now, now, meta?.subagent_type ?? null, meta?.subagent_session_id ?? null, stage.stage_run_id);
         db.prepare("UPDATE runs SET current_stage_key=?, updated_at=? WHERE run_id=?").run(stageKey, now, runId);
         db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, ?, ?, ?, ?)").run(newEventId(), runId, stageKey, EVENT_TYPES.STAGE_STARTED, JSON.stringify({ subagent_type: meta?.subagent_type ?? null }), now);
-        updateRepoStateLastEvent(db, now, {});
+        db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
+        const story = db.prepare("SELECT story_key, title FROM stories WHERE story_key=?").get(run.story_key);
+        return {
+            now,
+            story_key: run.story_key,
+            story_title: story?.title ?? "",
+        };
+    });
+    // Deterministic UI emission AFTER commit (never inside tx).
+    await emitUi(meta?.ui, [
+        `🟦 Stage started`,
+        `- Run: \`${runId}\``,
+        `- Stage: \`${stageKey}\``,
+        `- Story: \`${payload.story_key}\` — ${payload.story_title || "(untitled)"}`,
+    ].join("\n"), {
+        title: "Stage started",
+        message: `${stageKey} (${payload.story_key})`,
+        variant: "info",
+        durationMs: 2500,
     });
 }
-export function completeRun(db, runId) {
-    return withTx(db, () => {
+/**
+ * STAGE CLOSED (RUN COMPLETED) — now async so UI injection is deterministic.
+ */
+export async function completeRun(db, runId, ui) {
+    const payload = withTx(db, () => {
         const now = nowISO();
         const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId);
         if (!run)
@@ -196,11 +243,26 @@ export function completeRun(db, runId) {
         db.prepare("UPDATE runs SET status='completed', completed_at=?, updated_at=?, current_stage_key=NULL WHERE run_id=?").run(now, now, runId);
         db.prepare("UPDATE stories SET state='done', in_progress=0, locked_by_run_id=NULL, locked_at=NULL, updated_at=? WHERE story_key=?").run(now, run.story_key);
         db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, NULL, ?, ?, ?)").run(newEventId(), runId, EVENT_TYPES.RUN_COMPLETED, JSON.stringify({ story_key: run.story_key }), now);
-        updateRepoStateLastEvent(db, now, {});
+        db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
+        const story = db.prepare("SELECT story_key, title FROM stories WHERE story_key=?").get(run.story_key);
+        return { now, story_key: run.story_key, story_title: story?.title ?? "" };
+    });
+    await emitUi(ui, [
+        `✅ Run completed`,
+        `- Run: \`${runId}\``,
+        `- Story: \`${payload.story_key}\` — ${payload.story_title || "(untitled)"}`,
+    ].join("\n"), {
+        title: "Run completed",
+        message: `${payload.story_key} — done`,
+        variant: "success",
+        durationMs: 3000,
     });
 }
-export function failRun(db, runId, stageKey, errorText) {
-    return withTx(db, () => {
+/**
+ * STAGE CLOSED (RUN FAILED) — now async so UI injection is deterministic.
+ */
+export async function failRun(db, runId, stageKey, errorText, ui) {
+    const payload = withTx(db, () => {
         const now = nowISO();
         const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId);
         if (!run)
@@ -208,7 +270,21 @@ export function failRun(db, runId, stageKey, errorText) {
         db.prepare("UPDATE runs SET status='failed', error_text=?, updated_at=?, completed_at=? WHERE run_id=?").run(errorText, now, now, runId);
         db.prepare("UPDATE stories SET state='blocked', in_progress=0, locked_by_run_id=NULL, locked_at=NULL, updated_at=? WHERE story_key=?").run(now, run.story_key);
         db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, ?, ?, ?, ?)").run(newEventId(), runId, stageKey, EVENT_TYPES.RUN_FAILED, JSON.stringify({ error_text: errorText }), now);
-        updateRepoStateLastEvent(db, now, {});
+        db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
+        const story = db.prepare("SELECT story_key, title FROM stories WHERE story_key=?").get(run.story_key);
+        return { now, story_key: run.story_key, story_title: story?.title ?? "" };
+    });
+    await emitUi(ui, [
+        `⛔ Run failed`,
+        `- Run: \`${runId}\``,
+        `- Stage: \`${stageKey}\``,
+        `- Story: \`${payload.story_key}\` — ${payload.story_title || "(untitled)"}`,
+        `- Error: ${errorText}`,
+    ].join("\n"), {
+        title: "Run failed",
+        message: `${stageKey}: ${errorText}`,
+        variant: "error",
+        durationMs: 4500,
     });
 }
 export function abortRun(db, runId, reason) {
@@ -220,6 +296,6 @@ export function abortRun(db, runId, reason) {
         db.prepare("UPDATE runs SET status='aborted', error_text=?, updated_at=?, completed_at=? WHERE run_id=?").run(reason, now, now, runId);
         db.prepare("UPDATE stories SET state='approved', in_progress=0, locked_by_run_id=NULL, locked_at=NULL, updated_at=? WHERE story_key=?").run(now, run.story_key);
         db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, NULL, ?, ?, ?)").run(newEventId(), runId, EVENT_TYPES.RUN_ABORTED, JSON.stringify({ reason }), now);
-        updateRepoStateLastEvent(db, now, {});
+        db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astrocode-workflow",
-  "version": "0.1.59",
+  "version": "0.2.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/tools/injects.ts

@@ -5,34 +5,51 @@ import { withTx } from "../state/db";
 import { nowISO } from "../shared/time";
 import { sha256Hex } from "../shared/hash";
 
-const VALID_INJECT_TYPES = ['note', 'policy', 'reminder', 'debug'] as const;
-type InjectType = typeof VALID_INJECT_TYPES[number];
+const VALID_INJECT_TYPES = ["note", "policy", "reminder", "debug"] as const;
+type InjectType = (typeof VALID_INJECT_TYPES)[number];
 
 function validateInjectType(type: string): InjectType {
   if (!VALID_INJECT_TYPES.includes(type as InjectType)) {
-    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 as InjectType;
 }
 
-function validateTimestamp(timestamp: string | null): string | null {
+function validateTimestamp(timestamp: string | null | undefined): string | null {
   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}"`);
+    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: string, raw: string): string[] {
+  let v: unknown;
+  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 as string[];
+}
+
 function newInjectId(): string {
   return `inj_${Date.now()}_${Math.random().toString(16).slice(2)}`;
 }
@@ -58,17 +75,36 @@ export function createAstroInjectPutTool(opts: { ctx: any; config: AstrocodeConf
       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) as any;
 
         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,
@@ -81,7 +117,8 @@ export function createAstroInjectPutTool(opts: { ctx: any; config: AstrocodeConf
               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}`;
         }
 
@@ -108,9 +145,27 @@ export function createAstroInjectListTool(opts: { ctx: any; config: AstrocodeCon
     execute: async ({ scope, type, limit }) => {
       const where: string[] = [];
       const params: any[] = [];
-      if (scope) { where.push("scope = ?"); params.push(scope); }
-      if (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 ?`;
+
+      if (scope) {
+        where.push("scope = ?");
+        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 rows = db.prepare(sql).all(...params, limit) as any[];
       return JSON.stringify(rows, null, 2);
     },
@@ -147,8 +202,20 @@ export function createAstroInjectSearchTool(opts: { ctx: any; config: AstrocodeC
       const like = `%${q}%`;
       const where: string[] = ["(title LIKE ? OR body_md LIKE ? OR tags_json LIKE ?)"];
       const params: any[] = [like, like, like];
-      if (scope) { 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 ?`;
+
+      if (scope) {
+        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 rows = db.prepare(sql).all(...params, limit) as any[];
       return JSON.stringify(rows, null, 2);
     },
@@ -170,15 +237,25 @@ export type InjectRow = {
   updated_at: string;
 };
 
-export function selectEligibleInjects(db: SqliteDb, opts: {
-  nowIso: string;
-  scopeAllowlist: string[];
-  typeAllowlist: string[];
-  limit?: number;
-}): InjectRow[] {
+export function selectEligibleInjects(
+  db: SqliteDb,
+  opts: {
+    nowIso: string;
+    scopeAllowlist: string[];
+    typeAllowlist: string[];
+    limit?: number;
+  }
+): InjectRow[] {
   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(", ");
 
@@ -208,8 +285,11 @@ export function createAstroInjectEligibleTool(opts: { ctx: any; config: Astrocod
     },
     execute: async ({ scopes_json, types_json, limit }) => {
       const now = nowISO();
-      const scopes = JSON.parse(scopes_json) as string[];
-      const types = JSON.parse(types_json) as string[];
+      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,
@@ -234,10 +314,13 @@ export function createAstroInjectDebugDueTool(opts: { ctx: any; config: Astrocod
     },
     execute: async ({ scopes_json, types_json }) => {
       const now = nowISO();
-      const scopes = JSON.parse(scopes_json) as string[];
-      const types = JSON.parse(types_json) as string[];
+      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);
 
-      // Get ALL injects to analyze filtering
       const allInjects = db.prepare("SELECT * FROM injects").all() as any[];
 
       let total = allInjects.length;
@@ -245,25 +328,31 @@ export function createAstroInjectDebugDueTool(opts: { ctx: any; config: Astrocod
       let skippedExpired = 0;
       let skippedScope = 0;
       let skippedType = 0;
+      let skippedUnparseableExpiresAt = 0;
+
       const excludedReasons: any[] = [];
       const selectedInjects: any[] = [];
 
       for (const inject of allInjects) {
         const reasons: string[] = [];
 
-        // 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++;
@@ -273,7 +362,7 @@ export function createAstroInjectDebugDueTool(opts: { ctx: any; config: Astrocod
           excludedReasons.push({
             inject_id: inject.inject_id,
             title: inject.title,
-            reasons: reasons,
+            reasons,
             scope: inject.scope,
             type: inject.type,
             expires_at: inject.expires_at,
@@ -290,23 +379,28 @@ export function createAstroInjectDebugDueTool(opts: { ctx: any; config: Astrocod
         }
       }
 
-      return JSON.stringify({
-        now,
-        scopes_considered: scopes,
-        types_considered: types,
-        summary: {
-          total_injects: total,
-          selected_eligible: selected,
-          excluded_total: total - selected,
-          skipped_breakdown: {
-            expired: skippedExpired,
-            scope: skippedScope,
-            type: skippedType,
-          }
+      return JSON.stringify(
+        {
+          now,
+          scopes_considered: scopes,
+          types_considered: types,
+          summary: {
+            total_injects: total,
+            selected_eligible: selected,
+            excluded_total: total - selected,
+            skipped_breakdown: {
+              expired: skippedExpired,
+              expires_at_unparseable: skippedUnparseableExpiresAt,
+              scope: skippedScope,
+              type: skippedType,
+            },
+          },
+          selected_injects: selectedInjects,
+          excluded_injects: excludedReasons,
         },
-        selected_injects: selectedInjects,
-        excluded_injects: excludedReasons,
-      }, null, 2);
+        null,
+        2
+      );
     },
   });
 }