[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M72TR60KFGP53ASW3B0QMZQH":3,"skill-same:01M72TR60KFGP53ASW3B0QMZQH":44},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":17,"publishedAt":18,"linkOnly":19,"markdownContent":20,"markdownBody":21,"frontMatter":22,"refName":23,"commitSha":24,"skillDirectory":25,"forksCount":26,"repositoryHtmlUrl":27,"repositoryHomepageUrl":6,"ownerHtmlUrl":28,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":29,"install":30,"resources":43},"01M72TR60KFGP53ASW3B0QMZQH","ws-3-tasks",null,"Level 3 — Break plan into sequenced, atomic work units.","vempio\u002FWhittleSpec","vempio","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F226084226?v=4","01M72TQW11B57V5ZE8MQPKJ5QY","01M72TQW22F5C4SJ317ETCWHFW",4,"MIT","https:\u002F\u002Fgithub.com\u002Fvempio\u002FWhittleSpec\u002Fblob\u002Fmain\u002Fskills\u002Fws.3-tasks\u002FSKILL.md",[],[],"2026-11-10 22:39:42",false,"---\nname: ws-3-tasks\ndescription: Level 3 — Break plan into sequenced, atomic work units.\n---\n# ws.3-tasks\n\nLoad shared context: `ws._meta\u002FSKILL.md` — the sibling skill in the same skills directory this skill loaded from (resolves under any clone name, install location, or skills-root override). Also load: `ws._meta\u002Fshaping.md`, `ws._meta\u002Flifecycle.md`, `ws._meta\u002Fparallel-work.md`, `ws._meta\u002Fissue-tracking.md`.\n\n## Purpose\n\nBreak approved plan into concrete, sequenced tasks. Each 30 min - 2 h (see Task Sizing under Behaviors). Sequence for early integration feedback — walking skeleton first.\n\n## Prerequisites\n\n- `requirements.md` \u002F `umbrella-requirements.md` exists and approved \u002F `plan.md` \u002F `umbrella-plan.md` exists and approved \u002F User confirmed readiness\n\n### Multi-Slice Projects\n\nUmbrella shape is the **exception, not the default** (see `ws._meta\u002Fshaping.md` §Process-Shape Hard Rules). If the spec directory has `plan.md` (no `umbrella-plan.md`) → single-cycle: output `tasks.md`, ignore the rest of this section.\n\nIf `umbrella-plan.md` exists with a **Slice Status** table (umbrella already adopted — verify, don't infer): pick which slice to task (ask if unclear). Scope to that slice; reference umbrella specs for context. Output `tasks-\u003Cslice>.md`.\n\n## Process\n\n### 1. Review Plan\n\nLoad and summarize: \"Working on: [feature] \u002F Walking skeleton: [summary] \u002F Key components: [list]\"\n\n### 2. Identify Tasks\n\nBreak into atomic units. Each: 30 min - 2 h (see Task Sizing under Behaviors for full rule, including the no-sub-tasks-at-planning constraint and granularity test) \u002F clear verifiable outcome \u002F **one capability** — name the single user-job it serves; if the name needs an \"and\", split.\n\n### 3. Sequence for Integration\n\nOrder: (1) **Walking skeleton** -- end-to-end path working. (2) **Integration points early** -- surface issues first. (3) **Polish last**. Mark milestones: \"After this task, verify [X]\"\n\n#### Each Task = Self-Contained Vertical Slice (HARD RULE)\n\nEvery task MUST leave project **working and testable**. Not guideline -- structural constraint. Violations fixed before output.\n\n1. **Breaking changes include consumers.** Mandatory field \u002F schema change \u002F API alteration MUST update all consumers (fixtures, configs, tests, docs) in *same* task. Fix deferred to later = **rejected**.\n2. **Each task wires itself in.** Component MUST integrate into prod entry point + update integration\u002FBDD tests. Never accumulate unwired components.\n3. **BDD\u002Fdocs advance per task, or the task is recorded exempt.** Each task advances at least one BDD scenario red-to-green — unless its `BDD decision` (see § BDD decision) is `do not use`, recorded with the required reason. Operator docs update per behavior delivered. Separate \"write tests\"\u002F\"write docs\" task = **rejected**.\n\n**Invariant**: After every task -- the project's bound verification passes (`ws-binding get verification`; see `ws.4-run` §1a, never a hardcoded runner), BDD reflects reality, no fixture\u002Fconfig silently broken.\n\n### 4. Involvement Triage\n\nAssess each task's involvement level.\n\n| Level | Tag | Mode |\n|-------|-----|------|\n| **autonomous** | `[autonomous]` | Agent chains TDD phases, presents batch result |\n| **checkpoint** | `[checkpoint]` | Pauses at focus points for review |\n| **pair** | `[pair]` | Full interaction every TDD phase |\n\n#### Triage Criteria\n\nAutonomous only if ALL dimensions low-risk; any high-risk dimension elevates.\n\n| Dimension | autonomous | checkpoint | pair |\n|-----------|-----------|------------|------|\n| Reversibility | Trivially undone | Moderate | Hard (migrations, API contracts, data model) |\n| Domain risk | Plumbing, config | Business logic, understood | Correctness-critical, regulatory, security |\n| Novelty | Established patterns | Some unknowns | Uncharted, first use |\n| Blast radius | Local to one module | Module interfaces | Cross-system, affects data |\n\n#### Focus Areas (non-autonomous only)\n\nFor `[checkpoint]`\u002F`[pair]`, add `**Focus**` naming ACs needing scrutiny. Rest implicitly autonomous.\n\n```markdown\n### Task 2 [pair]: Implement order state machine with persistence\n- [ ] **Goal**: Orders transition through states and survive restarts\n- **Focus**: ACs 1-2 (state transition rules, error semantics)\n- **Touches**: src\u002Forder\u002Fstates.py, src\u002Forder\u002Frepo.py, src\u002Fconfig\u002Floader.py\n```\n\n#### Involvement Summary Table\n\nAdd at top of task file after Implementation Constraints:\n\n```markdown\n## Involvement Summary\n| Task | Level | Focus | Rationale |\n|------|-------|-------|-----------|\n| 1 [pair] | pair | API contract (ACs 1-2) | Walking skeleton, sets contract |\n| 2 [checkpoint] | checkpoint | Migration (AC 3) | Verify before committing to schema |\n| 3 [autonomous] | autonomous | -- | Standard CRUD, established patterns |\n```\n\nUser sign-off artifact. Present with the draft task list before execution.\n\nAgent proposes; user approves\u002Fadjusts. User may set blanket policies (\"nothing touching DB is autonomous\"). Record approved policies as implementation constraints.\n\n#### Slice Ledger (human-scannability)\n\nAbove the Involvement Summary, add a one-line-per-task ledger the user can scan in seconds to audit slicing **without** reading every task body:\n\n```markdown\n## Slice Ledger\n| Task | User-job (what the user DOES) | Surfaces touched | Distinct slice because… |\n|------|-------------------------------|------------------|--------------------------|\n| 1 | reach & read the Sent folder by alias | list_folders, search_messages, resolver | the discover-then-use loop, end to end |\n| 2 | reach Drafts\u002FTrash\u002Fthreads by alias | list_messages, read_message, get_thread | new user-jobs on new entry points |\n```\n\nThe ledger is the severed-capability test made visible. Two tells, scannable at a glance: if a row's **User-job** reads as advertising\u002Fexposing (\"make aliases discoverable\", \"update the catalog\") rather than a thing the user does, or if **Distinct slice because** can only cite a surface (\"it's the `list_folders` task\"), the slice is suspect — merge. A single surface spanning multiple tasks down the **Surfaces touched** column, or one capability's surfaces scattered across rows, is per-surface severance. Present the ledger FIRST at the STOP gate; it is what lets the human catch a bad cut in one line instead of reading the whole file.\n\n#### Involvement Sign-Off (presented at the single post-compliance gate)\n\nInvolvement is **not** presented here. There is exactly one sign-off gate, and it runs **after** vertical-slice compliance passes (see § STOP Gate: Vertical Slice Compliance). At that gate the task file is presented — Slice Ledger first, then the Involvement Summary, then enough task detail to judge the levels — in a single STOP. The involvement summary only makes sense shown with the task list, so it is never presented before compliance is clean.\n\n### 5. Validate Sequencing\n\n**AC-to-task coverage (mandatory, first)**: For every AC \u002F invariant \u002F enumerated sub-bullet in `requirements.md` \u002F `umbrella-requirements.md` within this slice's scope, name the task that makes it true. Produce the traceability table:\n\n```\nAC COVERAGE\n| requirements.md \u002F umbrella-requirements.md ref | Covered by task |\n|------------------------------------------------|-----------------|\n| Cluster X AC 1                                 | Task 2          |\n| Cluster X AC 2                                 | Task 2          |\n| Invariant 3                                    | Task 4          |\n| Cluster Y AC 1 (a)                             | Task 5          |\n| Cluster Y AC 1 (b)                             | -- GAP --       |\n```\n\nEvery AC maps to at least one task. `-- GAP --` = missing task (add one) or scope\u002Fspec drift (run `\u002Fws.refine`). **Known LLM failure mode**: drafting tasks from plan-component boundaries and silently dropping ACs that live only in `requirements.md` \u002F `umbrella-requirements.md`. Also: enumerated sub-bullets (\"for each of N sites: (a) X, (b) Y\") are N×K independent ACs — map each pair explicitly, not the parent bullet.\n\nCross-check `plan.md` \u002F `umbrella-plan.md` \u002F `decisions.md` too: any prescriptive statement (\"`_run_auto_continue` computes start_index from `next_step`\") = implicit AC. Unmapped → add a task or remove the prescription.\n\n**Sequencing questions**: \"First end-to-end feedback?\" \u002F \"Dependencies explicit?\" \u002F \"Should any split?\"\n\n#### Skip test\n\n**Mandatory, ALL tasks.** Mentally skip each task. Nothing demonstrable changes outside test suite -> infrastructure without payoff -> merge into task with demo.\n\n#### Underwhelm test\n\n**Mandatory, ALL tasks.** Imagine showing demo to senior stakeholder. \"You called me in for *this*?\" -> too thin or demo hides payoff. Merge thin tasks or rewrite demo.\n\n#### Severed-capability \u002F exposure test\n\n**Mandatory, ALL tasks.** Name the capability each task serves in one user-job phrase — a thing the user *does*. Then ask: *is this task's entire payload making a capability visible — advertising, cataloguing, documenting, adding to an index \u002F menu \u002F usage-hint — where the capability functions, or will function, without it?* If yes, merge it into the task delivering that behaviour. Equally reject per-surface slicing when those surfaces compose one capability. Both rules: `ws._meta\u002Fshaping.md` § Per-surface slicing and `ws._meta\u002Fshaping.md` § Exposure is not a slice. This test fires where the per-task Reachability pass cannot: an exposure-only task is independently demoable and \"wires into prod,\" so it passes Reachability while still being horizontal.\n\n#### Reachability pass\n\n**Mandatory, every task that produces user-facing output.** User-facing = page, screen, URL, command, generated artefact a person consumes — not internal modules, refactors, or schema migrations. For each such task, produce TWO outputs *before* the compliance gate. They are complementary: the boss demo forces narrative concreteness; the regret scenarios force adversarial generation. A leaf-only slice that survives one tends to die in the other.\n\n**Output A — Boss demo**: a scenario in which you call your senior stakeholder into a meeting, hand them the running product, and ask them to find and exercise the new capability *themselves*, *after only this task has shipped*. Specify:\n\n1. The opening prompt you give them (\"Find me the wireless headphones.\" \u002F \"Try the postal-code validator.\" \u002F \"Show me which orders qualify for free shipping.\").\n2. The exact sequence of *their* actions — clicks, typed input, commands — starting from the **product's own entry surface** for this kind of feature. Surface depends on artefact:\n   - UI page \u002F screen → in-product navigation: home page, menu, index page, in-product search, sitemap, or a workflow that lands here.\n   - CLI feature → root command + `--help`, or the discoverable subcommand listing.\n   - API endpoint → the consumer's real catalog \u002F OpenAPI doc \u002F SDK surface.\n   - Generated artefact (file, export, report) → the real output path or catalog the consumer already uses.\n   - Library \u002F module → the package's public surface (`__all__`, exported index, documented import path).\n\n   **README \u002F changelog \u002F docs are supporting evidence, not entry points — where the product has an in-product surface at all.** A page mentioned only in README but not linked from the site is still a leaf. Not your steps as the developer; the boss's steps as a first-time user.\n\n   **Applicability**: where the product has no surface other than what a reader opens — a library consumed by import, a framework distributed as files, a documentation site — the README or docs page *is* the entry point, and wiring it means linking it from wherever a reader actually arrives. Declare which case applies rather than assuming; a rule written for executables silently fails every repo that is not one.\n3. What they see at the end.\n\n**Output B — Three \"we'd regret shipping ONLY this task\" scenarios**, written as real-world phrases, not test cases. Same structure as the walking-skeleton adversarial pass at `[x]` time — and the reason it works here is the same: it forces *generation* of failure modes, which is harder to fake than narrating a smooth demo. If any scenario reads \"the new thing exists but no one can find \u002F use \u002F hear about it\" → re-cut.\n\n**At least one of the three MUST be a cross-cut, not a within-task bug.** State the product after *\"ship every task except this one\"* and after *\"ship only the tasks before this one.\"* \"Coherent, just less capability\" → legitimate additive scope (fan-out, keep). \"The product contradicts itself \u002F its catalog lies \u002F a half-built capability ships\" → this task is the missing half of another; merge. A within-task quality regret (\"the feature has a bug\", \"INBOX miscategorised\") does NOT satisfy this — the regret must be about what the CUT leaves behind. This is the check that catches exposure-only and per-surface-severed tasks, which the boss demo and within-task regrets wave through.\n\n**Re-cut triggers** (apply to either output):\n\n- **\"There's nothing to see yet — that'll come N tasks later.\"** → leaf-only slicing. Re-cut to ship something the boss can reach today.\n- **\"I can't find it from the menu — here's the URL.\"** → discoverability deferred. Re-cut to include the **in-product** discoverability surface (menu entry, index page, sitemap inclusion, root-command help, catalog\u002Findex entry — see Output A's surface list) in the *same* task. README additions don't count; they're supporting docs, not product navigation.\n- **\"Now pretend the navigation link is there...\"** → pretending bridges the gap = horizontal scaffolding in plain clothes. Re-cut.\n- **\"It works, but I called you in to see one button.\"** → too thin. Merge with adjacent task or surface a larger payoff. (Overlaps with Underwhelm test; both fire.)\n\nIf the boss can't get from \"Find me X\" to \"ah, here it is\" through their own actions on the running product — OR if any of the three regret scenarios reads \"exists but unreachable\" — the task is not a vertical slice. It is a leaf labelled as one.\n\nKnown failure mode: **leaf-only slicing**. Task ships a renderable page or generated artefact; menu entry, index link, or sitemap inclusion gets sequenced to a later task. Sounds reasonable (\"content first, navigation later\"), IS the well-trodden pattern in training data (MVC layering, \"data layer first\", \"scaffolding then polish\"), and IS horizontal scaffolding wearing a slice's clothes. The forbidden-words list in `ws._meta\u002Fshaping.md` § Slicing must never be justified by architecture catches *justification* language (`skeleton-then-flesh-out`, `walking-skeleton-with-deferred-X`) but not plain-English equivalents like \"don't open discoverability until content is complete\" — same antipattern, different words. The two outputs catch it two ways: the boss's narrated actions cannot reach the new artefact without the LLM noticing the gap mid-walkthrough; the regret scenarios cannot be honestly enumerated without one of them reading \"exists but no one can find it.\" A smooth demo papered over the gap? The regret scenarios should still surface it. Vague regret scenarios that miss the gap? The boss demo should still trip on the unreachable click. Both fake at once would require the LLM to actively lie in two complementary registers — much higher friction than letting one slip.\n\nKnown failure mode (mirror): **exposure-as-its-own-task**. Real case — an alias-resolution feature sliced as: Tasks 1-2 deliver the resolver and wire it into the message tools; Task 3 \"rebuild `list_folders` to advertise the aliases.\" Task 3 passed every per-task check — `list_folders` is independently demoable, \"wires into prod\" was literally yes, and its three regret scenarios were all internal bugs (miscategorised INBOX, phantom rows, weak wording). It was still horizontal: the discoverability-half of the capability whose behaviour shipped in Tasks 1-2, leaving a window where the agent's own catalog taught the localized folder names while the tools wanted the aliases. The cross-cut regret that kills it — \"ship 1-2 without 3 → the catalog contradicts the tools\" — was never generated, because per-task checks cannot see cross-task severance. Caught only by the human. This is why the cross-cut regret (Output B) and the separate-context review (below) are mandatory, not the per-task demo.\n\n**Verify before sequencing**: Ordering relies on assumption (\"X unavailable\")? Verify first -- filesystem, dry-run, test connection. 30-second check costs nothing; unverified assumption pushes feedback back days. Example: \"BDD can't run\" -> check dependencies exist. Present? BDD runs now. Missing? Tell user. Principle: **never sequence around unverified constraint.**\n\n**Separate-context slice review (mandatory, before the compliance gate)**: Self-review shares the slicing blind spot — the same context that sliced per-surface also writes the regret scenarios, blind in the same place, so it validates its own cut. Break that loop: the cut MUST be reviewed by a context that did not author it, given **only** task titles + one-line goals + surfaces-touched — NOT your justifications, ledger, or rationale. Single instruction: *\"For each task answer: is its entire payload exposing\u002Fadvertising\u002Fcataloguing\u002Fdocumenting a capability another task delivers? Do any tasks split one capability across surfaces (one per tool \u002F endpoint \u002F file \u002F screen)? List every task that is exposure-only or per-surface-severed with one reason each, else reply NONE.\"* A reviewer with no stake and one sharp question catches what invested self-review misses. Fold its findings (merge flagged tasks) before producing the compliance table. This is the highest-leverage check here — prose guardrails the authoring context skims; a differently-framed reader with no stake does not.\n\n\u003C!-- WS:DEFAULT independent-review-agent -->\nThe recommended way to obtain that independent context is a fresh subagent (the Agent tool), handed the titles-goals-surfaces list above with an explicit instruction: *\"Proceed as if you have no knowledge of prior context — review only what is handed to you.\"* Where the runtime offers no subagent, fall back to a clean-context second pass — a freshly-cleared session fed the same list and the same instruction, so it cannot see (and rubber-stamp) the authoring rationale — and escalate to a human checkpoint when the stakes are high (irreversible cuts, money\u002Fcommitment surfaces, or a \"NONE\" verdict on a large slice). Label this fallback's evidence **self-review fallback**, not independent review: it removes visible context, but not the authoring session's blind spots, habits, or unstated assumptions carried into the fresh pass — the thing genuine independence buys and this cannot. Never skip the review and never block on the mechanism: the requirement above is the invariant; the subagent is the default means.\n\u003C!-- \u002FWS -->\n\n#### STOP Gate: Vertical Slice Compliance, then Present\n\n**This is the single sign-off gate, in one order: compliance first, then present.** Do not present the task list until compliance passes. Produce compliance table:\n\n```\nVERTICAL SLICE COMPLIANCE\n| Task | Tests green after? | Breaks unfixed? | Wires into prod? | Demo? | BDD advanced? |\n|------|--------------------|-----------------|-------------------|-------|---------------|\n| 1    | [which tests]      | [no \u002F what]     | [yes\u002Fno\u002FN\u002FA]      | [concrete demo] | [which \u002F N\u002FA] |\n```\n\n**Gate rules -- violation = restructure:**\n\n1. **\"Tests green?\" blank** -> merge into adjacent task or add verification\n2. **\"Breaks unfixed?\" not \"no\"** -> fold fix into *this* task\n3. **\"Wires into prod?\" = \"no\" \u002F \"later task\" \u002F names a future task** -> unwired = horizontal; the task must connect the new artefact to BOTH (a) the code path that runs in production (imports, routes, registrations) AND (b) the **in-product** user-discoverability surface for this kind of feature (UI page → menu \u002F index \u002F sitemap; CLI feature → root help; API endpoint → catalog; generated artefact → real output path or index — see Reachability pass Output A for the surface list) — in the same task. README \u002F changelog \u002F docs are supporting evidence, not substitutes for in-product wiring. Internal-only tasks (refactor, plumbing, schema migration) write \"N\u002FA — no user surface\" and skip the user-discoverability half. User-facing tasks failing either half must absorb the missing wiring; deferring discoverability to \"Task N+k\" = leaf-only slicing (see Reachability pass under §Validate Sequencing).\n4. **\"Demo?\" blank \u002F \"run tests\"** -> merge into demonstrable task. Qualifying: \"open page, see X\" \u002F \"run command, see Y\". NOT: \"pytest passes\"\n5. **\"Demo?\" fails underwhelm test** -> merge thin tasks or surface user-facing change\n6. **\"BDD advanced?\" blank** -> restructure. Every cell is either progression evidence (which scenario, red-to-green) or the task's own `BDD decision: do not use — \u003Creason>` cited verbatim — never a bare blank, and never excused by being a single occurrence.\n\n**Rejected shapes**: \"connect\u002Fwire previously built components\" \u002F \"update fixtures for earlier changes\" \u002F \"write BDD tests\" near end \u002F stubs with no backing behavior.\n\nRe-run compliance after restructuring. Repeat until clean. State changes: \"Merged Task 7 into 1 because...\"\n\n**Only once compliance is clean, present** the task file for sign-off — Slice Ledger first, then the Involvement Summary, then enough task detail to judge the levels. STOP. Wait for user approval or adjustments before writing the final task file or starting `\u002Fws.4-run`. There is no earlier \"present\" step; this is the one gate.\n\n## Output Structure\n\nWrite to `tasks.md` (or `specs\u002F\u003Cfeature>\u002Ftasks.md`). Multi-slice: `tasks-\u003Cslice>.md`.\n\n```markdown\n# Tasks: [Feature Name] -- [Slice Name if multi-slice]\n\n## Implementation Constraints\n**Permitted**: Libraries: [list] \u002F Patterns: [list] \u002F Files: [scope]\n**Not Permitted**: [constraints]\n**Style**: [project conventions]\n\n## Slice Ledger\n| # | User-job (what someone DOES) | Surfaces touched | Distinct slice because… |\n|---|------------------------------|------------------|-------------------------|\n| 1 | [a thing the user\u002Foperator does] | [surfaces] | [user\u002Foperator-term reason — no layer\u002Fcomponent\u002Fsurface nouns] |\n\n## Involvement Summary\n| Task | Level | Focus | Rationale |\n|------|-------|-------|-----------|\n| 1 | pair | [ACs] | [why] |\n| 2 | autonomous | -- | [why] |\n\n## Walking Skeleton\n\n### Task 1 [pair]: [Name]\n- [ ] **Goal**: [achievement]\n- **Focus**: [ACs needing scrutiny -- omit for autonomous]\n- **Touches**: [files]\n- **Depends on**: None\n- **Parallel**: yes (alongside Task 4)\n- **Acceptance**:\n  1. [Criterion] -- **Demo**: [command + observation]\n- **Reachability** (required for user-facing tasks; non-user-facing: `N\u002FA — \u003Creason>`):\n  - **Surface**: [in-product entry point added by this task — e.g., \"menu item Shop > Headphones added to top nav\", \"`cli foo bar` listed in root `--help`\", \"endpoint listed in `\u002Fopenapi.json`\"]\n  - **Boss demo**: [opening prompt → boss's actions step-by-step from the surface above → what they see, written out verbatim, e.g., \"Tell boss: 'Find the wireless headphones.' Boss lands on `\u002F`. Clicks `Shop` in top nav. Sees `Headphones` category. Clicks. Sees product list with N entries.\"]\n  - **Three regret scenarios**: 1. [scenario] 2. [scenario] 3. [scenario]\n- **Tests green after**: [specific tests]\n- **BDD decision**: use | do not use — \u003Creason>  (see § BDD decision)\n\n### Task 2 [autonomous]: [Name]\n- [ ] **Goal**: [achievement]\n- **Touches**: [files]\n- **Depends on**: Task 1\n- **Acceptance**:\n  1. [Criterion] -- **Demo**: [command + observation]\n- **Reachability**: [as Task 1, or `N\u002FA — \u003Creason>` for non-user-facing]\n- **Tests green after**: [tests]\n- **BDD decision**: use | do not use — \u003Creason>  (see § BDD decision)\n\n**INTEGRATION MILESTONE**: After Task 2, verify [point]\n\n## Remaining Tasks\n### Task 3 [checkpoint]: [Name]\n[same structure]\n\n## Backlog (Deferred)\n- [Item] -- [why deferred]\n```\n\n## Behaviors\n\n### Task Sizing\n\nDefault size: **30 minutes to 2 hours** of focused work. Below 30 min → merge with neighbour. Above 2 h → split *only* if the split passes the slicing-justification rule in `ws._meta` (no technical-layer splits). Verifiable completion (\"X does Y\", not \"work on X\"). Vague = too big.\n\n**No sub-tasks at planning time.** `tasks.md` is a flat list (1, 2, 3, …) — never `2a\u002F2b\u002F2c`. Letter suffixes are an *execution-time* numbering tool only: preserve stable numbering when drift during Task 2 forces inserting a new item (record as `2a` so `3` still refers to the same work). Sub-tasks proposed at planning time are LLM sprawl — merge or restructure before presenting.\n\n**Granularity test before presenting:** read each task's Goal aloud. If it sounds like a step *inside* a larger task (\"wire X\", \"configure Y\", \"add fixture for Z\") rather than a unit the operator narrates (\"the order lands in the fulfillment queue\"), it's too granular — merge.\n\nAnti-example (narrated, not a shipped example — the original was private case-history): a skill-artefact slice decomposed into four tasks along technical-layer lines (schema → meta → book → exercise). Not separable for a skill artefact; produced churn that single-pass authoring would have avoided.\n\n### Outside-In Over Bottom-Up\n\nWhen feature has operator\u002Fuser interface, **prefer outside-in**:\n1. **Each task delivers working subcommand\u002Fendpoint** — interface + behaviour in same task. Not \"skeleton now, guts later.\"\n2. **Each task = verifiable behaviour** — BDD scenario goes green \u002F operator runs command \u002F coherent section reviewable. Stubs nothing verifies = horizontal.\n3. **Validate dependencies early** — external deps become first real subcommand.\n\n**Stub trap**: \"Build CLI skeleton first\" = horizontal layer. First task = first *real* subcommand end-to-end.\n\n**Bottom-up smell**: Can operator get real result after first task? \"Not implemented\" → no. Health check showing deps → yes.\n\n**BDD-worthy features**: draft `@todo` scenario titles in `.feature` alongside task file. Scope to next 1-2 tasks only — 13 failing scenarios from day one = no signal. Later batches via `\u002Fws.tdd.idea` just-in-time. Task goal \"write BDD tests for feature\" → bottom-up smell: BDD = outer loop *before* `\u002Fws.4-run`, not capstone.\n\n### BDD decision\n\nEvery drafted task records exactly one line — `BDD decision: use | do not use — \u003Creason>` — never silently omitted. One applicability test decides it: *does this task introduce a new user-facing behavioural contract?* Not \"no observable behaviour changes\" — a task with no observable result at all is a slicing smell (see § Skip test), not an exemption.\n\n- **Introduces a new user-facing behavioural contract, with an automatable boundary** → `use` by default; it drives the outer loop unless the user explicitly overrides.\n- **Introduces no new user-facing behavioural contract** (prose, config, a doc, a design artefact, or work with no executable boundary at all) → `do not use — not applicable: \u003Creason>`.\n- **Behaviour-preserving** (refactor, mechanical migration, internal reorganisation — no *new* contract, but an *existing* one crosses the change unchanged) → `do not use — behaviour-preserving: \u003Creason>`. This still owes **observable equivalence evidence**, never a free pass: a baseline captured *before* the change, compared against the result *after*. \"Already protected\" means tests existed *before* the change, or a characterisation baseline was captured *before* it — a test written after the change that passes immediately proves nothing (a baseline captured at completion is not a baseline). Capture happens at task drafting (when the pre-change state is already inspectable) or, failing that, at the start of `ws.4-run`'s implementation loop for this task — before the change begins, never after. Record it as an Acceptance sub-bullet (`- [ ] N. Behaviour-preserving: \u003Cwhat was captured, e.g. \"existing suite green pre-change\" or \"characterisation run: \u003Ccommand> → \u003Coutput>\"> — **Demo**: \u003Cpost-change comparison command + result>`), so the task's own AC sub-bullet coverage gate (`ws.4-run` § Completion Evidence) enforces the post-change comparison the same way it enforces every other AC — no separate mechanism needed.\n- **Explicit user override** of an otherwise-BDD-worthy feature → `do not use — user override: \u003Creason>; replacement evidence: \u003Creal invocation\u002Fdemo>`. Replacement evidence is mandatory on an override — a real invocation or demo, not a description of one:\n  ```text\n  BDD decision: do not use — user override: one-off script;\n  replacement evidence: \u003Creal invocation\u002Fdemo>\n  ```\n\n**Invalid reasons, standing alone:** small, inconvenient, slow setup, unit tests already exist, behaviour is obvious. None of these answers the applicability test; each needs a real reason from one of the four lines above, or the decision is incomplete.\n\n\"Full verification command\" and \"BDD policy\" are separate contracts — one command cannot represent both.\n\n\u003C!-- WS:EXAMPLE bdd-onboarding -->\n**Onboarding** (Claude-Code adapter example, not CORE): when the user has no prior BDD policy or asks, the decision point first offers a one-line explanation — \"BDD writes the user-visible behaviour as Given\u002FWhen\u002FThen scenarios that go red before code and green when it works; worth it for executable features with a checkable boundary, skip it for prose\u002Fconfig\" — plus a guided pick, before recording the line. Keep it to that one line to protect the always-loaded budget.\n\u003C!-- \u002FWS -->\n\n### Parallel-Safe Tasks\n\nNo unfinished dependencies = parallel-safe. Add `**Parallel**: yes (alongside Tasks X, Y)`. See `ws._meta\u002Fparallel-work.md`.\n\n### Technical Debt Cleanup\n\nDebt from plan\u002Fimplementation: cleanup in task that created it. Trivial (\u003C5 min) = same task. Substantial = dedicated task immediately after. \"Clean up later\" = \"never.\"\n\n### Level 0 Additions\n\nTrivially small follow-up discovered (\u003C5 min, 1-2 files): fold into current task.\n```markdown\n- **Level 0 addition**: [description] (discovered during implementation)\n```\n\n### Walking Skeleton Must Test Real Path\n\nWalking skeleton verifying third-party integration: acceptance criteria require **actual system's UI\u002FAPI**, not simulated equivalent. Convenient test over informative = **higher-order success theater**. Walking skeleton surfaces integration surprises early; shortcuts defeat this.\n\n**Rule**: \"Verify how system X sends data\" -> test uses X's actual UI\u002Fworkflow. Setup difficulty = information (riskier integration), not reason for easier test.\n\n### Documentation as Deliverable\n\nFeature with operator\u002Fuser interface: docs are implicit deliverable -- AC on interface tasks, not separate task.\n\nTask entry names the relevant operator doc: `- **Documentation**: docs\u002F\u003Carea-or-workflow>.md (from ws._meta\u002Fworkflow-doc.md template when applicable)`\n\nBDD `@docs` scenario verifies doc exists. Written incrementally during `ws.tdd.green`.\n\n**Rule**: Task builds something operator runs -> ACs include doc path. Missing = not done.\n\n### What NOT to Do\n\n- Tasks for \"might need\" features \u002F sequence for \"easy\" not feedback \u002F batch verifiable-independently tasks \u002F split feature from operational surface \u002F defer docs to \"write docs\" task \u002F **defer a user-facing artefact's discoverability to a later task — see § Reachability pass** \u002F **make exposure its own task, or slice one capability per surface — see § Severed-capability \u002F exposure test**\n\n## Tracker Sync\n\nTasks ready = work committed. First resolve the work ledger (`ws-binding get work-ledger`; see `ws._meta\u002FSKILL.md` § Work-ledger binding): `local` → the task file itself IS the durable committed record (stable numbers = identity, `[x]`\u002F`[~]` = state); no external issues — skip the rest of this section. When a tracker is bound, make the work visible there at the org's granularity:\n\n**Issue exists**: Verify scope matches. Shifted during planning -> suggest updates.\n\n**No issue**: Propose structure:\n```\nepic: \"[Feature]\" -- links to specs\u002F\u003Cfeature>\u002F\nissue 1: \"[summary]\" -- maps to tasks 1-N\nissue 2: \"[summary]\" -- maps to tasks N-M\n```\nOne issue per logical group. After confirmation, create tracked issues, update `requirements.md` \u002F `umbrella-requirements.md` with refs.\n\n## Transition\n\n### Before the STOP gate (mandatory)\n\nFrom `ws._meta`, not optional:\n\n1. **Compaction pass** — re-read and cut. Target ≥ 20% on first pass (`ws._meta\u002Fshaping.md` §Condensation is a deliverable).\n2. **Attention-budget check** — ask: *\"Is this still shorter than your attention span for one sitting?\"* (`ws._meta\u002Fshaping.md` §Attention Budget).\n3. **Size ceiling** — check against `ws._meta\u002Fshaping.md` §Artefact size ceilings, for `tasks.md`. Past the hard cap, *merge over-granular tasks* or *split scope* -- not \"umbrella by reflex\".\n\n### Readiness checklist\n\n- [ ] Walking skeleton first\n- [ ] Each AC has a concrete demo\n- [ ] Dependencies explicit\n- [ ] First integration milestone marked\n- [ ] Every task names one capability as a concrete observation — what is run, what is seen, what would count as wrong. A property nobody can look at (\"patterns are distinguishable\", \"it's robust\") is not testable: restate as an observation or cut.\n- [ ] Compliance table clean\n- [ ] Severed-capability\u002Fexposure test run on every task; no exposure-only or per-surface-severed task survives\n- [ ] Cross-cut regret written for each task (Output B): \"ship all-but-this\" \u002F \"ship only-before-this\" stated; none reveals a contradiction\u002Fhalf-built capability\n- [ ] Separate-context slice review run (fresh subagent by default, or a clean-context second pass when no subagent; titles+goals+surfaces only); findings folded\n- [ ] Slice Ledger present and presented first; every User-job is a thing the user does (no advertising\u002Fexposing rows), no surface scattered across tasks\n- [ ] Reachability pass persisted per user-facing task in tasks.md (Surface + Boss demo + three regret scenarios written into each task entry; non-user-facing tasks have explicit `N\u002FA — \u003Creason>`); no re-cut triggers fire\n- [ ] Tests + BDD fields filled\n- [ ] Involvement summary approved\n- [ ] Doc paths named (BDD)\n- [ ] Tracker reflects work\n- [ ] Before-the-STOP-gate steps done (compaction, attention budget, size ceiling)\n\nAsk: \"Ready to start? Run `\u002Fws.4-run 1` for first task.\" Multi-slice: `\u002Fws.4-run` discovers task file if only one `tasks*.md`.\n\n## During Implementation\n\nAs tasks complete: mark done \u002F note discoveries for `\u002Fws.refine` \u002F add deferred to Backlog \u002F update the tracker at milestones (not per-task).\n\n**Drift detected**: (1) Stop. (2) `\u002Fws.refine`. (3) Continue only after specs updated.\n\n## After All Tasks Complete\n\nRun `\u002Fws.9-retro` when done \u002F merged \u002F before next feature. Don't skip.\n\n### Multi-Slice: After Slice Completes\n\n1. `\u002Fws.9-retro` scoped to slice (`retro-\u003Cslice>.md`)\n2. Update slice status in `umbrella-plan.md`\n3. Next: `\u002Fws.3-tasks` (next slice) \u002F `\u002Fws.sweep` (verify integration) \u002F `\u002Fws.9-retro` full (all complete)\n\nSlice retro asks: \"Outcome affect upcoming slices?\" If so, update umbrella specs first.\n","# ws.3-tasks\n\nLoad shared context: `ws._meta\u002FSKILL.md` — the sibling skill in the same skills directory this skill loaded from (resolves under any clone name, install location, or skills-root override). Also load: `ws._meta\u002Fshaping.md`, `ws._meta\u002Flifecycle.md`, `ws._meta\u002Fparallel-work.md`, `ws._meta\u002Fissue-tracking.md`.\n\n## Purpose\n\nBreak approved plan into concrete, sequenced tasks. Each 30 min - 2 h (see Task Sizing under Behaviors). Sequence for early integration feedback — walking skeleton first.\n\n## Prerequisites\n\n- `requirements.md` \u002F `umbrella-requirements.md` exists and approved \u002F `plan.md` \u002F `umbrella-plan.md` exists and approved \u002F User confirmed readiness\n\n### Multi-Slice Projects\n\nUmbrella shape is the **exception, not the default** (see `ws._meta\u002Fshaping.md` §Process-Shape Hard Rules). If the spec directory has `plan.md` (no `umbrella-plan.md`) → single-cycle: output `tasks.md`, ignore the rest of this section.\n\nIf `umbrella-plan.md` exists with a **Slice Status** table (umbrella already adopted — verify, don't infer): pick which slice to task (ask if unclear). Scope to that slice; reference umbrella specs for context. Output `tasks-\u003Cslice>.md`.\n\n## Process\n\n### 1. Review Plan\n\nLoad and summarize: \"Working on: [feature] \u002F Walking skeleton: [summary] \u002F Key components: [list]\"\n\n### 2. Identify Tasks\n\nBreak into atomic units. Each: 30 min - 2 h (see Task Sizing under Behaviors for full rule, including the no-sub-tasks-at-planning constraint and granularity test) \u002F clear verifiable outcome \u002F **one capability** — name the single user-job it serves; if the name needs an \"and\", split.\n\n### 3. Sequence for Integration\n\nOrder: (1) **Walking skeleton** -- end-to-end path working. (2) **Integration points early** -- surface issues first. (3) **Polish last**. Mark milestones: \"After this task, verify [X]\"\n\n#### Each Task = Self-Contained Vertical Slice (HARD RULE)\n\nEvery task MUST leave project **working and testable**. Not guideline -- structural constraint. Violations fixed before output.\n\n1. **Breaking changes include consumers.** Mandatory field \u002F schema change \u002F API alteration MUST update all consumers (fixtures, configs, tests, docs) in *same* task. Fix deferred to later = **rejected**.\n2. **Each task wires itself in.** Component MUST integrate into prod entry point + update integration\u002FBDD tests. Never accumulate unwired components.\n3. **BDD\u002Fdocs advance per task, or the task is recorded exempt.** Each task advances at least one BDD scenario red-to-green — unless its `BDD decision` (see § BDD decision) is `do not use`, recorded with the required reason. Operator docs update per behavior delivered. Separate \"write tests\"\u002F\"write docs\" task = **rejected**.\n\n**Invariant**: After every task -- the project's bound verification passes (`ws-binding get verification`; see `ws.4-run` §1a, never a hardcoded runner), BDD reflects reality, no fixture\u002Fconfig silently broken.\n\n### 4. Involvement Triage\n\nAssess each task's involvement level.\n\n| Level | Tag | Mode |\n|-------|-----|------|\n| **autonomous** | `[autonomous]` | Agent chains TDD phases, presents batch result |\n| **checkpoint** | `[checkpoint]` | Pauses at focus points for review |\n| **pair** | `[pair]` | Full interaction every TDD phase |\n\n#### Triage Criteria\n\nAutonomous only if ALL dimensions low-risk; any high-risk dimension elevates.\n\n| Dimension | autonomous | checkpoint | pair |\n|-----------|-----------|------------|------|\n| Reversibility | Trivially undone | Moderate | Hard (migrations, API contracts, data model) |\n| Domain risk | Plumbing, config | Business logic, understood | Correctness-critical, regulatory, security |\n| Novelty | Established patterns | Some unknowns | Uncharted, first use |\n| Blast radius | Local to one module | Module interfaces | Cross-system, affects data |\n\n#### Focus Areas (non-autonomous only)\n\nFor `[checkpoint]`\u002F`[pair]`, add `**Focus**` naming ACs needing scrutiny. Rest implicitly autonomous.\n\n```markdown\n### Task 2 [pair]: Implement order state machine with persistence\n- [ ] **Goal**: Orders transition through states and survive restarts\n- **Focus**: ACs 1-2 (state transition rules, error semantics)\n- **Touches**: src\u002Forder\u002Fstates.py, src\u002Forder\u002Frepo.py, src\u002Fconfig\u002Floader.py\n```\n\n#### Involvement Summary Table\n\nAdd at top of task file after Implementation Constraints:\n\n```markdown\n## Involvement Summary\n| Task | Level | Focus | Rationale |\n|------|-------|-------|-----------|\n| 1 [pair] | pair | API contract (ACs 1-2) | Walking skeleton, sets contract |\n| 2 [checkpoint] | checkpoint | Migration (AC 3) | Verify before committing to schema |\n| 3 [autonomous] | autonomous | -- | Standard CRUD, established patterns |\n```\n\nUser sign-off artifact. Present with the draft task list before execution.\n\nAgent proposes; user approves\u002Fadjusts. User may set blanket policies (\"nothing touching DB is autonomous\"). Record approved policies as implementation constraints.\n\n#### Slice Ledger (human-scannability)\n\nAbove the Involvement Summary, add a one-line-per-task ledger the user can scan in seconds to audit slicing **without** reading every task body:\n\n```markdown\n## Slice Ledger\n| Task | User-job (what the user DOES) | Surfaces touched | Distinct slice because… |\n|------|-------------------------------|------------------|--------------------------|\n| 1 | reach & read the Sent folder by alias | list_folders, search_messages, resolver | the discover-then-use loop, end to end |\n| 2 | reach Drafts\u002FTrash\u002Fthreads by alias | list_messages, read_message, get_thread | new user-jobs on new entry points |\n```\n\nThe ledger is the severed-capability test made visible. Two tells, scannable at a glance: if a row's **User-job** reads as advertising\u002Fexposing (\"make aliases discoverable\", \"update the catalog\") rather than a thing the user does, or if **Distinct slice because** can only cite a surface (\"it's the `list_folders` task\"), the slice is suspect — merge. A single surface spanning multiple tasks down the **Surfaces touched** column, or one capability's surfaces scattered across rows, is per-surface severance. Present the ledger FIRST at the STOP gate; it is what lets the human catch a bad cut in one line instead of reading the whole file.\n\n#### Involvement Sign-Off (presented at the single post-compliance gate)\n\nInvolvement is **not** presented here. There is exactly one sign-off gate, and it runs **after** vertical-slice compliance passes (see § STOP Gate: Vertical Slice Compliance). At that gate the task file is presented — Slice Ledger first, then the Involvement Summary, then enough task detail to judge the levels — in a single STOP. The involvement summary only makes sense shown with the task list, so it is never presented before compliance is clean.\n\n### 5. Validate Sequencing\n\n**AC-to-task coverage (mandatory, first)**: For every AC \u002F invariant \u002F enumerated sub-bullet in `requirements.md` \u002F `umbrella-requirements.md` within this slice's scope, name the task that makes it true. Produce the traceability table:\n\n```\nAC COVERAGE\n| requirements.md \u002F umbrella-requirements.md ref | Covered by task |\n|------------------------------------------------|-----------------|\n| Cluster X AC 1                                 | Task 2          |\n| Cluster X AC 2                                 | Task 2          |\n| Invariant 3                                    | Task 4          |\n| Cluster Y AC 1 (a)                             | Task 5          |\n| Cluster Y AC 1 (b)                             | -- GAP --       |\n```\n\nEvery AC maps to at least one task. `-- GAP --` = missing task (add one) or scope\u002Fspec drift (run `\u002Fws.refine`). **Known LLM failure mode**: drafting tasks from plan-component boundaries and silently dropping ACs that live only in `requirements.md` \u002F `umbrella-requirements.md`. Also: enumerated sub-bullets (\"for each of N sites: (a) X, (b) Y\") are N×K independent ACs — map each pair explicitly, not the parent bullet.\n\nCross-check `plan.md` \u002F `umbrella-plan.md` \u002F `decisions.md` too: any prescriptive statement (\"`_run_auto_continue` computes start_index from `next_step`\") = implicit AC. Unmapped → add a task or remove the prescription.\n\n**Sequencing questions**: \"First end-to-end feedback?\" \u002F \"Dependencies explicit?\" \u002F \"Should any split?\"\n\n#### Skip test\n\n**Mandatory, ALL tasks.** Mentally skip each task. Nothing demonstrable changes outside test suite -> infrastructure without payoff -> merge into task with demo.\n\n#### Underwhelm test\n\n**Mandatory, ALL tasks.** Imagine showing demo to senior stakeholder. \"You called me in for *this*?\" -> too thin or demo hides payoff. Merge thin tasks or rewrite demo.\n\n#### Severed-capability \u002F exposure test\n\n**Mandatory, ALL tasks.** Name the capability each task serves in one user-job phrase — a thing the user *does*. Then ask: *is this task's entire payload making a capability visible — advertising, cataloguing, documenting, adding to an index \u002F menu \u002F usage-hint — where the capability functions, or will function, without it?* If yes, merge it into the task delivering that behaviour. Equally reject per-surface slicing when those surfaces compose one capability. Both rules: `ws._meta\u002Fshaping.md` § Per-surface slicing and `ws._meta\u002Fshaping.md` § Exposure is not a slice. This test fires where the per-task Reachability pass cannot: an exposure-only task is independently demoable and \"wires into prod,\" so it passes Reachability while still being horizontal.\n\n#### Reachability pass\n\n**Mandatory, every task that produces user-facing output.** User-facing = page, screen, URL, command, generated artefact a person consumes — not internal modules, refactors, or schema migrations. For each such task, produce TWO outputs *before* the compliance gate. They are complementary: the boss demo forces narrative concreteness; the regret scenarios force adversarial generation. A leaf-only slice that survives one tends to die in the other.\n\n**Output A — Boss demo**: a scenario in which you call your senior stakeholder into a meeting, hand them the running product, and ask them to find and exercise the new capability *themselves*, *after only this task has shipped*. Specify:\n\n1. The opening prompt you give them (\"Find me the wireless headphones.\" \u002F \"Try the postal-code validator.\" \u002F \"Show me which orders qualify for free shipping.\").\n2. The exact sequence of *their* actions — clicks, typed input, commands — starting from the **product's own entry surface** for this kind of feature. Surface depends on artefact:\n   - UI page \u002F screen → in-product navigation: home page, menu, index page, in-product search, sitemap, or a workflow that lands here.\n   - CLI feature → root command + `--help`, or the discoverable subcommand listing.\n   - API endpoint → the consumer's real catalog \u002F OpenAPI doc \u002F SDK surface.\n   - Generated artefact (file, export, report) → the real output path or catalog the consumer already uses.\n   - Library \u002F module → the package's public surface (`__all__`, exported index, documented import path).\n\n   **README \u002F changelog \u002F docs are supporting evidence, not entry points — where the product has an in-product surface at all.** A page mentioned only in README but not linked from the site is still a leaf. Not your steps as the developer; the boss's steps as a first-time user.\n\n   **Applicability**: where the product has no surface other than what a reader opens — a library consumed by import, a framework distributed as files, a documentation site — the README or docs page *is* the entry point, and wiring it means linking it from wherever a reader actually arrives. Declare which case applies rather than assuming; a rule written for executables silently fails every repo that is not one.\n3. What they see at the end.\n\n**Output B — Three \"we'd regret shipping ONLY this task\" scenarios**, written as real-world phrases, not test cases. Same structure as the walking-skeleton adversarial pass at `[x]` time — and the reason it works here is the same: it forces *generation* of failure modes, which is harder to fake than narrating a smooth demo. If any scenario reads \"the new thing exists but no one can find \u002F use \u002F hear about it\" → re-cut.\n\n**At least one of the three MUST be a cross-cut, not a within-task bug.** State the product after *\"ship every task except this one\"* and after *\"ship only the tasks before this one.\"* \"Coherent, just less capability\" → legitimate additive scope (fan-out, keep). \"The product contradicts itself \u002F its catalog lies \u002F a half-built capability ships\" → this task is the missing half of another; merge. A within-task quality regret (\"the feature has a bug\", \"INBOX miscategorised\") does NOT satisfy this — the regret must be about what the CUT leaves behind. This is the check that catches exposure-only and per-surface-severed tasks, which the boss demo and within-task regrets wave through.\n\n**Re-cut triggers** (apply to either output):\n\n- **\"There's nothing to see yet — that'll come N tasks later.\"** → leaf-only slicing. Re-cut to ship something the boss can reach today.\n- **\"I can't find it from the menu — here's the URL.\"** → discoverability deferred. Re-cut to include the **in-product** discoverability surface (menu entry, index page, sitemap inclusion, root-command help, catalog\u002Findex entry — see Output A's surface list) in the *same* task. README additions don't count; they're supporting docs, not product navigation.\n- **\"Now pretend the navigation link is there...\"** → pretending bridges the gap = horizontal scaffolding in plain clothes. Re-cut.\n- **\"It works, but I called you in to see one button.\"** → too thin. Merge with adjacent task or surface a larger payoff. (Overlaps with Underwhelm test; both fire.)\n\nIf the boss can't get from \"Find me X\" to \"ah, here it is\" through their own actions on the running product — OR if any of the three regret scenarios reads \"exists but unreachable\" — the task is not a vertical slice. It is a leaf labelled as one.\n\nKnown failure mode: **leaf-only slicing**. Task ships a renderable page or generated artefact; menu entry, index link, or sitemap inclusion gets sequenced to a later task. Sounds reasonable (\"content first, navigation later\"), IS the well-trodden pattern in training data (MVC layering, \"data layer first\", \"scaffolding then polish\"), and IS horizontal scaffolding wearing a slice's clothes. The forbidden-words list in `ws._meta\u002Fshaping.md` § Slicing must never be justified by architecture catches *justification* language (`skeleton-then-flesh-out`, `walking-skeleton-with-deferred-X`) but not plain-English equivalents like \"don't open discoverability until content is complete\" — same antipattern, different words. The two outputs catch it two ways: the boss's narrated actions cannot reach the new artefact without the LLM noticing the gap mid-walkthrough; the regret scenarios cannot be honestly enumerated without one of them reading \"exists but no one can find it.\" A smooth demo papered over the gap? The regret scenarios should still surface it. Vague regret scenarios that miss the gap? The boss demo should still trip on the unreachable click. Both fake at once would require the LLM to actively lie in two complementary registers — much higher friction than letting one slip.\n\nKnown failure mode (mirror): **exposure-as-its-own-task**. Real case — an alias-resolution feature sliced as: Tasks 1-2 deliver the resolver and wire it into the message tools; Task 3 \"rebuild `list_folders` to advertise the aliases.\" Task 3 passed every per-task check — `list_folders` is independently demoable, \"wires into prod\" was literally yes, and its three regret scenarios were all internal bugs (miscategorised INBOX, phantom rows, weak wording). It was still horizontal: the discoverability-half of the capability whose behaviour shipped in Tasks 1-2, leaving a window where the agent's own catalog taught the localized folder names while the tools wanted the aliases. The cross-cut regret that kills it — \"ship 1-2 without 3 → the catalog contradicts the tools\" — was never generated, because per-task checks cannot see cross-task severance. Caught only by the human. This is why the cross-cut regret (Output B) and the separate-context review (below) are mandatory, not the per-task demo.\n\n**Verify before sequencing**: Ordering relies on assumption (\"X unavailable\")? Verify first -- filesystem, dry-run, test connection. 30-second check costs nothing; unverified assumption pushes feedback back days. Example: \"BDD can't run\" -> check dependencies exist. Present? BDD runs now. Missing? Tell user. Principle: **never sequence around unverified constraint.**\n\n**Separate-context slice review (mandatory, before the compliance gate)**: Self-review shares the slicing blind spot — the same context that sliced per-surface also writes the regret scenarios, blind in the same place, so it validates its own cut. Break that loop: the cut MUST be reviewed by a context that did not author it, given **only** task titles + one-line goals + surfaces-touched — NOT your justifications, ledger, or rationale. Single instruction: *\"For each task answer: is its entire payload exposing\u002Fadvertising\u002Fcataloguing\u002Fdocumenting a capability another task delivers? Do any tasks split one capability across surfaces (one per tool \u002F endpoint \u002F file \u002F screen)? List every task that is exposure-only or per-surface-severed with one reason each, else reply NONE.\"* A reviewer with no stake and one sharp question catches what invested self-review misses. Fold its findings (merge flagged tasks) before producing the compliance table. This is the highest-leverage check here — prose guardrails the authoring context skims; a differently-framed reader with no stake does not.\n\n\u003C!-- WS:DEFAULT independent-review-agent -->\nThe recommended way to obtain that independent context is a fresh subagent (the Agent tool), handed the titles-goals-surfaces list above with an explicit instruction: *\"Proceed as if you have no knowledge of prior context — review only what is handed to you.\"* Where the runtime offers no subagent, fall back to a clean-context second pass — a freshly-cleared session fed the same list and the same instruction, so it cannot see (and rubber-stamp) the authoring rationale — and escalate to a human checkpoint when the stakes are high (irreversible cuts, money\u002Fcommitment surfaces, or a \"NONE\" verdict on a large slice). Label this fallback's evidence **self-review fallback**, not independent review: it removes visible context, but not the authoring session's blind spots, habits, or unstated assumptions carried into the fresh pass — the thing genuine independence buys and this cannot. Never skip the review and never block on the mechanism: the requirement above is the invariant; the subagent is the default means.\n\u003C!-- \u002FWS -->\n\n#### STOP Gate: Vertical Slice Compliance, then Present\n\n**This is the single sign-off gate, in one order: compliance first, then present.** Do not present the task list until compliance passes. Produce compliance table:\n\n```\nVERTICAL SLICE COMPLIANCE\n| Task | Tests green after? | Breaks unfixed? | Wires into prod? | Demo? | BDD advanced? |\n|------|--------------------|-----------------|-------------------|-------|---------------|\n| 1    | [which tests]      | [no \u002F what]     | [yes\u002Fno\u002FN\u002FA]      | [concrete demo] | [which \u002F N\u002FA] |\n```\n\n**Gate rules -- violation = restructure:**\n\n1. **\"Tests green?\" blank** -> merge into adjacent task or add verification\n2. **\"Breaks unfixed?\" not \"no\"** -> fold fix into *this* task\n3. **\"Wires into prod?\" = \"no\" \u002F \"later task\" \u002F names a future task** -> unwired = horizontal; the task must connect the new artefact to BOTH (a) the code path that runs in production (imports, routes, registrations) AND (b) the **in-product** user-discoverability surface for this kind of feature (UI page → menu \u002F index \u002F sitemap; CLI feature → root help; API endpoint → catalog; generated artefact → real output path or index — see Reachability pass Output A for the surface list) — in the same task. README \u002F changelog \u002F docs are supporting evidence, not substitutes for in-product wiring. Internal-only tasks (refactor, plumbing, schema migration) write \"N\u002FA — no user surface\" and skip the user-discoverability half. User-facing tasks failing either half must absorb the missing wiring; deferring discoverability to \"Task N+k\" = leaf-only slicing (see Reachability pass under §Validate Sequencing).\n4. **\"Demo?\" blank \u002F \"run tests\"** -> merge into demonstrable task. Qualifying: \"open page, see X\" \u002F \"run command, see Y\". NOT: \"pytest passes\"\n5. **\"Demo?\" fails underwhelm test** -> merge thin tasks or surface user-facing change\n6. **\"BDD advanced?\" blank** -> restructure. Every cell is either progression evidence (which scenario, red-to-green) or the task's own `BDD decision: do not use — \u003Creason>` cited verbatim — never a bare blank, and never excused by being a single occurrence.\n\n**Rejected shapes**: \"connect\u002Fwire previously built components\" \u002F \"update fixtures for earlier changes\" \u002F \"write BDD tests\" near end \u002F stubs with no backing behavior.\n\nRe-run compliance after restructuring. Repeat until clean. State changes: \"Merged Task 7 into 1 because...\"\n\n**Only once compliance is clean, present** the task file for sign-off — Slice Ledger first, then the Involvement Summary, then enough task detail to judge the levels. STOP. Wait for user approval or adjustments before writing the final task file or starting `\u002Fws.4-run`. There is no earlier \"present\" step; this is the one gate.\n\n## Output Structure\n\nWrite to `tasks.md` (or `specs\u002F\u003Cfeature>\u002Ftasks.md`). Multi-slice: `tasks-\u003Cslice>.md`.\n\n```markdown\n# Tasks: [Feature Name] -- [Slice Name if multi-slice]\n\n## Implementation Constraints\n**Permitted**: Libraries: [list] \u002F Patterns: [list] \u002F Files: [scope]\n**Not Permitted**: [constraints]\n**Style**: [project conventions]\n\n## Slice Ledger\n| # | User-job (what someone DOES) | Surfaces touched | Distinct slice because… |\n|---|------------------------------|------------------|-------------------------|\n| 1 | [a thing the user\u002Foperator does] | [surfaces] | [user\u002Foperator-term reason — no layer\u002Fcomponent\u002Fsurface nouns] |\n\n## Involvement Summary\n| Task | Level | Focus | Rationale |\n|------|-------|-------|-----------|\n| 1 | pair | [ACs] | [why] |\n| 2 | autonomous | -- | [why] |\n\n## Walking Skeleton\n\n### Task 1 [pair]: [Name]\n- [ ] **Goal**: [achievement]\n- **Focus**: [ACs needing scrutiny -- omit for autonomous]\n- **Touches**: [files]\n- **Depends on**: None\n- **Parallel**: yes (alongside Task 4)\n- **Acceptance**:\n  1. [Criterion] -- **Demo**: [command + observation]\n- **Reachability** (required for user-facing tasks; non-user-facing: `N\u002FA — \u003Creason>`):\n  - **Surface**: [in-product entry point added by this task — e.g., \"menu item Shop > Headphones added to top nav\", \"`cli foo bar` listed in root `--help`\", \"endpoint listed in `\u002Fopenapi.json`\"]\n  - **Boss demo**: [opening prompt → boss's actions step-by-step from the surface above → what they see, written out verbatim, e.g., \"Tell boss: 'Find the wireless headphones.' Boss lands on `\u002F`. Clicks `Shop` in top nav. Sees `Headphones` category. Clicks. Sees product list with N entries.\"]\n  - **Three regret scenarios**: 1. [scenario] 2. [scenario] 3. [scenario]\n- **Tests green after**: [specific tests]\n- **BDD decision**: use | do not use — \u003Creason>  (see § BDD decision)\n\n### Task 2 [autonomous]: [Name]\n- [ ] **Goal**: [achievement]\n- **Touches**: [files]\n- **Depends on**: Task 1\n- **Acceptance**:\n  1. [Criterion] -- **Demo**: [command + observation]\n- **Reachability**: [as Task 1, or `N\u002FA — \u003Creason>` for non-user-facing]\n- **Tests green after**: [tests]\n- **BDD decision**: use | do not use — \u003Creason>  (see § BDD decision)\n\n**INTEGRATION MILESTONE**: After Task 2, verify [point]\n\n## Remaining Tasks\n### Task 3 [checkpoint]: [Name]\n[same structure]\n\n## Backlog (Deferred)\n- [Item] -- [why deferred]\n```\n\n## Behaviors\n\n### Task Sizing\n\nDefault size: **30 minutes to 2 hours** of focused work. Below 30 min → merge with neighbour. Above 2 h → split *only* if the split passes the slicing-justification rule in `ws._meta` (no technical-layer splits). Verifiable completion (\"X does Y\", not \"work on X\"). Vague = too big.\n\n**No sub-tasks at planning time.** `tasks.md` is a flat list (1, 2, 3, …) — never `2a\u002F2b\u002F2c`. Letter suffixes are an *execution-time* numbering tool only: preserve stable numbering when drift during Task 2 forces inserting a new item (record as `2a` so `3` still refers to the same work). Sub-tasks proposed at planning time are LLM sprawl — merge or restructure before presenting.\n\n**Granularity test before presenting:** read each task's Goal aloud. If it sounds like a step *inside* a larger task (\"wire X\", \"configure Y\", \"add fixture for Z\") rather than a unit the operator narrates (\"the order lands in the fulfillment queue\"), it's too granular — merge.\n\nAnti-example (narrated, not a shipped example — the original was private case-history): a skill-artefact slice decomposed into four tasks along technical-layer lines (schema → meta → book → exercise). Not separable for a skill artefact; produced churn that single-pass authoring would have avoided.\n\n### Outside-In Over Bottom-Up\n\nWhen feature has operator\u002Fuser interface, **prefer outside-in**:\n1. **Each task delivers working subcommand\u002Fendpoint** — interface + behaviour in same task. Not \"skeleton now, guts later.\"\n2. **Each task = verifiable behaviour** — BDD scenario goes green \u002F operator runs command \u002F coherent section reviewable. Stubs nothing verifies = horizontal.\n3. **Validate dependencies early** — external deps become first real subcommand.\n\n**Stub trap**: \"Build CLI skeleton first\" = horizontal layer. First task = first *real* subcommand end-to-end.\n\n**Bottom-up smell**: Can operator get real result after first task? \"Not implemented\" → no. Health check showing deps → yes.\n\n**BDD-worthy features**: draft `@todo` scenario titles in `.feature` alongside task file. Scope to next 1-2 tasks only — 13 failing scenarios from day one = no signal. Later batches via `\u002Fws.tdd.idea` just-in-time. Task goal \"write BDD tests for feature\" → bottom-up smell: BDD = outer loop *before* `\u002Fws.4-run`, not capstone.\n\n### BDD decision\n\nEvery drafted task records exactly one line — `BDD decision: use | do not use — \u003Creason>` — never silently omitted. One applicability test decides it: *does this task introduce a new user-facing behavioural contract?* Not \"no observable behaviour changes\" — a task with no observable result at all is a slicing smell (see § Skip test), not an exemption.\n\n- **Introduces a new user-facing behavioural contract, with an automatable boundary** → `use` by default; it drives the outer loop unless the user explicitly overrides.\n- **Introduces no new user-facing behavioural contract** (prose, config, a doc, a design artefact, or work with no executable boundary at all) → `do not use — not applicable: \u003Creason>`.\n- **Behaviour-preserving** (refactor, mechanical migration, internal reorganisation — no *new* contract, but an *existing* one crosses the change unchanged) → `do not use — behaviour-preserving: \u003Creason>`. This still owes **observable equivalence evidence**, never a free pass: a baseline captured *before* the change, compared against the result *after*. \"Already protected\" means tests existed *before* the change, or a characterisation baseline was captured *before* it — a test written after the change that passes immediately proves nothing (a baseline captured at completion is not a baseline). Capture happens at task drafting (when the pre-change state is already inspectable) or, failing that, at the start of `ws.4-run`'s implementation loop for this task — before the change begins, never after. Record it as an Acceptance sub-bullet (`- [ ] N. Behaviour-preserving: \u003Cwhat was captured, e.g. \"existing suite green pre-change\" or \"characterisation run: \u003Ccommand> → \u003Coutput>\"> — **Demo**: \u003Cpost-change comparison command + result>`), so the task's own AC sub-bullet coverage gate (`ws.4-run` § Completion Evidence) enforces the post-change comparison the same way it enforces every other AC — no separate mechanism needed.\n- **Explicit user override** of an otherwise-BDD-worthy feature → `do not use — user override: \u003Creason>; replacement evidence: \u003Creal invocation\u002Fdemo>`. Replacement evidence is mandatory on an override — a real invocation or demo, not a description of one:\n  ```text\n  BDD decision: do not use — user override: one-off script;\n  replacement evidence: \u003Creal invocation\u002Fdemo>\n  ```\n\n**Invalid reasons, standing alone:** small, inconvenient, slow setup, unit tests already exist, behaviour is obvious. None of these answers the applicability test; each needs a real reason from one of the four lines above, or the decision is incomplete.\n\n\"Full verification command\" and \"BDD policy\" are separate contracts — one command cannot represent both.\n\n\u003C!-- WS:EXAMPLE bdd-onboarding -->\n**Onboarding** (Claude-Code adapter example, not CORE): when the user has no prior BDD policy or asks, the decision point first offers a one-line explanation — \"BDD writes the user-visible behaviour as Given\u002FWhen\u002FThen scenarios that go red before code and green when it works; worth it for executable features with a checkable boundary, skip it for prose\u002Fconfig\" — plus a guided pick, before recording the line. Keep it to that one line to protect the always-loaded budget.\n\u003C!-- \u002FWS -->\n\n### Parallel-Safe Tasks\n\nNo unfinished dependencies = parallel-safe. Add `**Parallel**: yes (alongside Tasks X, Y)`. See `ws._meta\u002Fparallel-work.md`.\n\n### Technical Debt Cleanup\n\nDebt from plan\u002Fimplementation: cleanup in task that created it. Trivial (\u003C5 min) = same task. Substantial = dedicated task immediately after. \"Clean up later\" = \"never.\"\n\n### Level 0 Additions\n\nTrivially small follow-up discovered (\u003C5 min, 1-2 files): fold into current task.\n```markdown\n- **Level 0 addition**: [description] (discovered during implementation)\n```\n\n### Walking Skeleton Must Test Real Path\n\nWalking skeleton verifying third-party integration: acceptance criteria require **actual system's UI\u002FAPI**, not simulated equivalent. Convenient test over informative = **higher-order success theater**. Walking skeleton surfaces integration surprises early; shortcuts defeat this.\n\n**Rule**: \"Verify how system X sends data\" -> test uses X's actual UI\u002Fworkflow. Setup difficulty = information (riskier integration), not reason for easier test.\n\n### Documentation as Deliverable\n\nFeature with operator\u002Fuser interface: docs are implicit deliverable -- AC on interface tasks, not separate task.\n\nTask entry names the relevant operator doc: `- **Documentation**: docs\u002F\u003Carea-or-workflow>.md (from ws._meta\u002Fworkflow-doc.md template when applicable)`\n\nBDD `@docs` scenario verifies doc exists. Written incrementally during `ws.tdd.green`.\n\n**Rule**: Task builds something operator runs -> ACs include doc path. Missing = not done.\n\n### What NOT to Do\n\n- Tasks for \"might need\" features \u002F sequence for \"easy\" not feedback \u002F batch verifiable-independently tasks \u002F split feature from operational surface \u002F defer docs to \"write docs\" task \u002F **defer a user-facing artefact's discoverability to a later task — see § Reachability pass** \u002F **make exposure its own task, or slice one capability per surface — see § Severed-capability \u002F exposure test**\n\n## Tracker Sync\n\nTasks ready = work committed. First resolve the work ledger (`ws-binding get work-ledger`; see `ws._meta\u002FSKILL.md` § Work-ledger binding): `local` → the task file itself IS the durable committed record (stable numbers = identity, `[x]`\u002F`[~]` = state); no external issues — skip the rest of this section. When a tracker is bound, make the work visible there at the org's granularity:\n\n**Issue exists**: Verify scope matches. Shifted during planning -> suggest updates.\n\n**No issue**: Propose structure:\n```\nepic: \"[Feature]\" -- links to specs\u002F\u003Cfeature>\u002F\nissue 1: \"[summary]\" -- maps to tasks 1-N\nissue 2: \"[summary]\" -- maps to tasks N-M\n```\nOne issue per logical group. After confirmation, create tracked issues, update `requirements.md` \u002F `umbrella-requirements.md` with refs.\n\n## Transition\n\n### Before the STOP gate (mandatory)\n\nFrom `ws._meta`, not optional:\n\n1. **Compaction pass** — re-read and cut. Target ≥ 20% on first pass (`ws._meta\u002Fshaping.md` §Condensation is a deliverable).\n2. **Attention-budget check** — ask: *\"Is this still shorter than your attention span for one sitting?\"* (`ws._meta\u002Fshaping.md` §Attention Budget).\n3. **Size ceiling** — check against `ws._meta\u002Fshaping.md` §Artefact size ceilings, for `tasks.md`. Past the hard cap, *merge over-granular tasks* or *split scope* -- not \"umbrella by reflex\".\n\n### Readiness checklist\n\n- [ ] Walking skeleton first\n- [ ] Each AC has a concrete demo\n- [ ] Dependencies explicit\n- [ ] First integration milestone marked\n- [ ] Every task names one capability as a concrete observation — what is run, what is seen, what would count as wrong. A property nobody can look at (\"patterns are distinguishable\", \"it's robust\") is not testable: restate as an observation or cut.\n- [ ] Compliance table clean\n- [ ] Severed-capability\u002Fexposure test run on every task; no exposure-only or per-surface-severed task survives\n- [ ] Cross-cut regret written for each task (Output B): \"ship all-but-this\" \u002F \"ship only-before-this\" stated; none reveals a contradiction\u002Fhalf-built capability\n- [ ] Separate-context slice review run (fresh subagent by default, or a clean-context second pass when no subagent; titles+goals+surfaces only); findings folded\n- [ ] Slice Ledger present and presented first; every User-job is a thing the user does (no advertising\u002Fexposing rows), no surface scattered across tasks\n- [ ] Reachability pass persisted per user-facing task in tasks.md (Surface + Boss demo + three regret scenarios written into each task entry; non-user-facing tasks have explicit `N\u002FA — \u003Creason>`); no re-cut triggers fire\n- [ ] Tests + BDD fields filled\n- [ ] Involvement summary approved\n- [ ] Doc paths named (BDD)\n- [ ] Tracker reflects work\n- [ ] Before-the-STOP-gate steps done (compaction, attention budget, size ceiling)\n\nAsk: \"Ready to start? Run `\u002Fws.4-run 1` for first task.\" Multi-slice: `\u002Fws.4-run` discovers task file if only one `tasks*.md`.\n\n## During Implementation\n\nAs tasks complete: mark done \u002F note discoveries for `\u002Fws.refine` \u002F add deferred to Backlog \u002F update the tracker at milestones (not per-task).\n\n**Drift detected**: (1) Stop. (2) `\u002Fws.refine`. (3) Continue only after specs updated.\n\n## After All Tasks Complete\n\nRun `\u002Fws.9-retro` when done \u002F merged \u002F before next feature. Don't skip.\n\n### Multi-Slice: After Slice Completes\n\n1. `\u002Fws.9-retro` scoped to slice (`retro-\u003Cslice>.md`)\n2. Update slice status in `umbrella-plan.md`\n3. Next: `\u002Fws.3-tasks` (next slice) \u002F `\u002Fws.sweep` (verify integration) \u002F `\u002Fws.9-retro` full (all complete)\n\nSlice retro asks: \"Outcome affect upcoming slices?\" If so, update umbrella specs first.\n",{"name":5,"description":7},"main","1ad262fc695612ff484ee364ff66ab5298bdda58","skills\u002Fws.3-tasks",0,"https:\u002F\u002Fgithub.com\u002Fvempio\u002FWhittleSpec","https:\u002F\u002Fgithub.com\u002Fvempio","2026-10-06 16:08:48",{"source":8,"skillName":5,"commands":31,"prompt":41,"zipAvailable":42},[32,35,38],{"tool":33,"command":34},"npx","npx skills add vempio\u002FWhittleSpec --skill ws-3-tasks",{"tool":36,"command":37},"bunx","bunx skills add vempio\u002FWhittleSpec --skill ws-3-tasks",{"tool":39,"command":40},"pnpm","pnpm dlx skills add vempio\u002FWhittleSpec --skill ws-3-tasks","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fvempio\u002FWhittleSpec\u002Fblob\u002Fmain\u002Fskills\u002Fws.3-tasks\u002FSKILL.md",true,[],[45,52,59,66,73,80],{"skillNo":46,"name":47,"nameZh":6,"description":48,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":49,"categories":50,"keywords":51,"publishedAt":18},"01M72TSQYBBJ3FG1MSMB9B33SZ","ws-tdd-review","Audit existing test code for quality, depth, and adherence to TDD principles.","https:\u002F\u002Fgithub.com\u002Fvempio\u002FWhittleSpec\u002Fblob\u002Fmain\u002Fskills\u002Fws.tdd.review\u002FSKILL.md",[],[],{"skillNo":53,"name":54,"nameZh":6,"description":55,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":56,"categories":57,"keywords":58,"publishedAt":18},"01M72TSN33MN2J0CW29MBY4WC4","ws-tdd-red","Phase 3 -- implement failing tests, validating assertion quality and depth.","https:\u002F\u002Fgithub.com\u002Fvempio\u002FWhittleSpec\u002Fblob\u002Fmain\u002Fskills\u002Fws.tdd.red\u002FSKILL.md",[],[],{"skillNo":60,"name":61,"nameZh":6,"description":62,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":63,"categories":64,"keywords":65,"publishedAt":18},"01M72TSJMTHFVC8FW2BGQ0NYD7","ws-tdd-outline","Phase 2 -- tree-level test design, examining intent and approach per test.","https:\u002F\u002Fgithub.com\u002Fvempio\u002FWhittleSpec\u002Fblob\u002Fmain\u002Fskills\u002Fws.tdd.outline\u002FSKILL.md",[],[],{"skillNo":67,"name":68,"nameZh":6,"description":69,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":70,"categories":71,"keywords":72,"publishedAt":18},"01M72TSFPHD749CY9KRV66T0RH","ws-tdd-idea","Phase 1 -- forest-level test case discovery, mapping the full problem space.","https:\u002F\u002Fgithub.com\u002Fvempio\u002FWhittleSpec\u002Fblob\u002Fmain\u002Fskills\u002Fws.tdd.idea\u002FSKILL.md",[],[],{"skillNo":74,"name":75,"nameZh":6,"description":76,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":77,"categories":78,"keywords":79,"publishedAt":18},"01M72TSD53VT09VF3EG67KA68E","ws-tdd-green","Phase 4 -- write minimal production code to make failing tests pass.","https:\u002F\u002Fgithub.com\u002Fvempio\u002FWhittleSpec\u002Fblob\u002Fmain\u002Fskills\u002Fws.tdd.green\u002FSKILL.md",[],[],{"skillNo":81,"name":82,"nameZh":6,"description":83,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":84,"categories":85,"keywords":86,"publishedAt":18},"01M72TS9TXQ9RHYF3VBGR87BF6","ws-tdd-meta","TDD shared context -- phased protocol, quality standards, and standing instructions for all TDD skills.","https:\u002F\u002Fgithub.com\u002Fvempio\u002FWhittleSpec\u002Fblob\u002Fmain\u002Fskills\u002Fws.tdd._meta\u002FSKILL.md",[],[]]