fix(workflows): resolve interrupt/resume session loss and stale state bugs

.atomic/settings.json

@@ -1,6 +1,6 @@
 {
   "scm": "github",
   "version": 1,
-  "lastUpdated": "2026-03-23T18:36:09.681Z",
+  "lastUpdated": "2026-03-24T09:26:46.121Z",
   "$schema": "https://raw.githubusercontent.com/flora131/atomic/main/assets/settings.schema.json"
 }

.atomic/workflows/.gitignore

@@ -0,0 +1 @@
+node_modules/

.atomic/workflows/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "atomic-workflows",
+  "private": true,
+  "type": "module",
+  "dependencies": {
+    "@bastani/atomic-workflows": "0.4.29"
+  }
+}

.devcontainer/Dockerfile

@@ -0,0 +1,27 @@
+FROM mcr.microsoft.com/devcontainers/base:ubuntu-24.04
+
+# Install Bun and OpenCode as the vscode user (both install to $HOME)
+USER vscode
+
+RUN curl -fsSL https://bun.sh/install | bash
+ENV BUN_INSTALL="/home/vscode/.bun"
+ENV PATH="${BUN_INSTALL}/bin:${PATH}"
+
+RUN curl -fsSL https://opencode.ai/install | bash
+ENV PATH="/home/vscode/.opencode/bin:${PATH}"
+
+RUN curl -fsSL https://claude.ai/install.sh | bash
+
+RUN curl -fsSL https://gh.io/copilot-install | bash
+
+# Install uv, cocoindex-code, and Playwright CLI
+ENV PATH="/home/vscode/.local/bin:${PATH}"
+RUN curl -LsSf https://astral.sh/uv/install.sh | sh \
+    && uv tool install --upgrade cocoindex-code --prerelease explicit --with "cocoindex>=1.0.0a24"
+
+RUN bun install -g @playwright/cli@latest
+
+# Write cocoindex global settings
+RUN mkdir -p /home/vscode/.cocoindex_code \
+    && printf 'embedding:\n  model: lightonai/LateOn-Code-edge\n  provider: sentence-transformers\n' \
+    > /home/vscode/.cocoindex_code/global_settings.yml

.devcontainer/devcontainer.json

@@ -0,0 +1,20 @@
+{
+  "name": "Atomic CLI",
+  "build": {
+    "dockerfile": "Dockerfile"
+  },
+  "features": {
+    "ghcr.io/devcontainers/features/github-cli:1": {}
+  },
+  "remoteEnv": {
+    "GH_TOKEN": "${localEnv:GH_TOKEN}",
+    "ANTHROPIC_API_KEY": "${localEnv:ANTHROPIC_API_KEY}"
+  },
+  "postCreateCommand": "bun install",
+  "customizations": {
+    "vscode": {
+      "extensions": ["oven.bun-vscode", "oxc.oxc-vscode"]
+    }
+  },
+  "remoteUser": "vscode"
+}

.github/agents/codebase-analyzer.md

@@ -28,24 +28,35 @@ You are a specialist at understanding HOW code works. Your job is to analyze imp
 
 ## Analysis Strategy
 
-### Code Intelligence
+### Semantic Code Search (Primary Discovery)
 
-Prefer LSP over Grep/Glob/Read for code navigation:
+ALWAYS try `ccc search` first to discover relevant files before deep reading:
+
+```bash
+ccc search <natural language query>          # semantic search
+ccc search --lang typescript <query>         # filter by language
+ccc search --path 'src/services/*' <query>   # filter by path
+```
+
+- Describe concepts and behavior in natural language (e.g., `ccc search webhook validation pipeline` not `ccc search validateWebhook`)
+- If `ccc search` fails with an init error, run `ccc init && ccc index` first, then retry
+
+### Code Intelligence (Precise Navigation)
+
+After `ccc search` identifies candidate files, use LSP for tracing:
 - `goToDefinition` / `goToImplementation` to jump to source
 - `findReferences` to see all usages across the codebase
 - `workspaceSymbol` to find where something is defined
 - `documentSymbol` to list all symbols in a file
 - `hover` for type info without reading the file
 - `incomingCalls` / `outgoingCalls` for call hierarchy
 
-Before renaming or changing a function signature, use
-`findReferences` to find all call sites first.
-
-Use Grep/Glob only for text/pattern searches (comments,
-strings, config values) where LSP doesn't help.
+### Grep/Glob (Fallback)
 
-After writing or editing code, check LSP diagnostics before
-moving on. Fix any type errors or missing imports immediately.
+Use Grep/Glob only when `ccc search` and LSP are insufficient:
+- Exact string matching (error messages, config values, import paths)
+- Regex pattern searches
+- File extension/name pattern matching
 
 ### Step 0: Sort Candidate Files by Recency
 

.github/agents/codebase-locator.md

@@ -28,36 +28,35 @@ You are a specialist at finding WHERE code lives in a codebase. Your job is to l
 
 ## Search Strategy
 
-### Code Intelligence
+### Semantic Code Search (Primary)
 
-Prefer LSP over Grep/Glob/Read for code navigation:
+ALWAYS try `ccc search` first for code discovery before falling back to other tools:
+
+```bash
+ccc search <natural language query>          # semantic search
+ccc search --lang typescript <query>         # filter by language
+ccc search --path 'src/services/*' <query>   # filter by path
+```
+
+- Describe concepts and behavior in natural language (e.g., `ccc search event bus dispatching` not `ccc search EventBus`)
+- If `ccc search` fails with an init error, run `ccc init && ccc index` first, then retry
+
+### Code Intelligence (Refinement)
+
+After `ccc search` identifies candidate files, use LSP for precise navigation:
 - `goToDefinition` / `goToImplementation` to jump to source
 - `findReferences` to see all usages across the codebase
 - `workspaceSymbol` to find where something is defined
 - `documentSymbol` to list all symbols in a file
 - `hover` for type info without reading the file
 - `incomingCalls` / `outgoingCalls` for call hierarchy
 
-Before renaming or changing a function signature, use
-`findReferences` to find all call sites first.
-
-Use Grep/Glob only for text/pattern searches (comments,
-strings, config values) where LSP doesn't help.
-
-After writing or editing code, check LSP diagnostics before
-moving on. Fix any type errors or missing imports immediately.
-
-### Initial Broad Search
-
-First, think deeply about the most effective search patterns for the requested feature or topic, considering:
-
-- Common naming conventions in this codebase
-- Language-specific directory structures
-- Related terms and synonyms that might be used
+### Grep/Glob (Fallback)
 
-1. Start with using your grep tool for finding keywords.
-2. Optionally, use glob for file patterns
-3. LS and Glob your way to victory as well!
+Use Grep/Glob only when `ccc search` and LSP are insufficient:
+- Exact string matching (error messages, config values, import paths)
+- Regex pattern searches
+- File extension/name pattern matching
 
 ### Refine by Language/Framework
 

.github/agents/codebase-online-researcher.md

@@ -22,6 +22,20 @@ You are an expert research specialist focused on finding accurate, relevant info
 
 Use DeepWiki as your first-choice research tool. When DeepWiki results are insufficient, out-of-date, or unavailable, escalate to the **playwright-cli** skill for live web research.
 
+## Semantic Code Search (For Codebase Queries)
+
+When your research involves understanding the local codebase, ALWAYS try `ccc search` first before Grep/Glob:
+
+```bash
+ccc search <natural language query>          # semantic search
+ccc search --lang typescript <query>         # filter by language
+ccc search --path 'src/services/*' <query>   # filter by path
+```
+
+- Describe concepts and behavior in natural language (e.g., `ccc search event adapter stream processing`)
+- If `ccc search` fails with an init error, run `ccc init && ccc index` first, then retry
+- Fall back to Grep/Glob for exact string matching or regex patterns
+
 ## Core Responsibilities
 
 When you receive a research query, you should:
@@ -129,8 +143,8 @@ Structure your findings as:
 - Start with 2-3 well-crafted DeepWiki queries before broadening scope
 - When DeepWiki falls short, use the **playwright-cli** skill to fetch full content from the most promising 3-5 web pages
 - If initial results are insufficient, refine search terms and try again
-- Use search operators effectively: quotes for exact phrases, minus for exclusions, site: for specific domains
-- Consider searching in different forms: tutorials, documentation, Q&A sites, and discussion forums
+- Use exact error messages and function names when available for higher precision
+- Compare guidance across at least two sources when possible
 - Prefer DeepWiki for repository-specific knowledge; use playwright-cli for live web content, search engine results, and recently published information
 
-Remember: You are the user's expert guide to external technical information. Combine DeepWiki for repository knowledge with the **playwright-cli** skill for live web research to provide comprehensive, up-to-date answers. Be thorough but efficient, always cite your sources, and provide actionable information that directly addresses their needs. Think deeply as you work.
+Remember: You are the user's expert guide to technical research. Combine DeepWiki for repository knowledge with the **playwright-cli** skill for live web research to provide comprehensive, up-to-date answers. Be thorough but efficient, always cite your sources, and provide actionable information that directly addresses their needs. Think deeply as you work.

.github/agents/codebase-pattern-finder.md

@@ -28,24 +28,33 @@ You are a specialist at finding code patterns and examples in the codebase. Your
 
 ## Search Strategy
 
-### Code Intelligence
+### Semantic Code Search (Primary Discovery)
 
-Prefer LSP over Grep/Glob/Read for code navigation:
+ALWAYS try `ccc search` first to find patterns and examples before falling back to other tools:
+
+```bash
+ccc search <natural language query>          # semantic search
+ccc search --lang typescript <query>         # filter by language
+ccc search --path 'src/services/*' <query>   # filter by path
+```
+
+- Describe the pattern or behavior you're looking for in natural language (e.g., `ccc search pagination with cursor` or `ccc search factory pattern for creating agents`)
+- If `ccc search` fails with an init error, run `ccc init && ccc index` first, then retry
+
+### Code Intelligence (Refinement)
+
+After `ccc search` identifies candidate files, use LSP for precise navigation:
 - `goToDefinition` / `goToImplementation` to jump to source
 - `findReferences` to see all usages across the codebase
 - `workspaceSymbol` to find where something is defined
 - `documentSymbol` to list all symbols in a file
-- `hover` for type info without reading the file
-- `incomingCalls` / `outgoingCalls` for call hierarchy
-
-Before renaming or changing a function signature, use
-`findReferences` to find all call sites first.
 
-Use Grep/Glob only for text/pattern searches (comments,
-strings, config values) where LSP doesn't help.
+### Grep/Glob (Fallback)
 
-After writing or editing code, check LSP diagnostics before
-moving on. Fix any type errors or missing imports immediately.
+Use Grep/Glob only when `ccc search` and LSP are insufficient:
+- Exact string matching (error messages, config values, import paths)
+- Regex pattern searches
+- File extension/name pattern matching
 
 ### Step 1: Identify Pattern Types
 

.github/agents/codebase-research-locator.md

@@ -28,7 +28,21 @@ You are a specialist at finding documents in the research/ directory. Your job i
 
 ## Search Strategy
 
-First, think deeply about the search approach - consider which directories to prioritize based on the query, what search patterns and synonyms to use, and how to best categorize the findings for the user.
+### Semantic Code Search (Primary Discovery)
+
+ALWAYS try `ccc search` first to discover relevant research documents before falling back to Grep/Glob:
+
+```bash
+ccc search --path 'research/*' <natural language query>   # search within research/
+ccc search --path 'specs/*' <natural language query>       # search within specs/
+ccc search --path 'research/*' --path 'specs/*' <query>    # search both
+```
+
+- Describe the topic in natural language (e.g., `ccc search --path 'research/*' rate limiting design decisions`)
+- If `ccc search` fails with an init error, run `ccc init && ccc index` first, then retry
+- Fall back to Grep/Glob for exact string matching or filename pattern searches
+
+Then think deeply about the search approach - consider which directories to prioritize based on the query, what search patterns and synonyms to use, and how to best categorize the findings for the user.
 
 ### Directory Structure
 

.github/agents/debugger.md

@@ -31,21 +31,30 @@ Available tools:
   - ALWAYS ASSUME you have the playwright-cli tool installed (if the `playwright-cli` command fails, fallback to `bunx playwright-cli`).
 - ALWAYS invoke your testing-anti-patterns skill BEFORE creating or modifying any tests.
 
+### Semantic Code Search (Primary Discovery)
+
+ALWAYS try `ccc search` first to find relevant code before falling back to other tools:
+
+```bash
+ccc search <natural language query>          # semantic search
+ccc search --lang typescript <query>         # filter by language
+ccc search --path 'src/services/*' <query>   # filter by path
+```
+
+- Describe the bug or behavior in natural language (e.g., `ccc search stream timeout error handling`)
+- If `ccc search` fails with an init error, run `ccc init && ccc index` first, then retry
+
 ### Code Intelligence
 
-Prefer LSP over Grep/Glob/Read for code navigation:
+After `ccc search` identifies candidate files, use LSP for precise navigation:
 - `goToDefinition` / `goToImplementation` to jump to source
 - `findReferences` to see all usages across the codebase
 - `workspaceSymbol` to find where something is defined
 - `documentSymbol` to list all symbols in a file
 - `hover` for type info without reading the file
 - `incomingCalls` / `outgoingCalls` for call hierarchy
 
-Before renaming or changing a function signature, use
-`findReferences` to find all call sites first.
-
-Use Grep/Glob only for text/pattern searches (comments,
-strings, config values) where LSP doesn't help.
+Use Grep/Glob only for exact string matching (error messages, config values) where `ccc search` and LSP don't help.
 
 After writing or editing code, check LSP diagnostics before
 moving on. Fix any type errors or missing imports immediately.

.github/agents/planner.md

@@ -8,6 +8,20 @@ You are the planner agent for the Ralph autonomous implementation workflow.
 
 Your job is to decompose the user's feature request into a structured, ordered list of implementation tasks optimized for **parallel execution** by multiple concurrent sub-agents.
 
+## Semantic Code Search (Primary Discovery)
+
+ALWAYS try `ccc search` first to understand the codebase before decomposing tasks:
+
+```bash
+ccc search <natural language query>          # semantic search
+ccc search --lang typescript <query>         # filter by language
+ccc search --path 'src/services/*' <query>   # filter by path
+```
+
+- Describe concepts and behavior in natural language (e.g., `ccc search authentication middleware flow`)
+- If `ccc search` fails with an init error, run `ccc init && ccc index` first, then retry
+- Fall back to Grep/Glob for exact string matching or regex patterns
+
 ## Critical: Parallel Execution Model
 
 **Multiple worker sub-agents execute tasks concurrently.** Your task decomposition directly impacts orchestration efficiency:

.github/agents/worker.md

@@ -82,9 +82,22 @@ Use the "Gang of Four" patterns as a shared vocabulary to solve recurring proble
 - If a completion promise is set, you may ONLY output it when the statement is completely and unequivocally TRUE. Do not output false promises to escape the loop, even if you think you're stuck or should exit for other reasons. The loop is designed to continue until genuine completion.
 - Tip: For refactors or code cleanup tasks prioritize using sub-agents to help you with the work and prevent overloading your context window, especially for a large number of file edits
 
+### Semantic Code Search (Primary Discovery)
+
+ALWAYS try `ccc search` first to find relevant code before falling back to other tools:
+
+```bash
+ccc search <natural language query>          # semantic search
+ccc search --lang typescript <query>         # filter by language
+ccc search --path 'src/services/*' <query>   # filter by path
+```
+
+- Describe concepts and behavior in natural language (e.g., `ccc search workflow conductor interrupt handling`)
+- If `ccc search` fails with an init error, run `ccc init && ccc index` first, then retry
+
 ### Code Intelligence
 
-Prefer LSP over Grep/Glob/Read for code navigation:
+After `ccc search` identifies candidate files, use LSP for precise navigation:
 - `goToDefinition` / `goToImplementation` to jump to source
 - `findReferences` to see all usages across the codebase
 - `workspaceSymbol` to find where something is defined
@@ -95,8 +108,7 @@ Prefer LSP over Grep/Glob/Read for code navigation:
 Before renaming or changing a function signature, use
 `findReferences` to find all call sites first.
 
-Use Grep/Glob only for text/pattern searches (comments,
-strings, config values) where LSP doesn't help.
+Use Grep/Glob only for exact string matching (error messages, config values, import paths) where `ccc search` and LSP don't help.
 
 After writing or editing code, check LSP diagnostics before
 moving on. Fix any type errors or missing imports immediately.
@@ -105,7 +117,7 @@ moving on. Fix any type errors or missing imports immediately.
 
 When you encounter ANY bug — whether introduced by your changes, discovered during testing, or pre-existing — you MUST follow this protocol:
 
-1. **Delegate debugging**: Use the Task tool to spawn a debugger agent. It can use DeepWiki for framework and library best practices.
+1. **Delegate debugging**: Use the Task tool to spawn a debugger agent. It can navigate the web for best practices.
 2. **Add the bug fix to the TOP of the task list AND update `blockedBy` on affected tasks**: Update `~/.atomic/sessions/workflows/{workflow_name}/{session_id}/tasks.json` with the bug fix as the FIRST item in the array (highest priority). Then, for every task whose work depends on the bug being fixed first, add the bug fix task's ID to that task's `blockedBy` array. This ensures those tasks cannot be started until the fix lands. Example:
     ```json
     [
@@ -123,7 +135,7 @@ Do NOT ignore bugs. Do NOT deprioritize them. Bugs always go to the TOP of the t
 
 - AFTER implementing the feature AND verifying its functionality by creating tests, mark the feature as complete in the task list
 - It is unacceptable to remove or edit tests because this could lead to missing or buggy functionality
-- Commit progress to git with descriptive commit messages by invoking the `gh-commit` skill (e.g. `/commit`)
+- Commit progress to git with descriptive commit messages by running the `/commit` command using the `Skill` tool (e.g. invoke skill `gh-commit`)
 - Write summaries of your progress in `~/.atomic/sessions/workflows/{workflow_name}/{session_id}/progress.txt`
     - Tip: this can be useful to revert bad code changes and recover working states of the codebase
 - Note: you are competing with another coding agent that also implements features. The one who does a better job implementing features will be promoted. Focus on quality, correctness, and thorough testing. The agent who breaks the rules for implementation will be fired.