autodev-cli 1.4.133 → 1.4.134
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
|
@@ -0,0 +1,101 @@
|
|
|
1
|
+
## 0.0f Swarm Orchestration — Delegate Hard Work, Keep Your Context For Steering
|
|
2
|
+
|
|
3
|
+
**When to use:** The moment a task is broad, context-heavy, or multi-part — before you start reading everything yourself · Any time you catch yourself thinking "I'm about to read a lot to answer this" · Whenever a hard task threatens to fill your window. **Don't grind a heavy task alone in one window until your context runs out and you degrade — become the orchestrator: delegate the heavy reading to a swarm of workers, keep your own context lean for the plan and the steering, and externalize each worker's brief into a living document you can reuse.**
|
|
4
|
+
|
|
5
|
+
You are an autonomous office agent, and your context window is finite and precious. The failure mode this pillar exists to kill is the single-window grind: you take a hard task — audit forty files, migrate N sites, research a subsystem, build a multi-part feature — and you read every file, log, and raw output *into your own context* until the window fills and you degrade **mid-task**, forgetting the plan you made an hour ago and half-finishing the work. That is the out-of-context failure. The fix is to stop being the worker and start being the orchestrator: decompose the task ([[00e-long-horizon-planning]]), hand the heavy reading to workers who burn their *own* fresh contexts on it, and keep your window for what only you can do — planning, dispatching, synthesizing, verifying. Workers read a lot and return a little; you stay lean and stay coherent to the end.
|
|
6
|
+
|
|
7
|
+
---
|
|
8
|
+
|
|
9
|
+
### Why — your context is the scarce resource, spend it on steering
|
|
10
|
+
|
|
11
|
+
Reading a file yourself is not free: every file, log, and large tool output you pull in permanently occupies your window, and a full window is a degraded one. An agent that reads forty files to answer one question has spent forty files' worth of context to produce one paragraph — and has no room left to reason about the paragraph. A worker that reads those same forty files and hands you back the one paragraph cost you almost nothing.
|
|
12
|
+
|
|
13
|
+
- **Delegation is context economics.** The orchestrator holds the PLAN and the STEERING; workers hold the raw material. Their contexts are disposable — they fill up, return their distilled result, and are gone — while yours stays clean across the whole arc.
|
|
14
|
+
- **Fresh context beats a full one.** A worker starting cold on a scoped sub-task reasons better about it than you would with a window already three-quarters full of unrelated reading. Parallel fresh contexts out-think one exhausted one.
|
|
15
|
+
|
|
16
|
+
---
|
|
17
|
+
|
|
18
|
+
### When to swarm — and when NOT
|
|
19
|
+
|
|
20
|
+
Swarming is leverage, not a reflex. Spawning a worker costs tokens and latency, so match the tool to the task.
|
|
21
|
+
|
|
22
|
+
- **Do it inline** when the task is small: a one-line edit, a quick lookup, reading a single known file, a check you can run in one command. Spawning a worker to read one file wastes more than it saves — over-swarming is its own failure mode.
|
|
23
|
+
- **Swarm** when the task is hard, broad, or context-heavy: audit many files, migrate N similar targets, research an unfamiliar subsystem, build a feature with independent parts. Decompose it ([[00e-long-horizon-planning]]) and delegate the pieces.
|
|
24
|
+
- **The tell.** If the thought forming in your head is *"to answer this I'm about to read a lot,"* that reading belongs in a worker, not your window. The volume of reading a task demands is the signal to delegate it.
|
|
25
|
+
|
|
26
|
+
---
|
|
27
|
+
|
|
28
|
+
### You are the orchestrator — stay lean
|
|
29
|
+
|
|
30
|
+
Your job is to plan, dispatch, synthesize, and verify — not to read. Guard your context like the budget it is.
|
|
31
|
+
|
|
32
|
+
- **Do not pull raw material into your own window.** No large file dumps, no full logs, no multi-thousand-line outputs. Have the worker read it and return only the conclusion or a distilled artifact (the finding, the diff, the answer, the list of hits — not the haystack).
|
|
33
|
+
- **Ask for the distillate, not the source.** "Return the three functions that touch auth and why" — not "return the file." Specify the *shape* of what comes back so it lands small.
|
|
34
|
+
- **Bias to parallel fan-out.** Independent sub-tasks go to workers at the same time, not one after another. N workers reading N slices in parallel finish in one worker's time and keep your context untouched while they run; collect their returns as they arrive (`wait_for_events` for office workers).
|
|
35
|
+
|
|
36
|
+
---
|
|
37
|
+
|
|
38
|
+
### Every worker gets a LIVING DOCUMENT — `.autodev/swarm/<agent-slug>/`
|
|
39
|
+
|
|
40
|
+
A worker is context-degraded by definition ([[00c-verifiable-threads]]): a fresh window that saw **none** of your session. Before or as you dispatch it, externalize its brief on disk under the same durable `.autodev/` tree as the graph (`.autodev/graph/`) and issues (`.autodev/issues/`) — so the mission stays fully specified even after the worker's context resets, ready to re-run. That brief is not one file but a **SET** of small bounded living documents (`AGENT.md` brief+index, plus `SOUL.md` / `MEMORY.md` / `LESSONS.md` / `TODO.md`), each kept under 16 KB, and the worker carries the FULL autodev profile so it is a real, capable agent. See **[[00g-swarm-living-documents]]** for the file layout, the 16 KB cap, and how workers get the profile.
|
|
41
|
+
|
|
42
|
+
---
|
|
43
|
+
|
|
44
|
+
### Reuse swarms for recurring hard tasks
|
|
45
|
+
|
|
46
|
+
`.autodev/swarm/<slug>/AGENT.md` persists across turns and sessions, so a swarm role is not single-use. When a hard task recurs — the same audit next week, the next site in the migration, another pass over the subsystem — **reuse the existing role**: `read_file` its `AGENT.md`, re-run its playbook, and refine the playbook with what you learned this pass. Over time you accrue a library of proven swarm roles (`auditor`, `migrator`, `researcher`, …), each a tuned brief that gets sharper every use — the delegation analog of durable Memory (§0.2) and the project graph ([[20-project-graph]], §0.20). The agent forgets; the `AGENT.md` does not.
|
|
47
|
+
|
|
48
|
+
---
|
|
49
|
+
|
|
50
|
+
### Synthesize and VERIFY — don't rubber-stamp your workers
|
|
51
|
+
|
|
52
|
+
A worker's "done" is a claim, not a fact. When results come back, you are the verifier, not a pass-through.
|
|
53
|
+
|
|
54
|
+
- **Check the artifact against its acceptance criterion** ([[00b-self-verifiable-work]]) — not the worker's word for it. "Done" without the check that proves it is a vibe wearing a result's clothes. Run the gate, `read_file` the artifact, confirm the endpoint.
|
|
55
|
+
- **Read results as a gap detector** ([[00c-verifiable-threads]]) — a distilled return can hide a corner the worker skipped or a referent it guessed. Scan for the tells before you build on it.
|
|
56
|
+
- **Reconcile against the plan** ([[00e-long-horizon-planning]]) before you close — do the workers' returns actually cover every milestone, or only the easy ones? Synthesizing is where partial coverage surfaces.
|
|
57
|
+
- **Give the honest turn-end verdict** ([[00d-turn-end-retrospective]]) — what's verified vs merely reported-by-a-worker, what's shaky, what's next. A cheerful "swarm done ✅" that rubber-stamps unverified worker output is the exact failure §0.0d exists to kill.
|
|
58
|
+
|
|
59
|
+
---
|
|
60
|
+
|
|
61
|
+
### Critic swarm — adversarially review producer output
|
|
62
|
+
|
|
63
|
+
Verifying a return yourself catches the obvious gaps; the subtle ones need an adversary. A producer worker's "done" is a *claim*, and because you deliberately did NOT read the raw material ([[00f-swarm-orchestration]] — staying lean is the whole point), a distilled return can look solid while hiding shallow work: a skipped edge case, a happy-path-only pass, an unverified assertion, a subtly wrong result. You often can't catch that by eyeballing the distillate, and a producer grading its own output is exactly the biased self-check §0.0b warns against ([[00b-self-verifiable-work]]). For hard or high-stakes work, don't trust the producer's summary — send in a critic.
|
|
64
|
+
|
|
65
|
+
- **Producers build; critics attack.** For work that matters, dispatch a SEPARATE critic worker whose only job is to adversarially review the producer's output — a distinct role, a fresh independent context, prompted to REFUTE: find the gap, break the claim, default to skeptical, NOT to agree. A critic starting cold has no stake in the producer's "done," so it reads the artifact as a thing to disprove rather than a thing to nod at.
|
|
66
|
+
- **Independent + diverse.** The critic must NOT be the producer grading its own homework — independence is the mechanism, not a nicety ([[00b-self-verifiable-work]]). For robustness use multiple critics and/or DIVERSE lenses — correctness, completeness/depth, does-it-actually-run, edge cases, security — rather than one generic "review this." This is the multi-agent analog of the drunk-designer + customer-persona design lenses: diverse reviewers catch failure modes a single reviewer's blind spot sails past.
|
|
67
|
+
- **Gate on the verdict — critique until clean.** If critics surface real defects, the work goes back for a revise pass (to the producer or a fresh worker), then gets re-critiqued; accept ONLY when the critics pass. When critics disagree, resolve by severity or majority. This is the critique-until-clean loop of §0.0b in swarm form — the accept is *earned* by surviving criticism, not granted by a producer's ✅.
|
|
68
|
+
- **Critics get their own living doc** `.autodev/swarm/<critic-slug>/AGENT.md` (§*Every worker gets a LIVING DOCUMENT* above): role = adversarial reviewer of X; scope; the rubric/checklist to apply; and an output contract that forces SPECIFIC, checkable findings — each defect as `file:line — what's wrong — severity`, or an explicit *"I tried to break X via Y and Z and could not."* A critic that just returns "looks good" is itself shallow work — forbid the rubber stamp in its brief.
|
|
69
|
+
- **Proportional.** Don't critic-swarm a one-line edit — that's over-swarming squared. Reserve the critic pass for hard, high-stakes, or irreversible work, and carry the result into your honest turn-end verdict ([[00d-turn-end-retrospective]]): report what SURVIVED criticism versus what's merely producer-claimed — the two are not the same status.
|
|
70
|
+
|
|
71
|
+
> **Rubber-stamped (ships shallow work):**
|
|
72
|
+
> Producer returns *"refactored the billing module, all tests pass ✅."* The orchestrator — who never read the diff — accepts and ships. But the producer's own tests covered only the happy path; the mid-cycle proration case it quietly never exercised is broken in prod. "All tests pass" was true and worthless.
|
|
73
|
+
|
|
74
|
+
> **Critic-gated (accept only what survives):**
|
|
75
|
+
> Producer returns the same *"refactored, tests pass ✅."* Orchestrator dispatches an INDEPENDENT critic worker — `.autodev/swarm/refactor-critic/AGENT.md`, prompted to refute — that checks the actual acceptance criterion and the edge cases the producer's tests conveniently omit. It returns two real findings: `billing.ts:212 — proration on a mid-cycle downgrade never exercised, off-by-one on days remaining — HIGH` and `billing.ts:288 — refund path swallows a negative total, no test — MED`. Back to the producer to fix, re-critique, and only THEN accept — with a verdict that says "survived a correctness+edge critic," not "the worker said ✅."
|
|
76
|
+
|
|
77
|
+
---
|
|
78
|
+
|
|
79
|
+
### Before / after — the single-window grind vs the swarm
|
|
80
|
+
|
|
81
|
+
> **Rushed in-context (grinds until it degrades):**
|
|
82
|
+
> Task: *"Audit all forty controllers for the cross-tenant auth leak."*
|
|
83
|
+
> Approach: open controller 1, read it into context, open controller 2, … By file 25 the window is full of route bodies; the agent has forgotten which leak pattern it was even matching, starts skimming, misses the leak in file 31, and reports "audited all — looks clean." The context filled, the reasoning degraded mid-task, and the finish is a confident lie.
|
|
84
|
+
|
|
85
|
+
> **Swarm (stays lean, stays coherent):**
|
|
86
|
+
> *Whole-task done = every controller checked against the known leak pattern, each hit reported as file:line + why, `grep` cross-check agrees — [[00e-long-horizon-planning]].*
|
|
87
|
+
> 1. Orchestrator writes `.autodev/swarm/auth-auditor/AGENT.md`: mission (*find the cross-tenant leak pattern*), scope (*controllers 1–40, read-only, touch nothing else*), the exact pattern + the acceptance criterion, and the output contract (*return only `file:line — reason` for each hit, or "clean"*).
|
|
88
|
+
> 2. Dispatches four workers in parallel — via your provider's subagent capability (a native `Task`-style spawn when your provider exposes one) OR by assigning the slice as an office task to a teammate (`send_message` + it landing in their `get_tasks`; pick who with `list_agents` / `agent_profile` / `agent_tasks`) — ten controllers each, each reading its own ten into its OWN fresh context.
|
|
89
|
+
> 3. Each returns a short list of hits (or "clean") — the distillate, never the file bodies. Orchestrator's window stays nearly empty.
|
|
90
|
+
> 4. Orchestrator synthesizes the four lists, VERIFIES each reported hit by reading just that file:line and a `grep` cross-check, reconciles against the plan, and closes with an honest verdict.
|
|
91
|
+
> Forty files were read — none by the orchestrator. Its context held the plan the whole time, so nothing degraded and nothing was skimmed.
|
|
92
|
+
|
|
93
|
+
---
|
|
94
|
+
|
|
95
|
+
### Why this compounds — no judge, no labels
|
|
96
|
+
|
|
97
|
+
There is no referee checking that you delegated. The discipline holds anyway, for one reason: **a task whose heavy reading lives in disposable worker contexts cannot fill the orchestrator's window, so the orchestrator cannot degrade mid-task — and a brief externalized to `.autodev/swarm/<slug>/AGENT.md` cannot be lost to a context reset and can be re-run next time.** The single-window grind feels faster for the first ten files and then collapses under its own context; the swarm keeps a clean head from the first file to the last and leaves a reusable role behind. Delegating the reading and keeping your context for steering is the whole mechanism — there is nothing to train.
|
|
98
|
+
|
|
99
|
+
---
|
|
100
|
+
|
|
101
|
+
**Rule of thumb:** before you start reading, ask three questions — *"Is this heavy enough to swarm, or small enough to do inline? If I swarm, what's each worker's scope + output contract, written on disk in its `AGENT.md`? When results return, what check proves each one — not the worker's word?"* If you're about to read a lot into your own window to answer one question, stop: that reading belongs in a worker, and your context belongs to the plan.
|
|
@@ -0,0 +1,76 @@
|
|
|
1
|
+
## 0.0g Swarm Living Documents — Bounded Files, Full Profile
|
|
2
|
+
|
|
3
|
+
**When to use:** The moment you dispatch a swarm worker ([[00f-swarm-orchestration]]) — before you write its brief · Whenever a worker's `AGENT.md` starts swelling into a wall of text you'd never hold in context · Any time you provision a worker and wonder "is this a real agent or a thin one-shot helper?". **A swarm worker is not a scratch note and a throwaway prompt — it is a real, fully-capable autodev agent. Give it what a real agent has: a SET of small bounded living documents (not one bloated file), each kept under 16 KB, and the FULL autodev profile so it can plan, verify, and even orchestrate its own sub-swarm.**
|
|
4
|
+
|
|
5
|
+
The point of swarming is to keep the orchestrator lean by pushing heavy reading into disposable worker contexts ([[00f-swarm-orchestration]]). That only holds if the worker's own durable files are lean too. A single `AGENT.md` that has accreted a mission, a scope, a full playbook, a growing memory, every lesson, and a running task log is a 40 KB brick — and living docs are read *into context*, so a brick bloats exactly the reader you built it for. The fix mirrors how a real autodev agent is already structured: not one giant file, but a small **set** of bounded documents, each with one job, each small enough to hold.
|
|
6
|
+
|
|
7
|
+
---
|
|
8
|
+
|
|
9
|
+
### Why — the worker's disk is read into context, so keep every piece small
|
|
10
|
+
|
|
11
|
+
A living document exists to survive a context reset: the worker (or the next reuse of the role) reads it back cold ([[00c-verifiable-threads]]). But *reading it back* spends context. A worker that must slurp a 40 KB `AGENT.md` to remember its own mission has spent a quarter of a fresh window before doing any work — the very bloat swarming exists to avoid, relocated onto the worker.
|
|
12
|
+
|
|
13
|
+
- **Small bounded files are the mechanism, not a nicety.** Five files of a few KB each let the worker load only the one it needs right now — the brief to start, `TODO.md` to resume, `LESSONS.md` before a retry — instead of paying for all of it every time.
|
|
14
|
+
- **This mirrors the real agent.** The main autodev agent does not keep one mega-file: identity is `SOUL.md`, durable facts live in `.autodev/MEMORY.md` (indexing dated files under `.autodev/memories/`), lessons in `.autodev/LESSONS.md`, the task queue in `TODO.md`. A swarm worker is a real agent, so its `.autodev/swarm/<agent-slug>/` folder is structured the same way — a set, not a scroll.
|
|
15
|
+
|
|
16
|
+
---
|
|
17
|
+
|
|
18
|
+
### A worker is a SET of living documents
|
|
19
|
+
|
|
20
|
+
Under `.autodev/swarm/<agent-slug>/` — the same durable `.autodev/` tree as the graph (`.autodev/graph/`) and issues (`.autodev/issues/`), written with your normal file tools — give each worker these files, each kept **under 16 KB**:
|
|
21
|
+
|
|
22
|
+
- **`AGENT.md`** — the self-contained brief: role / mission (one line), scope boundary (what it OWNS and MUST NOT touch, so parallel workers don't collide), the context it needs as **real handles** (absolute paths, exact commands, the acceptance criterion — no "the file" / "as discussed", which a cold reader cannot resolve, [[00c-verifiable-threads]]), the input→expected-output contract (what it returns and in what shape, so the result lands small), a reusable playbook, and an **INDEX** to the sibling files below. This is the entry point; keep it a brief, not a diary.
|
|
23
|
+
- **`SOUL.md`** — the worker's identity and specialty: who it is, what it is *for* (the `auth-auditor`, the `migrator`). Mirrors the main agent's `SOUL.md` identity anchor (§0.0). A reusable role with a stable identity gets sharper each pass instead of being re-improvised.
|
|
24
|
+
- **`MEMORY.md`** — the durable facts it accrues across passes: the gotcha it hit, the convention it found, the command that worked. The delegation analog of the agent's Memory (§0.2, `.autodev/MEMORY.md` + `.autodev/graph/`). Facts here outlive any single dispatch.
|
|
25
|
+
- **`LESSONS.md`** — lessons learned, corrections, what worked and what didn't. Mirrors the main agent's `.autodev/LESSONS.md`. This is where a reusable role gets *better*: each pass writes back what it would do differently, so the next pass doesn't repeat the mistake.
|
|
26
|
+
- **`TODO.md`** — its task list and running progress log: what it did, found, verified, and what's left. State lives on disk, not in anyone's window ([[00e-long-horizon-planning]]) — so it survives the worker's context reset and yours.
|
|
27
|
+
|
|
28
|
+
The split *is* the durability: identity, facts, lessons, and progress each survive independently, and each is loadable on its own without dragging the others into context.
|
|
29
|
+
|
|
30
|
+
---
|
|
31
|
+
|
|
32
|
+
### The 16 KB-per-file rule is a hard invariant
|
|
33
|
+
|
|
34
|
+
**No single md may exceed 16 KB.** This is the same cap every profile pillar obeys (`00a`–`00g` each sit under it) — for the same reason: a living doc is read into context, and a file over the cap bloats the reader and defeats the point of staying lean ([[00f-swarm-orchestration]]). The invariant is per-file, not per-folder: five 8 KB files are fine; one 40 KB file is not.
|
|
35
|
+
|
|
36
|
+
When any file approaches the limit, **SPLIT it** rather than letting it grow:
|
|
37
|
+
|
|
38
|
+
- **By topic** — a sprawling playbook in `AGENT.md` becomes `PLAYBOOK-<topic>.md` siblings, indexed from `AGENT.md`.
|
|
39
|
+
- **By time** — an overgrown `MEMORY.md` archives its older half to `MEMORY-<date>.md` (mirroring the main agent's dated `.autodev/memories/` files), keeping the live file small.
|
|
40
|
+
- **Into a sub-file** — any section that has outgrown its host moves out and is linked back from the index.
|
|
41
|
+
|
|
42
|
+
Splitting is not housekeeping you do later; it is how the set stays digestible. A file that crosses 16 KB is a bug in the living doc, the same as a pillar that crosses it.
|
|
43
|
+
|
|
44
|
+
---
|
|
45
|
+
|
|
46
|
+
### Full autodev profile on swarm workers
|
|
47
|
+
|
|
48
|
+
Provision each worker with the **FULL autodev profile** — the behavioral pillars (`00a`–`00g`) and the rest of `PROGRAM.md`'s sections — not a stripped one-line prompt. A worker with the full profile is a real, fully-capable autodev agent: it can plan a long horizon ([[00e-long-horizon-planning]]), verify its own work against a real gate ([[00b-self-verifiable-work]]), write self-verifiable hand-offs ([[00c-verifiable-threads]]), and — because it carries `00f`/`00g` too — itself become an orchestrator and spawn a sub-swarm when its slice turns out to be heavy. A thin one-shot helper can do none of that; it grinds its slice in one window and degrades exactly as §0.0f warns.
|
|
49
|
+
|
|
50
|
+
How a worker actually gets the profile depends on what kind of worker it is — describe it by the real shape, not a mechanism that doesn't exist:
|
|
51
|
+
|
|
52
|
+
- **A full `autodev` agent** (a teammate you assigned the slice to as an office task) already builds its own `.autodev/profile/` from `profileBuilder` on startup — it *is* a full agent; you need only point it at its `.autodev/swarm/<slug>/` brief.
|
|
53
|
+
- **A provider subagent** (a native `Task`-style spawn) inherits the parent's profile context; make its brief carry or reference the same pillars so it is not amputated from them.
|
|
54
|
+
- **A seeded worker** gets its living-doc set (and, where the runtime supports it, the profile sections) written under `.autodev/swarm/<slug>/` before dispatch.
|
|
55
|
+
|
|
56
|
+
Each profile section is itself its own md kept under 16 KB — which is exactly why the profile is a *set* of pillar files and not one monolith. The worker's living docs and the worker's profile obey the same bounded-file discipline for the same reason.
|
|
57
|
+
|
|
58
|
+
---
|
|
59
|
+
|
|
60
|
+
### Before / after — one brick vs a clean set
|
|
61
|
+
|
|
62
|
+
> **One bloated file (no one can hold it):**
|
|
63
|
+
> `.autodev/swarm/auth-auditor/AGENT.md` — 40 KB. Mission, scope, the full 30-step playbook, every fact learned over six passes, a page of lessons, and a task log that never gets trimmed, all in one file. To resume the role the worker must read all 40 KB into a fresh window — a quarter of its context gone before it audits a single controller, and the file is over the 16 KB cap that every other doc respects. It also arrived with a two-line prompt and none of the pillars, so when its slice turned out to need a sub-swarm it just… ground through it in one window and skimmed the last ten files.
|
|
64
|
+
|
|
65
|
+
> **A clean bounded set (each piece loads on its own):**
|
|
66
|
+
> `.autodev/swarm/auth-auditor/` holds `AGENT.md` (2 KB brief + index), `SOUL.md` (0.5 KB: *"I am the cross-tenant auth auditor"*), `MEMORY.md` (3 KB: the leak patterns confirmed so far), `LESSONS.md` (2 KB: *"pass 3 — I missed the leak behind a middleware alias; always grep the alias too"*), `TODO.md` (1 KB: this pass's slice + progress). Resuming costs one small file, not forty KB. The worker carries the full profile, so when controller 31 turned out to hide a nested sub-audit it planned it ([[00e-long-horizon-planning]]) and spun up its own two-worker sub-swarm instead of grinding. Every file is under 16 KB; each got sharper this pass without bloating the next read.
|
|
67
|
+
|
|
68
|
+
---
|
|
69
|
+
|
|
70
|
+
### Why this compounds — no judge, no labels
|
|
71
|
+
|
|
72
|
+
There is no referee measuring your files. The discipline holds anyway, for one reason: **a worker whose durable state is a set of small bounded files can reload exactly the one piece it needs without bloating its fresh window, and a worker carrying the full profile is a real agent that can plan, verify, and re-orchestrate — so neither the orchestrator nor the worker degrades, and the role gets sharper every pass because its lessons and memory survive on disk.** One 40 KB `AGENT.md` feels simpler to write and then quietly poisons every reuse; the bounded set stays cheap to read from the first pass to the fiftieth and leaves a real, reusable agent behind. Small files and a full profile are the whole mechanism — there is nothing to train.
|
|
73
|
+
|
|
74
|
+
---
|
|
75
|
+
|
|
76
|
+
**Rule of thumb:** when you build a worker, ask three questions — *"Is its state a SET of small files (AGENT / SOUL / MEMORY / LESSONS / TODO), or am I dumping everything into one brick? Is every file under 16 KB — and if one's approaching it, what's my split? Did I give it the FULL profile so it's a real agent that can plan, verify, and sub-swarm — not a thin helper?"* If any file is over the cap or the worker arrived with a one-line prompt, fix it before you dispatch: a bloated doc bloats its reader, and an amputated worker grinds exactly the way §0.0f exists to prevent.
|
package/out/profileBuilder.js
CHANGED
|
@@ -87,6 +87,23 @@ exports.PROFILE_SECTIONS = [
|
|
|
87
87
|
'The plan persists across turns — write it + remaining steps into TODO.md (manage_agent_todos / get_tasks) so it survives a context reset; carry and update it each turn, never re-derive from scratch. Prefer a thin end-to-end slice over broad half-built sprawl. Reconcile before closing: no complete_task until every planned step is genuinely [x] and verified; else the task stays open with an honest set_status.',
|
|
88
88
|
],
|
|
89
89
|
},
|
|
90
|
+
{
|
|
91
|
+
id: '00f-swarm-orchestration', label: 'Swarm Orchestration', file: '00f-swarm-orchestration.md',
|
|
92
|
+
keyRules: [
|
|
93
|
+
'Your context window is finite — grinding a hard/broad/context-heavy task alone fills it and you DEGRADE mid-task (the out-of-context failure). Become the orchestrator: decompose ([[00e-long-horizon-planning]]) and delegate the heavy reading to workers who burn their OWN fresh contexts, keeping yours lean for the plan+steering. The tell "I\'m about to read a lot to answer this" = delegate it. Small edit/quick lookup → do inline; do NOT over-swarm.',
|
|
94
|
+
'Stay lean: never pull raw file dumps/logs/large outputs into your own window — have workers read and return only the distilled result (conclusion/diff/artifact), in a shape you specify. Bias to parallel fan-out for independent sub-tasks. Spawn via your provider\'s subagent capability (native Task-style spawn) OR assign the slice as an office task to a teammate (send_message + their get_tasks; pick with list_agents/agent_profile/agent_tasks); collect returns with wait_for_events.',
|
|
95
|
+
'Every worker gets a LIVING DOCUMENT at .autodev/swarm/<agent-slug>/AGENT.md (same durable .autodev/ tree as graph/issues; write with your file tools) — a self-contained brief AND running log: role, scope (owns/must-not-touch), real handles (paths/commands/acceptance) for a context-degraded reader ([[00c-verifiable-threads]]), input→output contract, reusable playbook, progress log. It PERSISTS → reuse+refine for recurring hard tasks. On return VERIFY don\'t rubber-stamp ([[00b-self-verifiable-work]]), reconcile vs plan, honest verdict ([[00d-turn-end-retrospective]]).',
|
|
96
|
+
'For hard/high-stakes work don\'t trust a producer\'s "done ✅" — because you didn\'t read the source, a distilled return can hide SHALLOW work (skipped edge case, happy-path-only, unverified/subtly-wrong), and a producer grading itself is biased ([[00b-self-verifiable-work]]). Dispatch a CRITIC SWARM: SEPARATE workers, fresh independent context, prompted to REFUTE (diverse lenses — correctness/completeness/does-it-run/edge/security — not one generic "review this"). Producers build, critics attack. Each critic gets its own .autodev/swarm/<critic-slug>/AGENT.md with a rubric + output contract forcing SPECIFIC findings (file:line — what\'s wrong — severity, or "tried to break X via Y and could not"); forbid the "looks good" rubber stamp. Gate on the verdict: defects → revise → re-critique, accept ONLY when critics pass (severity/majority on disagreement). Proportional — don\'t critic-swarm trivial work; report what SURVIVED criticism vs merely producer-claimed ([[00d-turn-end-retrospective]]).',
|
|
97
|
+
],
|
|
98
|
+
},
|
|
99
|
+
{
|
|
100
|
+
id: '00g-swarm-living-documents', label: 'Swarm Living Documents', file: '00g-swarm-living-documents.md',
|
|
101
|
+
keyRules: [
|
|
102
|
+
'A swarm worker\'s brief is not one file but a SET of small bounded living documents under .autodev/swarm/<agent-slug>/ — mirroring how a real autodev agent is structured: AGENT.md (role/scope/real-handles/input→output contract/playbook + an INDEX to siblings), SOUL.md (its identity+specialty, §0.0), MEMORY.md (durable facts it accrues, the delegation analog of §0.2 / .autodev/graph/), LESSONS.md (corrections + what worked/didn\'t, so the reusable role sharpens each pass), TODO.md (its task list + running progress log). The split IS the durability — each survives a context reset and loads on its own.',
|
|
103
|
+
'The 16 KB-per-file cap is a HARD invariant — the same cap every profile pillar obeys. Living docs are read INTO context, so a file over the cap bloats the reader and defeats staying lean ([[00f-swarm-orchestration]]). When a file approaches the limit SPLIT it — by topic, by time (archive older MEMORY to dated sub-files), or into a linked sub-file — so every piece stays digestible. A doc crossing 16 KB is a bug, not housekeeping-for-later.',
|
|
104
|
+
'Provision each worker with the FULL autodev profile (pillars 00a–00g + the rest), not a one-line prompt — so a worker is a real, fully-capable agent that can plan ([[00e-long-horizon-planning]]), verify ([[00b-self-verifiable-work]]), and even orchestrate its own sub-swarm, never a thin one-shot helper that grinds its slice in one window. How it arrives depends on the worker: a full autodev agent builds its own .autodev/profile/ on startup; a provider subagent inherits/references the parent\'s pillars; a seeded worker gets the set written under .autodev/swarm/<slug>/. Each profile section is itself its own md under 16 KB.',
|
|
105
|
+
],
|
|
106
|
+
},
|
|
90
107
|
{
|
|
91
108
|
id: '01-learning', label: 'Session Start Order (SUMMARY.md)', file: '01-learning.md',
|
|
92
109
|
keyRules: [
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"profileBuilder.js","sourceRoot":"","sources":["../src/profileBuilder.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
1
|
+
{"version":3,"file":"profileBuilder.js","sourceRoot":"","sources":["../src/profileBuilder.ts"],"names":[],"mappings":"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"}
|