astrocode-workflow 0.0.1 → 0.0.2

package/dist/config/schema.js

@@ -95,8 +95,8 @@ const WorkflowSchema = z.object({
     default_mode: z.enum(["step", "loop"]).default("step"),
     default_max_steps: z.number().int().positive().default(1),
     loop_max_steps_hard_cap: z.number().int().positive().default(200),
-    plan_max_tasks: z.number().int().positive().default(7),
-    plan_max_lines: z.number().int().positive().default(80),
+    plan_max_tasks: z.number().int().positive().default(500),
+    plan_max_lines: z.number().int().positive().default(2000),
     forbid_prompt_narration: z.boolean().default(true),
     single_active_run_per_repo: z.boolean().default(true),
     lock_timeout_ms: z.number().int().positive().default(4000),

package/dist/tools/stage.js

@@ -7,7 +7,7 @@ import { putArtifact } from "../workflow/artifacts";
 import { nowISO } from "../shared/time";
 import { getAstroPaths, ensureAstroDirs, toPosix } from "../shared/paths";
 import { failRun, getActiveRun, getStageRuns, startStage, completeRun } from "../workflow/state-machine";
-import { newEventId } from "../state/ids";
+import { newEventId, newId } from "../state/ids";
 import { insertStory } from "../workflow/story-helpers";
 function nextStageKey(pipeline, current) {
     const i = pipeline.indexOf(current);
@@ -65,30 +65,31 @@ export function createAstroStageCompleteTool(opts) {
             const active = getActiveRun(db);
             const rid = run_id ?? active?.run_id;
             if (!rid)
-                throw new Error("No active run and no run_id provided.");
+                return "❌ No active run found. Start a run first.";
             const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(rid);
             if (!run)
-                throw new Error(`Run not found: ${rid}`);
+                return `❌ Run not found: ${rid}`;
             const sk = (stage_key ?? run.current_stage_key);
             if (!sk)
-                throw new Error("No stage_key provided and run.current_stage_key is null.");
+                return "❌ No stage_key provided and run has no current stage.";
             const stageRow = db.prepare("SELECT * FROM stage_runs WHERE run_id=? AND stage_key=?").get(rid, sk);
             if (!stageRow)
-                throw new Error(`Stage run not found: ${rid}/${sk}`);
+                return `❌ Stage run not found: ${rid}/${sk}`;
             if (stageRow.status !== "running") {
-                throw new Error(`Stage ${sk} is not running (status=${stageRow.status}). Start it first.`);
+                return `❌ Stage ${sk} is not running (status=${stageRow.status}). Start it first with astro_stage_start.`;
             }
             const parsed = parseStageOutputText(output_text);
-            if (parsed.error || !parsed.astro_json)
-                throw new Error(parsed.error ?? "ASTRO JSON missing");
+            if (parsed.error || !parsed.astro_json) {
+                return `❌ Stage completion failed: ${parsed.error ?? "ASTRO JSON missing"}. Please ensure output includes proper JSON markers.`;
+            }
             if (parsed.astro_json.stage_key !== sk) {
-                throw new Error(`ASTRO JSON stage_key mismatch: expected ${sk}, got ${parsed.astro_json.stage_key}`);
+                return `❌ Stage completion failed: ASTRO JSON stage_key mismatch (expected ${sk}, got ${parsed.astro_json.stage_key}).`;
             }
             // Evidence requirement
             const evidenceRequired = (sk === "verify" && config.workflow.evidence_required.verify) ||
                 (sk === "implement" && config.workflow.evidence_required.implement);
             if (evidenceRequired && (parsed.astro_json.evidence ?? []).length === 0) {
-                throw new Error(`Evidence is required for stage ${sk} but ASTRO JSON evidence[] is empty.`);
+                return `❌ Evidence is required for stage ${sk} but ASTRO JSON evidence[] is empty. Please provide evidence files.`;
             }
             const batonSummary = buildBatonSummary({ config, stage_key: sk, astro_json: parsed.astro_json, baton_md: parsed.baton_md });
             const now = nowISO();
@@ -161,7 +162,40 @@ export function createAstroStageCompleteTool(opts) {
                     for (const ns of parsed.astro_json.new_stories) {
                         const key = insertStory(db, { title: ns.title, body_md: ns.body_md ?? "", priority: ns.priority ?? 0, state: "queued" });
                         newStoryKeys.push(key);
-                        db.prepare("INSERT OR IGNORE INTO story_relations (parent_story_key, child_story_key, relation_type, reason, created_at) VALUES (?, ?, 'split', ?, ?)").run(run.story_key, key, relation_reason, now);
+                        db.prepare("INSERT INTO story_relations (relation_id, parent_key, child_key, relation_type, created_at) VALUES (?, ?, ?, ?, ?)").run(newId("rel"), run.story_key, key, relation_reason, now);
+                    }
+                }
+                // Automatic story splitting for complex tasks
+                if (allow_new_stories && parsed.astro_json.tasks?.length) {
+                    for (const task of parsed.astro_json.tasks) {
+                        const complexity = task.complexity ?? 5;
+                        const subtasks = task.subtasks ?? [];
+                        if (subtasks.length > 0) {
+                            // Split into subtasks
+                            for (const subtask of subtasks) {
+                                const key = insertStory(db, {
+                                    title: `${task.title}: ${subtask}`,
+                                    body_md: task.description ?? "",
+                                    priority: Math.max(1, 10 - complexity),
+                                    state: "queued",
+                                    epic_key: run.story_key
+                                });
+                                newStoryKeys.push(key);
+                                db.prepare("INSERT INTO story_relations (relation_id, parent_key, child_key, relation_type, created_at) VALUES (?, ?, ?, ?, ?)").run(newId("rel"), run.story_key, key, "auto-split subtask", now);
+                            }
+                        }
+                        else if (complexity > 5) {
+                            // Split complex tasks without subtasks
+                            const key = insertStory(db, {
+                                title: task.title,
+                                body_md: task.description ?? "",
+                                priority: Math.max(1, 10 - complexity),
+                                state: "queued",
+                                epic_key: run.story_key
+                            });
+                            newStoryKeys.push(key);
+                            db.prepare("INSERT INTO story_relations (relation_id, parent_key, child_key, relation_type, created_at) VALUES (?, ?, ?, ?, ?)").run(newId("rel"), run.story_key, key, "auto-split from plan", now);
+                        }
                     }
                 }
                 if (parsed.astro_json.status !== "ok") {

package/dist/tools/workflow.js

@@ -12,7 +12,7 @@ function stageGoal(stage, cfg) {
         case "frame":
             return "Define scope, constraints, and an unambiguous Definition of Done.";
         case "plan":
-            return `Produce a bounded task plan (<= ${cfg.workflow.plan_max_tasks} tasks) tied to files and tests.`;
+            return `Break down the work into 10-500 detailed tasks with subtasks, estimating complexity (1-10) for each. Focus on granular, implementable units.`;
         case "spec":
             return "Produce minimal spec/contract: interfaces, invariants, acceptance checks.";
         case "implement":
@@ -32,7 +32,7 @@ function stageConstraints(stage, cfg) {
         "If blocked: ask exactly ONE question and stop.",
     ];
     if (stage === "plan") {
-        common.push(`Hard limit: <= ${cfg.workflow.plan_max_tasks} tasks and <= ${cfg.workflow.plan_max_lines} lines of plan output.`);
+        common.push(`Aim for 10-500 tasks; no hard upper limit but prioritize granularity.`);
     }
     if (stage === "verify" && cfg.workflow.evidence_required.verify) {
         common.push("Evidence required: ASTRO JSON must include evidence[] paths.");
@@ -111,7 +111,7 @@ export function createAstroWorkflowProceedTool(opts) {
                     const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(active.run_id);
                     const story = db.prepare("SELECT * FROM stories WHERE story_key=?").get(run.story_key);
                     // Mark stage started + set subagent_type to the stage agent.
-                    const agentName = agentNameForStage(next.stage_key, config);
+                    const agentName = next.stage_key;
                     withTx(db, () => {
                         startStage(db, active.run_id, next.stage_key, { subagent_type: agentName });
                     });

package/dist/workflow/baton.d.ts

@@ -32,6 +32,12 @@ export declare const AstroJsonSchema: z.ZodObject<{
     summary: z.ZodDefault<z.ZodString>;
     decisions: z.ZodDefault<z.ZodArray<z.ZodString>>;
     next_actions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    tasks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        complexity: z.ZodOptional<z.ZodNumber>;
+        subtasks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
     files: z.ZodDefault<z.ZodArray<z.ZodObject<{
         path: z.ZodString;
         kind: z.ZodDefault<z.ZodString>;

package/dist/workflow/baton.js

@@ -12,6 +12,12 @@ export const AstroJsonSchema = z.object({
     summary: z.string().default(""),
     decisions: z.array(z.string()).default([]),
     next_actions: z.array(z.string()).default([]),
+    tasks: z.array(z.object({
+        title: z.string(),
+        description: z.string().optional(),
+        complexity: z.number().int().min(1).max(10).optional(),
+        subtasks: z.array(z.string()).optional(),
+    })).default([]),
     files: z.array(z.object({
         path: z.string(),
         kind: z.string().default("file"),

package/package.json

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

package/src/config/schema.ts

@@ -112,8 +112,8 @@ const WorkflowSchema = z.object({
   default_max_steps: z.number().int().positive().default(1),
   loop_max_steps_hard_cap: z.number().int().positive().default(200),
 
-  plan_max_tasks: z.number().int().positive().default(7),
-  plan_max_lines: z.number().int().positive().default(80),
+  plan_max_tasks: z.number().int().positive().default(500),
+  plan_max_lines: z.number().int().positive().default(2000),
 
   forbid_prompt_narration: z.boolean().default(true),
   single_active_run_per_repo: z.boolean().default(true),

package/src/tools/stage.ts

@@ -10,7 +10,7 @@ import { putArtifact } from "../workflow/artifacts";
 import { nowISO } from "../shared/time";
 import { getAstroPaths, ensureAstroDirs, toPosix } from "../shared/paths";
 import { failRun, getActiveRun, getStageRuns, startStage, completeRun } from "../workflow/state-machine";
-import { newEventId } from "../state/ids";
+import { newEventId, newId } from "../state/ids";
 import { insertStory } from "../workflow/story-helpers";
 
 function nextStageKey(pipeline: StageKey[], current: StageKey): StageKey | null {
@@ -75,37 +75,39 @@ export function createAstroStageCompleteTool(opts: { ctx: any; config: Astrocode
       const paths = getAstroPaths(repoRoot, config.db.path);
       ensureAstroDirs(paths);
 
-      const active = getActiveRun(db);
-      const rid = run_id ?? active?.run_id;
-      if (!rid) throw new Error("No active run and no run_id provided.");
+       const active = getActiveRun(db);
+       const rid = run_id ?? active?.run_id;
+       if (!rid) return "❌ No active run found. Start a run first.";
 
-      const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(rid) as any;
-      if (!run) throw new Error(`Run not found: ${rid}`);
+       const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(rid) as any;
+       if (!run) return `❌ Run not found: ${rid}`;
 
-      const sk = (stage_key ?? run.current_stage_key) as StageKey;
-      if (!sk) throw new Error("No stage_key provided and run.current_stage_key is null.");
+       const sk = (stage_key ?? run.current_stage_key) as StageKey;
+       if (!sk) return "❌ No stage_key provided and run has no current stage.";
 
-      const stageRow = db.prepare("SELECT * FROM stage_runs WHERE run_id=? AND stage_key=?").get(rid, sk) as StageRunRow | undefined;
-      if (!stageRow) throw new Error(`Stage run not found: ${rid}/${sk}`);
-      if (stageRow.status !== "running") {
-        throw new Error(`Stage ${sk} is not running (status=${stageRow.status}). Start it first.`);
-      }
+       const stageRow = db.prepare("SELECT * FROM stage_runs WHERE run_id=? AND stage_key=?").get(rid, sk) as StageRunRow | undefined;
+       if (!stageRow) return `❌ Stage run not found: ${rid}/${sk}`;
+       if (stageRow.status !== "running") {
+         return `❌ Stage ${sk} is not running (status=${stageRow.status}). Start it first with astro_stage_start.`;
+       }
 
-      const parsed = parseStageOutputText(output_text);
-      if (parsed.error || !parsed.astro_json) throw new Error(parsed.error ?? "ASTRO JSON missing");
+       const parsed = parseStageOutputText(output_text);
+       if (parsed.error || !parsed.astro_json) {
+         return `❌ Stage completion failed: ${parsed.error ?? "ASTRO JSON missing"}. Please ensure output includes proper JSON markers.`;
+       }
 
-      if (parsed.astro_json.stage_key !== sk) {
-        throw new Error(`ASTRO JSON stage_key mismatch: expected ${sk}, got ${parsed.astro_json.stage_key}`);
-      }
+       if (parsed.astro_json.stage_key !== sk) {
+         return `❌ Stage completion failed: ASTRO JSON stage_key mismatch (expected ${sk}, got ${parsed.astro_json.stage_key}).`;
+       }
 
       // Evidence requirement
       const evidenceRequired =
         (sk === "verify" && config.workflow.evidence_required.verify) ||
         (sk === "implement" && config.workflow.evidence_required.implement);
 
-      if (evidenceRequired && (parsed.astro_json.evidence ?? []).length === 0) {
-        throw new Error(`Evidence is required for stage ${sk} but ASTRO JSON evidence[] is empty.`);
-      }
+       if (evidenceRequired && (parsed.astro_json.evidence ?? []).length === 0) {
+         return `❌ Evidence is required for stage ${sk} but ASTRO JSON evidence[] is empty. Please provide evidence files.`;
+       }
 
       const batonSummary = buildBatonSummary({ config, stage_key: sk, astro_json: parsed.astro_json, baton_md: parsed.baton_md });
 
@@ -208,8 +210,63 @@ export function createAstroStageCompleteTool(opts: { ctx: any; config: Astrocode
             const key = insertStory(db, { title: ns.title, body_md: ns.body_md ?? "", priority: ns.priority ?? 0, state: "queued" });
             newStoryKeys.push(key);
             db.prepare(
-              "INSERT OR IGNORE INTO story_relations (parent_story_key, child_story_key, relation_type, reason, created_at) VALUES (?, ?, 'split', ?, ?)"
-            ).run(run.story_key, key, relation_reason, now);
+              "INSERT INTO story_relations (relation_id, parent_key, child_key, relation_type, created_at) VALUES (?, ?, ?, ?, ?)"
+            ).run(
+              newId("rel"),
+              run.story_key,
+              key,
+              relation_reason,
+              now
+            );
+          }
+        }
+
+        // Automatic story splitting for complex tasks
+        if (allow_new_stories && parsed.astro_json.tasks?.length) {
+          for (const task of parsed.astro_json.tasks) {
+            const complexity = task.complexity ?? 5;
+            const subtasks = task.subtasks ?? [];
+            if (subtasks.length > 0) {
+              // Split into subtasks
+              for (const subtask of subtasks) {
+                const key = insertStory(db, {
+                  title: `${task.title}: ${subtask}`,
+                  body_md: task.description ?? "",
+                  priority: Math.max(1, 10 - complexity),
+                  state: "queued",
+                  epic_key: run.story_key
+                });
+                newStoryKeys.push(key);
+                db.prepare(
+                  "INSERT INTO story_relations (relation_id, parent_key, child_key, relation_type, created_at) VALUES (?, ?, ?, ?, ?)"
+                ).run(
+                  newId("rel"),
+                  run.story_key,
+                  key,
+                  "auto-split subtask",
+                  now
+                );
+              }
+            } else if (complexity > 5) {
+              // Split complex tasks without subtasks
+              const key = insertStory(db, {
+                title: task.title,
+                body_md: task.description ?? "",
+                priority: Math.max(1, 10 - complexity),
+                state: "queued",
+                epic_key: run.story_key
+              });
+              newStoryKeys.push(key);
+              db.prepare(
+                "INSERT INTO story_relations (relation_id, parent_key, child_key, relation_type, created_at) VALUES (?, ?, ?, ?, ?)"
+              ).run(
+                newId("rel"),
+                run.story_key,
+                key,
+                "auto-split from plan",
+                now
+              );
+            }
           }
         }
 

package/src/tools/workflow.ts

@@ -16,7 +16,7 @@ function stageGoal(stage: StageKey, cfg: AstrocodeConfig): string {
     case "frame":
       return "Define scope, constraints, and an unambiguous Definition of Done.";
     case "plan":
-      return `Produce a bounded task plan (<= ${cfg.workflow.plan_max_tasks} tasks) tied to files and tests.`;
+      return `Break down the work into 10-500 detailed tasks with subtasks, estimating complexity (1-10) for each. Focus on granular, implementable units.`;
     case "spec":
       return "Produce minimal spec/contract: interfaces, invariants, acceptance checks.";
     case "implement":
@@ -38,7 +38,7 @@ function stageConstraints(stage: StageKey, cfg: AstrocodeConfig): string[] {
   ];
 
   if (stage === "plan") {
-    common.push(`Hard limit: <= ${cfg.workflow.plan_max_tasks} tasks and <= ${cfg.workflow.plan_max_lines} lines of plan output.`);
+    common.push(`Aim for 10-500 tasks; no hard upper limit but prioritize granularity.`);
   }
   if (stage === "verify" && cfg.workflow.evidence_required.verify) {
     common.push("Evidence required: ASTRO JSON must include evidence[] paths.");
@@ -135,8 +135,8 @@ export function createAstroWorkflowProceedTool(opts: { ctx: any; config: Astroco
           const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(active.run_id) as any;
           const story = db.prepare("SELECT * FROM stories WHERE story_key=?").get(run.story_key) as any;
 
-          // Mark stage started + set subagent_type to the stage agent.
-          const agentName = agentNameForStage(next.stage_key, config);
+           // Mark stage started + set subagent_type to the stage agent.
+           const agentName = next.stage_key;
           withTx(db, () => {
             startStage(db, active.run_id, next.stage_key, { subagent_type: agentName });
           });

package/src/workflow/baton.ts

@@ -21,6 +21,15 @@ export const AstroJsonSchema = z.object({
   decisions: z.array(z.string()).default([]),
   next_actions: z.array(z.string()).default([]),
 
+  tasks: z.array(
+    z.object({
+      title: z.string(),
+      description: z.string().optional(),
+      complexity: z.number().int().min(1).max(10).optional(),
+      subtasks: z.array(z.string()).optional(),
+    })
+  ).default([]),
+
   files: z.array(
     z.object({
       path: z.string(),