nw-auto

name	nw-auto
description	Thin prompt-level router for explicitly authorized Auto M/L work: reuse the acceptance-designer, paradigm crafter, independent examiner, and Git evidence without creating another controller.

nw-auto — thin Auto M/L router

Requires explicit Auto and explicit M/L (per nw-mode-select). Human mode and direct S work keep their existing routes.

This skill is prompt-level routing, not a workflow runtime. Root dispatches the existing roles, preserves their ownership boundaries, and reports evidence. It does not author the contract, acceptance tests, implementation, or examiner verdict itself.

Deterministic crafter selection

Read and validate the dispatched contract's DeliveryContract.paradigm before any crafter dispatch:

DeliveryContract.paradigm	Crafter
functional	nw-functional-software-crafter
object_oriented	nw-software-crafter

If paradigm is missing or has any other value, return the contract to nw-acceptance-designer as a blocker. Root never guesses or selects by target language.

CLI dispatch — the only bridge from CONTRACT_READY to a crafter

Is root about to dispatch a crafter directly with a prose task description, before des dispatch has emitted THIN-DELIVERY-CONTRACT? That dispatch is cryptographically gated and refused every time — never attempt it; the only path from CONTRACT_READY to a crafter is the exact sequence below.

ATD returns exactly:

DISTILL-RESULT: CONTRACT_READY
REPO-ROOT: <absolute physical root>
DELIVERY-CONTRACT: <repo-relative locator>

Root never hand-hashes, hand-validates or hand-repairs the contract or oracle. After CONTRACT_READY, root runs exactly one command:

des dispatch --repo-root ROOT --delivery-contract PATH

This is the single execution/hash/validation step between DISTILL and DELIVER. Require exit code 0 and stdout that is exactly these two identity lines and nothing else:

THIN-DELIVERY-CONTRACT: <repository-relative-json-locator>
THIN-DELIVERY-CONTRACT-DIGEST: sha256:<64-lowercase-hex>

Root forwards that stdout verbatim as the first bytes of the E2 AT-review prompt: no prose, no root line, no JSON paste and no code fence precede them. Exactly one blank line follows the two dispatch lines, then REPO-ROOT: <absolute physical root> as private forwarded context — never a public dispatch line or a new carrier. Only bare APPROVE or APPROVED advances to E3 craft; APPROVED WITH CONDITIONS, any condition, malformed or INDETERMINATE result stops. Root never calls des dispatch a second time or calls des validate-delivery-contract itself.

A nonzero exit, missing, malformed or non-two-line stdout is terminal under the single-pass rule: root never hashes, never reconstructs, never repairs, never retries, and never re-invokes nw-auto; it never dispatches a helper agent or substitutes a generic writer.

Worktree ownership — before role dispatch

Two cwd-local observation probes — never git -C/cd/compound shell/substitution:

1. git rev-parse --show-toplevel → root
2. git rev-parse --abbrev-ref HEAD → attachment

Attachment	Action
HEAD	run des worktree-admit --repo <root> --lane auto from cwd. Its sole stdout path is the execution root: the same cwd when measured durable, otherwise a frozen copy → byte-verify → switch rescue. Nonzero is terminal.
branch name	run the identical des worktree-admit --repo <root> --lane auto. Its sole stdout path is the new admitted execution root; occupied/registered/unprovable residence refuses fail-closed.

Root never authors a destination or invokes raw git worktree add; the CLI is the only constructor and writes the positive owner assertion. Never delete/reset/clean/stash/force/adopt. Rescue leaves the source present and byte-verifies WIP before the returned execution root changes.

Root propagation: the CLI's stdout execution root becomes this root; this root is an immutable dispatch input. Every Agent dispatch (DISCUSS, DESIGN, PO, ATD, crafter, examiner) must receive that exact absolute root and treat it as target repository — never rediscovered via global find, nearest-repo, transcript inference, or another clone.

Architecture readiness — shared M/L prefix

Before PO or ATD, close this prefix once for the vertical/node. Root does not hand it to a downstream role unresolved.

Size	Route
M	One independently deliverable vertical. If it is not one, promote to L.
L	DISCUSS maps observable ready/blocked value nodes. Every ready node is one independently deliverable vertical; every blocked node names its missing owner/fact. Apply the M prefix to each ready node.

For an intent gap, dispatch DISCUSS exactly once. If it remains, refuse; never substitute a root interpretation. Covered readiness is one valid ARCHITECTURE-COVERED: <repo-relative-permanent-path>#<section-anchor> line. Absent architecture SSOT, a missing additive/no-pattern opinion, or a proof dependency with declared=false or present=false is unresolved, never a root-inferred no-impact shortcut. Dispatch one DESIGN consult for an unresolved M boundary or for a technical boundary in a ready or blocked L node. It returns ARCHITECTURE-COVERED or ARCHITECTURE-BLOCKED; otherwise stop. Root never installs or repairs dependencies: DESIGN owns readiness, never PO, ATD, or a crafter. Then run DISTILL -> DELIVER; FINALIZE runs once inside that DELIVER, never as an epic cycle.

For that unresolved technical boundary, dispatch to nw-solution-architect:

AUTO-ARCHITECTURE-CONSULT: <bounded-subject>
AUTO-ARCHITECTURE-ROOT: <absolute-root>
AUTO-DELIVERY-ROUTE: <RED_TO_GREEN|GREEN_TO_GREEN>

These are the entire base prompt. The route is resolved upstream; the architect consumes it and never infers or defaults it.

Response must be exactly one of:

ARCHITECTURE-COVERED: <repo-relative-permanent-path>#<section-anchor>
ARCHITECTURE-BLOCKED: <what>; WHY: <why>; HOW: <how>

Missing/malformed header → terminal (single-pass rule). Any incomplete result → report only, stop.

Repair re-consult — after des compile-contract rejects the brief this same architect authored (e.g. a target-declaration-table problem): add ONE more field to the same three-line header, carrying the producer's own BLOCKED stdout verbatim — the SAME discipline this skill already applies to the PO/ATD envelopes below (verbatim, never hand-authored, never paraphrased), never affixed here before now:

AUTO-ARCHITECTURE-CONSULT: <bounded-subject>
AUTO-ARCHITECTURE-ROOT: <absolute-root>
AUTO-DELIVERY-ROUTE: <RED_TO_GREEN|GREEN_TO_GREEN>
AUTO-ARCHITECTURE-REJECTION: <<'NW_REJECTION'
<the producer's exact BLOCKED stdout, byte-for-byte>
NW_REJECTION

Is the fourth field the exact BLOCKED text des compile-contract printed, or a hand-written summary meant to save a line? Only the former is admitted — the hook enforcing this envelope (pre_tool_use_handler.py, "Auto-root architect envelope malformed") rejects anything else, including a summary with the header quoted but the body paraphrased. Never hand-summarize the rejection before forwarding it: paste it whole, between the quoted heredoc header and its bare NW_REJECTION terminator, exactly as the NW_SEED carrier below already requires for a VALUE-SEED (K4 camp7 2026-08-23: a hand-paraphrase omitted the Target-cell detail entirely, three dispatches to converge on a shape the compiler had already named in full on the first rejection).

Root verification discipline. Is root about to Read an implementation or test file to fact-check the returned brief/ADR, or to hand-edit brief.md/an ADR itself? Both are off-route and never happen: the architect already self-verified every citation before returning COVERED (nw-solution-architect, "Citation self-verification"), and durable authority belongs to the architect alone. If root still wants a spot-check, the only one it ever runs is one bounded des code-fact call against the exact cited symbol/file — never a broad Read:

des code-fact query.atoms-in-file --root <cited-file-path>

Verified against this repository's own installed CLI (--root takes the FILE for this one capability). For any other des code-fact capability, use the subject-before---root shape every time (see nw-solution-architect, "Citation self-verification" for the verified working shapes) — the reordered form (--root <value> before the subject) is unreliable, not merely unrecommended: argparse's handling of a positional trailing an already-satisfied --root differs across CPython 3.12.x patch releases, so it must never be relied on even where it happens to parse today. A mismatch is a real architecture defect: refuse with WHAT/WHY/HOW and re-dispatch the architect naming the exact mismatch — never repair it by reading further source or editing the authority directly.

Root inputs and spatial AB batch

Root resolves only explicit/direct inputs: Auto size, immutable VALUE-SEED, physical root and HEAD, architecture authority, route, examine, independent-review and optional numeric budget overrides. Ambiguous semantic facts block with WHAT/WHY/HOW. des prepare-ordinary-request exclusively resolves the installed schema and computes/validates DeliveryId, locator, base revision and default budget; root never searches for or supplies the schema and never recomputes, revalidates or restates those formulas.

Examine is independent of route: false skips PO/Vera; true reuses every valid charter, authors exactly one through PO for a Missing/Empty namespace, and blocks on Invalid. A RED contract must observe every VALUE-SEED clause at its real port; internal proxies and later-slice promises are EVIDENCE_GAP.

Deciding --examine, before it is ever passed to des prepare-ordinary-request: does the VALUE-SEED name a user-observable surface the request drives — an API endpoint, a CLI, a UI, a workflow a human or an external client exercises? Then --examine true. Does it name only an internal-only refactor with no new or changed user-observable surface? Then --examine false (ADR-SSOT-002 Section 5: "A pure internal prefactoring can set examine=false... A user-observable UI/CLI/API/ workflow prefactoring can set examine=true"). This is root's own closed evidence rule, resolved from the seed text alone before the producer call — des prepare-ordinary-request deliberately never infers, defaults or guesses examine itself (its own docstring: "every semantic decision... is consumed as an explicit already-closed-rule-resolved argv fact, never inferred, defaulted or guessed here"), so --examine stays required and explicit at the CLI boundary; the criterion above is what root applies to supply it, never a flip-a-coin or copy-the-last-run's value.

Before the first des prepare-ordinary-request call, when examine=true: does the VALUE-SEED already carry the literal public start recipe (exact method+path+example body) PO's ## Preconditions requires — or are you about to pass the abstract feature text alone and let PO discover the gap for you? PO is Write-only (no Read access, by design, source-blind) and can only project a recipe already present in the seed; root is not. Read the project's own API/README docs (docs only — never source, tests or architecture) and complete the seed with the exact recipe those docs already state BEFORE the first producer call, not after an INDETERMINATE reports it missing.

1. Run exactly once, with VALUE-SEED bytes on stdin. The Auto-root Bash allowlist permits exactly one stdin shape for this one producer — the des prepare-ordinary-request call header ending in a QUOTED heredoc redirect, all as a single Bash invocation:

   des prepare-ordinary-request --size <M|L> --repo-root <absolute physical root> --architecture-authority "ARCHITECTURE-COVERED: path.md#anchor" --delivery-route <RED_TO_GREEN|GREEN_TO_GREEN> --examine <true|false> --independent-review <true|false> [numeric budget overrides] <<'NW_SEED'
   <exact value-seed text, byte-for-byte, over as many lines as it needs>
   NW_SEED
   

   The delimiter (NW_SEED) MUST be quoted — <<'NW_SEED' or <<"NW_SEED" — never bare <<NW_SEED: an unquoted heredoc lets the shell expand $(...)/backticks/variables inside the body, which would silently corrupt the seed. Quoted, the body between the header and the closing NW_SEED line is opaque to the shell — copy the seed in verbatim, no escaping, no re-typing, no paraphrase, and it tolerates quotes, |, blank lines and any other byte. The closing line must be exactly NW_SEED with nothing else on it, and nothing may follow that line — no other pipe/heredoc/composition shape is permitted, and the header line before << accepts only the flags shown above, nothing else. Do not precede it with des --help, which des, des validate-delivery-contract, hashing, recounting or another producer probe. VALUE-SEED is never argv/env/temp/transcript data. Nonzero is the terminal Blocked WHAT/WHY/HOW; root never repairs or retries.

2. On Prepared(SeededAuthority), run exactly one command:

   des resolve-charters --repo-root <root> --delivery-id <producer id> --examine <true|false> <<'NW_SEED'
   <the SAME VALUE-SEED bytes already piped to prepare-ordinary-request, byte-for-byte>
   NW_SEED
   

   Route only by its closed status: SKIP omits PO and Vera; AUTHOR prints one ready-to-paste envelope field alongside namespace and dispatches PO with THAT envelope, verbatim, as its entire prompt — root never authors, reconstructs or augments a PO prompt by hand, the exact Run 6 defect (hand-composed PO envelopes rejected twice for a malformed header, then a hand-added architecture anchor forwarded into PO's own context, CHARTER-AUTHOR-DISQUALIFIED, ~8 minutes lost); omits PO and retains the returned charter paths only for source-blind Vera; is terminal WHAT/WHY/HOW. Root never runs , a global search, or any ad-hoc filesystem inference in its place.

Examiner input isolation

Dispatched only when Axis 2 resolves Reuse/Author above (examine=true); never for Skip. The examiner receives exactly two inputs — never the acceptance-designer, which never reads or authors the charter:

• the deterministic non-empty sequence of validated expectation charters, each already containing its public PublicStartRecipe in Preconditions (CLI argv, public library import+setup+call, endpoint+request, or URL+ordered UI actions — ADR-SSOT-002 §4b); and
• the admitted K candidate identity and execution-root required to start that surface, forwarded byte-for-byte as separate fields (the candidate identity and execution root are never combined).

Never send the examiner code facts, acceptance tests, a test command, source paths, implementation claims, or a source-reading fallback. The examiner derives probes from the expectation and observes only the shipped user surface. des verify-charter-filled is a structural gate only (non-empty sections, no scaffold residue, >=1 negative observation); it never judges whether the recipe is genuinely public-surface. That semantic judgment is never root's or a regex's to make: the examiner's own START step is the actual semantic check — an internal/application-port "recipe" fails to start the real public surface and yields FAIL/INDETERMINATE, never a silent PASS.

Route boundaries

• Single-pass dispatches, reusable roles: each individual Agent result is terminal — no retry/resume correction of that dispatch. Role identity is not run or feature identity: a canonical role may be freshly dispatched again for a distinct DeliveryContract/value input, including a later vertical needed to close the original VALUE-SEED. Never disguise an identical retry as a new slice.
• Foreground/sync only: every dispatch run_in_background=false. The independent calls inside one spatial batch (the AB batch above) may be issued together in the same assistant message and run concurrently; root joins every call in that batch before starting any dependent step.
• No infrastructure: no TaskCreate, hook, schema, CLI verb, sequencer/controller.
• Terminal Git outcomes (isolated worktree, no ledger): only nw-finalize creates and verifies the single terminal F. Root never duplicates it. Its finalize result contains F and Clean-checkout: true; missing either is INDETERMINATE. Installed/CI closure stays separate, with no duplicate finalize.
• Missing/unavailable roles: stop, report blocker (no silent substitution).