@bastani/atomic 0.5.11 → 0.5.12-0

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

@@ -1,46 +0,0 @@
-/**
- * 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">;
-export default _default;
-//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,26 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,92 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,57 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,49 +0,0 @@
-/**
- * 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">;
-export default _default;
-//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,14 +0,0 @@
-/**
- * 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 consecutive reviewer passes return zero findings.
- *
- * Run: atomic workflow -n ralph -a claude "<your spec>"
- */
-declare const _default: import("../../../index.ts").WorkflowDefinition<"claude">;
-export default _default;
-//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,14 +0,0 @@
-/**
- * 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 consecutive reviewer passes return zero findings.
- *
- * Run: atomic workflow -n ralph -a copilot "<your spec>"
- */
-declare const _default: import("../../../index.ts").WorkflowDefinition<"copilot">;
-export default _default;
-//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,17 +0,0 @@
-/**
- * Deterministic working-tree probes used by the Ralph loop.
- *
- * The reviewer and debugger sub-agents both benefit from knowing exactly which
- * files were touched in the current iteration. Asking an LLM to figure that
- * out via tool calls is expensive and lossy, so we capture `git status -s`
- * directly from the workflow runner and inject it into prompts.
- *
- * Failures (no git binary, not a repo, command non-zero) collapse to "" so
- * the prompts can fall back to the "working tree clean" branch.
- */
-/**
- * Run `git status -s` from the given cwd. Returns trimmed stdout, or "" on
- * any error. Never throws.
- */
-export declare function safeGitStatusS(cwd?: string): Promise<string>;
-//# sourceMappingURL=git.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/ralph/helpers/git.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;GAGG;AACH,wBAAsB,cAAc,CAClC,GAAG,GAAE,MAAsB,GAC1B,OAAO,CAAC,MAAM,CAAC,CAejB"}

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

@@ -1,119 +0,0 @@
-/**
- * Ralph Prompt Utilities
- *
- * Prompts used by the Ralph plan → orchestrate → review → debug loop:
- *   - buildPlannerPrompt:        initial planning OR re-planning from a debugger report
- *   - buildOrchestratorPrompt:   spawn workers to execute the task list
- *   - buildReviewPrompt:         structured code review with injected git status
- *   - buildDebuggerReportPrompt: diagnose review findings, produce a re-plan brief
- *
- * Plus parsing helpers for the reviewer JSON output and the debugger markdown
- * report.
- *
- * Zero-dependency: no imports from the Atomic runtime.
- */
-export interface PlannerContext {
-    /** 1-indexed loop iteration. Iteration 1 = initial plan; >1 = re-plan. */
-    iteration: number;
-    /** Markdown report from the previous iteration's debugger sub-agent. */
-    debuggerReport?: string;
-}
-/**
- * Build the planner prompt. The first iteration decomposes the original spec;
- * subsequent iterations decompose the work needed to resolve the debugger
- * report from the previous loop iteration.
- */
-export declare function buildPlannerPrompt(spec: string, context?: PlannerContext): string;
-export interface OrchestratorContext {
-    /**
-     * Trailing commentary from the planner's last assistant message, if any.
-     * The Copilot and OpenCode workflows create a fresh session for each
-     * sub-agent, so the planner's in-session output is NOT automatically
-     * visible to the orchestrator — only what the planner persisted via
-     * `TaskCreate`. Forward the planner's final text here so the orchestrator
-     * sees any caveats, risks, or execution hints that didn't fit into task
-     * bodies.
-     */
-    plannerNotes?: string;
-}
-/**
- * Build the orchestrator prompt. The orchestrator retrieves the planner's
- * task list, validates the dependency graph, and spawns parallel workers.
- *
- * @param spec - The original user specification. Required because the
- *   orchestrator runs in a fresh session on Copilot/OpenCode and needs the
- *   end-user goal to resolve ambiguous tasks.
- * @param context - Optional planner handoff context (trailing commentary).
- */
-export declare function buildOrchestratorPrompt(spec: string, context?: OrchestratorContext): string;
-/** A single finding from the reviewer sub-agent. */
-export interface ReviewFinding {
-    title: string;
-    body: string;
-    confidence_score?: number;
-    priority?: number;
-    code_location?: {
-        absolute_file_path: string;
-        line_range: {
-            start: number;
-            end: number;
-        };
-    };
-}
-/** Parsed reviewer JSON output. */
-export interface ReviewResult {
-    findings: ReviewFinding[];
-    overall_correctness: string;
-    overall_explanation: string;
-    overall_confidence_score?: number;
-}
-export interface ReviewContext {
-    /** Output of `git status -s` captured immediately before the review. */
-    gitStatus: string;
-    /** 1-indexed loop iteration, used in the prompt header. */
-    iteration?: number;
-    /**
-     * Whether this is the second consecutive review pass within the same loop
-     * iteration (i.e. the previous pass had zero findings and we are
-     * confirming before counting two clean reviews in a row).
-     */
-    isConfirmationPass?: boolean;
-}
-/**
- * Build the reviewer prompt. Injects deterministic `git status -s` so the
- * reviewer doesn't have to re-discover what changed.
- */
-export declare function buildReviewPrompt(spec: string, context: ReviewContext): string;
-export interface DebuggerContext {
-    /** 1-indexed loop iteration the debugger is investigating. */
-    iteration: number;
-    /** Output of `git status -s` from immediately before the review. */
-    gitStatus: string;
-}
-/**
- * Build a prompt asking the debugger sub-agent to investigate a set of review
- * findings and produce a structured report. The debugger MUST NOT apply
- * fixes — its only deliverable is the report, which the next iteration's
- * planner consumes.
- */
-export declare function buildDebuggerReportPrompt(review: ReviewResult | null, rawReview: string, context: DebuggerContext): string;
-/**
- * Parse the reviewer's JSON output. Tries, in order:
- *   1. Direct JSON.parse on the entire content.
- *   2. The LAST fenced ```json (or unlabelled) code block.
- *   3. The LAST balanced object containing a "findings" key in surrounding prose.
- *
- * Filters out P3 (minor/style) findings — only P0/P1/P2 count as actionable.
- * Returns null when no parse strategy succeeds.
- */
-export declare function parseReviewResult(content: string): ReviewResult | null;
-/**
- * Extract the LAST fenced ```markdown block from a piece of text. Used for
- * parsing the debugger's structured report out of a long Claude pane
- * scrollback or any other output that may include extra prose.
- *
- * Falls back to the trimmed full input when no fenced block is present, so
- * the planner still receives the debugger's content even if formatting drifts.
- */
-export declare function extractMarkdownBlock(content: string): string;
-//# sourceMappingURL=prompts.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/ralph/helpers/prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH,MAAM,WAAW,cAAc;IAC7B,0EAA0E;IAC1E,SAAS,EAAE,MAAM,CAAC;IAClB,wEAAwE;IACxE,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,cAAiC,GACzC,MAAM,CAwER;AAMD,MAAM,WAAW,mBAAmB;IAClC;;;;;;;;OAQG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,mBAAwB,GAChC,MAAM,CAsGR;AAMD,oDAAoD;AACpD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE;QACd,kBAAkB,EAAE,MAAM,CAAC;QAC3B,UAAU,EAAE;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,GAAG,EAAE,MAAM,CAAA;SAAE,CAAC;KAC5C,CAAC;CACH;AAED,mCAAmC;AACnC,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,wBAAwB,CAAC,EAAE,MAAM,CAAC;CACnC;AAED,MAAM,WAAW,aAAa;IAC5B,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAC;IAClB,2DAA2D;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,aAAa,GACrB,MAAM,CAqFR;AAMD,MAAM,WAAW,eAAe;IAC9B,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,YAAY,GAAG,IAAI,EAC3B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,eAAe,GACvB,MAAM,CAwFR;AAMD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAgDtE;AAmBD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAS5D"}

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

@@ -1,20 +0,0 @@
-/**
- * Review analysis helpers for the Ralph workflow.
- *
- * Simplified versions of the internal conductor-based helpers,
- * operating on direct values instead of StageOutput maps.
- */
-import type { ReviewResult } from "./prompts.ts";
-/**
- * Check whether the reviewer produced actionable findings.
- *
- * Returns true when:
- * 1. The parsed ReviewResult has one or more findings, OR
- * 2. The review could not be parsed (null) but the raw response
- *    text is non-empty (treat unparseable output as actionable).
- *
- * @param review  - Parsed ReviewResult, or null if parsing failed.
- * @param rawText - The raw reviewer response text.
- */
-export declare function hasActionableFindings(review: ReviewResult | null, rawText: string): boolean;
-//# sourceMappingURL=review.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"review.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/ralph/helpers/review.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,YAAY,GAAG,IAAI,EAC3B,OAAO,EAAE,MAAM,GACd,OAAO,CAQT"}

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

@@ -1,14 +0,0 @@
-/**
- * Ralph workflow for OpenCode — 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 consecutive reviewer passes return zero findings.
- *
- * Run: atomic workflow -n ralph -a opencode "<your spec>"
- */
-declare const _default: import("../../../index.ts").WorkflowDefinition<"opencode">;
-export default _default;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/ralph/opencode/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;;AA4BH,wBAyKa"}

package/dist/sdk/workflows/index.d.ts

@@ -1,24 +0,0 @@
-/**
- * atomic/workflows
- *
- * Workflow SDK for defining dynamic agent workflows.
- * Workflows use defineWorkflow().run().compile() with ctx.stage()
- * for spawning agent sessions using native TypeScript control flow.
- */
-export { defineWorkflow, WorkflowBuilder } from "../define-workflow.ts";
-export type { AgentType, ValidationWarning, Transcript, SavedMessage, SaveTranscript, SessionContext, SessionRef, SessionHandle, SessionRunOptions, WorkflowContext, WorkflowOptions, WorkflowDefinition, WorkflowInput, WorkflowInputType, StageClientOptions, StageSessionOptions, ProviderClient, ProviderSession, CopilotClient, CopilotClientOptions, CopilotSession, CopilotSessionConfig, OpencodeClient, OpencodeSession, ClaudeClientWrapper, ClaudeSessionWrapper, ClaudeQueryDefaults, } from "../types.ts";
-export type { SessionEvent as CopilotSessionEvent } from "@github/copilot-sdk";
-export type { SessionPromptResponse as OpenCodePromptResponse } from "@opencode-ai/sdk/v2";
-export type { SessionMessage as ClaudeSessionMessage } from "@anthropic-ai/claude-agent-sdk";
-export { createClaudeSession, claudeQuery, clearClaudeSession, validateClaudeWorkflow } from "../providers/claude.ts";
-export type { ClaudeSessionOptions, ClaudeQueryOptions, ClaudeQueryResult } from "../providers/claude.ts";
-export { validateCopilotWorkflow } from "../providers/copilot.ts";
-export { validateOpenCodeWorkflow } from "../providers/opencode.ts";
-export type { TmuxResult, TmuxSession, SessionType } from "../runtime/tmux.ts";
-export { SOCKET_NAME, isTmuxInstalled, getMuxBinary, resetMuxBinaryCache, isInsideTmux, isInsideAtomicSocket, createSession, createWindow, createPane, sendLiteralText, sendSpecialKey, sendKeysAndSubmit, capturePane, capturePaneVisible, capturePaneScrollback, killSession, killWindow, sessionExists, listSessions, attachSession, spawnMuxAttach, switchClient, getCurrentSession, attachOrSwitch, detachAndAttachAtomic, selectWindow, setSessionEnv, getSessionEnv, parseSessionName, waitForOutput, tmuxRun, normalizeTmuxCapture, normalizeTmuxLines, paneLooksReady, paneHasActiveTask, paneIsIdle, waitForPaneReady, attemptSubmitRounds, } from "../runtime/tmux.ts";
-export { AGENTS, discoverWorkflows, findWorkflow, loadWorkflowsMetadata, WORKFLOWS_GITIGNORE, } from "../runtime/discovery.ts";
-export type { DiscoveredWorkflow, WorkflowWithMetadata, } from "../runtime/discovery.ts";
-export { WorkflowLoader } from "../runtime/loader.ts";
-export { executeWorkflow } from "../runtime/executor.ts";
-export type { WorkflowRunOptions } from "../runtime/executor.ts";
-//# sourceMappingURL=index.d.ts.map

package/dist/sdk/workflows/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sdk/workflows/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExE,YAAY,EACV,SAAS,EACT,iBAAiB,EACjB,UAAU,EACV,YAAY,EACZ,cAAc,EACd,cAAc,EACd,UAAU,EACV,aAAa,EACb,iBAAiB,EACjB,eAAe,EACf,eAAe,EACf,kBAAkB,EAClB,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,cAAc,EACd,eAAe,EACf,aAAa,EACb,oBAAoB,EACpB,cAAc,EACd,oBAAoB,EACpB,cAAc,EACd,eAAe,EACf,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,aAAa,CAAC;AAGrB,YAAY,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC/E,YAAY,EAAE,qBAAqB,IAAI,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAC3F,YAAY,EAAE,cAAc,IAAI,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAG7F,OAAO,EAAE,mBAAmB,EAAE,WAAW,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AACtH,YAAY,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE1G,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAElE,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AAGpE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAC/E,OAAO,EACL,WAAW,EACX,eAAe,EACf,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,oBAAoB,EACpB,aAAa,EACb,YAAY,EACZ,UAAU,EACV,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,WAAW,EACX,kBAAkB,EAClB,qBAAqB,EACrB,WAAW,EACX,UAAU,EACV,aAAa,EACb,YAAY,EACZ,aAAa,EACb,cAAc,EACd,YAAY,EACZ,iBAAiB,EACjB,cAAc,EACd,qBAAqB,EACrB,YAAY,EACZ,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,OAAO,EACP,oBAAoB,EACpB,kBAAkB,EAClB,cAAc,EACd,iBAAiB,EACjB,UAAU,EACV,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,MAAM,EACN,iBAAiB,EACjB,YAAY,EACZ,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACV,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAGtD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,YAAY,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/services/config/definitions.d.ts

@@ -1,85 +0,0 @@
-/**
- * Agent configuration definitions for atomic CLI
- */
-export interface AgentConfig {
-    /** Display name for the agent */
-    name: string;
-    /** Command to execute the agent */
-    cmd: string;
-    /** Flags used when spawning the agent in interactive chat mode */
-    chat_flags: string[];
-    /** Environment variables to set when spawning the agent (merged with process env) */
-    env_vars: Record<string, string>;
-    /** Config folder relative to repo root */
-    folder: string;
-    /** URL for installation instructions */
-    install_url: string;
-    /** Paths to exclude when copying (relative to folder) */
-    exclude: string[];
-    /** Project files managed by `atomic init` for provider onboarding */
-    onboarding_files: Array<{
-        source: string;
-        destination: string;
-        merge: boolean;
-    }>;
-}
-declare const AGENT_KEYS: readonly ["claude", "opencode", "copilot"];
-export type AgentKey = (typeof AGENT_KEYS)[number];
-export declare const AGENT_CONFIG: Record<AgentKey, AgentConfig>;
-export declare function isValidAgent(key: string): key is AgentKey;
-export declare function getAgentConfig(key: AgentKey): AgentConfig;
-export declare function getAgentKeys(): AgentKey[];
-/**
- * Source Control Management (SCM) configuration definitions
- */
-/** SCM keys for iteration */
-declare const SCM_KEYS: readonly ["github", "sapling"];
-/** Supported source control types — derived from SCM_KEYS tuple. */
-export type SourceControlType = (typeof SCM_KEYS)[number];
-export interface ScmConfig {
-    /** Internal identifier */
-    name: string;
-    /** Display name for prompts */
-    displayName: string;
-    /** Primary CLI tool (git or sl) */
-    cliTool: string;
-    /** Code review tool (gh, jf submit, arc diff, etc.) */
-    reviewTool: string;
-    /** Code review system (github, phabricator) */
-    reviewSystem: string;
-    /** Directory marker for potential future auto-detection */
-    detectDir: string;
-    /** Code review command file name */
-    reviewCommandFile: string;
-    /** Required configuration files */
-    requiredConfigFiles?: string[];
-}
-export declare const SCM_CONFIG: Record<SourceControlType, ScmConfig>;
-/** Commands that have SCM-specific variants */
-export declare const SCM_SPECIFIC_COMMANDS: string[];
-/**
- * SCM-variant skill names, grouped by source control type.
- *
- * These are the skills that `installGlobalSkills` removes from the global
- * scope after the initial install, and that `installLocalScmSkills`
- * re-installs per-project based on the user's selected SCM. Passed to
- * `npx skills add --skill <name>` as explicit names (the skills CLI does
- * not support glob patterns like `gh-*`).
- */
-export declare const SCM_SKILLS_BY_TYPE: Record<SourceControlType, readonly string[]>;
-/** Flat list of every SCM-variant skill across all source control types. */
-export declare const ALL_SCM_SKILLS: readonly string[];
-/**
- * Get all SCM keys for iteration
- */
-export declare function getScmKeys(): SourceControlType[];
-/**
- * Check if a string is a valid SCM type
- */
-export declare function isValidScm(key: string): key is SourceControlType;
-/**
- * Get the configuration for a specific SCM type
- */
-export declare function getScmConfig(key: SourceControlType): ScmConfig;
-export {};
-//# sourceMappingURL=definitions.d.ts.map