Project Implementer - execute a verified plan, task by task, in one chat
This is the build step of the single-session vertical: task-design produced the plan, task-verify-plan audited it, this executes it - one task at a time, in the plan's dependency order, in your context so every diff is inspectable as it lands. It carries the implementer seat's execution protocol only; the coding conventions themselves need no restating - the path-scoped rules auto-attach the house skill per file type, the preferences docs the alfred-preferences.md rule names - the project's actual style among them - are read before the first edit, and the plan's task cards name the stack traps.
The measurements behind these rules live in references/evidence.md - an audit appendix, not a run-time load.
The plan FILE is the whole input - not the chat that produced it. In a long build carried conversation, not the tools, is the dominant token cost, so a fresh session (or /clear between tasks) keeps the context at plan size - offer one where a hook's fresh-session text says it pays back with the cache warm; the per-task ticks below make any task boundary a safe resume point.
When to use
- You have a task plan and want to build it in this chat: it honors each task's contract, writes code + tests, gates each task green before the next, then hands to the build review.
- Not for a plan-less ad-hoc edit, or the whole gated cycle from design to done (/task-solve).
Modes. Mode flags right after the command - --mode-auto-run-on, --mode-auto-run-off, --mode-output-scorer-on, --mode-output-scorer-off - are switches, not the request: strip them; with only flags typed, run as with no arguments. Under the hook's auto-run contract, follow it. With no hook line (hooks off, Cursor), -on holds for this run only: each stop takes its (Recommended) option, listed in the close, an unmarked one waits, nothing goes outward, no fresh-session hand-off, and the close says auto-run ended; --mode-output-scorer-on grades this run's output like a typed stack. A typed 'no stops' or 'run it without asking me' is no waiver in this flow: say in one line that --mode-auto-run-on right after the command turns auto-run on, and never hand-write an AUTO line.
Build mode - this chat or the implementer seats
Pick the mode. When the invocation names no mode and no calling flow has already recorded one (task-solve's mode <session|agents> approval line, an orchestrator's brief), ask ONE question before building and hold the answer; a mode the run already picked is inherited, never re-asked. The mark sits on the mode the habits-execution-strategy verdict picks (parallel seats moves it to the seats, listed first):
Build here or through the implementer seats? <the verdict's reason>
- 'In this chat (Recommended)' - <why it fits one chat>
- 'Dispatch the implementer seats' - <the tasks that run in parallel>
Build. In-chat: build in this chat, the protocol below. On an agents answer: dispatch each task to its <stack>-implementer seat instead, exactly as the roster spells it (alfred-code:<seat> where the core plugin carries it) - up to ALFRED_CODE_MAXIMUM_RUN_AGENTS at once (default 5), each on its frontmatter model unless you name one.
Stamp the approval before the first dispatch. <data root>/state/approvals/<plan id>/APPROVAL (<plan id> is the plan file's name without .md), first line APPROVED <plan id> - "<the user's words, verbatim>" on their explicit approval (under auto-run the hook's AUTO stamp already stands - leave it); the dispatch hook blocks an unstamped implementer; delete the file when the run completes. A question the idle timeout closed is no answer: its result opens 'No response after' and says the user may be away from keyboard, even when it carries an option already selected - write no APPROVED or AUTO line from it; re-ask, or stop and say what waits. Write the stamp at the ABSOLUTE path <project root>/<data root>/state/approvals/<plan id>/APPROVAL with the Write tool, and give every implementer brief the line plan: <plan id> - the dispatch hook passes a brief only on its own plan's stamp. A relative write follows whatever cwd the shell drifted to and the dispatch then bounces. The stamp belongs to the session that dispatches - written when its own decision lands, deleted at its own close; an earlier session's leftover stamp is not consent.
If the stamp is refused, ask - never dispatch around it. If BOTH the Write tool and an absolute-path Bash write are refused by the harness's classifier, stop and ask rather than retrying blind or dispatching around the gate:
Both write routes refused the approval stamp: <the refusal>.
- 'Retry the stamp (Recommended)' - allow the write at the prompt
- 'Run the tasks inline' - no dispatch, no stamp
Stay the only orchestrator. Keep the main session the only orchestrator, routing a red per the repair-agent rules, and ticking the plan file as reports land - and each seat's gate is build + fast tests only, never a minutes-long run like integration replays or an E2E pass; the full suite stays with this session's finish step. Dispatch nothing you were not asked to.
No plan approval line, one ask before task 1. The approval is the calling flow's too - and a plan file that carries no Approved: line when this skill is invoked on its own gets ONE approval ask before task 1, its answer written to the plan as Approved: <date> - "<the user's words, verbatim>":
<plan file> carries no Approved: line. Build it?
- 'Approve - build task 1 (Recommended)' - stamped as Approved:
- 'Changes needed' - I ask what to change next, in plain text
The protocol - per task, in plan order
Before reading the plan, load habits-plan-writing (the Skill tool) - the card fields and status marks below are its shape - and habits-test-first, the loop every card's test: runs on.
Take exactly one task. Its card is the contract: the files it owns, the traps it names, the file:symbol anchors, the test: it writes first, and its acceptance criterion. When the plan lives in a file (it should - task-design writes it to <docs-path>/work/plans/), mark the task IN_PROGRESS there before touching code. Jump to the anchors - the designer already located them; do not re-navigate the repo.
Build the slice + its tests together. The acceptance criterion is what the tests prove; a task without its test is not built, it is drafted. The card's test: comes first, by habits-test-first - its red, a run that failed on the assertion the criterion names, is the only red that counts. The card's log_points go in with the slice, through the repo's logging seam at the level and with the identifiers the card names - never left for a later pass, never a second logger. Every line meets 'The bar I build to' - structure, quality, naming, comments - and every judgment call lands with its precedent. Stay inside the task's boundary - a needed change outside it is a flag, not a detour (see below).
Gate the task green. Build + the relevant tests after each task, not at the end of the plan - the plan header's Build: command set where it has one, scoped to the touched projects and never a subset of it: a gate that drops the build passes what only the build catches (a template binding error, a missing provider). Resolve every red INLINE in this session - keep the fix loop here, quoting each build/test run so every attempt stays inspectable; the in-chat build dispatches nothing. The loop is bounded the way the resolver seats' is: after the FIFTH red run of one task's gate the next act is ONE ask, never a sixth run - the mark on 'Keep fixing inline' when the last red run changed, else on the resolver seat (or 'Stop' where the project installed none), listed first. Load the stack's convention skills for the trap list when the red points at one.
<task> is red after 5 runs: <the last error>.
- 'Keep fixing inline (Recommended)' - <what the last run changed>
- 'Hand it to a resolver seat' - <the seat>
- 'Stop' - the task stays red in the plan
Close the task honestly - the per-task completion gate is habits-done-gate's rule, carried here so no load stands between it and the tick: run the acceptance command after the last edit and quote its output before any done word. Run it, then tick the task DONE with its evidence line - the acceptance command's own quoted output - in the plan file, append the task's judgment calls to the plan's ## Decisions ledger (choice + precedent, per the bar), and refresh the plan's one-line resume note (next task + any mid-task state). The file, not the chat, is what a compacted or fresh session resumes from - it must never be more than one task stale. Then the next task. Partial is stated as partial. A task whose acceptance criterion is a RUN that has not happened yet - an integration pass, a manual try, a suite the gate deferred - stays IN_PROGRESS with a needs: <the run> line; 'code complete, builds' is not DONE. A task stamped FAILED ends the turn with ONE ask before any further run or edit - a 'reported to the user' line in the plan with no ask behind it is the measured failure:
<task> FAILED: <why>.
- 'Stop and report (Recommended)' - the plan records it
- 'Continue inline' - <the next attempt>
- 'Resolver seat' - <the seat>
- 'Revert' - back to the task's start
The bar I build to
The review-and-fix loop's five stages - structure, code quality, naming, logging, comments - are the bar the built slice meets on the FIRST pass, so a later loop over this code finds nothing. Hold each as you write, not as a pass afterwards. references/build-bar.md carries the five rung by rung - Read it before the first task of a plan, and again at any task whose card names a stage this run has not applied yet:
- Structure - a new file lands where the repo's best-organized module puts that kind of file, in the folder the task card names; never a dump folder, never a folder for one file.
- Code quality - the seven decision-level rules the plan settled apply to every line you add, and the line-level list in the reference applies with them.
- Naming - the repo's own vocabulary and casing for every identifier, one name per concept; no
data / info / manager / helper where a specific word exists.
- Logging - the card's
log_points, per the build step that places them: through the repo's seam, at the card's level with the card's identifiers, nothing beyond them.
- Comments - the always-on quality-gates rule's comments line, made concrete at write time. A checkable claim in a comment (a symbol, a count, an invariant) is true against the code you wrote; an existing comment your edit made stale is fixed in the same edit.
A model change never leaves its task without its migration - generated by the tool, or hand-written when the tool cannot run here. A schema model with no migration fails every integration test at boot (the .NET example: EF Core's PendingModelChangesWarning).
The user's preferences first. Build to the preferences docs alfred-preferences.md names - PERSONAL-CODE-, ARCHITECTURE-, GIT- and PROJECT-CODE-, the personal and architecture docs above the project one - ahead of the house conventions. Where an entry and a skill or another instruction disagree, ask the user which wins, the entry's side marked (Recommended) - a seat builds the entry's side and names the clash on decisions:. A task that cannot meet one stops and asks, naming the id - a seat returns NEEDS_CONTEXT - since a waiver is the user's Except: line, never the build's.
Decisions. A judgment call the card left open - two idiomatic shapes, a placement, a name at a seam - is decided here, never bounced back: pick the option most consistent with the codebase's existing patterns and record it as the choice - precedent: <file:symbol or named rule>, or no precedent - <reason> said explicitly and still decided. In-chat, append it to the plan file's ## Decisions ledger; a dispatched seat reports it as decisions: lines for the orchestrator to fold in, never editing the shared plan file itself (siblings build in parallel). A bounce (an in-chat ask, a seat's NEEDS_CONTEXT) is for a user-level requirement or scope beyond the card, never for a how-to-build call.
Reuse before recreation. Before new code, stop at the first rung that holds: the app's own seam for the capability; the stdlib, runtime or framework already does it; an existing helper in this repo or an already-referenced package does it (search first - a second copy is a defect, consolidate to the existing seam); it is one line; only then the minimum code that works. Less code that still works - never the flimsier algorithm, never at the cost of validation at a trust boundary, error handling that prevents data loss, or secret handling.
The seam rung: any capability the project wraps - such as the clock, the file system, logging, settings, a process or the network - goes through the abstraction the touched class or the project already routes it through; search them first.
- A member the project's own interface lacks is added to it, its implementation and a test - never inlined as the raw call.
- When that interface sits outside the task's files, stop and name the member as a contract change (a seat's
BLOCKED_CONTRACT_CHANGE).
- A framework seam the project chose, such as
ILogger<T> or TimeProvider, is used through its members or an extension over it, never a new wrapper.
Callers first on a bug fix. Before changing a function to fix a bug, list its callers (the navigation tools' references) and fix once where they all route through - a guard on only the reported path leaves every sibling caller broken, and one guard in the shared function is also the smaller diff.
When the plan meets reality
A task proves wrong mid-build (the seam isn't where the plan said, a trap the audit missed): stop the task and name the delta - never silently redesign while implementing. The re-entry is the USER's call on the FIRST occurrence, not a counter you spend: end the turn with ONE ask (plain-text options where the harness lacks the tool) and re-enter only on that answer. The plan is the contract; reality wins, but through a revision, not a drift.
<task> proves wrong: <the delta>.
- 'Re-design this slice with task-design (Recommended)' - <the delta, named>
- 'Continue against the delta' - <what changes>
- 'Stop the build here' - the plan records where
A tool the environment blocks (a generator hanging on denied egress, a command the sandbox refuses): the task still finishes in this session - take the in-session route before any ask. The .NET example, an EF Core migration: dotnet ef migrations add <Name> with --project AND --startup-project both set to the project holding the design-time DbContext factory - the tools take that factory first and boot no host; failing that, hand-write the migration and its model-snapshot change from the nearest prior migration. Only a task with no in-session route becomes a blocker ask, and that ask recommends the route - never 'retry the same command' or 'you run it'.
Scope beyond the plan (a bug discovered nearby, a refactor itch): flag it and ask (plain-text options where the harness lacks the tool). Never rides along. A bug reported AFTER a cycle stamped COMPLETE or outside any active cycle takes the second ask:
Out of plan: <the item>.
- 'Leave it for later (Recommended)' - named in the report
- 'Add it to the plan' - a revision, then build
<the bug>, reported outside an active cycle.
- 'Defer (Recommended)' - named in the report
- 'Fix now, ad hoc' - <the fix>
- 'Open a new cycle' - a new plan file
A shared contract surfaces (a DTO both sides compile against, a schema semantic): stop the task and put it through ONE ask - the same BLOCKED_CONTRACT_CHANGE discipline the dispatched seats follow:
<task> touches a shared contract: <the DTO or schema>.
- 'Hand it to the cross-domain flow (Recommended)' - you run `/task-solve-cross`; this build stops here
- 'Keep it in this plan as a scoped change' - <the scope>
- 'Stop the build' - the plan records where
Don't game it
The acceptance criterion is satisfied by behavior, never by weakening the test that checks it. A green gate means the commands ran and their output says green - quoted, not assumed. Never suppress a warning, stub a path, or narrow a test to advance to the next task; a task that cannot go green honestly goes back to design as a named delta.
Finish - the in-session verifier
Known ceilings. File every deliberate simplification this build made as a where | limit | revisit when row - never a code comment - before the close: Read references/known-ceilings.md and file the rows by its procedure; the close report says how many rows it filed, or none.
All tasks green: run the full suite once - the workspace's affected set (nx affected -t test lint build in an Nx workspace), else every touched project plus the projects that depend on it, never a hand-picked list - quoting the command in the report and in any verifier brief. A red called pre-existing, or a fix closed on a pass the unpatched code was never seen to fail ('uncapped', 'no longer reproduces'), needs that check run on the base (a stash or a worktree) and quoted - else the report says unproven. Then review the assembled diff against the plan - the reviewer through ONE ask unless a calling flow already chose it, pointed at the plan file so it reviews against the plan, not in isolation, and apply its findings; then the done-gate on the whole feature.
All tasks green (<the suite command>). Who reviews the diff?
- 'task-verify-code in-session (Recommended)' - inline, the single-chat form of the verifier seat
- 'The <stack>-verifier seat' - dispatched, isolated, on its frontmatter model
Report against the plan, one line per task - task | status (DONE / deferred / revised) | evidence (the green command and what it proved) - then the suite + the review result, the ## Decisions ledger by its entry count (never re-pasted), and anything deferred or revised with its reason. The vertical is complete: design (task-design) -> audit (task-verify-plan) -> build (this) -> review (task-verify-code / <stack>-verifier) - one session, every step inspectable.
Example
Executing the records-list export plan (the task-design example, gated by task-verify-plan - three tasks, plus the audit's cancellation fix folded into Tasks 1-2):
- Task 1 - jump to the plan's query-seam anchor, add the export projection + its streaming test (rows streamed, never materialized - the card's trap), thread the cancellation token per the audit. Module tests green, output quoted. DONE.
- Task 2 - the streamed export entry point on the Task 1 seam, mapped to a transfer shape at the edge (the card's boundary trap). Tests green. DONE.
- Task 3 - integration test: header row, one data row, success status, and the audit's empty-set shape. Green on the full suite. DONE.
- Finish - full suite once,
task-verify-code over the assembled diff (one finding: a stray debug log - fixed), done-gate run.
task 1 export projection | DONE | module tests green (streamed, cancellation threaded)
task 2 streamed endpoint | DONE | tests green (edge maps to transfer shape)
task 3 integration test | DONE | full suite green incl. empty-set shape
suite + verify-code: green, 1 finding fixed; nothing deferred
1---2name: task-implement3description: "Use to build a task plan in this chat, task by task - 'execute the plan', 'build the plan', 'implement task 2'. Not for ad-hoc edits or the full gated cycle."4metadata:5 source: https://skillmd.com/skills/envoydev/task-implement6---78# Project Implementer - execute a verified plan, task by task, in one chat910This is the build step of the single-session vertical: `task-design` produced the plan, `task-verify-plan` audited it, this executes it - one task at a time, in the plan's dependency order, in your context so every diff is inspectable as it lands. It carries the implementer seat's *execution protocol* only; the coding conventions themselves need no restating - the path-scoped rules auto-attach the house skill per file type, the preferences docs the alfred-preferences.md rule names - the project's actual style among them - are read before the first edit, and the plan's task cards name the stack traps.1112The measurements behind these rules live in `references/evidence.md` - an audit appendix, not a run-time load.1314The plan FILE is the whole input - not the chat that produced it. In a long build carried conversation, not the tools, is the dominant token cost, so a fresh session (or `/clear` between tasks) keeps the context at plan size - offer one where a hook's fresh-session text says it pays back with the cache warm; the per-task ticks below make any task boundary a safe resume point.1516## When to use1718- You have a task plan and want to build it in this chat: it honors each task's contract, writes code + tests, gates each task green before the next, then hands to the build review.19- Not for a plan-less ad-hoc edit, or the whole gated cycle from design to done (/task-solve).2021**Modes.** Mode flags right after the command - `--mode-auto-run-on`, `--mode-auto-run-off`, `--mode-output-scorer-on`, `--mode-output-scorer-off` - are switches, not the request: strip them; with only flags typed, run as with no arguments. Under the hook's auto-run contract, follow it. With no hook line (hooks off, Cursor), `-on` holds for this run only: each stop takes its `(Recommended)` option, listed in the close, an unmarked one waits, nothing goes outward, no fresh-session hand-off, and the close says auto-run ended; `--mode-output-scorer-on` grades this run's output like a typed stack. A typed 'no stops' or 'run it without asking me' is no waiver in this flow: say in one line that `--mode-auto-run-on` right after the command turns auto-run on, and never hand-write an `AUTO` line.2223## Build mode - this chat or the implementer seats24251. **Pick the mode.** When the invocation names no mode and no calling flow has already recorded one (`task-solve`'s `mode <session|agents>` approval line, an orchestrator's brief), ask ONE question before building and hold the answer; a mode the run already picked is inherited, never re-asked. The mark sits on the mode the `habits-execution-strategy` verdict picks (`parallel seats` moves it to the seats, listed first):2627 ```ask28 Build here or through the implementer seats? <the verdict's reason>29 - 'In this chat (Recommended)' - <why it fits one chat>30 - 'Dispatch the implementer seats' - <the tasks that run in parallel>31 ```322. **Build.** In-chat: build in this chat, the protocol below. On an agents answer: dispatch each task to its `<stack>-implementer` seat instead, exactly as the roster spells it (`alfred-code:<seat>` where the core plugin carries it) - up to `ALFRED_CODE_MAXIMUM_RUN_AGENTS` at once (default 5), each on its frontmatter model unless you name one.333. **Stamp the approval before the first dispatch.** `<data root>/state/approvals/<plan id>/APPROVAL` (`<plan id>` is the plan file's name without `.md`), first line `APPROVED <plan id> - "<the user's words, verbatim>"` on their explicit approval (under auto-run the hook's `AUTO` stamp already stands - leave it); the dispatch hook blocks an unstamped implementer; delete the file when the run completes. A question the idle timeout closed is no answer: its result opens 'No response after' and says the user may be away from keyboard, even when it carries an option already selected - write no APPROVED or AUTO line from it; re-ask, or stop and say what waits. Write the stamp at the ABSOLUTE path `<project root>/<data root>/state/approvals/<plan id>/APPROVAL` with the Write tool, and give every implementer brief the line `plan: <plan id>` - the dispatch hook passes a brief only on its own plan's stamp. A relative write follows whatever cwd the shell drifted to and the dispatch then bounces. The stamp belongs to the session that dispatches - written when its own decision lands, deleted at its own close; an earlier session's leftover stamp is not consent.344. **If the stamp is refused, ask - never dispatch around it.** If BOTH the Write tool and an absolute-path Bash write are refused by the harness's classifier, stop and ask rather than retrying blind or dispatching around the gate:3536 ```ask37 Both write routes refused the approval stamp: <the refusal>.38 - 'Retry the stamp (Recommended)' - allow the write at the prompt39 - 'Run the tasks inline' - no dispatch, no stamp40 ```415. **Stay the only orchestrator.** Keep the main session the only orchestrator, routing a red per the repair-agent rules, and ticking the plan file as reports land - and each seat's gate is build + fast tests only, never a minutes-long run like integration replays or an E2E pass; the full suite stays with this session's finish step. Dispatch nothing you were not asked to.426. **No plan approval line, one ask before task 1.** The approval is the calling flow's too - and a plan file that carries no `Approved:` line when this skill is invoked on its own gets ONE approval ask before task 1, its answer written to the plan as `Approved: <date> - "<the user's words, verbatim>"`:4344 ```ask45 <plan file> carries no Approved: line. Build it?46 - 'Approve - build task 1 (Recommended)' - stamped as Approved:47 - 'Changes needed' - I ask what to change next, in plain text48 ```4950## The protocol - per task, in plan order5152Before reading the plan, load `habits-plan-writing` (the Skill tool) - the card fields and status marks below are its shape - and `habits-test-first`, the loop every card's `test:` runs on.53541. **Take exactly one task.** Its card is the contract: the files it owns, the traps it names, the `file:symbol` anchors, the `test:` it writes first, and its acceptance criterion. When the plan lives in a file (it should - `task-design` writes it to `<docs-path>/work/plans/`), mark the task `IN_PROGRESS` there before touching code. Jump to the anchors - the designer already located them; do not re-navigate the repo.552. **Build the slice + its tests together.** The acceptance criterion is what the tests prove; a task without its test is not built, it is drafted. The card's `test:` comes first, by `habits-test-first` - its red, a run that failed on the assertion the criterion names, is the only red that counts. The card's `log_points` go in with the slice, through the repo's logging seam at the level and with the identifiers the card names - never left for a later pass, never a second logger. Every line meets 'The bar I build to' - structure, quality, naming, comments - and every judgment call lands with its precedent. Stay inside the task's boundary - a needed change outside it is a flag, not a detour (see below).563. **Gate the task green.** Build + the relevant tests after each task, not at the end of the plan - the plan header's `Build:` command set where it has one, scoped to the touched projects and never a subset of it: a gate that drops the build passes what only the build catches (a template binding error, a missing provider). Resolve every red INLINE in this session - keep the fix loop here, quoting each build/test run so every attempt stays inspectable; the in-chat build dispatches nothing. The loop is bounded the way the resolver seats' is: after the FIFTH red run of one task's gate the next act is ONE ask, never a sixth run - the mark on 'Keep fixing inline' when the last red run changed, else on the resolver seat (or 'Stop' where the project installed none), listed first. Load the stack's convention skills for the trap list when the red points at one.5758 ```ask59 <task> is red after 5 runs: <the last error>.60 - 'Keep fixing inline (Recommended)' - <what the last run changed>61 - 'Hand it to a resolver seat' - <the seat>62 - 'Stop' - the task stays red in the plan63 ```644. **Close the task honestly** - the per-task completion gate is `habits-done-gate`'s rule, carried here so no load stands between it and the tick: run the acceptance command after the last edit and quote its output before any done word. Run it, then tick the task `DONE` with its evidence line - the acceptance command's own quoted output - in the plan file, append the task's judgment calls to the plan's `## Decisions` ledger (choice + precedent, per the bar), and refresh the plan's one-line resume note (next task + any mid-task state). The file, not the chat, is what a compacted or fresh session resumes from - it must never be more than one task stale. Then the next task. Partial is stated as partial. A task whose acceptance criterion is a RUN that has not happened yet - an integration pass, a manual try, a suite the gate deferred - stays `IN_PROGRESS` with a `needs: <the run>` line; 'code complete, builds' is not DONE. A task stamped `FAILED` ends the turn with ONE ask before any further run or edit - a 'reported to the user' line in the plan with no ask behind it is the measured failure:6566 ```ask67 <task> FAILED: <why>.68 - 'Stop and report (Recommended)' - the plan records it69 - 'Continue inline' - <the next attempt>70 - 'Resolver seat' - <the seat>71 - 'Revert' - back to the task's start72 ```7374## The bar I build to7576The review-and-fix loop's five stages - structure, code quality, naming, logging, comments - are the bar the built slice meets on the FIRST pass, so a later loop over this code finds nothing. Hold each as you write, not as a pass afterwards. `references/build-bar.md` carries the five rung by rung - Read it before the first task of a plan, and again at any task whose card names a stage this run has not applied yet:7778- **Structure** - a new file lands where the repo's best-organized module puts that kind of file, in the folder the task card names; never a dump folder, never a folder for one file.79- **Code quality** - the seven decision-level rules the plan settled apply to every line you add, and the line-level list in the reference applies with them.80- **Naming** - the repo's own vocabulary and casing for every identifier, one name per concept; no `data` / `info` / `manager` / `helper` where a specific word exists.81- **Logging** - the card's `log_points`, per the build step that places them: through the repo's seam, at the card's level with the card's identifiers, nothing beyond them.82- **Comments** - the always-on quality-gates rule's comments line, made concrete at write time. A checkable claim in a comment (a symbol, a count, an invariant) is true against the code you wrote; an existing comment your edit made stale is fixed in the same edit.8384**A model change never leaves its task without its migration** - generated by the tool, or hand-written when the tool cannot run here. A schema model with no migration fails every integration test at boot (the .NET example: EF Core's `PendingModelChangesWarning`).8586**The user's preferences first.** Build to the preferences docs `alfred-preferences.md` names - PERSONAL-CODE-, ARCHITECTURE-, GIT- and PROJECT-CODE-, the personal and architecture docs above the project one - ahead of the house conventions. Where an entry and a skill or another instruction disagree, ask the user which wins, the entry's side marked (Recommended) - a seat builds the entry's side and names the clash on `decisions:`. A task that cannot meet one stops and asks, naming the id - a seat returns NEEDS_CONTEXT - since a waiver is the user's `Except:` line, never the build's.8788**Decisions.** A judgment call the card left open - two idiomatic shapes, a placement, a name at a seam - is decided here, never bounced back: pick the option most consistent with the codebase's existing patterns and record it as `the choice - precedent: <file:symbol or named rule>`, or `no precedent - <reason>` said explicitly and still decided. In-chat, append it to the plan file's `## Decisions` ledger; a dispatched seat reports it as `decisions:` lines for the orchestrator to fold in, never editing the shared plan file itself (siblings build in parallel). A bounce (an in-chat ask, a seat's NEEDS_CONTEXT) is for a user-level requirement or scope beyond the card, never for a how-to-build call.8990**Reuse before recreation.** Before new code, stop at the first rung that holds: the app's own seam for the capability; the stdlib, runtime or framework already does it; an existing helper in this repo or an already-referenced package does it (search first - a second copy is a defect, consolidate to the existing seam); it is one line; only then the minimum code that works. Less code that still works - never the flimsier algorithm, never at the cost of validation at a trust boundary, error handling that prevents data loss, or secret handling.9192The seam rung: any capability the project wraps - such as the clock, the file system, logging, settings, a process or the network - goes through the abstraction the touched class or the project already routes it through; search them first.9394- A member the project's own interface lacks is added to it, its implementation and a test - never inlined as the raw call.95- When that interface sits outside the task's files, stop and name the member as a contract change (a seat's `BLOCKED_CONTRACT_CHANGE`).96- A framework seam the project chose, such as `ILogger<T>` or `TimeProvider`, is used through its members or an extension over it, never a new wrapper.9798**Callers first on a bug fix.** Before changing a function to fix a bug, list its callers (the navigation tools' references) and fix once where they all route through - a guard on only the reported path leaves every sibling caller broken, and one guard in the shared function is also the smaller diff.99100## When the plan meets reality101102- **A task proves wrong mid-build** (the seam isn't where the plan said, a trap the audit missed): stop the task and name the delta - never silently redesign while implementing. The re-entry is the USER's call on the FIRST occurrence, not a counter you spend: end the turn with ONE ask (plain-text options where the harness lacks the tool) and re-enter only on that answer. The plan is the contract; reality wins, but through a revision, not a drift.103104 ```ask105 <task> proves wrong: <the delta>.106 - 'Re-design this slice with task-design (Recommended)' - <the delta, named>107 - 'Continue against the delta' - <what changes>108 - 'Stop the build here' - the plan records where109 ```110- **A tool the environment blocks** (a generator hanging on denied egress, a command the sandbox refuses): the task still finishes in this session - take the in-session route before any ask. The .NET example, an EF Core migration: `dotnet ef migrations add <Name>` with `--project` AND `--startup-project` both set to the project holding the design-time DbContext factory - the tools take that factory first and boot no host; failing that, hand-write the migration and its model-snapshot change from the nearest prior migration. Only a task with no in-session route becomes a blocker ask, and that ask recommends the route - never 'retry the same command' or 'you run it'.111- **Scope beyond the plan** (a bug discovered nearby, a refactor itch): flag it and ask (plain-text options where the harness lacks the tool). Never rides along. A bug reported AFTER a cycle stamped COMPLETE or outside any active cycle takes the second ask:112113 ```ask114 Out of plan: <the item>.115 - 'Leave it for later (Recommended)' - named in the report116 - 'Add it to the plan' - a revision, then build117 ```118119 ```ask120 <the bug>, reported outside an active cycle.121 - 'Defer (Recommended)' - named in the report122 - 'Fix now, ad hoc' - <the fix>123 - 'Open a new cycle' - a new plan file124 ```125- **A shared contract surfaces** (a DTO both sides compile against, a schema semantic): stop the task and put it through ONE ask - the same BLOCKED_CONTRACT_CHANGE discipline the dispatched seats follow:126127 ```ask128 <task> touches a shared contract: <the DTO or schema>.129 - 'Hand it to the cross-domain flow (Recommended)' - you run `/task-solve-cross`; this build stops here130 - 'Keep it in this plan as a scoped change' - <the scope>131 - 'Stop the build' - the plan records where132 ```133134## Don't game it135136The acceptance criterion is satisfied by behavior, never by weakening the test that checks it. A green gate means the commands ran and their output says green - quoted, not assumed. Never suppress a warning, stub a path, or narrow a test to advance to the next task; a task that cannot go green honestly goes back to design as a named delta.137138## Finish - the in-session verifier139140**Known ceilings.** File every deliberate simplification this build made as a `where | limit | revisit when` row - never a code comment - before the close: Read `references/known-ceilings.md` and file the rows by its procedure; the close report says how many rows it filed, or `none`.141142All tasks green: run the full suite once - the workspace's affected set (`nx affected -t test lint build` in an Nx workspace), else every touched project plus the projects that depend on it, never a hand-picked list - quoting the command in the report and in any verifier brief. A red called pre-existing, or a fix closed on a pass the unpatched code was never seen to fail ('uncapped', 'no longer reproduces'), needs that check run on the base (a stash or a worktree) and quoted - else the report says `unproven`. Then review the assembled diff against the plan - the reviewer through ONE ask unless a calling flow already chose it, pointed at the plan file so it reviews against the plan, not in isolation, and apply its findings; then the done-gate on the whole feature.143144```ask145All tasks green (<the suite command>). Who reviews the diff?146- 'task-verify-code in-session (Recommended)' - inline, the single-chat form of the verifier seat147- 'The <stack>-verifier seat' - dispatched, isolated, on its frontmatter model148```149150Report against the plan, one line per task - `task | status (DONE / deferred / revised) | evidence (the green command and what it proved)` - then the suite + the review result, the `## Decisions` ledger by its entry count (never re-pasted), and anything deferred or revised with its reason. The vertical is complete: design (`task-design`) -> audit (`task-verify-plan`) -> build (this) -> review (`task-verify-code` / `<stack>-verifier`) - one session, every step inspectable.151152## Example153154Executing the records-list export plan (the `task-design` example, gated by `task-verify-plan` - three tasks, plus the audit's cancellation fix folded into Tasks 1-2):155156- Task 1 - jump to the plan's query-seam anchor, add the export projection + its streaming test (rows streamed, never materialized - the card's trap), thread the cancellation token per the audit. Module tests green, output quoted. DONE.157- Task 2 - the streamed export entry point on the Task 1 seam, mapped to a transfer shape at the edge (the card's boundary trap). Tests green. DONE.158- Task 3 - integration test: header row, one data row, success status, and the audit's empty-set shape. Green on the full suite. DONE.159- Finish - full suite once, `task-verify-code` over the assembled diff (one finding: a stray debug log - fixed), done-gate run.160161```text162task 1 export projection | DONE | module tests green (streamed, cancellation threaded)163task 2 streamed endpoint | DONE | tests green (edge maps to transfer shape)164task 3 integration test | DONE | full suite green incl. empty-set shape165suite + verify-code: green, 1 finding fixed; nothing deferred166```