@bastani/atomic 0.5.0-3 → 0.5.0-5

package/.atomic/workflows/hello-parallel/opencode/index.ts

@@ -15,55 +15,79 @@ export default defineWorkflow({
   name: "hello-parallel",
   description: "Parallel OpenCode demo: describe → [summarize-a, summarize-b] → merge",
 })
-  .session({
-    name: "describe",
-    description: "Ask the agent to describe the project",
-    run: async (ctx) => {
-      const client = createOpencodeClient({ baseUrl: ctx.serverUrl });
-
-      const session = await client.session.create({ title: "describe" });
-      await client.tui.selectSession({ sessionID: session.data!.id });
-
-      const result = await client.session.prompt({
-        sessionID: session.data!.id,
-        parts: [{ type: "text", text: ctx.userPrompt }],
-      });
-
-      ctx.save(result.data!);
-    },
-  })
-  .session([
-    {
-      name: "summarize-a",
-      description: "Summarize the description as bullet points",
-      run: async (ctx) => {
-        const research = await ctx.transcript("describe");
-        const client = createOpencodeClient({ baseUrl: ctx.serverUrl });
-
-        const session = await client.session.create({ title: "summarize-a" });
+  .run(async (ctx) => {
+    const describe = await ctx.session(
+      { name: "describe", description: "Ask the agent to describe the project" },
+      async (s) => {
+        const client = createOpencodeClient({ baseUrl: s.serverUrl });
+
+        const session = await client.session.create({ title: "describe" });
         await client.tui.selectSession({ sessionID: session.data!.id });
 
         const result = await client.session.prompt({
           sessionID: session.data!.id,
-          parts: [
-            {
-              type: "text",
-              text: `Summarize the following in 2-3 bullet points:\n\n${research.content}`,
-            },
-          ],
+          parts: [{ type: "text", text: s.userPrompt }],
         });
 
-        ctx.save(result.data!);
+        s.save(result.data!);
       },
-    },
-    {
-      name: "summarize-b",
-      description: "Summarize the description as a one-liner",
-      run: async (ctx) => {
-        const research = await ctx.transcript("describe");
-        const client = createOpencodeClient({ baseUrl: ctx.serverUrl });
-
-        const session = await client.session.create({ title: "summarize-b" });
+    );
+
+    const [summarizeA, summarizeB] = await Promise.all([
+      ctx.session(
+        { name: "summarize-a", description: "Summarize the description as bullet points" },
+        async (s) => {
+          const research = await s.transcript(describe);
+          const client = createOpencodeClient({ baseUrl: s.serverUrl });
+
+          const session = await client.session.create({ title: "summarize-a" });
+          await client.tui.selectSession({ sessionID: session.data!.id });
+
+          const result = await client.session.prompt({
+            sessionID: session.data!.id,
+            parts: [
+              {
+                type: "text",
+                text: `Summarize the following in 2-3 bullet points:\n\n${research.content}`,
+              },
+            ],
+          });
+
+          s.save(result.data!);
+        },
+      ),
+      ctx.session(
+        { name: "summarize-b", description: "Summarize the description as a one-liner" },
+        async (s) => {
+          const research = await s.transcript(describe);
+          const client = createOpencodeClient({ baseUrl: s.serverUrl });
+
+          const session = await client.session.create({ title: "summarize-b" });
+          await client.tui.selectSession({ sessionID: session.data!.id });
+
+          const result = await client.session.prompt({
+            sessionID: session.data!.id,
+            parts: [
+              {
+                type: "text",
+                text: `Summarize the following in a single sentence:\n\n${research.content}`,
+              },
+            ],
+          });
+
+          s.save(result.data!);
+        },
+      ),
+    ]);
+
+    await ctx.session(
+      { name: "merge", description: "Merge both summaries into a final output" },
+      async (s) => {
+        const bullets = await s.transcript(summarizeA);
+        const oneliner = await s.transcript(summarizeB);
+        const client = createOpencodeClient({ baseUrl: s.serverUrl });
+
+        const session = await client.session.create({ title: "merge" });
         await client.tui.selectSession({ sessionID: session.data!.id });
 
         const result = await client.session.prompt({
@@ -71,45 +95,21 @@ export default defineWorkflow({
           parts: [
             {
               type: "text",
-              text: `Summarize the following in a single sentence:\n\n${research.content}`,
+              text: [
+                "Combine the following two summaries into one concise paragraph:",
+                "",
+                "## Bullet points",
+                bullets.content,
+                "",
+                "## One-liner",
+                oneliner.content,
+              ].join("\n"),
             },
           ],
         });
 
-        ctx.save(result.data!);
+        s.save(result.data!);
       },
-    },
-  ])
-  .session({
-    name: "merge",
-    description: "Merge both summaries into a final output",
-    run: async (ctx) => {
-      const bullets = await ctx.transcript("summarize-a");
-      const oneliner = await ctx.transcript("summarize-b");
-      const client = createOpencodeClient({ baseUrl: ctx.serverUrl });
-
-      const session = await client.session.create({ title: "merge" });
-      await client.tui.selectSession({ sessionID: session.data!.id });
-
-      const result = await client.session.prompt({
-        sessionID: session.data!.id,
-        parts: [
-          {
-            type: "text",
-            text: [
-              "Combine the following two summaries into one concise paragraph:",
-              "",
-              "## Bullet points",
-              bullets.content,
-              "",
-              "## One-liner",
-              oneliner.content,
-            ].join("\n"),
-          },
-        ],
-      });
-
-      ctx.save(result.data!);
-    },
+    );
   })
   .compile();

package/.atomic/workflows/ralph/claude/index.ts

@@ -1,20 +1,12 @@
 /**
  * Ralph workflow for Claude Code — plan → orchestrate → review → debug loop.
  *
- * One Claude TUI runs in a tmux pane for the duration of the workflow. Each
- * loop iteration invokes sub-agents via @-mention syntax (planner,
- * orchestrator, reviewer, and — when findings remain — debugger). The loop
+ * Each sub-agent invocation spawns its own visible session in the graph,
+ * so users can see each iteration's progress in real time. The loop
  * terminates when:
  *   - {@link MAX_LOOPS} iterations have completed, OR
  *   - Two consecutive reviewer passes return zero findings.
  *
- * A loop is one cycle of plan → orchestrate → review. When a review returns
- * zero findings on the FIRST pass we re-run only the reviewer (still inside
- * the same loop iteration) to confirm; if that confirmation pass is also
- * clean we stop. The debugger only runs when findings remain after the
- * reviewer pass(es), and its markdown report is fed back to the planner on
- * the next iteration.
- *
  * Run: atomic workflow -n ralph -a claude "<your spec>"
  */
 
@@ -48,102 +40,145 @@ export default defineWorkflow({
   description:
     "Plan → orchestrate → review → debug loop with bounded iteration",
 })
-  .session({
-    name: "ralph-loop",
-    description:
-      "Drive plan/orchestrate/review/debug iterations until clean or capped",
-    run: async (ctx) => {
-      await createClaudeSession({ paneId: ctx.paneId });
-
-      let consecutiveClean = 0;
-      let debuggerReport = "";
-
-      for (let iteration = 1; iteration <= MAX_LOOPS; iteration++) {
-        // ── Plan ────────────────────────────────────────────────────────────
-        await claudeQuery({
-          paneId: ctx.paneId,
-          prompt: asAgentCall(
-            "planner",
-            buildPlannerPrompt(ctx.userPrompt, {
-              iteration,
-              debuggerReport: debuggerReport || undefined,
-            }),
-          ),
-        });
-
-        // ── Orchestrate ─────────────────────────────────────────────────────
-        await claudeQuery({
-          paneId: ctx.paneId,
-          prompt: asAgentCall("orchestrator", buildOrchestratorPrompt()),
-        });
-
-        // ── Review (first pass) ─────────────────────────────────────────────
-        let gitStatus = await safeGitStatusS();
-        let reviewQuery = await claudeQuery({
-          paneId: ctx.paneId,
-          prompt: asAgentCall(
-            "reviewer",
-            buildReviewPrompt(ctx.userPrompt, { gitStatus, iteration }),
-          ),
-        });
-        let reviewRaw = reviewQuery.output;
-        let parsed = parseReviewResult(reviewRaw);
-
-        if (!hasActionableFindings(parsed, reviewRaw)) {
-          consecutiveClean += 1;
-          if (consecutiveClean >= CONSECUTIVE_CLEAN_THRESHOLD) {
-            break;
-          }
+  .run(async (ctx) => {
+    let consecutiveClean = 0;
+    let debuggerReport = "";
+    // Track the most recent session so the next stage can declare it as a
+    // dependency — this chains planner → orchestrator → reviewer → [confirm]
+    // → [debugger] → next planner in the graph instead of showing every
+    // stage as an independent sibling under the root.
+    let prevStage: string | undefined;
+    const depsOn = (): string[] | undefined =>
+      prevStage ? [prevStage] : undefined;
 
-          // Confirmation pass — re-run reviewer only, NOT plan/orchestrate.
-          gitStatus = await safeGitStatusS();
-          reviewQuery = await claudeQuery({
-            paneId: ctx.paneId,
+    for (let iteration = 1; iteration <= MAX_LOOPS; iteration++) {
+      // ── Plan ────────────────────────────────────────────────────────────
+      const plannerName = `planner-${iteration}`;
+      await ctx.session(
+        { name: plannerName, dependsOn: depsOn() },
+        async (s) => {
+          await createClaudeSession({ paneId: s.paneId });
+          await claudeQuery({
+            paneId: s.paneId,
             prompt: asAgentCall(
-              "reviewer",
-              buildReviewPrompt(ctx.userPrompt, {
-                gitStatus,
+              "planner",
+              buildPlannerPrompt(s.userPrompt, {
                 iteration,
-                isConfirmationPass: true,
+                debuggerReport: debuggerReport || undefined,
               }),
             ),
           });
-          reviewRaw = reviewQuery.output;
-          parsed = parseReviewResult(reviewRaw);
+          s.save(s.sessionId);
+        },
+      );
+      prevStage = plannerName;
 
-          if (!hasActionableFindings(parsed, reviewRaw)) {
-            consecutiveClean += 1;
-            if (consecutiveClean >= CONSECUTIVE_CLEAN_THRESHOLD) {
-              break;
-            }
-          } else {
-            consecutiveClean = 0;
-            // fall through to debugger
-          }
-        } else {
-          consecutiveClean = 0;
-        }
+      // ── Orchestrate ─────────────────────────────────────────────────────
+      const orchName = `orchestrator-${iteration}`;
+      await ctx.session(
+        { name: orchName, dependsOn: depsOn() },
+        async (s) => {
+          await createClaudeSession({ paneId: s.paneId });
+          await claudeQuery({
+            paneId: s.paneId,
+            prompt: asAgentCall(
+              "orchestrator",
+              buildOrchestratorPrompt(s.userPrompt),
+            ),
+          });
+          s.save(s.sessionId);
+        },
+      );
+      prevStage = orchName;
 
-        // ── Debug (only if findings remain AND another iteration is allowed) ─
-        if (
-          hasActionableFindings(parsed, reviewRaw) &&
-          iteration < MAX_LOOPS
-        ) {
-          const debuggerQuery = await claudeQuery({
-            paneId: ctx.paneId,
+      // ── Review (first pass) ─────────────────────────────────────────────
+      let gitStatus = await safeGitStatusS();
+      const reviewerName = `reviewer-${iteration}`;
+      const review = await ctx.session(
+        { name: reviewerName, dependsOn: depsOn() },
+        async (s) => {
+          await createClaudeSession({ paneId: s.paneId });
+          const result = await claudeQuery({
+            paneId: s.paneId,
             prompt: asAgentCall(
-              "debugger",
-              buildDebuggerReportPrompt(parsed, reviewRaw, {
-                iteration,
-                gitStatus,
-              }),
+              "reviewer",
+              buildReviewPrompt(s.userPrompt, { gitStatus, iteration }),
             ),
           });
-          debuggerReport = extractMarkdownBlock(debuggerQuery.output);
+          s.save(s.sessionId);
+          return result.output;
+        },
+      );
+      prevStage = reviewerName;
+
+      let reviewRaw = review.result;
+      let parsed = parseReviewResult(reviewRaw);
+
+      if (!hasActionableFindings(parsed, reviewRaw)) {
+        consecutiveClean += 1;
+        if (consecutiveClean >= CONSECUTIVE_CLEAN_THRESHOLD) break;
+
+        // Confirmation pass — re-run reviewer only
+        gitStatus = await safeGitStatusS();
+        const confirmName = `reviewer-${iteration}-confirm`;
+        const confirm = await ctx.session(
+          { name: confirmName, dependsOn: depsOn() },
+          async (s) => {
+            await createClaudeSession({ paneId: s.paneId });
+            const result = await claudeQuery({
+              paneId: s.paneId,
+              prompt: asAgentCall(
+                "reviewer",
+                buildReviewPrompt(s.userPrompt, {
+                  gitStatus,
+                  iteration,
+                  isConfirmationPass: true,
+                }),
+              ),
+            });
+            s.save(s.sessionId);
+            return result.output;
+          },
+        );
+        prevStage = confirmName;
+
+        reviewRaw = confirm.result;
+        parsed = parseReviewResult(reviewRaw);
+
+        if (!hasActionableFindings(parsed, reviewRaw)) {
+          consecutiveClean += 1;
+          if (consecutiveClean >= CONSECUTIVE_CLEAN_THRESHOLD) break;
+        } else {
+          consecutiveClean = 0;
         }
+      } else {
+        consecutiveClean = 0;
       }
 
-      ctx.save(ctx.sessionId);
-    },
+      // ── Debug (only if findings remain AND another iteration is allowed) ─
+      if (hasActionableFindings(parsed, reviewRaw) && iteration < MAX_LOOPS) {
+        const debuggerName = `debugger-${iteration}`;
+        const debugger_ = await ctx.session(
+          { name: debuggerName, dependsOn: depsOn() },
+          async (s) => {
+            await createClaudeSession({ paneId: s.paneId });
+            const result = await claudeQuery({
+              paneId: s.paneId,
+              prompt: asAgentCall(
+                "debugger",
+                buildDebuggerReportPrompt(parsed, reviewRaw, {
+                  iteration,
+                  gitStatus,
+                }),
+              ),
+            });
+            s.save(s.sessionId);
+            return result.output;
+          },
+        );
+        prevStage = debuggerName;
+        debuggerReport = extractMarkdownBlock(debugger_.result);
+      }
+    }
   })
   .compile();