astrocode-workflow 0.4.0 → 0.4.1

package/src/tools/story.ts

@@ -8,6 +8,7 @@ import type { StoryState } from "../state/types";
 import { insertStory } from "../workflow/story-helpers";
 
 
+
 export function createAstroStoryQueueTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
   const { db } = opts;
 

package/src/tools/workflow.ts

@@ -1,5 +1,6 @@
 // src/tools/workflow.ts
 import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import path from "node:path";
 import type { AstrocodeConfig } from "../config/schema";
 import type { SqliteDb } from "../state/db";
 import { withTx } from "../state/db";
@@ -19,9 +20,12 @@ import { buildStageDirective, directiveHash } from "../workflow/directives";
 import { injectChatPrompt } from "../ui/inject";
 import { nowISO } from "../shared/time";
 import { newEventId } from "../state/ids";
+
 import { debug } from "../shared/log";
 import { createToastManager } from "../ui/toasts";
 import type { AgentConfig } from "@opencode-ai/sdk";
+import { acquireRepoLock } from "../state/repo-lock";
+import { workflowRepoLock } from "../state/workflow-repo-lock";
 
 // Agent name mapping for case-sensitive resolution
 export const STAGE_TO_AGENT_MAP: Record<string, string> = {
@@ -184,8 +188,20 @@ export function createAstroWorkflowProceedTool(opts: { ctx: any; config: Astroco
       max_steps: tool.schema.number().int().positive().default(config.workflow.default_max_steps),
     },
     execute: async ({ mode, max_steps }) => {
+      const repoRoot = (ctx as any).directory as string;
+      const lockPath = path.join(repoRoot, ".astro", "astro.lock");
       const sessionId = (ctx as any).sessionID as string | undefined;
-      const steps = Math.min(max_steps, config.workflow.loop_max_steps_hard_cap);
+
+      return workflowRepoLock(
+        { acquireRepoLock },
+        {
+          lockPath,
+          repoRoot,
+          sessionId,
+          owner: "astro_workflow_proceed",
+          advisory: true, // Advisory mode: warn instead of blocking on lock contention
+          fn: async () => {
+        const steps = Math.min(max_steps, config.workflow.loop_max_steps_hard_cap);
 
       const actions: string[] = [];
       const warnings: string[] = [];
@@ -408,6 +424,8 @@ export function createAstroWorkflowProceedTool(opts: { ctx: any; config: Astroco
       }
 
       return lines.join("\n").trim();
+          },
+        });
     },
   });
 }

package/src/ui/inject.ts

@@ -1,4 +1,5 @@
 // src/ui/inject.ts
+import { recordInjection, recordError } from "../shared/metrics";
 type InjectionItem = {
   ctx: any;
   sessionId: string;
@@ -33,16 +34,26 @@ async function tryInjectOnce(item: InjectionItem): Promise<void> {
   const { ctx, sessionId, text, agent = "Astro" } = item;
   const prefixedText = `[${agent}]\n\n${text}`;
 
-  const { session, prompt } = getPromptInvoker(ctx);
+  const injectionRecorder = recordInjection({ sessionId, attempts: item.attempts + 1, agent });
+  const injectionStart = injectionRecorder.start();
 
-  // IMPORTANT: force correct `this` binding
-  await prompt.call(session, {
-    path: { id: sessionId },
-    body: {
-      parts: [{ type: "text", text: prefixedText }],
-      agent,
-    },
-  });
+  try {
+    const { session, prompt } = getPromptInvoker(ctx);
+
+    // IMPORTANT: force correct `this` binding
+    await prompt.call(session, {
+      path: { id: sessionId },
+      body: {
+        parts: [{ type: "text", text: prefixedText }],
+        agent,
+      },
+    });
+
+    injectionRecorder.end(injectionStart, true);
+  } catch (error) {
+    injectionRecorder.end(injectionStart, false);
+    throw error;
+  }
 }
 
 async function runSessionQueue(sessionId: string) {
@@ -69,6 +80,7 @@ async function runSessionQueue(sessionId: string) {
           console.warn(
             `[Astrocode] Injection failed permanently after ${item.attempts} attempts: ${msg}`
           );
+          recordError("injection_failure", `Injection failed after ${item.attempts} attempts: ${msg}`);
           item.reject(err);
           continue;
         }

package/src/workflow/repair.ts

@@ -72,11 +72,11 @@ export function repairState(db: SqliteDb, config: AstrocodeConfig): RepairReport
     if (stageRuns.length < pipeline.length) {
       const existingKeys = new Set(stageRuns.map((s) => s.stage_key));
       const insert = db.prepare(
-        "INSERT INTO stage_runs (stage_run_id, run_id, stage_key, stage_index, status, updated_at) VALUES (?, ?, ?, ?, 'pending', ?)"
+        "INSERT INTO stage_runs (stage_run_id, run_id, stage_key, stage_index, status, created_at, updated_at) VALUES (?, ?, ?, ?, 'pending', ?, ?)"
       );
       pipeline.forEach((key, idx) => {
         if (!existingKeys.has(key as any)) {
-          insert.run(newStageRunId(), active.run_id, key, idx, now);
+          insert.run(newStageRunId(), active.run_id, key, idx, now, now);
           push(report, `Inserted missing stage_run ${key} for run ${active.run_id}`);
         }
       });