astrocode-workflow 0.3.1 → 0.3.2

package/src/tools/stage.ts

@@ -13,6 +13,7 @@ import { getAstroPaths, ensureAstroDirs, toPosix } from "../shared/paths";
 import { failRun, getActiveRun, getStageRuns, startStage, completeRun } from "../workflow/state-machine";
 import { newEventId, newId } from "../state/ids";
 import { insertStory } from "../workflow/story-helpers";
+import { withRepoLock } from "../state/repo-lock";
 
 function nextStageKey(pipeline: StageKey[], current: StageKey): StageKey | null {
   const i = pipeline.indexOf(current);
@@ -128,6 +129,15 @@ export function createAstroStageCompleteTool(opts: { ctx: any; config: Astrocode
     },
     execute: async ({ run_id, stage_key, output_text, allow_new_stories, relation_reason }) => {
       const repoRoot = ctx.directory as string;
+      const lockPath = path.join(repoRoot, ".astro", "astro.lock");
+      const sessionId = (ctx as any).sessionID as string | undefined;
+
+      return withRepoLock({
+        lockPath,
+        repoRoot,
+        sessionId,
+        owner: "astro_stage_complete",
+        fn: async () => {
       const paths = getAstroPaths(repoRoot, config.db.path);
       ensureAstroDirs(paths);
 
@@ -391,6 +401,8 @@ Ensure JSON has required fields (stage_key, status) and valid syntax.`;
       lines.push(context);
 
       return lines.join("\n").trim();
+        },
+      });
     },
   });
 }

package/src/tools/status.ts

@@ -1,7 +1,9 @@
 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 { decideNextAction, getActiveRun, getStageRuns, getStory } from "../workflow/state-machine";
+import { withRepoLock } from "../state/repo-lock";
 
 function statusIcon(status: string): string {
   switch (status) {
@@ -36,7 +38,7 @@ function stageIcon(status: string): string {
 }
 
 export function createAstroStatusTool(opts: { ctx: any; config: AstrocodeConfig; db?: SqliteDb | null }): ToolDefinition {
-  const { config, db } = opts;
+  const { ctx, config, db } = opts;
 
   return tool({
     description: "Show a compact Astrocode status dashboard: active run/stage, pipeline, story board counts, and next action.",
@@ -55,7 +57,17 @@ export function createAstroStatusTool(opts: { ctx: any; config: AstrocodeConfig;
         ].join("\n");
       }
 
-      try {
+      const repoRoot = ctx.directory as string;
+      const lockPath = path.join(repoRoot, ".astro", "astro.lock");
+      const sessionId = (ctx as any).sessionID as string | undefined;
+
+      return withRepoLock({
+        lockPath,
+        repoRoot,
+        sessionId,
+        owner: "astro_status",
+        fn: async () => {
+          try {
         const active = getActiveRun(db);
 
         const lines: string[] = [];
@@ -129,7 +141,9 @@ export function createAstroStatusTool(opts: { ctx: any; config: AstrocodeConfig;
           `⛔ Database error.`,
           `Error: ${msg}`,
         ].join("\n");
-      }
+          }
+        },
+      });
     },
   });
 }

package/src/tools/story.ts

@@ -1,4 +1,5 @@
 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";
@@ -6,10 +7,11 @@ import { nowISO } from "../shared/time";
 import type { StoryState } from "../state/types";
 
 import { insertStory } from "../workflow/story-helpers";
+import { withRepoLock } from "../state/repo-lock";
 
 
 export function createAstroStoryQueueTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
-  const { db } = opts;
+  const { ctx, db } = opts;
 
   return tool({
     description: "Create a queued story (ticket) in Astrocode. Returns story_key.",
@@ -20,18 +22,30 @@ export function createAstroStoryQueueTool(opts: { ctx: any; config: AstrocodeCon
       priority: tool.schema.number().int().default(0),
     },
     execute: async ({ title, body_md, epic_key, priority }) => {
-      const story_key = withTx(db, () => {
-        const key = insertStory(db, { title, body_md, epic_key: epic_key ?? null, priority: priority ?? 0, state: 'queued' });
-        return key;
+      const repoRoot = ctx.directory as string;
+      const lockPath = path.join(repoRoot, ".astro", "astro.lock");
+      const sessionId = (ctx as any).sessionID as string | undefined;
+
+      return withRepoLock({
+        lockPath,
+        repoRoot,
+        sessionId,
+        owner: "astro_story_queue",
+        fn: async () => {
+          const story_key = withTx(db, () => {
+            const key = insertStory(db, { title, body_md, epic_key: epic_key ?? null, priority: priority ?? 0, state: 'queued' });
+            return key;
+          });
+
+          return `✅ Queued story ${story_key}: ${title}`;
+        },
       });
-
-      return `✅ Queued story ${story_key}: ${title}`;
     },
   });
 }
 
 export function createAstroStoryApproveTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
-  const { db } = opts;
+  const { ctx, db } = opts;
 
   return tool({
     description: "Approve a story so it becomes eligible to run.",
@@ -39,14 +53,26 @@ export function createAstroStoryApproveTool(opts: { ctx: any; config: AstrocodeC
       story_key: tool.schema.string().min(1),
     },
     execute: async ({ story_key }) => {
-      const now = nowISO();
-      const row = db.prepare("SELECT story_key, state, title FROM stories WHERE story_key=?").get(story_key) as any;
-      if (!row) throw new Error(`Story not found: ${story_key}`);
-
-      if (row.state === "approved") return `ℹ️ Story ${story_key} already approved.`;
-
-      db.prepare("UPDATE stories SET state='approved', approved_at=?, updated_at=? WHERE story_key=?").run(now, now, story_key);
-      return `✅ Approved story ${story_key}: ${row.title}`;
+      const repoRoot = ctx.directory as string;
+      const lockPath = path.join(repoRoot, ".astro", "astro.lock");
+      const sessionId = (ctx as any).sessionID as string | undefined;
+
+      return withRepoLock({
+        lockPath,
+        repoRoot,
+        sessionId,
+        owner: "astro_story_approve",
+        fn: async () => {
+          const now = nowISO();
+          const row = db.prepare("SELECT story_key, state, title FROM stories WHERE story_key=?").get(story_key) as any;
+          if (!row) throw new Error(`Story not found: ${story_key}`);
+
+          if (row.state === "approved") return `ℹ️ Story ${story_key} already approved.`;
+
+          db.prepare("UPDATE stories SET state='approved', approved_at=?, updated_at=? WHERE story_key=?").run(now, now, story_key);
+          return `✅ Approved story ${story_key}: ${row.title}`;
+        },
+      });
     },
   });
 }

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,11 @@ import { buildStageDirective, directiveHash } from "../workflow/directives";
 import { injectChatPrompt } from "../ui/inject";
 import { nowISO } from "../shared/time";
 import { newEventId } from "../state/ids";
+import { withRepoLock } from "../state/repo-lock";
 import { debug } from "../shared/log";
 import { createToastManager } from "../ui/toasts";
 import type { AgentConfig } from "@opencode-ai/sdk";
+import { acquireRepoLock } from "../state/repo-lock";
 
 // Agent name mapping for case-sensitive resolution
 export const STAGE_TO_AGENT_MAP: Record<string, string> = {
@@ -184,8 +187,17 @@ 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 withRepoLock({
+        lockPath,
+        repoRoot,
+        sessionId,
+        owner: "astro_workflow_proceed",
+        fn: async () => {
+        const steps = Math.min(max_steps, config.workflow.loop_max_steps_hard_cap);
 
       const actions: string[] = [];
       const warnings: string[] = [];
@@ -408,6 +420,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;
         }