@bastani/atomic 0.5.12-5 → 0.5.13-0

package/dist/sdk/workflows/builtin/deep-research-codebase/claude/index.d.ts

@@ -0,0 +1,62 @@
+/**
+ * deep-research-codebase / claude
+ *
+ * A deterministically-orchestrated, distributed version of the
+ * `research-codebase` skill. The research-codebase skill spawns
+ * codebase-locator / codebase-analyzer / codebase-pattern-finder /
+ * codebase-research-locator / codebase-research-analyzer /
+ * codebase-online-researcher sub-agents on the fly via LLM judgment;
+ * this workflow spawns the same agents on a deterministic schedule
+ * driven by the codebase's lines of code.
+ *
+ * Topology:
+ *
+ *           ┌─→ codebase-scout
+ *   parent ─┤
+ *           └─→ research-history
+ *                     │
+ *                     ▼
+ *   ┌──────────────────────────────────────────────────┐
+ *   │  explorer-1   explorer-2   ...   explorer-N      │   (Promise.all)
+ *   └──────────────────────────────────────────────────┘
+ *                     │
+ *                     ▼
+ *                aggregator
+ *
+ * Stage 1a — codebase-scout
+ *   Pure-TypeScript: lists files (git ls-files), counts LOC (batched wc -l),
+ *   renders a depth-bounded ASCII tree, and bin-packs directories into N
+ *   partitions where N is determined by the LOC heuristic. Then makes one
+ *   short LLM call to produce an architectural orientation that primes the
+ *   downstream explorers. Returns structured data via `handle.result` and
+ *   the agent's prose via `ctx.transcript(handle)`.
+ *
+ * Stage 1b — research-history (parallel sibling of scout)
+ *   Dispatches the codebase-research-locator and codebase-research-analyzer
+ *   sub-agents over the project's existing research/ directory to surface
+ *   prior decisions, completed investigations, and unresolved questions.
+ *   Output is consumed via session transcript (≤400 words) and feeds into
+ *   the aggregator as supplementary context.
+ *
+ * Stage 2 — explorer-1..N (parallel; depends on scout + history)
+ *   Each explorer is a coordinator that dispatches specialized sub-agents
+ *   over its assigned partition (single LOC-balanced slice of the codebase):
+ *     - codebase-locator       → finds relevant files in the partition
+ *     - codebase-analyzer      → documents how the most relevant files work
+ *     - codebase-pattern-finder → finds existing pattern examples
+ *     - codebase-online-researcher → (conditional) external library docs
+ *   The explorer never reads files directly — it orchestrates specialists
+ *   and writes a synthesized findings document to a known scratch path.
+ *
+ * Stage 3 — aggregator
+ *   Reads each explorer's scratch file by path (file-based handoff to keep
+ *   the aggregator's own context lean — we deliberately do NOT inline N
+ *   transcripts into the prompt). Folds in the research-history overview
+ *   as supplementary context. Synthesizes a single research document at
+ *   research/docs/YYYY-MM-DD-<slug>.md.
+ *
+ * Context-engineering decisions are documented at each stage below.
+ */
+declare const _default: import("../../../index.ts").WorkflowDefinition<"claude", "prompt">;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/sdk/workflows/builtin/deep-research-codebase/claude/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/deep-research-codebase/claude/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;;AA4BH,wBAuNa"}

package/dist/sdk/workflows/builtin/deep-research-codebase/copilot/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * deep-research-codebase / copilot
+ *
+ * Copilot replica of the Claude deep-research-codebase workflow. The Claude
+ * version dispatches specialist sub-agents (codebase-locator, codebase-
+ * analyzer, etc.) inside a single explorer session via `@"name (agent)"`
+ * syntax — a Claude-specific feature. Copilot sessions are bound to a single
+ * agent for their entire lifetime, so we keep the SAME graph topology
+ * (scout ∥ history → explorer-1..N → aggregator) but drive each explorer
+ * through the locate → analyze → patterns → synthesize sequence inline using
+ * the default agent's built-in file tools.
+ *
+ * Topology (identical to Claude version):
+ *
+ *           ┌─→ codebase-scout
+ *   parent ─┤
+ *           └─→ research-history
+ *                     │
+ *                     ▼
+ *   ┌──────────────────────────────────────────────────┐
+ *   │  explorer-1   explorer-2   ...   explorer-N      │   (Promise.all)
+ *   └──────────────────────────────────────────────────┘
+ *                     │
+ *                     ▼
+ *                aggregator
+ *
+ * Copilot-specific concerns baked in:
+ *
+ *
+ *  • F5 — every `ctx.stage()` call is a FRESH session with no memory of prior
+ *    stages. We forward the scout overview, history overview, and partition
+ *    assignment explicitly into each explorer's first prompt. The aggregator
+ *    gets the same plus the explorer scratch file paths.
+ *
+ *  • F9 — `s.save()` receives `SessionEvent[]` via `s.session.getMessages()`
+ *    (Copilot's correct shape). Passing anything else breaks downstream
+ *    `transcript()` reads.
+ *
+ *  • F6 — every prompt explicitly requires trailing prose AFTER any tool
+ *    call, so `transcript()` is never empty. A Copilot turn whose final
+ *    message is a tool call produces an empty assistant.message terminator
+ *    (F1); trailing prose is our insurance.
+ */
+declare const _default: import("../../../index.ts").WorkflowDefinition<"copilot", "prompt">;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/sdk/workflows/builtin/deep-research-codebase/copilot/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/deep-research-codebase/copilot/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;;AAuBH,wBA+La"}

package/dist/sdk/workflows/builtin/deep-research-codebase/helpers/heuristic.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Determine how many parallel explorer sub-agents to spawn for the
+ * deep-research-codebase workflow, based on lines of code in the codebase.
+ *
+ * The heuristic balances coverage against coordination overhead:
+ *   - Too few explorers leave parts of the codebase under-investigated.
+ *   - Too many explorers flood the aggregator with redundant findings,
+ *     burn tokens on coordination, and exhaust tmux/process budgets.
+ *
+ * Tier choices were anchored to the rough sizes of common project shapes:
+ *
+ *   <    5,000 LOC →  2 explorers   scripts, single-purpose tools
+ *   <   25,000 LOC →  3 explorers   small libraries, CLI utilities
+ *   <  100,000 LOC →  5 explorers   medium applications
+ *   <  500,000 LOC →  7 explorers   large applications, small monorepos
+ *   <2,000,000 LOC →  9 explorers   large monorepos
+ *   ≥2,000,000 LOC → 12 explorers   massive monorepos (hard cap)
+ *
+ * The hard cap of 12 prevents runaway parallelism: each explorer is a
+ * Claude tmux pane plus an LLM session, so the cost grows linearly in
+ * tokens, processes, and walltime as well as in aggregator context.
+ */
+export declare function calculateExplorerCount(loc: number): number;
+/** Human-readable rationale for the heuristic decision — surfaced in logs/prompts. */
+export declare function explainHeuristic(loc: number, count: number): string;
+//# sourceMappingURL=heuristic.d.ts.map

package/dist/sdk/workflows/builtin/deep-research-codebase/helpers/heuristic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heuristic.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/deep-research-codebase/helpers/heuristic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQ1D;AAED,sFAAsF;AACtF,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAInE"}

package/dist/sdk/workflows/builtin/deep-research-codebase/helpers/prompts.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Prompt builders for the deep-research-codebase workflow.
+ *
+ * Context-engineering principles applied throughout:
+ *   - Position-aware placement: the research question is repeated at the
+ *     TOP and BOTTOM of every prompt (recall is 85-95% at the edges and
+ *     drops to 76-82% in the middle — see context-fundamentals).
+ *   - Informativity over exhaustiveness: each explorer prompt contains
+ *     only that explorer's partition, never the full file list.
+ *   - Explicit trailing commentary (F6): every prompt asks the agent to
+ *     produce a short text summary AFTER any tool/file output, so the
+ *     transcript is not empty when downstream stages read it.
+ *   - File-based handoff (filesystem-context skill): explorer findings
+ *     are written to disk and the aggregator reads them by path, instead
+ *     of inlining N transcripts into the aggregator's prompt.
+ *   - Documentarian role: every prompt explicitly forbids critique or
+ *     improvement suggestions; we are recording what exists.
+ */
+import type { PartitionUnit } from "./scout.ts";
+/** Slugify the user's prompt for use in the final research filename. */
+export declare function slugifyPrompt(prompt: string): string;
+export declare function buildScoutPrompt(opts: {
+    question: string;
+    tree: string;
+    totalLoc: number;
+    totalFiles: number;
+    explorerCount: number;
+    partitionPreview: PartitionUnit[][];
+}): string;
+export declare function buildExplorerPrompt(opts: {
+    question: string;
+    index: number;
+    total: number;
+    partition: PartitionUnit[];
+    scoutOverview: string;
+    scratchPath: string;
+    root: string;
+}): string;
+/**
+ * The research-history scout dispatches specialized sub-agents to surface
+ * historical context from the project's `research/` directory:
+ *   - codebase-research-locator → finds prior research docs about the topic
+ *   - codebase-research-analyzer → extracts key insights from the most
+ *     relevant docs
+ *
+ * Output is consumed via session transcript (not file write) — kept short
+ * (≤400 words) so the aggregator can embed it cheaply.
+ */
+export declare function buildHistoryPrompt(opts: {
+    question: string;
+    root: string;
+}): string;
+/**
+ * Generic explorer prompt (Copilot / OpenCode). Drives a single default-agent
+ * session through the locate → analyze → patterns → synthesize sequence using
+ * built-in tools directly, instead of Claude's sub-agent dispatch.
+ */
+export declare function buildExplorerPromptGeneric(opts: {
+    question: string;
+    index: number;
+    total: number;
+    partition: PartitionUnit[];
+    scoutOverview: string;
+    historyOverview: string;
+    scratchPath: string;
+    root: string;
+}): string;
+/**
+ * Generic research-history prompt (Copilot / OpenCode). A single default-agent
+ * session searches the project's research/ directory using its own file tools,
+ * instead of dispatching Claude's codebase-research-locator / analyzer
+ * sub-agents.
+ */
+export declare function buildHistoryPromptGeneric(opts: {
+    question: string;
+    root: string;
+}): string;
+export declare function buildAggregatorPrompt(opts: {
+    question: string;
+    totalLoc: number;
+    totalFiles: number;
+    explorerCount: number;
+    explorerFiles: {
+        index: number;
+        scratchPath: string;
+        partition: PartitionUnit[];
+    }[];
+    finalPath: string;
+    scoutOverview: string;
+    historyOverview: string;
+}): string;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/sdk/workflows/builtin/deep-research-codebase/helpers/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/deep-research-codebase/helpers/prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAOhD,wEAAwE;AACxE,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAUpD;AAMD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,aAAa,EAAE,EAAE,CAAC;CACrC,GAAG,MAAM,CA2DT;AAMD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,MAAM,CAwKT;AAMD;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,MAAM,CAkET;AAkBD;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,MAAM,CAgLT;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,MAAM,CAoET;AAMD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE;QACb,KAAK,EAAE,MAAM,CAAC;QACd,WAAW,EAAE,MAAM,CAAC;QACpB,SAAS,EAAE,aAAa,EAAE,CAAC;KAC5B,EAAE,CAAC;IACJ,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;CACzB,GAAG,MAAM,CA6IT"}

package/dist/sdk/workflows/builtin/deep-research-codebase/helpers/scout.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Codebase scout: deterministic helpers for the deep-research-codebase workflow.
+ *
+ * Responsibilities:
+ *   1. Discover the codebase root (git toplevel, falling back to cwd).
+ *   2. List all source files, respecting .gitignore when in a git repo.
+ *   3. Count lines of code per file using batched `wc -l`.
+ *   4. Render a compact directory tree (depth-bounded) for prompt context.
+ *   5. Build "partition units" by aggregating LOC at depth-1, then drilling
+ *      down on any unit that is too large to live in a single explorer.
+ *   6. Bin-pack partition units into N balanced groups (largest-first).
+ *
+ * Everything here is pure TypeScript + child_process — no LLM calls.
+ */
+/** Per-file LOC + path. */
+export type FileStats = {
+    path: string;
+    loc: number;
+};
+/**
+ * A "partition unit" is the atomic chunk of work that gets bin-packed into
+ * an explorer. It is always one directory (possibly drilled down to depth 2)
+ * with all of the code files that live anywhere underneath it.
+ */
+export type PartitionUnit = {
+    /** Repo-relative path, e.g. "src/cli" or "packages/foo/src". */
+    path: string;
+    loc: number;
+    fileCount: number;
+    /** Repo-relative file paths inside this unit (full recursive listing). */
+    files: string[];
+};
+export type CodebaseScout = {
+    /** Absolute path to the repository root. */
+    root: string;
+    totalLoc: number;
+    totalFiles: number;
+    /** Compact rendered directory tree (depth-bounded) for prompt context. */
+    tree: string;
+    /** Partition units, sorted by LOC descending. */
+    units: PartitionUnit[];
+};
+/** Resolve the project root. Prefers `git rev-parse --show-toplevel`. */
+export declare function getCodebaseRoot(): string;
+/**
+ * Run the full scout: list files, count LOC, render tree, build partition units.
+ */
+export declare function scoutCodebase(root: string): CodebaseScout;
+/**
+ * Bin-pack partition units into `count` balanced groups. Greedy
+ * largest-first: assign each unit to the currently-lightest bin.
+ *
+ * If there are fewer units than requested bins, the result has exactly
+ * `units.length` non-empty bins (we never return empty bins).
+ */
+export declare function partitionUnits(units: PartitionUnit[], count: number): PartitionUnit[][];
+//# sourceMappingURL=scout.d.ts.map

package/dist/sdk/workflows/builtin/deep-research-codebase/helpers/scout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scout.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/deep-research-codebase/helpers/scout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AA+BH,2BAA2B;AAC3B,MAAM,MAAM,SAAS,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtD;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,0EAA0E;IAC1E,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,KAAK,EAAE,aAAa,EAAE,CAAC;CACxB,CAAC;AAEF,yEAAyE;AACzE,wBAAgB,eAAe,IAAI,MAAM,CAUxC;AAmMD;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAiBzD;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,aAAa,EAAE,EACtB,KAAK,EAAE,MAAM,GACZ,aAAa,EAAE,EAAE,CAwBnB"}

package/dist/sdk/workflows/builtin/deep-research-codebase/opencode/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * deep-research-codebase / opencode
+ *
+ * OpenCode replica of the Claude deep-research-codebase workflow. The Claude
+ * version dispatches specialist sub-agents (codebase-locator, codebase-
+ * analyzer, etc.) inside a single explorer session via `@"name (agent)"`
+ * syntax — a Claude-specific feature. OpenCode sessions are bound to a
+ * single agent for their lifetime, so we keep the SAME graph topology
+ * (scout ∥ history → explorer-1..N → aggregator) but drive each explorer
+ * through the locate → analyze → patterns → synthesize sequence inline using
+ * the default agent's built-in file tools.
+ *
+ * Topology (identical to Claude version):
+ *
+ *           ┌─→ codebase-scout
+ *   parent ─┤
+ *           └─→ research-history
+ *                     │
+ *                     ▼
+ *   ┌──────────────────────────────────────────────────┐
+ *   │  explorer-1   explorer-2   ...   explorer-N      │   (Promise.all)
+ *   └──────────────────────────────────────────────────┘
+ *                     │
+ *                     ▼
+ *                aggregator
+ *
+ * OpenCode-specific concerns baked in:
+ *
+ *  • F5 — every `ctx.stage()` call is a FRESH session with no memory of
+ *    prior stages. We forward the scout overview, history overview, and
+ *    partition assignment explicitly into each explorer's first prompt.
+ *
+ *  • F9 — `s.save()` receives the `{ info, parts }` payload from
+ *    `s.client.session.prompt()` via `result.data!`. Passing the full
+ *    `result` (with its wrapping) or raw `result.data.parts` breaks
+ *    downstream `transcript()` reads.
+ *
+ *  • F6 — every prompt explicitly requires trailing prose AFTER any tool
+ *    call so the rendered transcript has content. OpenCode's `parts` array
+ *    mixes text/tool/reasoning/file parts; without trailing text the
+ *    transcript extractor returns an empty string.
+ *
+ *  • F3 — transcript extraction relies on the runtime's text-only rendering
+ *    of `result.data.parts`. The helpers call `ctx.transcript(handle)` which
+ *    returns `{ path, content }` where content is already text-filtered.
+ */
+declare const _default: import("../../../index.ts").WorkflowDefinition<"opencode", "prompt">;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/sdk/workflows/builtin/deep-research-codebase/opencode/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/deep-research-codebase/opencode/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;;AAuBH,wBA2Na"}

package/dist/sdk/workflows/builtin/ralph/claude/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Ralph workflow for Claude Code — plan → orchestrate → review → debug 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 parallel reviewer passes both return zero findings.
+ *
+ * The reviewer stages use the Claude Agent SDK's structured output
+ * (`outputFormat`) to guarantee the review result matches the
+ * {@link ReviewResultSchema} — no manual JSON parsing required.
+ *
+ * Run: atomic workflow -n ralph -a claude "<your spec>"
+ */
+declare const _default: import("../../../index.ts").WorkflowDefinition<"claude", "prompt">;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/sdk/workflows/builtin/ralph/claude/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/ralph/claude/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;;AAiEH,wBAwJa"}

package/dist/sdk/workflows/builtin/ralph/copilot/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Ralph workflow for Copilot — plan → orchestrate → review → debug 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 parallel reviewer passes both return zero findings.
+ *
+ * The reviewer stages use a `submit_review` custom tool (defined via
+ * `defineTool` with Zod schema validation) to guarantee the review result
+ * matches the {@link ReviewResultSchema}. The Copilot SDK validates tool
+ * call arguments against the Zod schema before the handler fires.
+ *
+ * Run: atomic workflow -n ralph -a copilot "<your spec>"
+ */
+declare const _default: import("../../../index.ts").WorkflowDefinition<"copilot", "prompt">;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/sdk/workflows/builtin/ralph/copilot/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/ralph/copilot/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;;AA6DH,wBA2La"}

package/dist/sdk/workflows/builtin/ralph/helpers/git.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Deterministic changeset probes used by the Ralph loop.
+ *
+ * The reviewer and debugger sub-agents both benefit from knowing exactly which
+ * files were touched by the current work. We compute a diff relative to the
+ * parent branch (auto-discovered, defaulting to main) so the changeset
+ * includes BOTH committed and uncommitted changes — not just the working tree.
+ *
+ * Git command failures are captured — not swallowed — so downstream agents
+ * can distinguish "nothing changed" from "git broke" and course-correct.
+ */
+/**
+ * Discover the parent (base) branch for the current HEAD.
+ *
+ * Strategy:
+ * 1. Find the merge-base between HEAD and each default-branch candidate.
+ *    The candidate whose merge-base is closest to HEAD (fewest commits away)
+ *    is the winner.
+ * 2. If no candidate exists locally, fall back to "main".
+ *
+ * This handles the common case of feature branches off main/master without
+ * requiring configuration.
+ */
+export declare function discoverBaseBranch(cwd?: string): Promise<string>;
+/** The result of capturing the full changeset for a review. */
+export interface BranchChangeset {
+    /** The base branch the diff is relative to (e.g. "main") */
+    baseBranch: string;
+    /**
+     * `git diff --stat` output showing files changed, insertions, deletions
+     * relative to the merge-base with the parent branch. Includes both
+     * committed AND uncommitted changes.
+     */
+    diffStat: string;
+    /**
+     * Short list of uncommitted working-tree changes (`git status -s`).
+     * Useful for the reviewer to distinguish "already committed" from
+     * "still in-flight".
+     */
+    uncommitted: string;
+    /**
+     * `git diff --name-status` output listing each changed file with its
+     * status (A=added, M=modified, D=deleted, R=renamed).
+     */
+    nameStatus: string;
+    /**
+     * Human-readable error messages for any git commands that failed during
+     * changeset capture. Empty when everything succeeded. Downstream prompts
+     * surface these so the reviewing agent can course-correct (e.g. run the
+     * git commands itself, or flag the gap as a finding).
+     */
+    errors: string[];
+}
+/**
+ * Capture the full changeset for the current branch relative to its parent.
+ *
+ * Combines:
+ * - `git diff <merge-base>..HEAD --stat` (committed changes)
+ * - `git diff --stat` (uncommitted staged+unstaged changes)
+ * - `git status -s` (working tree snapshot)
+ *
+ * Into a single {@link BranchChangeset} that gives the reviewer complete
+ * visibility into everything this branch has done.
+ *
+ * Git failures are collected in {@link BranchChangeset.errors} rather than
+ * swallowed, so downstream agents see exactly what broke and can compensate.
+ */
+export declare function captureBranchChangeset(cwd?: string): Promise<BranchChangeset>;
+//# sourceMappingURL=git.d.ts.map

package/dist/sdk/workflows/builtin/ralph/helpers/git.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/ralph/helpers/git.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AA0DH;;;;;;;;;;;GAWG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,GAAE,MAAsB,GAC1B,OAAO,CAAC,MAAM,CAAC,CA4BjB;AAID,+DAA+D;AAC/D,MAAM,WAAW,eAAe;IAC9B,4DAA4D;IAC5D,UAAU,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,GAAE,MAAsB,GAC1B,OAAO,CAAC,eAAe,CAAC,CAuC1B"}