@bastani/atomic 0.5.17 → 0.5.18-0

package/README.md

@@ -220,6 +220,12 @@ atomic session connect <session-name>
 
 # Interactive session picker (fuzzy-search)
 atomic session connect
+
+# Kill a session by name (prompts for confirmation)
+atomic session kill <session-name>
+
+# Kill all sessions in scope (prompts for confirmation)
+atomic session kill
 ```
 
 Session names follow a predictable pattern:
@@ -979,6 +985,7 @@ During `atomic chat`, there is no Atomic-owned TUI — `atomic chat -a <agent>`
 | `atomic workflow list`          | List available workflows, grouped by source                           |
 | `atomic session list`           | List all running sessions on the atomic tmux socket                   |
 | `atomic session connect [name]` | Attach to a session (interactive picker when no name given)           |
+| `atomic session kill [name]`    | Kill a session by name, or all sessions when no name is given         |
 | `atomic completions <shell>`    | Output shell completion script (bash, zsh, fish, powershell)          |
 | `atomic config set <k> <v>`     | Set configuration values (currently supports `telemetry`)             |
 
@@ -1000,12 +1007,15 @@ The `session` command is available at three levels — scoped or global:
 | ---------------------------------------- | ----------------------------------------------------- |
 | `atomic session list`                    | List all running sessions                             |
 | `atomic session connect [name]`          | Attach to a session (interactive picker when no name) |
+| `atomic session kill [name]`             | Kill a session, or all sessions when no name is given |
 | `atomic chat session list`               | List running chat sessions only                       |
 | `atomic chat session connect [name]`     | Attach to a chat session                              |
+| `atomic chat session kill [name]`        | Kill a chat session, or all chat sessions             |
 | `atomic workflow session list`           | List running workflow sessions only                   |
 | `atomic workflow session connect [name]` | Attach to a workflow session                          |
+| `atomic workflow session kill [name]`    | Kill a workflow session, or all workflow sessions     |
 
-Both `list` and `connect` accept `-a <agent>` (repeatable) to filter by agent backend.
+`list`, `connect`, and `kill` all accept `-a <agent>` (repeatable) to filter by agent backend. `kill` prompts for confirmation before terminating sessions.
 
 ```bash
 atomic session list                      # All sessions
@@ -1013,6 +1023,9 @@ atomic session list -a claude            # Only Claude sessions
 atomic session connect my-session        # Attach by name
 atomic session connect                   # Interactive picker
 atomic chat session list -a copilot      # Chat sessions for Copilot only
+atomic session kill my-session           # Kill one session by name
+atomic session kill                      # Kill all sessions (with confirmation)
+atomic workflow session kill -a claude   # Kill all Claude workflow sessions
 ```
 
 #### `atomic chat` Flags

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

@@ -1,64 +1,60 @@
 /**
  * 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.
+ * A deterministically-orchestrated, distributed codebase researcher built on
+ * the Claude Agent SDK's native sub-agent dispatch. Specialist sub-agents
+ * (codebase-locator / codebase-pattern-finder / codebase-analyzer /
+ * codebase-online-researcher / codebase-research-locator /
+ * codebase-research-analyzer) are spawned as separate headless `ctx.stage()`
+ * calls — each binds the SDK's `agent` option to the desired specialist
+ * instead of relying on a coordinator agent that dispatches them via the
+ * `@"name (agent)"` prompt syntax.
+ *
+ * Why SDK primitives instead of in-prompt orchestration:
+ *
+ *   • Each specialist runs in an ISOLATED conversation. The locator's giant
+ *     file index doesn't pollute the analyzer's context window, and the
+ *     online-researcher doesn't see the analyzer's reasoning at all. This is
+ *     `multi-agent-patterns` swarm-style isolation, not orchestrator-style.
+ *
+ *   • There is no orchestrator turn whose context grows linearly with the
+ *     number of specialists. Token cost per partition is bounded by the four
+ *     specialists' independent prompts — adding more partitions scales
+ *     cleanly because every fan-out is a fresh session.
+ *
+ *   • Failure of one specialist does not abort the partition mid-thought —
+ *     the runtime fails the stage, but its siblings' outputs are still on
+ *     disk and the aggregator can continue with whatever completed.
+ *
+ *   • The synthesis step that combines specialist outputs is plain TypeScript
+ *     (`renderExplorerMarkdown` in helpers/scratch.ts) — no extra LLM call
+ *     just to concatenate four markdown sections.
  *
  * Topology:
  *
- *           ┌─→ codebase-scout
+ *           ┌─→ codebase-scout (visible)
  *   parent ─┤
- *           └─→ research-history
- *                     │
- *                     ▼
- *   ┌──────────────────────────────────────────────────┐
- *   │  explorer-1   explorer-2   ...   explorer-N      │   (Promise.all, headless)
- *   └──────────────────────────────────────────────────┘
- *                     │
- *                     ▼
- *                aggregator
- *
- * Explorers run headless (in-process, no tmux window) — they are transparent
- * to the graph, so the visible topology is: [scout, history] → 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.
+ *           └─→ history-locator → history-analyzer (headless)
+ *                                       │
+ *                                       ▼
+ *   ┌──────────────────────────────────────────────────────────────────────┐
+ *   │  Per-partition (Promise.all over partitions, all stages headless):    │
+ *   │                                                                       │
+ *   │     locator-i      ∥   pattern-finder-i        (Layer 1, parallel)    │
+ *   │            │                                                          │
+ *   │            ▼                                                          │
+ *   │     analyzer-i     ∥   online-researcher-i     (Layer 2, parallel)    │
+ *   │            │                                                          │
+ *   │            ▼                                                          │
+ *   │     deterministic write to scratch file (TS helper, no LLM)           │
+ *   └──────────────────────────────────────────────────────────────────────┘
+ *                                       │
+ *                                       ▼
+ *                                  aggregator (visible)
+ *
+ * Specialist stages run headless (in-process via the Agent SDK's `query()`),
+ * so they are transparent to the workflow graph. The visible nodes are just:
+ *   parent → [codebase-scout] → aggregator
  */
 declare const _default: import("../../../index.ts").WorkflowDefinition<"claude", "prompt">;
 export default _default;

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

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

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

@@ -1,48 +1,29 @@
 /**
  * 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.
+ * Copilot replica of the Claude deep-research-codebase workflow. Specialist
+ * sub-agents are dispatched as separate headless `ctx.stage()` calls — each
+ * binds the SDK's session to a single named agent via `sessionOpts: { agent }`,
+ * which is the SDK-native way to spawn a sub-agent on Copilot.
  *
- * Topology (identical to Claude version):
+ * Copilot-specific concerns baked in (see references/failure-modes.md):
  *
- *           ┌─→ codebase-scout
- *   parent ─┤
- *           └─→ research-history
- *                     │
- *                     ▼
- *   ┌──────────────────────────────────────────────────┐
- *   │  explorer-1   explorer-2   ...   explorer-N      │   (Promise.all, headless)
- *   └──────────────────────────────────────────────────┘
- *                     │
- *                     ▼
- *                aggregator
+ *   • F5 — every `ctx.stage()` is a FRESH session. Each specialist receives
+ *     everything it needs (research question, scope, scout overview, and —
+ *     for layer-2 specialists — verbatim locator output) in its first prompt.
  *
- * Explorers run headless (in-process, no tmux window) — they are transparent
- * to the graph, so the visible topology is: [scout, history] → aggregator.
+ *   • F1 — Copilot's last assistant turn is often empty when the agent ends
+ *     on a tool call. We use `getAssistantText()` (canonical concatenation
+ *     of every top-level non-empty assistant turn, ignoring sub-agent
+ *     `parentToolCallId` traffic) instead of `.at(-1).data.content`.
  *
- * Copilot-specific concerns baked in:
+ *   • F6 — every prompt explicitly requires trailing prose AFTER any tool
+ *     call so `getAssistantText()` and downstream `transcript()` reads are
+ *     never empty.
  *
+ *   • F9 — `s.save()` receives `SessionEvent[]` from `s.session.getMessages()`.
  *
- *  • 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.
+ * See claude/index.ts for the full design rationale and topology diagram.
  */
 declare const _default: import("../../../index.ts").WorkflowDefinition<"copilot", "prompt">;
 export default _default;

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

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

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

@@ -2,7 +2,7 @@
  * Determine how many parallel explorer sub-agents to spawn for the
  * deep-research-codebase workflow, based on lines of code in the codebase.
  *
- * Scales linearly: one explorer per `LOC_PER_EXPLORER` (2.5K) lines of code,
+ * Scales linearly: one explorer per `LOC_PER_EXPLORER` (5K) lines of code,
  * with a floor of 2 for tiny or empty codebases. The actual number of
  * spawned explorers is still bounded by the number of partition units
  * the scout finds (see `partitionUnits` in ./scout.ts), so we never get

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

@@ -1,20 +1,40 @@
 /**
  * Prompt builders for the deep-research-codebase workflow.
  *
+ * Each builder produces a focused, single-responsibility prompt for one
+ * specialist sub-agent. The sub-agents themselves are dispatched as separate
+ * `ctx.stage(...)` calls via the provider SDK's native `agent` parameter
+ * (Claude SDK options, Copilot sessionOpts, OpenCode session.prompt). Because
+ * each sub-agent already carries a detailed system prompt in `.claude/agents/`,
+ * `.opencode/agents/`, and `.github/agents/`, these user-prompts are intentionally
+ * short — they only supply the topic, the scope, and the output shape the
+ * downstream synthesizer expects.
+ *
  * 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.
+ *
+ *   • Position-aware framing: the research question is repeated at the TOP
+ *     and BOTTOM of every prompt. Long-context recall is strongest at the
+ *     edges of the context window (see `context-fundamentals`).
+ *
+ *   • Informativity over exhaustiveness: each per-partition prompt embeds
+ *     ONLY that partition's directories — never the full file list. This
+ *     keeps token cost roughly constant in N rather than O(N²).
+ *
+ *   • Forward-only data flow: the analyzer prompt embeds the locator's
+ *     output verbatim; the online-researcher prompt does the same. No
+ *     sub-agent has to re-discover what its sibling already produced.
+ *
+ *   • Trailing-prose guarantee (failure-modes F6): every prompt asks for a
+ *     short prose recap as the final assistant turn so downstream stages
+ *     reading via `transcript()` never get an empty string when the agent
+ *     ends on a tool call.
+ *
+ *   • Documentarian framing: every prompt explicitly forbids critique or
+ *     improvement suggestions. We are recording what EXISTS.
+ *
+ *   • File-based handoff (filesystem-context skill): explorer findings are
+ *     written deterministically to a scratch file by TypeScript (no extra
+ *     LLM "synthesizer" stage) and the aggregator reads them by path.
  */
 import type { PartitionUnit } from "./scout.ts";
 /** Slugify the user's prompt for use in the final research filename. */
@@ -27,52 +47,52 @@ export declare function buildScoutPrompt(opts: {
     explorerCount: number;
     partitionPreview: PartitionUnit[][];
 }): string;
-export declare function buildExplorerPrompt(opts: {
+/** codebase-locator — find files in the partition relevant to the question. */
+export declare function buildLocatorPrompt(opts: {
     question: string;
+    partition: PartitionUnit[];
+    root: string;
+    scoutOverview: string;
     index: number;
     total: number;
+}): string;
+/** codebase-pattern-finder — surface concrete reusable code patterns. */
+export declare function buildPatternFinderPrompt(opts: {
+    question: string;
     partition: PartitionUnit[];
-    scoutOverview: string;
-    scratchPath: string;
     root: string;
+    scoutOverview: string;
+    index: number;
+    total: number;
 }): 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: {
+/** codebase-analyzer — document HOW the most relevant impl files work. */
+export declare function buildAnalyzerPrompt(opts: {
     question: string;
+    partition: PartitionUnit[];
+    locatorOutput: string;
     root: string;
+    scoutOverview: string;
+    index: number;
+    total: number;
 }): 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: {
+/** codebase-online-researcher — focused external doc fetch when libs are central. */
+export declare function buildOnlineResearcherPrompt(opts: {
     question: string;
+    partition: PartitionUnit[];
+    locatorOutput: string;
+    root: string;
     index: number;
     total: number;
-    partition: PartitionUnit[];
-    scoutOverview: string;
-    historyOverview: string;
-    scratchPath: string;
+}): string;
+/** codebase-research-locator — find prior research docs about the topic. */
+export declare function buildHistoryLocatorPrompt(opts: {
+    question: 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: {
+/** codebase-research-analyzer — synthesize insights from located research docs. */
+export declare function buildHistoryAnalyzerPrompt(opts: {
     question: string;
+    locatorOutput: string;
     root: string;
 }): string;
 export declare function buildAggregatorPrompt(opts: {

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

@@ -1 +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"}
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/deep-research-codebase/helpers/prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAYhD,wEAAwE;AACxE,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAUpD;AA6BD,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,CAyDT;AAeD,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,MAAM,CAuET;AAED,yEAAyE;AACzE,wBAAgB,wBAAwB,CAAC,IAAI,EAAE;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,MAAM,CAwDT;AAED,0EAA0E;AAC1E,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,MAAM,CA0FT;AAED,qFAAqF;AACrF,wBAAgB,2BAA2B,CAAC,IAAI,EAAE;IAChD,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,MAAM,CA2ET;AAMD,4EAA4E;AAC5E,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,MAAM,CAsDT;AAED,mFAAmF;AACnF,wBAAgB,0BAA0B,CAAC,IAAI,EAAE;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,MAAM,CAuDT;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,CAwIT"}

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

@@ -0,0 +1,43 @@
+/**
+ * Deterministic synthesis of per-partition explorer scratch files.
+ *
+ * Each partition is investigated by four specialist sub-agents dispatched
+ * directly via the provider SDK's `agent` parameter:
+ *
+ *   - codebase-locator           → file index for the partition
+ *   - codebase-pattern-finder    → reusable code patterns in the partition
+ *   - codebase-analyzer          → how the most relevant impl files work
+ *   - codebase-online-researcher → external library docs (when central)
+ *
+ * Rather than spawn a fifth "synthesizer" LLM stage just to concatenate four
+ * markdown sections, we do that synthesis in plain TypeScript here. This keeps
+ * the per-partition cost at exactly four LLM calls and avoids burning tokens
+ * on a step whose output is fully determined by its inputs.
+ *
+ * The file we write is the canonical handoff to the aggregator — it MUST keep
+ * the heading shape that buildAggregatorPrompt() promises ("Scope / Files in
+ * Scope / How It Works / Patterns / External References / Out-of-Partition
+ * References"), or the aggregator will look for sections that don't exist.
+ */
+import type { PartitionUnit } from "./scout.ts";
+export type ExplorerSections = {
+    index: number;
+    total: number;
+    partition: PartitionUnit[];
+    /** Full assistant text from the codebase-locator sub-agent. */
+    locatorOutput: string;
+    /** Full assistant text from the codebase-pattern-finder sub-agent. */
+    patternsOutput: string;
+    /** Full assistant text from the codebase-analyzer sub-agent. */
+    analyzerOutput: string;
+    /** Full assistant text from the codebase-online-researcher sub-agent. */
+    onlineOutput: string;
+};
+/** Render the markdown body deterministically. */
+export declare function renderExplorerMarkdown(sections: ExplorerSections): string;
+/**
+ * Write a partition's deterministic scratch file. Returns the absolute path so
+ * the caller can record it in the explorer manifest the aggregator reads.
+ */
+export declare function writeExplorerScratchFile(scratchPath: string, sections: ExplorerSections): Promise<string>;
+//# sourceMappingURL=scratch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scratch.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/workflows/builtin/deep-research-codebase/helpers/scratch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,+DAA+D;IAC/D,aAAa,EAAE,MAAM,CAAC;IACtB,sEAAsE;IACtE,cAAc,EAAE,MAAM,CAAC;IACvB,gEAAgE;IAChE,cAAc,EAAE,MAAM,CAAC;IACvB,yEAAyE;IACzE,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAOF,kDAAkD;AAClD,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,CAsDzE;AAED;;;GAGG;AACH,wBAAsB,wBAAwB,CAC5C,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,MAAM,CAAC,CAKjB"}

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

@@ -1,51 +1,29 @@
 /**
  * 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.
+ * OpenCode replica of the Claude deep-research-codebase workflow. Specialist
+ * sub-agents are dispatched as separate headless `ctx.stage()` calls — each
+ * call passes `agent: "<name>"` to `s.client.session.prompt()` directly,
+ * which is OpenCode's SDK-native way to route a turn to a sub-agent.
  *
- * Topology (identical to Claude version):
+ * OpenCode-specific concerns baked in (see references/failure-modes.md):
  *
- *           ┌─→ codebase-scout
- *   parent ─┤
- *           └─→ research-history
- *                     │
- *                     ▼
- *   ┌──────────────────────────────────────────────────┐
- *   │  explorer-1   explorer-2   ...   explorer-N      │   (Promise.all, headless)
- *   └──────────────────────────────────────────────────┘
- *                     │
- *                     ▼
- *                aggregator
+ *   • F5 — every `ctx.stage()` is a FRESH session. Each specialist receives
+ *     everything it needs (research question, scope, scout overview, and —
+ *     for layer-2 specialists — verbatim locator output) in its first prompt.
  *
- * Explorers run headless (in-process, no tmux window) — they are transparent
- * to the graph, so the visible topology is: [scout, history] → aggregator.
+ *   • F3 — `result.data!.parts` is a heterogenous array (text/tool/reasoning/
+ *     file parts). Use `extractResponseText()` to filter to text parts only;
+ *     concatenating raw `parts` produces `[object Object]` strings.
  *
- * OpenCode-specific concerns baked in:
+ *   • F6 — every prompt explicitly requires trailing prose so transcripts and
+ *     `extractResponseText()` reads are never empty.
  *
- *  • 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 unwrapped `{ info, parts }` payload from
+ *     `result.data!`; passing the full `result` or raw `result.data!.parts`
+ *     breaks downstream `transcript()` reads.
  *
- *  • 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.
+ * See claude/index.ts for the full design rationale and topology diagram.
  */
 declare const _default: import("../../../index.ts").WorkflowDefinition<"opencode", "prompt">;
 export default _default;

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/atomic",
-  "version": "0.5.17",
+  "version": "0.5.18-0",
   "description": "Configuration management CLI and SDK for coding agents",
   "type": "module",
   "license": "MIT",

package/src/cli.ts

@@ -13,6 +13,7 @@
  *   atomic workflow session connect <id>      Attach to a session
  *   atomic session list                       List all running sessions
  *   atomic session connect [id]               Interactive session picker
+ *   atomic session kill [id]                  Kill a session (or all when no id)
  *   atomic config set <key> <value>           Set configuration value
  *   atomic --version                          Show version
  *   atomic --help                             Show help
@@ -77,6 +78,22 @@ function addSessionSubcommand(parent: Command, scope: "chat" | "workflow" | "all
             }
         });
 
+    sessionCmd
+        .command("kill")
+        .description("Kill a running session (omit id to kill all)")
+        .argument("[session_id]", "Session name to kill (omit to kill all)")
+        .option(
+            "-a, --agent <name>",
+            `Filter by agent backend (${Object.keys(AGENT_CONFIG).join(", ")}); repeatable`,
+            collectAgent,
+            [] as string[],
+        )
+        .action(async (sessionId, localOpts) => {
+            const { sessionKillCommand } = await import("./commands/cli/session.ts");
+            const exitCode = await sessionKillCommand(sessionId, localOpts.agent, scope);
+            process.exit(exitCode);
+        });
+
     return sessionCmd;
 }
 
@@ -131,7 +148,8 @@ Examples:
   $ atomic chat -a opencode                         Start OpenCode interactively
   $ atomic chat -a claude "fix the bug"             Claude with initial prompt
   $ atomic chat session list                        List running sessions
-  $ atomic chat session connect <id>                Attach to a session`,
+  $ atomic chat session connect <id>                Attach to a session
+  $ atomic chat session kill [id]                   Kill a chat session (or all)`,
         )
         .action(async (localOpts, cmd) => {
             const validAgents = Object.keys(AGENT_CONFIG);
@@ -201,7 +219,8 @@ Examples:
   $ atomic workflow -n gen-spec -a claude --research_doc=notes.md --focus=standard
                                                     Run a structured-input workflow
   $ atomic workflow session list                    List running sessions
-  $ atomic workflow session connect <id>            Attach to a session`,
+  $ atomic workflow session connect <id>            Attach to a session
+  $ atomic workflow session kill [id]               Kill a workflow session (or all)`,
         )
         .action(async (localOpts, cmd) => {
             const { workflowCommand } = await import("./commands/cli/workflow.ts");