corecoder 0.9.0__tar.gz → 0.10.0__tar.gz

{corecoder-0.9.0 → corecoder-0.10.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: corecoder
-Version: 0.9.0
-Summary: Minimal AI coding agent (2,908 lines of Python) inspired by Claude Code. Works with any LLM. (formerly NanoCoder)
+Version: 0.10.0
+Summary: Minimal AI coding agent (2,989 lines of Python) inspired by Claude Code. Works with any LLM. (formerly NanoCoder)
 Project-URL: Homepage, https://github.com/he-yufeng/CoreCoder
 Project-URL: Repository, https://github.com/he-yufeng/CoreCoder
 Project-URL: Issues, https://github.com/he-yufeng/CoreCoder/issues
@@ -37,7 +37,7 @@ Description-Content-Type: text/markdown
 
 # CoreCoder
 
-**The nanoGPT of coding agents. A 1.4k-line engine inside 2,908 readable lines of pure Python: understand how a coding agent actually works, then fork your own.**
+**The nanoGPT of coding agents. A 1.4k-line engine inside 2,989 readable lines of pure Python: understand how a coding agent actually works, then fork your own.**
 
 *learn from it · fork it · ship something better*
 
@@ -47,7 +47,7 @@ Description-Content-Type: text/markdown
 [![Python](https://img.shields.io/badge/python-3.10+-blue)](https://python.org)
 [![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 [![Tests](https://github.com/he-yufeng/CoreCoder/actions/workflows/ci.yml/badge.svg)](https://github.com/he-yufeng/CoreCoder/actions)
-[![engine](https://img.shields.io/badge/engine-1405_LoC-blue)](article/00-index_EN.md)
+[![engine](https://img.shields.io/badge/engine-1483_LoC-blue)](article/00-index_EN.md)
 [![essays](https://img.shields.io/badge/source--reading-8_bilingual-orange)](article/00-index_EN.md)
 
 </div>
@@ -60,7 +60,7 @@ Description-Content-Type: text/markdown
 
 | | CoreCoder | Claude Code | aider | nanoGPT |
 |---|---|---|---|---|
-| Lines of code | ~1,405 engine / 2,908 total | hundreds of thousands (closed) | tens of thousands of Python | ~600 (two files) |
+| Lines of code | ~1,405 engine / 2,989 total | hundreds of thousands (closed) | tens of thousands of Python | ~600 (two files) |
 | Time to read it all | one afternoon | can't (closed) | a few days of slogging | one afternoon |
 | Breakpoint, change, rerun? | yes, every line | no | yes, but there's a lot | yes |
 | What it's for | understand one, then fork your own | production coding assistant | terminal pair-programming | minimal GPT for teaching |
@@ -71,9 +71,9 @@ The nanoGPT column is there as a reference point: minimal, readable, but it teac
 
 I've always felt coding agents get talked about as if they were arcane. Strip a tool like Claude Code or Cursor all the way down and the core is a `while` loop wrapped around a large model, plus seven or eight tools that let it actually do things. The hard part was never the loop; it's everything the loop has to cope with once it meets the real world. CoreCoder is the minimal version that writes that core out honestly.
 
-The engine (loop, model interface, context, tools, sessions) is 1,405 lines once you drop blank lines and comments. Counting the outer CLI, config and packaging too, the whole package is 25 files: 2,908 physical lines, 2,364 net, every one short enough to read in a single sitting. The growth since the original 1,161-line snapshot went into visible features: plan mode, hooks and checkpoints, each documented below.
+The engine (loop, model interface, context, tools, sessions) is 1,405 lines once you drop blank lines and comments. Counting the outer CLI, config and packaging too, the whole package is 25 files: 2,989 physical lines, 2,442 net, every one short enough to read in a single sitting. The growth since the original 1,161-line snapshot went into visible features: plan mode, hooks and checkpoints, each documented below.
 
-And it really runs: reads and writes files, executes shell, spawns sub-agents, compacts context in three tiers, and tells you the tokens and dollars a run burned whenever you ask. Anything that would mutate your disk or run a command stops for your consent first. The suite has 242 offline tests and an opt-in live smoke test. But the point of it running isn't to become your daily driver. It runs so the walkthrough can't lie: a reference that shows how an agent works has to actually work.
+And it really runs: reads and writes files, executes shell, spawns sub-agents, compacts context in three tiers, and tells you the tokens and dollars a run burned whenever you ask. Anything that would mutate your disk or run a command stops for your consent first. The suite has 246 offline tests and an opt-in live smoke test. But the point of it running isn't to become your daily driver. It runs so the walkthrough can't lie: a reference that shows how an agent works has to actually work.
 
 The code came out of a public teardown: open analyses have already exposed a lot of the load-bearing architecture inside production agents like Claude Code. I took the most essential layer and rewrote it honestly, in as little code as I could. So reading CoreCoder is roughly like reading a runnable, annotated take on how that kind of agent works, except it's only a minimal reimplementation, sitting right there on your machine for you to take apart and change.
 
@@ -126,7 +126,7 @@ Laid out flat, the whole project is this big. Skim it before you clone and you'l
 corecoder/
 ├── agent.py        agent loop + parallel tool exec       240 lines   ← start here
 ├── llm.py          streaming client + retry + cost        364 lines
-├── context.py      three-tier context compaction          220 lines
+├── context.py      three-tier context compaction          224 lines
 ├── session.py      save / resume + path-traversal guard    97 lines
 ├── permissions.py  consent for mutating tools              81 lines
 ├── hooks.py        Pre/PostToolUse shell hooks             87 lines
@@ -145,7 +145,7 @@ corecoder/
     ├── read.py       file read                             56 lines
     ├── write.py      file write                            46 lines
     ├── todo.py       agent-maintained task checklist       79 lines
-    ├── agent.py      sub-agent teams + isolation         143 lines
+    ├── agent.py      sub-agent teams + isolation         224 lines
     └── base.py       tool base class                       32 lines
 examples/
 ├── plan_hooks_demo.py  offline plan mode + hooks demo (no API key)
@@ -197,6 +197,15 @@ report = agent_tool.execute(tasks=[
 
 One to eight workers run up to four at a time, each through the normal agent loop. Reports come back in input order, not completion order, and one worker's exception does not cancel its siblings. Shared token accounting and interactive permission prompts are serialized, so concurrency doesn't lose cost or interleave consent. There is no scheduler, shared message bus, recursive spawning, or second agent loop. `examples/multi_agent_demo.py` runs the researcher / implementer / reviewer pattern offline with scripted findings; no API key and no model-quality claim.
 
+Dependencies are just as small: set `depends_on` on a worker, and it starts only after every named dependency has finished successfully. Each dependent worker receives those upstream reports in its own prompt, while a failed dependency skips only the affected branch. Independent work in the same call still runs concurrently, and the returned report keeps the original input order:
+
+```python
+{"name": "implementer", "task": "Fix using the research", "depends_on": ["researcher"]},
+{"name": "reviewer", "task": "Review the fix", "depends_on": ["implementer"]},
+```
+
+Names must be unique, references must exist, and cycles are rejected before any worker starts. It is still one blocking tool call, not a background orchestration service.
+
 Every one of these *whys* is traced down to the actual lines of code in the series below.
 
 ## The source-reading series · 8 bilingual essays

{corecoder-0.9.0 → corecoder-0.10.0}/README.md

@@ -2,7 +2,7 @@
 
 # CoreCoder
 
-**The nanoGPT of coding agents. A 1.4k-line engine inside 2,908 readable lines of pure Python: understand how a coding agent actually works, then fork your own.**
+**The nanoGPT of coding agents. A 1.4k-line engine inside 2,989 readable lines of pure Python: understand how a coding agent actually works, then fork your own.**
 
 *learn from it · fork it · ship something better*
 
@@ -12,7 +12,7 @@
 [![Python](https://img.shields.io/badge/python-3.10+-blue)](https://python.org)
 [![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 [![Tests](https://github.com/he-yufeng/CoreCoder/actions/workflows/ci.yml/badge.svg)](https://github.com/he-yufeng/CoreCoder/actions)
-[![engine](https://img.shields.io/badge/engine-1405_LoC-blue)](article/00-index_EN.md)
+[![engine](https://img.shields.io/badge/engine-1483_LoC-blue)](article/00-index_EN.md)
 [![essays](https://img.shields.io/badge/source--reading-8_bilingual-orange)](article/00-index_EN.md)
 
 </div>
@@ -25,7 +25,7 @@
 
 | | CoreCoder | Claude Code | aider | nanoGPT |
 |---|---|---|---|---|
-| Lines of code | ~1,405 engine / 2,908 total | hundreds of thousands (closed) | tens of thousands of Python | ~600 (two files) |
+| Lines of code | ~1,405 engine / 2,989 total | hundreds of thousands (closed) | tens of thousands of Python | ~600 (two files) |
 | Time to read it all | one afternoon | can't (closed) | a few days of slogging | one afternoon |
 | Breakpoint, change, rerun? | yes, every line | no | yes, but there's a lot | yes |
 | What it's for | understand one, then fork your own | production coding assistant | terminal pair-programming | minimal GPT for teaching |
@@ -36,9 +36,9 @@ The nanoGPT column is there as a reference point: minimal, readable, but it teac
 
 I've always felt coding agents get talked about as if they were arcane. Strip a tool like Claude Code or Cursor all the way down and the core is a `while` loop wrapped around a large model, plus seven or eight tools that let it actually do things. The hard part was never the loop; it's everything the loop has to cope with once it meets the real world. CoreCoder is the minimal version that writes that core out honestly.
 
-The engine (loop, model interface, context, tools, sessions) is 1,405 lines once you drop blank lines and comments. Counting the outer CLI, config and packaging too, the whole package is 25 files: 2,908 physical lines, 2,364 net, every one short enough to read in a single sitting. The growth since the original 1,161-line snapshot went into visible features: plan mode, hooks and checkpoints, each documented below.
+The engine (loop, model interface, context, tools, sessions) is 1,405 lines once you drop blank lines and comments. Counting the outer CLI, config and packaging too, the whole package is 25 files: 2,989 physical lines, 2,442 net, every one short enough to read in a single sitting. The growth since the original 1,161-line snapshot went into visible features: plan mode, hooks and checkpoints, each documented below.
 
-And it really runs: reads and writes files, executes shell, spawns sub-agents, compacts context in three tiers, and tells you the tokens and dollars a run burned whenever you ask. Anything that would mutate your disk or run a command stops for your consent first. The suite has 242 offline tests and an opt-in live smoke test. But the point of it running isn't to become your daily driver. It runs so the walkthrough can't lie: a reference that shows how an agent works has to actually work.
+And it really runs: reads and writes files, executes shell, spawns sub-agents, compacts context in three tiers, and tells you the tokens and dollars a run burned whenever you ask. Anything that would mutate your disk or run a command stops for your consent first. The suite has 246 offline tests and an opt-in live smoke test. But the point of it running isn't to become your daily driver. It runs so the walkthrough can't lie: a reference that shows how an agent works has to actually work.
 
 The code came out of a public teardown: open analyses have already exposed a lot of the load-bearing architecture inside production agents like Claude Code. I took the most essential layer and rewrote it honestly, in as little code as I could. So reading CoreCoder is roughly like reading a runnable, annotated take on how that kind of agent works, except it's only a minimal reimplementation, sitting right there on your machine for you to take apart and change.
 
@@ -91,7 +91,7 @@ Laid out flat, the whole project is this big. Skim it before you clone and you'l
 corecoder/
 ├── agent.py        agent loop + parallel tool exec       240 lines   ← start here
 ├── llm.py          streaming client + retry + cost        364 lines
-├── context.py      three-tier context compaction          220 lines
+├── context.py      three-tier context compaction          224 lines
 ├── session.py      save / resume + path-traversal guard    97 lines
 ├── permissions.py  consent for mutating tools              81 lines
 ├── hooks.py        Pre/PostToolUse shell hooks             87 lines
@@ -110,7 +110,7 @@ corecoder/
     ├── read.py       file read                             56 lines
     ├── write.py      file write                            46 lines
     ├── todo.py       agent-maintained task checklist       79 lines
-    ├── agent.py      sub-agent teams + isolation         143 lines
+    ├── agent.py      sub-agent teams + isolation         224 lines
     └── base.py       tool base class                       32 lines
 examples/
 ├── plan_hooks_demo.py  offline plan mode + hooks demo (no API key)
@@ -162,6 +162,15 @@ report = agent_tool.execute(tasks=[
 
 One to eight workers run up to four at a time, each through the normal agent loop. Reports come back in input order, not completion order, and one worker's exception does not cancel its siblings. Shared token accounting and interactive permission prompts are serialized, so concurrency doesn't lose cost or interleave consent. There is no scheduler, shared message bus, recursive spawning, or second agent loop. `examples/multi_agent_demo.py` runs the researcher / implementer / reviewer pattern offline with scripted findings; no API key and no model-quality claim.
 
+Dependencies are just as small: set `depends_on` on a worker, and it starts only after every named dependency has finished successfully. Each dependent worker receives those upstream reports in its own prompt, while a failed dependency skips only the affected branch. Independent work in the same call still runs concurrently, and the returned report keeps the original input order:
+
+```python
+{"name": "implementer", "task": "Fix using the research", "depends_on": ["researcher"]},
+{"name": "reviewer", "task": "Review the fix", "depends_on": ["implementer"]},
+```
+
+Names must be unique, references must exist, and cycles are rejected before any worker starts. It is still one blocking tool call, not a background orchestration service.
+
 Every one of these *whys* is traced down to the actual lines of code in the series below.
 
 ## The source-reading series · 8 bilingual essays

{corecoder-0.9.0 → corecoder-0.10.0}/README_CN.md

@@ -2,7 +2,7 @@
 
 # CoreCoder
 
-**编程 agent 里的 nanoGPT。1.4k 行引擎、整包 2908 行纯 Python 全部一口气可读，读懂一个 coding agent 到底怎么运作，再 fork 出你自己的。**
+**编程 agent 里的 nanoGPT。1.4k 行引擎、整包 2989 行纯 Python 全部一口气可读，读懂一个 coding agent 到底怎么运作，再 fork 出你自己的。**
 
 *learn from it · fork it · ship something better*
 
@@ -12,7 +12,7 @@
 [![Python](https://img.shields.io/badge/python-3.10+-blue)](https://python.org)
 [![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 [![Tests](https://github.com/he-yufeng/CoreCoder/actions/workflows/ci.yml/badge.svg)](https://github.com/he-yufeng/CoreCoder/actions)
-[![engine](https://img.shields.io/badge/engine-1405_LoC-blue)](article/)
+[![engine](https://img.shields.io/badge/engine-1483_LoC-blue)](article/)
 [![源码导读](https://img.shields.io/badge/源码导读-8篇双语-orange)](article/)
 
 </div>
@@ -25,7 +25,7 @@
 
 | | CoreCoder | Claude Code | aider | nanoGPT |
 |---|---|---|---|---|
-| 代码量 | 引擎约 1405 行 / 整包 2908 行 | 几十万行（闭源） | 数万行 Python | 约 600 行（两个文件） |
+| 代码量 | 引擎约 1483 行 / 整包 2989 行 | 几十万行（闭源） | 数万行 Python | 约 600 行（两个文件） |
 | 读完要多久 | 一个下午 | 读不了（闭源） | 得啃几天 | 一个下午 |
 | 能不能下断点改了再跑 | 能，每一行 | 不能 | 能，但量大 | 能 |
 | 定位 | 读懂并 fork 出你自己的 agent | 生产级编程助手 | 终端结对编程 | 教学用最小 GPT |
@@ -36,9 +36,9 @@ nanoGPT 那一列是拿来对照的：它最小、可读，但教的是训一个
 
 我一直觉得 coding agent 被讲得太玄了。把 Claude Code、Cursor 这类工具扒到底，核心是一个 while 循环套着一个大模型，外加七八个让它能真正动手的工具。难的从来不是这个循环，而是循环跑进真实世界以后要兜的那些底。CoreCoder 就是把这个核心老老实实写出来的最小版本。
 
-引擎部分（循环、模型接口、上下文、工具、会话）去掉空行和注释是 1405 行。连最外层的 CLI、配置、打包一起算，整个包 25 个文件、物理 2908 行、净 2364 行，每个文件都短到能一口气读完。自 1161 行快照之后的增长都花在了看得见的功能上：plan mode、hooks、checkpoints，下文各有交代。
+引擎部分（循环、模型接口、上下文、工具、会话）去掉空行和注释是 1483 行。连最外层的 CLI、配置、打包一起算，整个包 25 个文件、物理 2989 行、净 2442 行，每个文件都短到能一口气读完。自 1161 行快照之后的增长都花在了看得见的功能上：plan mode、hooks、checkpoints，下文各有交代。
 
-它真能跑：读写文件、执行 shell、派子 agent、分三层压上下文，还能随时把这趟烧掉的 token 和美元数报给你。任何要动你磁盘、要跑命令的调用，都会先停下来等你点头。现在有 242 个离线测试，另有按需开启的真实 API 冒烟。但能跑不是为了劝你拿去日用，而是为了让这份「注释」不撒谎：一个解释 agent 怎么运作的范例，自己得真能运作。
+它真能跑：读写文件、执行 shell、派子 agent、分三层压上下文，还能随时把这趟烧掉的 token 和美元数报给你。任何要动你磁盘、要跑命令的调用，都会先停下来等你点头。现在有 246 个离线测试，另有按需开启的真实 API 冒烟。但能跑不是为了劝你拿去日用，而是为了让这份「注释」不撒谎：一个解释 agent 怎么运作的范例，自己得真能运作。
 
 代码来自一次公开拆解。公开的源码分析里，Claude Code 这类生产级 agent 暴露出不少关键架构，我挑出最核心的一层，用尽量少的代码诚实地复写了一遍。所以读 CoreCoder，约等于读一份基于公开源码分析的「可运行注释版」：讲的是这类 agent 的核心思路，而它本身只是最小复写，就摆在你机器上，随你拆、随你改。
 
@@ -91,7 +91,7 @@ corecoder -p "给 parse_config() 加错误处理"   # 一次性模式，干完
 corecoder/
 ├── agent.py        agent 主循环 + 并行工具执行       240 行   ← 从这里开始读
 ├── llm.py          流式客户端 + 重试 + 成本统计       364 行
-├── context.py      三层上下文压缩                     220 行
+├── context.py      三层上下文压缩                     224 行
 ├── session.py      会话存盘 / 续聊 + 路径穿越防护      97 行
 ├── permissions.py  改动类工具的用户授权                81 行
 ├── hooks.py        工具调用前后的用户 shell 钩子        87 行
@@ -110,7 +110,7 @@ corecoder/
     ├── read.py       文件读取                           56 行
     ├── write.py      文件写入                           46 行
     ├── todo.py       agent 自维护的任务清单             79 行
-    ├── agent.py      子 agent 团队与隔离                143 行
+    ├── agent.py      子 agent 团队与隔离                224 行
     └── base.py       工具基类                           32 行
 examples/
 ├── plan_hooks_demo.py  离线 plan mode + hooks 演示（免 API key）
@@ -162,6 +162,15 @@ report = agent_tool.execute(tasks=[
 
 1 到 8 个 worker、最多 4 个并发，每个仍走原来的 agent 循环。报告按输入顺序返回，不按完成顺序；单个 worker 出错不会取消其他 worker。共享的 token 记账和交互式授权提示都串行化，并发不会漏账，也不会把确认问题交错打印。没有调度器、共享消息总线、递归派生或第二个 agent 循环。`examples/multi_agent_demo.py` 用脚本化结论离线演示 researcher / implementer / reviewer，不需要 API key，也不拿它冒充真实模型质量验证。
 
+依赖关系也只有一行：给 worker 写上 `depends_on`，它会等所有指定依赖成功完成后再启动，并在自己的 prompt 里收到这些上游报告。某个依赖失败时，只跳过受影响的下游分支，同一次调用里的独立任务照常并发，最终报告仍按输入顺序返回：
+
+```python
+{"name": "implementer", "task": "结合研究结论提出修复", "depends_on": ["researcher"]},
+{"name": "reviewer", "task": "审查这个修复", "depends_on": ["implementer"]},
+```
+
+worker 名不能重复，依赖必须指向已有名字，循环依赖会在任何 worker 启动前直接拒绝。它依然是一次阻塞式工具调用，不是常驻的编排服务。
+
 每一个「为什么」，下面的文章系列都拆到了具体代码行。
 
 ## 配套源码导读 · 八篇双语

{corecoder-0.9.0 → corecoder-0.10.0}/article/00-index.md

@@ -8,7 +8,7 @@
 
 因为 Claude Code 本体太大了。它的代码量在几十万行的量级，光一个负责跑 shell 命令的 BashTool 就上千行，真要逐行读完，多数人会在第三个文件就关掉编辑器。可 agent 的核心其实没那么复杂，复杂的是工程化之后那些为真实世界兜底的边角：模型半路被打断怎么办、上下文塞满了怎么办、十个工具调用同时回来怎么办、provider 偶尔抽风返回 500 又怎么办。这些东西摊在几十万行里，你很难一眼看到骨架。
 
-CoreCoder 做的事，是把这套骨架压到一千四百行出头的纯 Python。准确说，agent 引擎（循环、模型接口、上下文、工具、会话）去掉空行和注释是 1405 行；连最外层的 CLI 终端、配置和打包都算上，整个包去掉空行和注释 2364 行，物理代码 2908 行。每个文件都短到能一口气读完，跑起来又确实是个能改代码、能跑命令、能自己开子任务、能压缩上下文、能算钱的 agent。它不是玩具。它是把生产级 agent 的每个设计决策，拣出最核心的那版，用最少的代码诚实地写一遍。
+CoreCoder 做的事，是把这套骨架压到一千四百行出头的纯 Python。准确说，agent 引擎（循环、模型接口、上下文、工具、会话）去掉空行和注释是 1483 行；连最外层的 CLI 终端、配置和打包都算上，整个包去掉空行和注释 2442 行，物理代码 2989 行。每个文件都短到能一口气读完，跑起来又确实是个能改代码、能跑命令、能自己开子任务、能压缩上下文、能算钱的 agent。它不是玩具。它是把生产级 agent 的每个设计决策，拣出最核心的那版，用最少的代码诚实地写一遍。
 
 读它，约等于读一份 Claude Code 的「可运行注释版」。区别在于，CoreCoder 的每一行你都能在自己机器上断点、改、跑、看它出什么效果。本系列里我引用的每一个行数、每一段代码，都是从仓库里现读现核的，不是凭印象。这点我后面会反复较真，因为编码 agent 这个领域，太多文章在凭感觉编数字。
 

{corecoder-0.9.0 → corecoder-0.10.0}/article/00-index_EN.md

@@ -8,7 +8,7 @@ First, use CoreCoder, an open source project whose core runs to just over fourte
 
 Because Claude Code itself is too big. Its codebase runs into the hundreds of thousands of lines, and the BashTool alone, the part that runs shell commands, is over a thousand. Read it line by line and most people close the editor by the third file. Yet the core of an agent isn't really that complicated. What's complicated is everything engineered around it to survive the real world: what to do when the model gets interrupted mid-stream, when the context window fills up, when ten tool calls come back at once, when a provider hiccups and returns a 500. Spread across hundreds of thousands of lines, that skeleton is hard to see.
 
-What CoreCoder does is squeeze the skeleton down to just over fourteen hundred lines of pure Python. To be precise, the agent engine (the loop, model interface, context, tools, session) is 1,405 lines once you drop blank lines and comments; add the outermost CLI terminal, config, and packaging and the whole package is 2,364 lines without blanks and comments, 2,908 physical. Every file is short enough to read in one sitting, and what runs is genuinely an agent: it edits code, runs commands, spins up its own subtasks, compresses context, tracks cost. It is not a toy. It takes every design decision a production agent makes, picks the most essential version of each, and writes it out honestly in the least code it can.
+What CoreCoder does is squeeze the skeleton down to just over fourteen hundred lines of pure Python. To be precise, the agent engine (the loop, model interface, context, tools, session) is 1,483 lines once you drop blank lines and comments; add the outermost CLI terminal, config, and packaging and the whole package is 2,442 lines without blanks and comments, 2,989 physical. Every file is short enough to read in one sitting, and what runs is genuinely an agent: it edits code, runs commands, spins up its own subtasks, compresses context, tracks cost. It is not a toy. It takes every design decision a production agent makes, picks the most essential version of each, and writes it out honestly in the least code it can.
 
 Reading it is close to reading a runnable, annotated edition of Claude Code. The difference is that every line of CoreCoder is something you can breakpoint, change, run, and watch on your own machine. Every line count and every snippet I quote in this series is read straight out of the repository, not recalled from memory. I'll keep being pedantic about that, because in the coding-agent space far too many write-ups just make the numbers up.
 

{corecoder-0.9.0 → corecoder-0.10.0}/article/05-parallel-and-subagents.md

@@ -73,7 +73,7 @@ _local.cwd = running
 
 ## 子 agent：给自己开一个分身
 
-`agent` 工具（`corecoder/tools/agent.py`，143 行）解决的是另一个问题。有些子任务很重，比如「把这个陌生代码库摸一遍，告诉我认证是怎么实现的」。这种活如果让主 agent 自己干，它得读一大堆文件、跑一堆搜索，这些中间过程全堆进主对话的窗口，等它摸清楚了，窗口也被探索垃圾塞得差不多了，真正的任务反而没空间了。
+`agent` 工具（`corecoder/tools/agent.py`，224 行）解决的是另一个问题。有些子任务很重，比如「把这个陌生代码库摸一遍，告诉我认证是怎么实现的」。这种活如果让主 agent 自己干，它得读一大堆文件、跑一堆搜索，这些中间过程全堆进主对话的窗口，等它摸清楚了，窗口也被探索垃圾塞得差不多了，真正的任务反而没空间了。
 
 子 agent 的思路是：派一个有独立上下文的分身去干这件重活，它在自己的窗口里折腾，干完只把一个精简结论交回来。主 agent 的窗口始终干净，只多了一句「认证是这么实现的」。
 

{corecoder-0.9.0 → corecoder-0.10.0}/article/05-parallel-and-subagents_EN.md

@@ -73,7 +73,7 @@ I pull this passage out on its own because it's a particularly good teaching poi
 
 ## Sub-agents: spawning a clone of yourself
 
-The `agent` tool (`corecoder/tools/agent.py`, 143 lines) solves a different problem. Some subtasks are heavy, say "go over this unfamiliar codebase and tell me how authentication is implemented." If the main agent does this itself, it has to read a pile of files and run a bunch of searches, and all that intermediate process piles into the main conversation's window; by the time it's figured things out, the window is nearly stuffed with exploration garbage and the real task has no room left.
+The `agent` tool (`corecoder/tools/agent.py`, 224 lines) solves a different problem. Some subtasks are heavy, say "go over this unfamiliar codebase and tell me how authentication is implemented." If the main agent does this itself, it has to read a pile of files and run a bunch of searches, and all that intermediate process piles into the main conversation's window; by the time it's figured things out, the window is nearly stuffed with exploration garbage and the real task has no room left.
 
 The sub-agent's idea is: dispatch a clone with its own independent context to do this heavy work, let it churn in its own window, and hand back only a distilled conclusion when done. The main agent's window stays clean throughout, with just one extra line, "authentication is implemented this way."
 

{corecoder-0.9.0 → corecoder-0.10.0}/corecoder/__init__.py

@@ -1,6 +1,6 @@
 """CoreCoder - Minimal AI coding agent inspired by Claude Code's architecture."""
 
-__version__ = "0.9.0"
+__version__ = "0.10.0"
 
 from corecoder.agent import Agent
 from corecoder.config import Config

{corecoder-0.9.0 → corecoder-0.10.0}/corecoder/tools/agent.py

@@ -48,6 +48,11 @@ class AgentTool(Tool):
                             "type": "string",
                             "description": "What this worker should accomplish",
                         },
+                        "depends_on": {
+                            "type": "array",
+                            "description": "Worker names that must finish successfully before this worker starts",
+                            "items": {"type": "string"},
+                        },
                     },
                     "required": ["task"],
                 },
@@ -86,7 +91,40 @@ class AgentTool(Tool):
             hooks=parent.hooks,
         )
 
-    def _run_one(self, item: dict, cwd: str | None) -> str:
+    def _dependency_waves(self, work: list[dict]) -> list[list[dict]]:
+        by_name = {}
+        for item in work:
+            name = item["name"]
+            if name in by_name:
+                raise ValueError(f"duplicate worker name {name!r}")
+            by_name[name] = item
+        for item in work:
+            dependencies = item.get("depends_on", [])
+            if not isinstance(dependencies, list) or any(
+                not isinstance(dependency, str) or not dependency.strip() for dependency in dependencies
+            ):
+                raise ValueError(f"worker {item['name']!r} has an invalid depends_on list")
+            item["depends_on"] = [dependency.strip() for dependency in dependencies]
+            for dependency in item["depends_on"]:
+                if dependency == item["name"]:
+                    raise ValueError(f"worker {item['name']!r} depends on itself")
+                if dependency not in by_name:
+                    raise ValueError(f"worker {item['name']!r} depends on unknown worker {dependency!r}")
+
+        pending = work[:]
+        completed = set()
+        waves = []
+        while pending:
+            ready = [item for item in pending if all(name in completed for name in item["depends_on"])]
+            if not ready:
+                raise ValueError("worker dependency cycle detected")
+            waves.append(ready)
+            completed.update(item["name"] for item in ready)
+            ready_names = {item["name"] for item in ready}
+            pending = [item for item in pending if item["name"] not in ready_names]
+        return waves
+
+    def _run_one(self, item: dict, cwd: str | None, dependency_reports: dict | None = None) -> str:
         # Each worker gets the session cwd without leaking its own cd back.
         from .bash import get_tracked_cwd, set_tracked_cwd
 
@@ -95,6 +133,10 @@ class AgentTool(Tool):
             set_tracked_cwd(cwd)
             name = item.get("name")
             prompt = item["task"] if name is None else f"You are {name}.\n\n{item['task']}"
+            if dependency_reports:
+                prompt += "\n\nCompleted upstream reports:\n" + "\n\n".join(
+                    f"### {dependency}\n{report}" for dependency, report in dependency_reports.items()
+                )
             result = self._new_subagent().chat(prompt)
             if len(result) > 5000:
                 result = result[:4500] + "\n... (sub-agent output truncated)"
@@ -125,7 +167,13 @@ class AgentTool(Tool):
                     return f"Error: task {i} needs a non-empty 'task' string"
                 if name is not None and (not isinstance(name, str) or not name.strip()):
                     return f"Error: task {i} needs a non-empty 'name' when provided"
-                work.append({"task": prompt, "name": name.strip() if name else f"agent-{i}"})
+                work.append(
+                    {
+                        "task": prompt,
+                        "name": name.strip() if name else f"agent-{i}",
+                        "depends_on": item.get("depends_on", []),
+                    }
+                )
 
         from .bash import get_tracked_cwd
 
@@ -136,8 +184,41 @@ class AgentTool(Tool):
                 return result
             return f"[Sub-agent completed]\n{result}"
 
-        # pool.map returns in task order even when workers finish out of order.
-        with concurrent.futures.ThreadPoolExecutor(max_workers=min(4, len(work))) as pool:
-            results = list(pool.map(lambda item: self._run_one(item, cwd), work))
-        reports = [f"### {item['name']}\n{result}" for item, result in zip(work, results)]
+        try:
+            waves = self._dependency_waves(work)
+        except ValueError as e:
+            return f"Error: {e}"
+
+        results = {}
+        for wave in waves:
+            ready = []
+            for item in wave:
+                failed_dependency = next(
+                    (
+                        dependency
+                        for dependency in item["depends_on"]
+                        if results[dependency].startswith(("Sub-agent error:", "Sub-agent skipped:"))
+                    ),
+                    None,
+                )
+                if failed_dependency is not None:
+                    results[item["name"]] = f"Sub-agent skipped: dependency {failed_dependency!r} failed"
+                else:
+                    ready.append(item)
+            if not ready:
+                continue
+            with concurrent.futures.ThreadPoolExecutor(max_workers=min(4, len(ready))) as pool:
+                completed = list(
+                    pool.map(
+                        lambda item: self._run_one(
+                            item,
+                            cwd,
+                            {dependency: results[dependency] for dependency in item["depends_on"]},
+                        ),
+                        ready,
+                    )
+                )
+            results.update({item["name"]: result for item, result in zip(ready, completed)})
+
+        reports = [f"### {item['name']}\n{results[item['name']]}" for item in work]
         return f"[Sub-agent team: {len(work)} reports]\n\n" + "\n\n".join(reports)

{corecoder-0.9.0 → corecoder-0.10.0}/examples/multi_agent_demo.py

@@ -48,6 +48,22 @@ def run_demo() -> int:
         ]
     )
     print(result)
+    dependent = tool.execute(
+        tasks=[
+            {"name": "researcher", "task": "Find semantic risks in sorted(set(records))."},
+            {
+                "name": "implementer",
+                "task": "Propose an order-preserving deduplication using the research.",
+                "depends_on": ["researcher"],
+            },
+            {
+                "name": "reviewer",
+                "task": "Review the research and proposed fix for unhashable records.",
+                "depends_on": ["researcher", "implementer"],
+            },
+        ]
+    )
+    print("\n[Dependent pipeline]\n" + dependent)
     print(f"\nThree workers reported in {time.monotonic() - started:.2f}s (offline scripted findings).")
     return 0
 

{corecoder-0.9.0 → corecoder-0.10.0}/pyproject.toml

@@ -5,8 +5,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "corecoder"
-version = "0.9.0"
-description = "Minimal AI coding agent (2,908 lines of Python) inspired by Claude Code. Works with any LLM. (formerly NanoCoder)"
+version = "0.10.0"
+description = "Minimal AI coding agent (2,989 lines of Python) inspired by Claude Code. Works with any LLM. (formerly NanoCoder)"
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.10"

{corecoder-0.9.0 → corecoder-0.10.0}/tests/test_multi_agent.py

@@ -28,6 +28,8 @@ def test_multi_agent_schema_accepts_named_tasks():
     assert tasks["maxItems"] == 8
     assert tasks["items"]["required"] == ["task"]
     assert "name" in tasks["items"]["properties"]
+    assert tasks["items"]["properties"]["depends_on"]["type"] == "array"
+    assert tasks["items"]["properties"]["depends_on"]["items"] == {"type": "string"}
     assert schema["anyOf"] == [{"required": ["task"]}, {"required": ["tasks"]}]
 
 
@@ -38,6 +40,7 @@ def test_offline_multi_agent_demo(capsys):
     assert "### implementer" in output
     assert "### reviewer" in output
     assert "unhashable records" in output
+    assert "Dependent pipeline" in output
 
 
 def test_single_sub_agent_keeps_its_existing_contract(monkeypatch):
@@ -121,6 +124,89 @@ def test_multi_agent_failure_does_not_cancel_siblings(monkeypatch):
     assert "Sub-agent error: synthetic failure" in result
 
 
+def test_multi_agent_dependencies_share_results_in_dependency_order(monkeypatch):
+    _, tool, _ = parent_agent()
+    events = []
+    prompts = {}
+
+    def fake_chat(self, text, **kwargs):
+        role = text.split("\n", 1)[0].removeprefix("You are ").removesuffix(".")
+        prompts[role] = text
+        events.append(("start", role))
+        if role == "implementer":
+            assert ("end", "researcher") in events
+            assert "researcher report" in text
+        elif role == "reviewer":
+            assert ("end", "implementer") in events
+            assert "implementer report" in text
+        events.append(("end", role))
+        return f"{role} report"
+
+    monkeypatch.setattr(Agent, "chat", fake_chat)
+    result = tool.execute(
+        tasks=[
+            {"name": "reviewer", "task": "Review both outputs", "depends_on": ["implementer"]},
+            {"name": "implementer", "task": "Use the research", "depends_on": ["researcher"]},
+            {"name": "researcher", "task": "Inspect first"},
+        ]
+    )
+
+    assert events.index(("end", "researcher")) < events.index(("start", "implementer"))
+    assert events.index(("end", "implementer")) < events.index(("start", "reviewer"))
+    assert result.index("### reviewer") < result.index("### implementer") < result.index("### researcher")
+    assert "researcher report" in prompts["implementer"]
+    assert "implementer report" in prompts["reviewer"]
+
+
+def test_multi_agent_failed_dependency_skips_downstream_but_not_independent_work(monkeypatch):
+    _, tool, _ = parent_agent()
+    started = []
+
+    def fake_chat(self, text, **kwargs):
+        role = text.split("\n", 1)[0].removeprefix("You are ").removesuffix(".")
+        started.append(role)
+        if role == "researcher":
+            raise RuntimeError("research failed")
+        return f"{role} report"
+
+    monkeypatch.setattr(Agent, "chat", fake_chat)
+    result = tool.execute(
+        tasks=[
+            {"name": "researcher", "task": "fail"},
+            {"name": "implementer", "task": "must not start", "depends_on": ["researcher"]},
+            {"name": "reviewer", "task": "independent review"},
+        ]
+    )
+
+    assert started == ["researcher", "reviewer"]
+    assert "Sub-agent skipped: dependency 'researcher' failed" in result
+    assert "reviewer report" in result
+
+
+def test_multi_agent_rejects_invalid_dependencies_without_spawning(monkeypatch):
+    _, tool, _ = parent_agent()
+
+    def unexpected_chat(self, text, **kwargs):
+        raise AssertionError("invalid work must not spawn")
+
+    monkeypatch.setattr(Agent, "chat", unexpected_chat)
+    invalid_calls = [
+        {"tasks": [{"name": "same", "task": "one"}, {"name": "same", "task": "two"}]},
+        {"tasks": [{"name": "one", "task": "one", "depends_on": ["missing"]}]},
+        {"tasks": [{"name": "one", "task": "one", "depends_on": ["one"]}]},
+        {
+            "tasks": [
+                {"name": "one", "task": "one", "depends_on": ["two"]},
+                {"name": "two", "task": "two", "depends_on": ["one"]},
+            ]
+        },
+        {"tasks": [{"name": "one", "task": "one", "depends_on": "researcher"}]},
+        {"tasks": [{"name": "one", "task": "one", "depends_on": ["  "]}]},
+    ]
+    for kwargs in invalid_calls:
+        assert tool.execute(**kwargs).startswith("Error:")
+
+
 def test_multi_agent_rejects_ambiguous_or_unbounded_work(monkeypatch):
     _, tool, _ = parent_agent()