Point Skywalker spawn targets at the build director

Author: TheGreatAxios

CHANGELOG.md

@@ -15,6 +15,11 @@ parallel copies under `docs/` or `scripts/notes/`. At cut time: rename
 
 ### Directors
 
+- **Skywalker spawn-target for product code is `build`.** Prompt and
+  skill copy that still said `spawn implement` / `task(agent="implement")`
+  now dispatch `build`. Intent graph `explore → implement → critique`
+  and slash `/implement` are unchanged.
+
 - **Skywalker may DIY tiny product writes (CL-6629).** Path tools
   (`write_file` / `edit_file` / `delete_file`) remount on the primary
   session. Tiny/single-file/one-route bounded edits are the exception;

plugins/corbits-skills/skills/dispatch/SKILL.md

@@ -2,18 +2,18 @@
 name: dispatch
 user-invocable: false
 argument-hint: "[<name> | dispatch/<name>/ | dispatch/<name>/dispatch.yaml | <spec-file> ]"
-description: Multi-lane DAG orchestration. Skywalker recipe — use_skill("dispatch"). Spawns explore, intern, implement, plan, and critique. DAG product tasks go through implement; Skywalker may DIY tiny edits outside the DAG.
+description: Multi-lane DAG orchestration. Skywalker recipe — use_skill("dispatch"). Spawns explore, intern, build, plan, and critique. DAG product tasks go through build; Skywalker may DIY tiny edits outside the DAG.
 ---
 
 # Dispatch
 
-You are Skywalker. This skill is loadable with `use_skill("dispatch")`. Follow this recipe. DAG product tasks go through implement workers. Do not write `dispatch.yaml` or `plan.md` yourself (intern cannot write; implement writes manifests). Tiny / single-file / one-route product edits outside this DAG may be DIY with write_file/edit_file/delete_file.
+You are Skywalker. This skill is loadable with `use_skill("dispatch")`. Follow this recipe. DAG product tasks go through build workers. Do not write `dispatch.yaml` or `plan.md` yourself (intern cannot write; build writes manifests). Tiny / single-file / one-route product edits outside this DAG may be DIY with write_file/edit_file/delete_file.
 
 Orchestrate parallel director runs across a dependency graph. Fan out work, fan in reports, critique, verify, re-dispatch fixes, and synthesize until done.
 
 Hard cap: **at most 4 workers at once** unless the operator explicitly asks for a wider fan-out. Track progress with `manage_tasks`.
 
-Closed directors used here: `explore`, `intern`, `implement`, `plan`, `critique`. Optional consults: `greybeard`, `tester`. Never a catch-all worker. DAG node agents are `explore`, `intern`, and `implement` only.
+Closed directors used here: `explore`, `intern`, `build`, `plan`, `critique`. Optional consults: `greybeard`, `tester`. Never a catch-all worker. DAG node agents are `explore`, `intern`, and `build` only.
 
 ## Input resolution
 
@@ -33,13 +33,13 @@ If the spec is vague, incomplete, or contradictory: stop and report Blockers. Do
 |---|---|
 | Map the codebase, gather facts | `task(agent="explore")` |
 | Eng plan from a spec (no ship) | `task(agent="plan")` |
-| Write `dispatch.yaml` / `plan.md` / status artifacts (mechanical brief; no product feature work) | `task(agent="implement")` |
-| Ship product code + tests | `task(agent="implement")` |
+| Write `dispatch.yaml` / `plan.md` / status artifacts (mechanical brief; no product feature work) | `task(agent="build")` |
+| Ship product code + tests | `task(agent="build")` |
 | Review a landed task (defects, evidence, no fix) | `task(agent="critique")` |
 | Architecture judgment before a large DAG | `task(agent="greybeard")` |
 | Independent suite / repro evidence | `task(agent="tester")` |
 
-Skywalker classifies, spawns, tracks, and synthesizes. Path tools (`write_file` / `edit_file` / `delete_file`) are mounted for DIY tiny/bounded product edits; spawn remains the default for DAG product work. Durable orchestration artifacts (`dispatch.yaml`, `plan.md`, status) still go through implement — intern does not have write tools (`INTERN_TOOLS` = run_shell, read_file, list_dir). Do not spawn a blob agent to author the manifest. Do not write those manifests on Skywalker.
+Skywalker classifies, spawns, tracks, and synthesizes. Path tools (`write_file` / `edit_file` / `delete_file`) are mounted for DIY tiny/bounded product edits; spawn remains the default for DAG product work. Durable orchestration artifacts (`dispatch.yaml`, `plan.md`, status) still go through build — intern does not have write tools (`INTERN_TOOLS` = run_shell, read_file, list_dir). Do not spawn a blob agent to author the manifest. Do not write those manifests on Skywalker.
 
 Prefer typed briefs: `intent`, `success_criteria`, `do_not`, `report_focus`, and `agent`.
 
@@ -49,9 +49,9 @@ Use **explore** when the task is pure research. No code changes. Output is findi
 
 Use **intern** when the work is mechanical and well-specified: git commit after a level fans in, exact shell, mechanical git. Intern cannot write files.
 
-Use **implement** when the task ships product code — including work that needs judgment, new abstractions, or tests — and for mechanical writes of `dispatch.yaml` / `plan.md` / status artifacts (write tools; intern does not have them). There is no catch-all implementation agent.
+Use **build** when the task ships product code — including work that needs judgment, new abstractions, or tests — and for mechanical writes of `dispatch.yaml` / `plan.md` / status artifacts (write tools; intern does not have them). There is no catch-all implementation agent.
 
-Critique is not a DAG node agent type. After implement (and after non-trivial intern landings), spawn `task(agent="critique")` with the task's objective, paths, and diff. Simple intern tasks may skip critique.
+Critique is not a DAG node agent type. After build (and after non-trivial intern landings), spawn `task(agent="critique")` with the task's objective, paths, and diff. Simple intern tasks may skip critique.
 
 Classify each product task as `feature` or `bugfix`:
 
@@ -61,25 +61,25 @@ Classify each product task as `feature` or `bugfix`:
 
 ## Phase 1: Planning
 
-Runs when the input is a spec (or a request with no existing manifest). The spec should be complete enough that an implement worker could succeed from it.
+Runs when the input is a spec (or a request with no existing manifest). The spec should be complete enough that a build worker could succeed from it.
 
 1. If the spec still needs an ordered eng plan, spawn `task(agent="plan")`. Do not skip this when requirements are large or ambiguous.
 2. Spawn `explore` workers only as needed to map scope. Distinct path/package lenses if parallel.
 3. Consult `greybeard` before large multi-lane work when architecture is in play.
 4. Break the goal into discrete tasks, each small enough for one director.
 5. Identify dependencies (DAG edges). Same-file writers at the same level must be merged or serialized via `depends-on`.
-6. Assign `explore` | `intern` | `implement` per the guide above.
+6. Assign `explore` | `intern` | `build` per the guide above.
 7. Detect verify commands from `package.json`, Makefile, or project docs.
 8. Add per-task verification to each plan (build for compiled changes, tests for test-writing tasks).
 9. Default commit strategy is **per-task** (debuggable). Use grouped only when the operator wants a cleaner history **and** Phase 5 will catch issues.
-10. Mark which tasks need critique (complex implement → yes; simple intern → no; when unsure, yes).
+10. Mark which tasks need critique (complex build → yes; simple intern → no; when unsure, yes).
 11. Seed `manage_tasks` with one item per DAG task (plus plan / verify / critique items as needed).
 
-If requirements are not actionable, stop. Ask: "Can an implement worker succeed with only this information?"
+If requirements are not actionable, stop. Ask: "Can a build worker succeed with only this information?"
 
 ## Phase 2: Directory structure
 
-Have **implement** write the run tree (mechanical brief; no product feature work). Do not write these files on Skywalker. Do not use intern — intern cannot write files. Do not use a catch-all worker.
+Have **build** write the run tree (mechanical brief; no product feature work). Do not write these files on Skywalker. Do not use intern — intern cannot write files. Do not use a catch-all worker.
 
 ```
 dispatch/
@@ -125,7 +125,7 @@ commits:
 tasks:
   - id: 1a-extract_auth_module
     type: feature               # feature | bugfix (omit for explore)
-    agent: implement            # implement | intern | explore
+    agent: build            # build | intern | explore
     depends-on: []
     receives: []                # subset of depends-on; default = depends-on
     status: pending             # pending | dispatched | completed | failed | fixing
@@ -134,7 +134,7 @@ tasks:
 
   - id: 2a-integrate_modules
     type: feature
-    agent: implement
+    agent: build
     depends-on: [1a-extract_auth_module, 1b-extract_logging_module]
     status: pending
 ```
@@ -143,7 +143,7 @@ Task statuses: `pending` → `dispatched` → `completed` | `failed` | `fixing`.
 
 ### Task `plan.md`
 
-Implement writes one per task (mechanical brief). Include: objective, requirements covered, context (paths and symbols — no line numbers, no dispatch-dir cross-refs), files to modify, constraints, verification (test-first for bugfix), and `do_not`.
+Build writes one per task (mechanical brief). Include: objective, requirements covered, context (paths and symbols — no line numbers, no dispatch-dir cross-refs), files to modify, constraints, verification (test-first for bugfix), and `do_not`.
 
 Every product-task brief must tell the worker:
 
@@ -165,16 +165,16 @@ Before any product spawn:
 
 Empty task list → mark the run `completed` and report. Do not invent work.
 
-Present the DAG (ids, agents, deps, critique flags, verify commands, commit strategy) to the operator. Wait for go-ahead on large or ambiguous runs. Then set status `in-progress` (implement updates the manifest if it is on disk).
+Present the DAG (ids, agents, deps, critique flags, verify commands, commit strategy) to the operator. Wait for go-ahead on large or ambiguous runs. Then set status `in-progress` (build updates the manifest if it is on disk).
 
 ## Phase 4: Execute the DAG
 
 1. **Ready set:** `pending` tasks whose `depends-on` are all `completed`.
 2. **Batch:** take a safe parallel subset, **at most 4 live workers** (including in-flight critique). Same-file writers and shared mutable state (build artifacts, test DBs) must not share a batch — serialize with `depends-on`.
-3. **Spawn** each task with `task(agent="<id from manifest>")`. Inject upstream reports (not a rewritten `plan.md`) into the brief. Split ownership by path/package when two implement workers run together.
-4. **Fan in:** trust the worker report (and `output.yaml` when implement wrote one). Missing report or `status: failed` → mark `failed`. Do not re-fan-out an identical brief; change `success_criteria` / `do_not` or tell the operator.
+3. **Spawn** each task with `task(agent="<id from manifest>")`. Inject upstream reports (not a rewritten `plan.md`) into the brief. Split ownership by path/package when two build workers run together.
+4. **Fan in:** trust the worker report (and `output.yaml` when build wrote one). Missing report or `status: failed` → mark `failed`. Do not re-fan-out an identical brief; change `success_criteria` / `do_not` or tell the operator.
 5. **Level commit:** after a level's product tasks self-report complete, intern commits per the strategy (per-task default). Workers must not have committed.
-6. **Critique:** for tasks with `critique.enabled`, spawn `task(agent="critique")` on that commit/diff + objective. Blocking findings → re-dispatch `implement` with those findings in `success_criteria` / `do_not` (status `fixing`). Cap re-fix rounds (1–2), then report Blockers.
+6. **Critique:** for tasks with `critique.enabled`, spawn `task(agent="critique")` on that commit/diff + objective. Blocking findings → re-dispatch `build` with those findings in `success_criteria` / `do_not` (status `fixing`). Cap re-fix rounds (1–2), then report Blockers.
 7. Repeat until no pending tasks remain, or deadlock / all remaining failed → stop and ask.
 
 Keep `manage_tasks` in sync as items move `todo` → `doing` → `done` / stay blocked.
@@ -186,7 +186,7 @@ If the working tree has unrelated uncommitted changes before Phase 4, ask the op
 Must `task(agent="tester")` for the suite (or intern for one named mechanical command). Do not run the full verify pipeline on the parent via Skywalker `run_shell`. Compare against any baseline you captured.
 
 - Green, or same failures as baseline → proceed.
-- New failures → attribute to a task/commit, re-dispatch `implement` on that lane, re-verify. Cap rounds, then Blockers.
+- New failures → attribute to a task/commit, re-dispatch `build` on that lane, re-verify. Cap rounds, then Blockers.
 - Do not declare done on a worker "ready" that ignored blocking critique or verify.
 
 ## Phase 6: Complete
@@ -206,8 +206,8 @@ Re-resolve input to the existing `dispatch/<name>/`. Re-validate the remaining D
 
 ## Non-negotiables
 
-- You are Skywalker. Spawn directors. Do not implement product features. Do not author dispatch YAML/plan files yourself or via a catch-all worker. Durable orchestration files go through implement.
+- You are Skywalker. Spawn directors. Do not implement product features. Do not author dispatch YAML/plan files yourself or via a catch-all worker. Durable orchestration files go through build.
 - `use_skill("dispatch")` loads this recipe. It is a command.
-- Agents: `explore`, `intern`, `implement` only for DAG nodes. Critique via `task(agent="critique")`. Plan via `task(agent="plan")` when a spec needs an eng plan first.
+- Agents: `explore`, `intern`, `build` only for DAG nodes. Critique via `task(agent="critique")`. Plan via `task(agent="plan")` when a spec needs an eng plan first.
 - Progress: `manage_tasks`.
 - At most 4 workers at once unless the operator asks for more.

plugins/corbits-skills/skills/implement/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: implement
-description: Disciplined per-commit workflow — Skywalker spawns greybeard, implement, intern/tester, critique.
+description: Disciplined per-commit workflow — Skywalker spawns greybeard, build, intern/tester, critique.
 ---
 
 # Implement
@@ -26,7 +26,7 @@ Track commit-sized units with `manage_tasks`. One item per unit that will become
 
 ## Per-commit spawn loop
 
-For each unit, run these steps in order. Do not skip. When this loop is running, do not DIY the unit — spawn implement.
+For each unit, run these steps in order. Do not skip. When this loop is running, do not DIY the unit — spawn build.
 
 ### 1. Review — greybeard
 
@@ -38,18 +38,18 @@ Send:
 - Design decisions and trade-offs
 - Uncertainties
 
-Adjust the plan from the report, then spawn implement. Greybeard is for approach, not execution.
+Adjust the plan from the report, then spawn build. Greybeard is for approach, not execution.
 
 ### 2. Implement
 
-`task(agent="implement")` with a typed brief:
+`task(agent="build")` with a typed brief:
 
 - `intent`
 - `success_criteria`
 - `do_not`
 - `report_focus`
 
-**Bug fixes:** tell implement to start from a failing test — write the repro, confirm it fails, then fix, then confirm it passes. If the test does not fail first, the bug is not understood.
+**Bug fixes:** tell build to start from a failing test — write the repro, confirm it fails, then fix, then confirm it passes. If the test does not fail first, the bug is not understood.
 
 **Features:** tests ship with the change. The test asserts the new behavior, not merely that the process did not crash.
 
@@ -62,20 +62,20 @@ Keep scope to this unit. Additional work becomes a later `manage_tasks` item, no
 - `intern` — mechanical full pipeline
 - `tester` — suite / repro
 
-Do not move forward with a broken build. If failures come from this unit, re-dispatch implement. If they are pre-existing and unrelated, report Blockers and stop. Do not substitute a partial compile for the full gate.
+Do not move forward with a broken build. If failures come from this unit, re-dispatch build. If they are pre-existing and unrelated, report Blockers and stop. Do not substitute a partial compile for the full gate.
 
 ### 4. Critique
 
 `task(agent="critique")` on the diff. Include the intent agreed with greybeard so critique evaluates plan vs execution, not only surface quality. Limit findings to this unit; pre-existing issues in touched files are out of scope unless they block the gate.
 
-If critique is **blocking**, re-dispatch implement once or twice with those findings in `success_criteria` / `do_not`, then re-run the build gate and critique. After two re-fix rounds, report Blockers — do not loop forever.
+If critique is **blocking**, re-dispatch build once or twice with those findings in `success_criteria` / `do_not`, then re-run the build gate and critique. After two re-fix rounds, report Blockers — do not loop forever.
 
 When critique is clean (or remaining findings are acknowledged judgment calls), mark the unit done and start the next.
 
 ## Hard rules
 
 - Tiny / single-file / one-route / clear bounded edits: DIY with write_file/edit_file/delete_file. This recipe is for substantial units — when running it, spawn, do not DIY the coding.
-- Spawn with `task(agent="greybeard")`, `task(agent="implement")`, `task(agent="intern")` or `task(agent="tester")`, and `task(agent="critique")`.
+- Spawn with `task(agent="greybeard")`, `task(agent="build")`, `task(agent="intern")` or `task(agent="tester")`, and `task(agent="critique")`.
 - Track only with `manage_tasks`.
 - Do not shortcut the loop. Skipping greybeard “because this is simple” or skipping critique “because the build passed” defeats the recipe.
 - Build must pass before treating a unit as done.