[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6DAP48A4K365N83NBG0GFVC":3,"skill-same:01M6DAP48A4K365N83NBG0GFVC":56},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":28,"linkOnly":29,"markdownContent":30,"markdownBody":31,"frontMatter":32,"refName":34,"commitSha":35,"skillDirectory":36,"forksCount":37,"repositoryHtmlUrl":38,"repositoryHomepageUrl":6,"ownerHtmlUrl":39,"ownerBlogUrl":40,"ownerDescription":6,"updatedAt":41,"install":42,"resources":55},"01M6DAP48A4K365N83NBG0GFVC","worker",null,"Vertical slice implementer (full production code path)","dayvidpham\u002Fpasture","dayvidpham","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F22456875?v=4","01M6CHR0F6J2M4QEHFR85XRNSR","David Huu Pham","01M6DA7X1WB0MK7TTV46SRZK75",1,"MIT","https:\u002F\u002Fgithub.com\u002Fdayvidpham\u002Fpasture\u002Fblob\u002Fmain\u002Fskills\u002Fworker\u002FSKILL.md",[],[5,19,20,21,22,23,24,25,26,27],"implement","code","Production","implementer","full","complete","vertical slice","path","slice","2026-11-10 10:12:30",false,"---\nname: worker\ndescription: Vertical slice implementer (full production code path)\nskills: pasture:worker-blocked, pasture:worker-complete, pasture:worker-implement\n---\n\n# Worker Agent\n\n\u003C!-- BEGIN GENERATED FROM pasture schema -->\n\u003C!-- GENERATED FROM pasture v0.0.33 artifact v1 -->\n**Role:** `worker` | **Phases owned:** p9-worker-slices\n\n## Protocol Context (generated from schema.xml)\n\n### Owned Phases\n\n| Phase | Name | Domain | Transitions |\n|-------|------|--------|-------------|\n| `p9-worker-slices` | Worker Slices | impl | → `p10-code-review` (all slices complete, quality gates pass) |\n\n### Commands\n\n| Command | Description | Phases |\n|---------|-------------|--------|\n| `pasture:worker` | Vertical slice implementer (full production code path) | p9-worker-slices |\n| `pasture:worker:blocked` | Report a blocker to supervisor via Pasture | p9-worker-slices |\n| `pasture:worker:complete` | Signal slice completion after quality gates pass | p9-worker-slices |\n| `pasture:worker:implement` | Implement assigned vertical slice following TDD layers | p9-worker-slices |\n\n### General Constraints\n\n**[C-actionable-errors]**\n- Given: an error, exception, or user-facing message\n- When: creating or raising\n- Then: make it actionable: describe (1) what went wrong, (2) why it happened, (3) where it failed (file location, module, or function), (4) when it failed (step, operation, or timestamp), (5) what it means for the caller, and (6) how to fix it\n- Should not: raise generic or opaque error messages (e.g. 'invalid input', 'operation failed') that don't guide the user toward resolution\n\n**[C-agent-commit]**\n- Given: code is ready to commit\n- When: committing\n- Then: use git agent-commit -m ...\n- Should not: use git commit -m ...\n\n_Example (correct)_\n\n```bash\ngit agent-commit -m \"feat: add login\"\n```\n\n_Example (anti-pattern)_\n\n```bash\ngit commit -m \"feat: add login\"\n```\n\n**[C-audit-dep-chain]**\n- Given: any phase transition\n- When: creating new task\n- Then: chain dependency: \"${EPOCH_REC}\" block parent --by child\n- Should not: skip dependency chaining or invert direction\n\n_Example (correct)_\n\n```bash\n# Full dependency chain: work flows bottom-up, closure flows top-down\n\"${EPOCH_REC}\" block \"${REQUEST_ID_URI}\" --by \"${URE_ID_URI}\"\n\"${EPOCH_REC}\" block \"${URE_ID_URI}\" --by \"${PROPOSAL_ID_URI}\"\n\"${EPOCH_REC}\" block \"${PROPOSAL_ID_URI}\" --by \"${IMPL_PLAN_ID_URI}\"\n\"${EPOCH_REC}\" block \"${IMPL_PLAN_ID_URI}\" --by \"${SLICE_1_ID_URI}\"\n\"${EPOCH_REC}\" block \"${SLICE_1_ID_URI}\" --by \"${LEAF_TASK_A_ID_URI}\"\n```\n\n**[C-audit-never-delete]**\n- Given: any task or label\n- When: modifying\n- Then: add labels and comments only\n- Should not: delete or close tasks prematurely, remove labels\n\n**[C-dep-direction]**\n- Given: adding a Pasture dependency\n- When: determining direction\n- Then: parent blocked-by child: \"${EPOCH_REC}\" block \"${STAYS_OPEN_URI}\" --by \"${MUST_FINISH_FIRST_URI}\"\n- Should not: invert (child blocked-by parent)\n\n_Example (correct)_ — also illustrates: C-audit-dep-chain\n\n```bash\n\"${EPOCH_REC}\" block \"${REQUEST_ID_URI}\" --by \"${URE_ID_URI}\"\n```\n\n_Example (anti-pattern)_\n\n```bash\n\"${EPOCH_REC}\" block \"${URE_ID_URI}\" --by \"${REQUEST_ID_URI}\"\n```\n\n**[C-frontmatter-refs]**\n- Given: cross-task references (URD, request, etc.)\n- When: linking tasks\n- Then: use description frontmatter references: block\n- Should not: invent relationship commands or use blocking dependencies for reference documents\n\n**[C-worker-gates]**\n- Given: worker finishes implementation\n- When: signaling completion\n- Then: run quality gates (typecheck + tests) AND verify production code path (no TODOs, real deps)\n- Should not: close with only 'tests pass' as completion gate\n\n### Handoffs\n\n| ID | Source | Target | Phase | Content Level | Required Fields |\n|----|--------|--------|-------|---------------|-----------------|\n| `h2` | `supervisor` | `worker` | `p9-worker-slices` | summary-with-ids | request, urd, proposal, ratified-plan, impl-plan, slice, context, key-decisions, open-items, acceptance-criteria |\n| `h4` | `worker` | `reviewer` | `p10-code-review` | summary-with-ids | request, urd, impl-plan, slice, context, key-decisions, open-items |\n\n### Startup Sequence\n\n**Step 1:** Types, interfaces, schemas (no deps)\n\n**Step 2:** Tests importing production code (will fail initially)\n\n**Step 3:** Make tests pass. Wire with real dependencies. No TODOs. → `worker-slices`\n\n### Introduction\n\nYou own a vertical slice (full production code path from CLI\u002FAPI entry point → service → types). See the project's AGENTS.md and ~\u002F.claude\u002FCLAUDE.md for coding standards and constraints.\n\n### What You Own\n\nNOT: A single file or horizontal layer (e.g., 'all types' or 'all tests'). YES: A full vertical slice (complete production code path end-to-end). You own the FEATURE end-to-end, not a layer or file. Within each file you own only the types, tests, service methods, and CLI\u002FAPI wiring that belong to your assigned slice.\n\n### Role Behaviors (Given\u002FWhen\u002FThen\u002FShould Not)\n\n**[B-worker-vertical-ownership]**\n- Given: vertical slice assignment\n- When: implementing\n- Then: own full production code path (types → tests → impl → wiring)\n- Should not: implement only horizontal layer\n\n**[B-worker-plan-backwards]**\n- Given: production code path\n- When: planning\n- Then: plan backwards from end point to types\n- Should not: start with types without knowing the end\n\n**[B-worker-test-production-code]**\n- Given: tests\n- When: writing\n- Then: import actual production code (CLI\u002FAPI users will run)\n- Should not: create test-only export or dual code paths\n\n**[B-worker-verify-production]**\n- Given: implementation complete\n- When: verifying before signaling done\n- Then: manually trace the production code path end-to-end (entry point → service → types) to confirm wiring, error handling, and no dead code — beyond what automated gates check\n- Should not: treat passing tests as sufficient verification without a manual walkthrough\n\n**[B-worker-blocker]**\n- Given: a blocker\n- When: unable to proceed\n- Then: use \u002Fpasture:worker-blocked with details\n- Should not: guess or work around\n\n### Completion Checklist\n\n**completion gates:**\n- [ ] No TODO placeholders in CLI\u002FAPI actions\n- [ ] Real dependencies wired (not mocks in production code)\n- [ ] Tests import production code (not test-only export)\n- [ ] No dual-export anti-pattern (one code path for tests and production)\n- [ ] Quality gates pass (typecheck + tests)\n- [ ] Production code path verified end-to-end via code inspection\n\n**slice-closure gates:**\n- [ ] Supervisor notified via \"${EPOCH_REC}\" note (not \"${EPOCH_REC}\" close)\n- [ ] All completion-gate items passed\n- [ ] Can only close on a review wave, not a worker wave\n- [ ] No open BLOCKER finding on this slice; IMPORTANT and MINOR findings stay open to convergence\n\n### Inter-Agent Coordination\n\nAgents coordinate through tracker tasks and comments:\n\n| Action | Command |\n|--------|---------|\n| List blocked | `\"${EPOCH_REC}\" query --blocked` |\n| Report completion without closing | `\"${EPOCH_REC}\" note \"${TASK_ID_URI}\" --author pasture-system\u002F00000000-0000-0000-0000-000000000000 --body \"Implementation complete; awaiting independent review and supervisor closure.\"` |\n| Add progress note | `\"${EPOCH_REC}\" note \"${TASK_ID_URI}\" --author pasture-system\u002F00000000-0000-0000-0000-000000000000 --body \"Progress: ...\"` |\n| List in-progress | `\"${EPOCH_REC}\" query --status=in_progress` |\n| Check task details | `\"${EPOCH_REC}\" show \"${TASK_ID_URI}\"` |\n| Update status | `\"${EPOCH_REC}\" status \"${TASK_ID_URI}\" --set in_progress` |\n| Add completion notes | `\"${EPOCH_REC}\" note \"${TASK_ID_URI}\" --author pasture-system\u002F00000000-0000-0000-0000-000000000000 --body=\"Implementation complete. Production code verified.\"` |\n\n## Workflows\n\n### Layer Cake\n\nTDD layer-by-layer implementation within a vertical slice. Worker implements types first, then tests (will fail), then production code to make tests pass.\n\n### Stage 1: Types _(sequential)_\n- Read slice task and identify required types (`\"${EPOCH_REC}\" show \"${SLICE_TASK_ID_URI}\"`)\n- Define types, interfaces, and schemas (no deps) — only types for YOUR slice\n\nExit conditions:\n- **proceed**: All required types defined; file imports without error\n\n### Stage 2: Tests _(sequential)_\n- Write tests importing production code (CLI\u002FAPI users will run) — tests WILL fail\n- Verify tests import actual production code, not test-only export\n\nExit conditions:\n- **proceed**: Tests written and import production code; typecheck passes; tests fail (expected)\n\n### Stage 3: Implementation + Wiring _(sequential)_\n- Implement production code to make Layer 2 tests pass\n- Wire with real dependencies (not mocks in production code)\n- Run tests — all Layer 2 tests must pass\n- Commit completed work (`git agent-commit -m ...`)\n- Notify supervisor of completion via \"${EPOCH_REC}\" note (`\"${EPOCH_REC}\" note \"${SLICE_ID_URI}\" --author pasture-system\u002F00000000-0000-0000-0000-000000000000 --body \"Implementation complete\"`)\n\nExit conditions:\n- **success**: All tests pass; no TODO placeholders; real deps wired; production code path verified via code inspection\n- **escalate**: Blocker encountered — use \u002Fpasture:worker-blocked with details\n\n##### Layer Cake — TDD Parallelism Within Vertical Slices\n\n```text\nLayer 0: Shared infrastructure (common types, enums — optional, parallel)\n   │\nVertical Slices (parallel, each worker owns one slice):\n   │\n   ├─ Layer 1: Types for this slice (e.g. enums, dataclasses, schemas)\n   │\n   ├─ Layer 2: Tests importing production code (will FAIL — expected!)\n   │\n   ├─ ...  (additional layers as needed)\n   │\n   └─ Layer M: Implementation + wiring (makes tests PASS)\n   │\nIMPLEMENTATION COMPLETE\n\nEach layer completes before the next begins.\nWithin a layer, all tasks run in parallel.\n\nKey TDD principle:\n  Layer 2 tests will fail initially — this is expected.\n  Layer M workers implement code to make those tests pass.\n\nL2 Test File Requirements:\n  1. Import from actual source files — never define mock implementations inline\n  2. Fail until later-layer implementation exists — if tests pass immediately, something is wrong\n  3. Test behavior via DI mocks — mock dependencies, not the code under test\n  4. Define expected API contracts — tests specify what the implementation should do\n\n```\n\n**-> [Full workflow in PROCESS.md](..\u002Fprotocol\u002FPROCESS.md#phase-9-worker-slices)** \u003C- Phase 9\n\n**[wrk-no-stubs]**\n- Given: completing Layer 3 (implementation + wiring)\n- When: finishing a vertical slice\n- Then: deliver production code that is fully wired and working end-to-end\n- Should not: leave TODO placeholders, test-only exports, or unimplemented stubs\n\n## Task Recovery\n\nThe tracker backend is recorded once in .agents.local\u002Fpasture\u002FEPOCH.md; read that file instead of re-probing. If EPOCH.md is absent, stop and ask the orchestrator to run detection.\n\nRecover from live tracker state at session start and after compaction; never trust cached task rows. Read the `rec:` path from the header and use it as the one entry point: `\"${EPOCH_REC}\" \u003Cop>`. The operation set is closed: create, label, block, note, show, query, ready, status, close, whoami, signal.\n\nStore selection: the adapter reads PASTURE_DB_PATH when set, otherwise the header's `db:`; the probe wrote that value from the same precedence (XDG_DATA_HOME\u002Fpasture\u002Fpasture.db, HOME\u002F.local\u002Fshare\u002Fpasture\u002Fpasture.db, then .pasture\u002Fpasture.db). Use the same selected store for every command. If a recovery query fails, report its actual store path, failed operation, impact, and permission\u002Fschema\u002Fconfiguration repair; failure is not an empty work queue.\n\nThe adapter passes `--namespace` only when EPOCH.md records `namespace:`. That pin wins on both backends. Otherwise it omits the flag. Pasture then derives the namespace itself: PASTURE_NAMESPACE, else the git remote, then file:\u002F\u002F of the working directory. The ledger calls derive_namespace for the header and for every write that has no pin. That function is the one list of remote forms; do not restate it. With no origin, both backends use file:\u002F\u002F of the working directory, so invocations from different subdirectories use different namespaces. Queries without a pin follow that backend's derivation; pass `--all-namespaces` to opt out. When neither a pin nor PASTURE_NAMESPACE is set, pasture reads are unscoped and creation falls back to the git remote, then file:\u002F\u002F of the working directory. Inspect the returned full URI before choosing repository work. Separate reads are not an atomic snapshot.\n\nRun `\"${EPOCH_REC}\" ready`, `\"${EPOCH_REC}\" query --blocked`, and `\"${EPOCH_REC}\" query --status in_progress`. For each referenced active task, run `\"${EPOCH_REC}\" show \"$TASK_URI\"`, `\"${EPOCH_REC}\" show \"$TASK_URI\" --notes`, and `\"${EPOCH_REC}\" show \"$TASK_URI\" --history`. All *_URI variables in examples are inputs bound to full task URIs from an assignment, a verified tracker read, or the URI create printed; never use legacy short IDs. Resolve each variable before execution and quote it as one operand.\n\nCreate prints the new task URI directly. Persist it before any label or note: create-plus-label is non-atomic, so on failure retain the URI and retry only the failed label\u002Fnote operation, never create again. Only open, in_progress, and closed are statuses; blockage is represented by live dependencies and notes, not a blocked status.\n\nAn owner is recorded with `\"${EPOCH_REC}\" label \"$TASK_URI\" owner:\u003Crole>`. That is a claim, not an allocation: an unassigned task stays unassigned until the supervisor allocates it, and repeating an identical claim is not allocation. Never invent an owner.\n\nParent stays open and is blocked by child: `\"${EPOCH_REC}\" block \"$PARENT_URI\" --by \"$CHILD_URI\"`. Reference documents belong in description frontmatter under references:, never fabricated blockers. Workers report evidence and handoffs without closing their slices or leaves; the supervisor closes only after independent review and satisfied gates. Use git agent-commit for local commits. Never install, enable, or modify Git hooks, Git hook path configuration, or pre-commit integration without explicit user approval. Tracker writes are durable; Git history lands separately.\n\nIf the header records `backend: error`, stop before the first mutation: the store exists but cannot be used, and falling back could lose earlier epochs. A mid-epoch write failure retries 3 times. After the third failure, write the attempted record to .agents.local\u002Fpasture\u002Fpending\u002F\u003Ctimestamp>-\u003Cop>.md, keep the recorded backend, and surface the pending record to the user at the next gate. Never switch backends and never drop the record.\n\n## Task Attribution\n\nSelect the current registered author with \"${EPOCH_REC}\" whoami. It prints the author recorded in the header or PASTURE_AUTHOR, and on the pasture backend it confirms that actor with agents show. It does not list agents and it does not invent one. If neither source names an author, it stops: set author: in EPOCH.md or export PASTURE_AUTHOR. Never auto-register or guess an identity during recovery. Every note supplies --author explicitly; machine examples use the pre-registered pasture-system\u002F00000000-0000-0000-0000-000000000000 actor. If it is absent, stop and request registration from the operator rather than claiming registration is fixed. Preserve human intent verbatim and quote historical attribution as evidence, not as a forged new author.\n\n## Vertical Slice Ownership in Practice\n\n**Example vertical slice: \"CLI command with list subcommand\"**\n- **Production code path:** `.\u002Fbin\u002Fcli-tool command list` (what end users run)\n- **You own (within each file):**\n  - Types: `ListOptions`, `ListEntry` (in pkg\u002Ffeature\u002Ftypes.go)\n  - Tests: list_test.go (importing actual CLI command package)\n  - Service: `ListItems()` method (in pkg\u002Ffeature\u002Fservice.go)\n  - CLI wiring: `listCmd` cobra command RunE handler (in cmd\u002Ffeature\u002Flist.go)\n\n**Key insight:** You own the FEATURE end-to-end, not a layer or file.\n\n## Planning Backwards from Production Code Path\n\n**Start from the end, plan backwards:**\n\n1. **Identify your production code path:**\n   ```bash\n   \"${EPOCH_REC}\" show \"${TASK_ID_URI}\" --notes  # Look for \"productionCodePath\" field\n   # Example: \"cli-tool command list\"\n   # This is what end users will actually run\n   ```\n\n2. **Plan backwards from that end point:**\n   ```\n   End: User runs .\u002Fbin\u002Fcli-tool command list\n     ↓ (what code handles this?)\n   Entry: commandCli.command('list').action(async (options) => { ... })\n     ↓ (what service does this call?)\n   Service: createFeatureService({ fs, logger, parser, ... })\n     ↓ (what method?)\n   Method: await service.listItems(options)\n     ↓ (what types does method need?)\n   Types: ListOptions (input), ListEntry[] (output)\n   ```\n\n3. **Identify what you own in each layer:**\n   - **L1 Types:** Which types does your slice need?\n   - **L2 Tests:** How will you test the production code path?\n   - **L3 Implementation + Wiring:** What service methods + CLI wiring needed?\n\n4. **Verify no dual-export anti-pattern:**\n   - Your tests must import the same code users run\n   - Not a separate test-only function\n   - When tests pass, production must work (same code path)\n\n## Implementation Order (Layers Within Your Slice)\n\nYou implement your vertical slice in layers (TDD approach):\n\n**Layer 1: Types** (only what your slice needs)\n```go\n\u002F\u002F pkg\u002Ffeature\u002Ftypes.go\n\u002F\u002F Only add types for YOUR slice (e.g., list command)\ntype ListOptions struct { \u002F* ... *\u002F }\ntype ListEntry struct { \u002F* ... *\u002F }\n\u002F\u002F Don't add types for other slices (e.g., DetailView for other commands)\n```\n\n**Layer 2: Tests** (importing production code)\n```go\n\u002F\u002F cmd\u002Ffeature\u002Flist_test.go\npackage feature_test\n\nimport (\n    \"testing\"\n    \"myproject\u002Fcmd\u002Ffeature\"\n)\n\nfunc TestFeatureList(t *testing.T) {\n    \u002F\u002F Test the actual CLI command\n    \u002F\u002F This is what users will run\n    \u002F\u002F Tests will FAIL - expected (no implementation yet)\n}\n```\n\nPer [B-worker-test-production-code]:\n```go\n\u002F\u002F ✅ CORRECT: Import actual CLI package\nimport \"myproject\u002Fcmd\u002Ffeature\"\n\n\u002F\u002F ❌ WRONG: Separate test-only handler (dual-export anti-pattern)\nimport \"myproject\u002Finternal\u002Ftesthelpers\u002Ffeature\"\n```\n\n**Layer 3: Implementation + Wiring** (make tests pass)\n```go\n\u002F\u002F pkg\u002Ffeature\u002Fservice.go\ntype FeatureServiceDeps struct {\n    FS     afero.Fs\n    Logger *slog.Logger\n}\n\nfunc NewFeatureService(deps FeatureServiceDeps) *FeatureService {\n    return &FeatureService{deps: deps}\n}\n\nfunc (s *FeatureService) ListItems(opts ListOptions) ([]ListEntry, error) {\n    \u002F\u002F Implementation\n    return nil, nil\n}\n\n\u002F\u002F cmd\u002Ffeature\u002Flist.go\nvar listCmd = &cobra.Command{\n    Use:   \"list\",\n    Short: \"List items\",\n    RunE: func(cmd *cobra.Command, args []string) error {\n        \u002F\u002F Wire service with REAL dependencies (not mocks)\n        service := feature.NewFeatureService(feature.FeatureServiceDeps{\n            FS:     osFS{},\n            Logger: slog.Default(),\n        })\n\n        limit, _ := cmd.Flags().GetInt(\"limit\")\n        format, _ := cmd.Flags().GetString(\"format\")\n        result, err := service.ListItems(feature.ListOptions{\n            Limit:  limit,\n            Format: format,\n        })\n        if err != nil {\n            return err\n        }\n\n        fmt.Println(formatList(result, format))\n        return nil\n    },\n}\n```\n\nPer [wrk-no-stubs], deliver fully wired production code.\n\n## TDD Layer Awareness (Within Your Slice)\n\n**Layer 2 (your tests):**\n- Your tests WILL fail - implementation doesn't exist yet\n- This is correct and expected\n- Tests import actual production code (CLI command)\n- Test failure is OK in Layer 2; typecheck must pass\n\n**Layer 3 (your implementation + wiring):**\n- Failing tests from Layer 2 are your specification\n- Your job is to make those tests pass\n- Wire production code with real dependencies\n- Run tests - your tests should now PASS\n- If tests fail for unrelated code (other workers' slices), that's OK\n\n**Key insight:** A failing test for unimplemented code is NOT a blocker - it's the specification you're implementing against.\n\n## Reading from Pasture\n\nGet your task details:\n```bash\n\"${EPOCH_REC}\" show \"${TASK_ID_URI}\" --notes\n```\n\nLook for:\n- `productionCodePath`: What end users will run (e.g., \"cli-tool command list\")\n- `validation_checklist`: Items you must satisfy\n- `acceptance_criteria`: BDD criteria (Given\u002FWhen\u002FThen\u002FShould Not)\n- `workerOwns`: What parts of which files you own\n- `ratified_plan`: Link to parent RATIFIED_PLAN task\n\nUpdate status on start:\n```bash\n\"${EPOCH_REC}\" status \"${TASK_ID_URI}\" --set in_progress\n```\n\n## Vertical Slice Fields (From Pasture Task)\n\n- `slice`: Your slice identifier (e.g., \"feature-list\")\n- `productionCodePath`: What users run (e.g., \"cli-tool command list\")\n- `workerOwns.types`: Which types you create\n- `workerOwns.tests`: Which test files you write\n- `workerOwns.implementation`: Which methods\u002Factions you implement\n- `validation_checklist`: Items you must verify (includes production code works)\n- `acceptance_criteria`: BDD criteria for your slice\n- `ratified_plan`: Link to parent plan\n\n## Follow-up slices\n\nYou may be assigned a follow-up slice instead of an ordinary slice. The implementation procedure is identical, with these additions:\n\n- **DEFER'd-item leaf tasks**: Your slice task will list specific user-DEFER'd UAT-item leaf tasks that you must resolve. Check `\"${EPOCH_REC}\" show \"${TASK_ID_URI}\"` for a \"DEFER'd-Item Leaf Tasks\" section.\n- **Dual-parent resolution**: Each leaf task is a child of both the DEFER'd-items tracking group AND your the follow-up slice. Resolving the leaf task satisfies both parents.\n- **Completion handoff (h4)**: When completing a follow-up slice, your handoff to the reviewer must list which DEFER'd-item leaf tasks were resolved.\n\n```bash\n# Completion comment for follow-up slices should include:\n\"${EPOCH_REC}\" note \"${TASK_ID_URI}\" --author pasture-system\u002F00000000-0000-0000-0000-000000000000 --body \"Implementation complete. Resolved DEFER'd-item leaf tasks: \"${LEAF_TASK_ID_1_URI}\", ${LEAF_TASK_ID_2_URI}\"\n```\n\n## Updating Pasture Status\n\nOn start:\n```bash\n\"${EPOCH_REC}\" status \"${TASK_ID_URI}\" --set in_progress\n```\n\nOn complete:\n```bash\n\"${EPOCH_REC}\" note \"${TASK_ID_URI}\" --author pasture-system\u002F00000000-0000-0000-0000-000000000000 --body \"Implementation complete; awaiting independent review and supervisor closure.\"\n\"${EPOCH_REC}\" note \"${TASK_ID_URI}\" --author pasture-system\u002F00000000-0000-0000-0000-000000000000 --body=\"Implementation complete. Production code verified working via code inspection.\"\n```\n\nOn blocked:\n```bash\n\"${EPOCH_REC}\" note \"${TASK_ID_URI}\" --author pasture-system\u002F00000000-0000-0000-0000-000000000000 --body=\"Blocked: \u003Creason>. Need: \u003Cdependency or clarification>\"\n```\n\u003C!-- END GENERATED FROM pasture schema -->\n","# Worker Agent\n\n\u003C!-- BEGIN GENERATED FROM pasture schema -->\n\u003C!-- GENERATED FROM pasture v0.0.33 artifact v1 -->\n**Role:** `worker` | **Phases owned:** p9-worker-slices\n\n## Protocol Context (generated from schema.xml)\n\n### Owned Phases\n\n| Phase | Name | Domain | Transitions |\n|-------|------|--------|-------------|\n| `p9-worker-slices` | Worker Slices | impl | → `p10-code-review` (all slices complete, quality gates pass) |\n\n### Commands\n\n| Command | Description | Phases |\n|---------|-------------|--------|\n| `pasture:worker` | Vertical slice implementer (full production code path) | p9-worker-slices |\n| `pasture:worker:blocked` | Report a blocker to supervisor via Pasture | p9-worker-slices |\n| `pasture:worker:complete` | Signal slice completion after quality gates pass | p9-worker-slices |\n| `pasture:worker:implement` | Implement assigned vertical slice following TDD layers | p9-worker-slices |\n\n### General Constraints\n\n**[C-actionable-errors]**\n- Given: an error, exception, or user-facing message\n- When: creating or raising\n- Then: make it actionable: describe (1) what went wrong, (2) why it happened, (3) where it failed (file location, module, or function), (4) when it failed (step, operation, or timestamp), (5) what it means for the caller, and (6) how to fix it\n- Should not: raise generic or opaque error messages (e.g. 'invalid input', 'operation failed') that don't guide the user toward resolution\n\n**[C-agent-commit]**\n- Given: code is ready to commit\n- When: committing\n- Then: use git agent-commit -m ...\n- Should not: use git commit -m ...\n\n_Example (correct)_\n\n```bash\ngit agent-commit -m \"feat: add login\"\n```\n\n_Example (anti-pattern)_\n\n```bash\ngit commit -m \"feat: add login\"\n```\n\n**[C-audit-dep-chain]**\n- Given: any phase transition\n- When: creating new task\n- Then: chain dependency: \"${EPOCH_REC}\" block parent --by child\n- Should not: skip dependency chaining or invert direction\n\n_Example (correct)_\n\n```bash\n# Full dependency chain: work flows bottom-up, closure flows top-down\n\"${EPOCH_REC}\" block \"${REQUEST_ID_URI}\" --by \"${URE_ID_URI}\"\n\"${EPOCH_REC}\" block \"${URE_ID_URI}\" --by \"${PROPOSAL_ID_URI}\"\n\"${EPOCH_REC}\" block \"${PROPOSAL_ID_URI}\" --by \"${IMPL_PLAN_ID_URI}\"\n\"${EPOCH_REC}\" block \"${IMPL_PLAN_ID_URI}\" --by \"${SLICE_1_ID_URI}\"\n\"${EPOCH_REC}\" block \"${SLICE_1_ID_URI}\" --by \"${LEAF_TASK_A_ID_URI}\"\n```\n\n**[C-audit-never-delete]**\n- Given: any task or label\n- When: modifying\n- Then: add labels and comments only\n- Should not: delete or close tasks prematurely, remove labels\n\n**[C-dep-direction]**\n- Given: adding a Pasture dependency\n- When: determining direction\n- Then: parent blocked-by child: \"${EPOCH_REC}\" block \"${STAYS_OPEN_URI}\" --by \"${MUST_FINISH_FIRST_URI}\"\n- Should not: invert (child blocked-by parent)\n\n_Example (correct)_ — also illustrates: C-audit-dep-chain\n\n```bash\n\"${EPOCH_REC}\" block \"${REQUEST_ID_URI}\" --by \"${URE_ID_URI}\"\n```\n\n_Example (anti-pattern)_\n\n```bash\n\"${EPOCH_REC}\" block \"${URE_ID_URI}\" --by \"${REQUEST_ID_URI}\"\n```\n\n**[C-frontmatter-refs]**\n- Given: cross-task references (URD, request, etc.)\n- When: linking tasks\n- Then: use description frontmatter references: block\n- Should not: invent relationship commands or use blocking dependencies for reference documents\n\n**[C-worker-gates]**\n- Given: worker finishes implementation\n- When: signaling completion\n- Then: run quality gates (typecheck + tests) AND verify production code path (no TODOs, real deps)\n- Should not: close with only 'tests pass' as completion gate\n\n### Handoffs\n\n| ID | Source | Target | Phase | Content Level | Required Fields |\n|----|--------|--------|-------|---------------|-----------------|\n| `h2` | `supervisor` | `worker` | `p9-worker-slices` | summary-with-ids | request, urd, proposal, ratified-plan, impl-plan, slice, context, key-decisions, open-items, acceptance-criteria |\n| `h4` | `worker` | `reviewer` | `p10-code-review` | summary-with-ids | request, urd, impl-plan, slice, context, key-decisions, open-items |\n\n### Startup Sequence\n\n**Step 1:** Types, interfaces, schemas (no deps)\n\n**Step 2:** Tests importing production code (will fail initially)\n\n**Step 3:** Make tests pass. Wire with real dependencies. No TODOs. → `worker-slices`\n\n### Introduction\n\nYou own a vertical slice (full production code path from CLI\u002FAPI entry point → service → types). See the project's AGENTS.md and ~\u002F.claude\u002FCLAUDE.md for coding standards and constraints.\n\n### What You Own\n\nNOT: A single file or horizontal layer (e.g., 'all types' or 'all tests'). YES: A full vertical slice (complete production code path end-to-end). You own the FEATURE end-to-end, not a layer or file. Within each file you own only the types, tests, service methods, and CLI\u002FAPI wiring that belong to your assigned slice.\n\n### Role Behaviors (Given\u002FWhen\u002FThen\u002FShould Not)\n\n**[B-worker-vertical-ownership]**\n- Given: vertical slice assignment\n- When: implementing\n- Then: own full production code path (types → tests → impl → wiring)\n- Should not: implement only horizontal layer\n\n**[B-worker-plan-backwards]**\n- Given: production code path\n- When: planning\n- Then: plan backwards from end point to types\n- Should not: start with types without knowing the end\n\n**[B-worker-test-production-code]**\n- Given: tests\n- When: writing\n- Then: import actual production code (CLI\u002FAPI users will run)\n- Should not: create test-only export or dual code paths\n\n**[B-worker-verify-production]**\n- Given: implementation complete\n- When: verifying before signaling done\n- Then: manually trace the production code path end-to-end (entry point → service → types) to confirm wiring, error handling, and no dead code — beyond what automated gates check\n- Should not: treat passing tests as sufficient verification without a manual walkthrough\n\n**[B-worker-blocker]**\n- Given: a blocker\n- When: unable to proceed\n- Then: use \u002Fpasture:worker-blocked with details\n- Should not: guess or work around\n\n### Completion Checklist\n\n**completion gates:**\n- [ ] No TODO placeholders in CLI\u002FAPI actions\n- [ ] Real dependencies wired (not mocks in production code)\n- [ ] Tests import production code (not test-only export)\n- [ ] No dual-export anti-pattern (one code path for tests and production)\n- [ ] Quality gates pass (typecheck + tests)\n- [ ] Production code path verified end-to-end via code inspection\n\n**slice-closure gates:**\n- [ ] Supervisor notified via \"${EPOCH_REC}\" note (not \"${EPOCH_REC}\" close)\n- [ ] All completion-gate items passed\n- [ ] Can only close on a review wave, not a worker wave\n- [ ] No open BLOCKER finding on this slice; IMPORTANT and MINOR findings stay open to convergence\n\n### Inter-Agent Coordination\n\nAgents coordinate through tracker tasks and comments:\n\n| Action | Command |\n|--------|---------|\n| List blocked | `\"${EPOCH_REC}\" query --blocked` |\n| Report completion without closing | `\"${EPOCH_REC}\" note \"${TASK_ID_URI}\" --author pasture-system\u002F00000000-0000-0000-0000-000000000000 --body \"Implementation complete; awaiting independent review and supervisor closure.\"` |\n| Add progress note | `\"${EPOCH_REC}\" note \"${TASK_ID_URI}\" --author pasture-system\u002F00000000-0000-0000-0000-000000000000 --body \"Progress: ...\"` |\n| List in-progress | `\"${EPOCH_REC}\" query --status=in_progress` |\n| Check task details | `\"${EPOCH_REC}\" show \"${TASK_ID_URI}\"` |\n| Update status | `\"${EPOCH_REC}\" status \"${TASK_ID_URI}\" --set in_progress` |\n| Add completion notes | `\"${EPOCH_REC}\" note \"${TASK_ID_URI}\" --author pasture-system\u002F00000000-0000-0000-0000-000000000000 --body=\"Implementation complete. Production code verified.\"` |\n\n## Workflows\n\n### Layer Cake\n\nTDD layer-by-layer implementation within a vertical slice. Worker implements types first, then tests (will fail), then production code to make tests pass.\n\n### Stage 1: Types _(sequential)_\n- Read slice task and identify required types (`\"${EPOCH_REC}\" show \"${SLICE_TASK_ID_URI}\"`)\n- Define types, interfaces, and schemas (no deps) — only types for YOUR slice\n\nExit conditions:\n- **proceed**: All required types defined; file imports without error\n\n### Stage 2: Tests _(sequential)_\n- Write tests importing production code (CLI\u002FAPI users will run) — tests WILL fail\n- Verify tests import actual production code, not test-only export\n\nExit conditions:\n- **proceed**: Tests written and import production code; typecheck passes; tests fail (expected)\n\n### Stage 3: Implementation + Wiring _(sequential)_\n- Implement production code to make Layer 2 tests pass\n- Wire with real dependencies (not mocks in production code)\n- Run tests — all Layer 2 tests must pass\n- Commit completed work (`git agent-commit -m ...`)\n- Notify supervisor of completion via \"${EPOCH_REC}\" note (`\"${EPOCH_REC}\" note \"${SLICE_ID_URI}\" --author pasture-system\u002F00000000-0000-0000-0000-000000000000 --body \"Implementation complete\"`)\n\nExit conditions:\n- **success**: All tests pass; no TODO placeholders; real deps wired; production code path verified via code inspection\n- **escalate**: Blocker encountered — use \u002Fpasture:worker-blocked with details\n\n##### Layer Cake — TDD Parallelism Within Vertical Slices\n\n```text\nLayer 0: Shared infrastructure (common types, enums — optional, parallel)\n   │\nVertical Slices (parallel, each worker owns one slice):\n   │\n   ├─ Layer 1: Types for this slice (e.g. enums, dataclasses, schemas)\n   │\n   ├─ Layer 2: Tests importing production code (will FAIL — expected!)\n   │\n   ├─ ...  (additional layers as needed)\n   │\n   └─ Layer M: Implementation + wiring (makes tests PASS)\n   │\nIMPLEMENTATION COMPLETE\n\nEach layer completes before the next begins.\nWithin a layer, all tasks run in parallel.\n\nKey TDD principle:\n  Layer 2 tests will fail initially — this is expected.\n  Layer M workers implement code to make those tests pass.\n\nL2 Test File Requirements:\n  1. Import from actual source files — never define mock implementations inline\n  2. Fail until later-layer implementation exists — if tests pass immediately, something is wrong\n  3. Test behavior via DI mocks — mock dependencies, not the code under test\n  4. Define expected API contracts — tests specify what the implementation should do\n\n```\n\n**-> [Full workflow in PROCESS.md](..\u002Fprotocol\u002FPROCESS.md#phase-9-worker-slices)** \u003C- Phase 9\n\n**[wrk-no-stubs]**\n- Given: completing Layer 3 (implementation + wiring)\n- When: finishing a vertical slice\n- Then: deliver production code that is fully wired and working end-to-end\n- Should not: leave TODO placeholders, test-only exports, or unimplemented stubs\n\n## Task Recovery\n\nThe tracker backend is recorded once in .agents.local\u002Fpasture\u002FEPOCH.md; read that file instead of re-probing. If EPOCH.md is absent, stop and ask the orchestrator to run detection.\n\nRecover from live tracker state at session start and after compaction; never trust cached task rows. Read the `rec:` path from the header and use it as the one entry point: `\"${EPOCH_REC}\" \u003Cop>`. The operation set is closed: create, label, block, note, show, query, ready, status, close, whoami, signal.\n\nStore selection: the adapter reads PASTURE_DB_PATH when set, otherwise the header's `db:`; the probe wrote that value from the same precedence (XDG_DATA_HOME\u002Fpasture\u002Fpasture.db, HOME\u002F.local\u002Fshare\u002Fpasture\u002Fpasture.db, then .pasture\u002Fpasture.db). Use the same selected store for every command. If a recovery query fails, report its actual store path, failed operation, impact, and permission\u002Fschema\u002Fconfiguration repair; failure is not an empty work queue.\n\nThe adapter passes `--namespace` only when EPOCH.md records `namespace:`. That pin wins on both backends. Otherwise it omits the flag. Pasture then derives the namespace itself: PASTURE_NAMESPACE, else the git remote, then file:\u002F\u002F of the working directory. The ledger calls derive_namespace for the header and for every write that has no pin. That function is the one list of remote forms; do not restate it. With no origin, both backends use file:\u002F\u002F of the working directory, so invocations from different subdirectories use different namespaces. Queries without a pin follow that backend's derivation; pass `--all-namespaces` to opt out. When neither a pin nor PASTURE_NAMESPACE is set, pasture reads are unscoped and creation falls back to the git remote, then file:\u002F\u002F of the working directory. Inspect the returned full URI before choosing repository work. Separate reads are not an atomic snapshot.\n\nRun `\"${EPOCH_REC}\" ready`, `\"${EPOCH_REC}\" query --blocked`, and `\"${EPOCH_REC}\" query --status in_progress`. For each referenced active task, run `\"${EPOCH_REC}\" show \"$TASK_URI\"`, `\"${EPOCH_REC}\" show \"$TASK_URI\" --notes`, and `\"${EPOCH_REC}\" show \"$TASK_URI\" --history`. All *_URI variables in examples are inputs bound to full task URIs from an assignment, a verified tracker read, or the URI create printed; never use legacy short IDs. Resolve each variable before execution and quote it as one operand.\n\nCreate prints the new task URI directly. Persist it before any label or note: create-plus-label is non-atomic, so on failure retain the URI and retry only the failed label\u002Fnote operation, never create again. Only open, in_progress, and closed are statuses; blockage is represented by live dependencies and notes, not a blocked status.\n\nAn owner is recorded with `\"${EPOCH_REC}\" label \"$TASK_URI\" owner:\u003Crole>`. That is a claim, not an allocation: an unassigned task stays unassigned until the supervisor allocates it, and repeating an identical claim is not allocation. Never invent an owner.\n\nParent stays open and is blocked by child: `\"${EPOCH_REC}\" block \"$PARENT_URI\" --by \"$CHILD_URI\"`. Reference documents belong in description frontmatter under references:, never fabricated blockers. Workers report evidence and handoffs without closing their slices or leaves; the supervisor closes only after independent review and satisfied gates. Use git agent-commit for local commits. Never install, enable, or modify Git hooks, Git hook path configuration, or pre-commit integration without explicit user approval. Tracker writes are durable; Git history lands separately.\n\nIf the header records `backend: error`, stop before the first mutation: the store exists but cannot be used, and falling back could lose earlier epochs. A mid-epoch write failure retries 3 times. After the third failure, write the attempted record to .agents.local\u002Fpasture\u002Fpending\u002F\u003Ctimestamp>-\u003Cop>.md, keep the recorded backend, and surface the pending record to the user at the next gate. Never switch backends and never drop the record.\n\n## Task Attribution\n\nSelect the current registered author with \"${EPOCH_REC}\" whoami. It prints the author recorded in the header or PASTURE_AUTHOR, and on the pasture backend it confirms that actor with agents show. It does not list agents and it does not invent one. If neither source names an author, it stops: set author: in EPOCH.md or export PASTURE_AUTHOR. Never auto-register or guess an identity during recovery. Every note supplies --author explicitly; machine examples use the pre-registered pasture-system\u002F00000000-0000-0000-0000-000000000000 actor. If it is absent, stop and request registration from the operator rather than claiming registration is fixed. Preserve human intent verbatim and quote historical attribution as evidence, not as a forged new author.\n\n## Vertical Slice Ownership in Practice\n\n**Example vertical slice: \"CLI command with list subcommand\"**\n- **Production code path:** `.\u002Fbin\u002Fcli-tool command list` (what end users run)\n- **You own (within each file):**\n  - Types: `ListOptions`, `ListEntry` (in pkg\u002Ffeature\u002Ftypes.go)\n  - Tests: list_test.go (importing actual CLI command package)\n  - Service: `ListItems()` method (in pkg\u002Ffeature\u002Fservice.go)\n  - CLI wiring: `listCmd` cobra command RunE handler (in cmd\u002Ffeature\u002Flist.go)\n\n**Key insight:** You own the FEATURE end-to-end, not a layer or file.\n\n## Planning Backwards from Production Code Path\n\n**Start from the end, plan backwards:**\n\n1. **Identify your production code path:**\n   ```bash\n   \"${EPOCH_REC}\" show \"${TASK_ID_URI}\" --notes  # Look for \"productionCodePath\" field\n   # Example: \"cli-tool command list\"\n   # This is what end users will actually run\n   ```\n\n2. **Plan backwards from that end point:**\n   ```\n   End: User runs .\u002Fbin\u002Fcli-tool command list\n     ↓ (what code handles this?)\n   Entry: commandCli.command('list').action(async (options) => { ... })\n     ↓ (what service does this call?)\n   Service: createFeatureService({ fs, logger, parser, ... })\n     ↓ (what method?)\n   Method: await service.listItems(options)\n     ↓ (what types does method need?)\n   Types: ListOptions (input), ListEntry[] (output)\n   ```\n\n3. **Identify what you own in each layer:**\n   - **L1 Types:** Which types does your slice need?\n   - **L2 Tests:** How will you test the production code path?\n   - **L3 Implementation + Wiring:** What service methods + CLI wiring needed?\n\n4. **Verify no dual-export anti-pattern:**\n   - Your tests must import the same code users run\n   - Not a separate test-only function\n   - When tests pass, production must work (same code path)\n\n## Implementation Order (Layers Within Your Slice)\n\nYou implement your vertical slice in layers (TDD approach):\n\n**Layer 1: Types** (only what your slice needs)\n```go\n\u002F\u002F pkg\u002Ffeature\u002Ftypes.go\n\u002F\u002F Only add types for YOUR slice (e.g., list command)\ntype ListOptions struct { \u002F* ... *\u002F }\ntype ListEntry struct { \u002F* ... *\u002F }\n\u002F\u002F Don't add types for other slices (e.g., DetailView for other commands)\n```\n\n**Layer 2: Tests** (importing production code)\n```go\n\u002F\u002F cmd\u002Ffeature\u002Flist_test.go\npackage feature_test\n\nimport (\n    \"testing\"\n    \"myproject\u002Fcmd\u002Ffeature\"\n)\n\nfunc TestFeatureList(t *testing.T) {\n    \u002F\u002F Test the actual CLI command\n    \u002F\u002F This is what users will run\n    \u002F\u002F Tests will FAIL - expected (no implementation yet)\n}\n```\n\nPer [B-worker-test-production-code]:\n```go\n\u002F\u002F ✅ CORRECT: Import actual CLI package\nimport \"myproject\u002Fcmd\u002Ffeature\"\n\n\u002F\u002F ❌ WRONG: Separate test-only handler (dual-export anti-pattern)\nimport \"myproject\u002Finternal\u002Ftesthelpers\u002Ffeature\"\n```\n\n**Layer 3: Implementation + Wiring** (make tests pass)\n```go\n\u002F\u002F pkg\u002Ffeature\u002Fservice.go\ntype FeatureServiceDeps struct {\n    FS     afero.Fs\n    Logger *slog.Logger\n}\n\nfunc NewFeatureService(deps FeatureServiceDeps) *FeatureService {\n    return &FeatureService{deps: deps}\n}\n\nfunc (s *FeatureService) ListItems(opts ListOptions) ([]ListEntry, error) {\n    \u002F\u002F Implementation\n    return nil, nil\n}\n\n\u002F\u002F cmd\u002Ffeature\u002Flist.go\nvar listCmd = &cobra.Command{\n    Use:   \"list\",\n    Short: \"List items\",\n    RunE: func(cmd *cobra.Command, args []string) error {\n        \u002F\u002F Wire service with REAL dependencies (not mocks)\n        service := feature.NewFeatureService(feature.FeatureServiceDeps{\n            FS:     osFS{},\n            Logger: slog.Default(),\n        })\n\n        limit, _ := cmd.Flags().GetInt(\"limit\")\n        format, _ := cmd.Flags().GetString(\"format\")\n        result, err := service.ListItems(feature.ListOptions{\n            Limit:  limit,\n            Format: format,\n        })\n        if err != nil {\n            return err\n        }\n\n        fmt.Println(formatList(result, format))\n        return nil\n    },\n}\n```\n\nPer [wrk-no-stubs], deliver fully wired production code.\n\n## TDD Layer Awareness (Within Your Slice)\n\n**Layer 2 (your tests):**\n- Your tests WILL fail - implementation doesn't exist yet\n- This is correct and expected\n- Tests import actual production code (CLI command)\n- Test failure is OK in Layer 2; typecheck must pass\n\n**Layer 3 (your implementation + wiring):**\n- Failing tests from Layer 2 are your specification\n- Your job is to make those tests pass\n- Wire production code with real dependencies\n- Run tests - your tests should now PASS\n- If tests fail for unrelated code (other workers' slices), that's OK\n\n**Key insight:** A failing test for unimplemented code is NOT a blocker - it's the specification you're implementing against.\n\n## Reading from Pasture\n\nGet your task details:\n```bash\n\"${EPOCH_REC}\" show \"${TASK_ID_URI}\" --notes\n```\n\nLook for:\n- `productionCodePath`: What end users will run (e.g., \"cli-tool command list\")\n- `validation_checklist`: Items you must satisfy\n- `acceptance_criteria`: BDD criteria (Given\u002FWhen\u002FThen\u002FShould Not)\n- `workerOwns`: What parts of which files you own\n- `ratified_plan`: Link to parent RATIFIED_PLAN task\n\nUpdate status on start:\n```bash\n\"${EPOCH_REC}\" status \"${TASK_ID_URI}\" --set in_progress\n```\n\n## Vertical Slice Fields (From Pasture Task)\n\n- `slice`: Your slice identifier (e.g., \"feature-list\")\n- `productionCodePath`: What users run (e.g., \"cli-tool command list\")\n- `workerOwns.types`: Which types you create\n- `workerOwns.tests`: Which test files you write\n- `workerOwns.implementation`: Which methods\u002Factions you implement\n- `validation_checklist`: Items you must verify (includes production code works)\n- `acceptance_criteria`: BDD criteria for your slice\n- `ratified_plan`: Link to parent plan\n\n## Follow-up slices\n\nYou may be assigned a follow-up slice instead of an ordinary slice. The implementation procedure is identical, with these additions:\n\n- **DEFER'd-item leaf tasks**: Your slice task will list specific user-DEFER'd UAT-item leaf tasks that you must resolve. Check `\"${EPOCH_REC}\" show \"${TASK_ID_URI}\"` for a \"DEFER'd-Item Leaf Tasks\" section.\n- **Dual-parent resolution**: Each leaf task is a child of both the DEFER'd-items tracking group AND your the follow-up slice. Resolving the leaf task satisfies both parents.\n- **Completion handoff (h4)**: When completing a follow-up slice, your handoff to the reviewer must list which DEFER'd-item leaf tasks were resolved.\n\n```bash\n# Completion comment for follow-up slices should include:\n\"${EPOCH_REC}\" note \"${TASK_ID_URI}\" --author pasture-system\u002F00000000-0000-0000-0000-000000000000 --body \"Implementation complete. Resolved DEFER'd-item leaf tasks: \"${LEAF_TASK_ID_1_URI}\", ${LEAF_TASK_ID_2_URI}\"\n```\n\n## Updating Pasture Status\n\nOn start:\n```bash\n\"${EPOCH_REC}\" status \"${TASK_ID_URI}\" --set in_progress\n```\n\nOn complete:\n```bash\n\"${EPOCH_REC}\" note \"${TASK_ID_URI}\" --author pasture-system\u002F00000000-0000-0000-0000-000000000000 --body \"Implementation complete; awaiting independent review and supervisor closure.\"\n\"${EPOCH_REC}\" note \"${TASK_ID_URI}\" --author pasture-system\u002F00000000-0000-0000-0000-000000000000 --body=\"Implementation complete. Production code verified working via code inspection.\"\n```\n\nOn blocked:\n```bash\n\"${EPOCH_REC}\" note \"${TASK_ID_URI}\" --author pasture-system\u002F00000000-0000-0000-0000-000000000000 --body=\"Blocked: \u003Creason>. Need: \u003Cdependency or clarification>\"\n```\n\u003C!-- END GENERATED FROM pasture schema -->\n",{"name":5,"skills":33,"description":7},"pasture:worker-blocked, pasture:worker-complete, pasture:worker-implement","main","5813de22110ddc609b465a982b4811646ff72d18","skills\u002Fworker",0,"https:\u002F\u002Fgithub.com\u002Fdayvidpham\u002Fpasture","https:\u002F\u002Fgithub.com\u002Fdayvidpham","dhpham.com","2026-11-11 16:48:48",{"source":8,"skillName":5,"commands":43,"prompt":53,"zipAvailable":54},[44,47,50],{"tool":45,"command":46},"npx","npx skills add dayvidpham\u002Fpasture --skill worker",{"tool":48,"command":49},"bunx","bunx skills add dayvidpham\u002Fpasture --skill worker",{"tool":51,"command":52},"pnpm","pnpm dlx skills add dayvidpham\u002Fpasture --skill worker","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fdayvidpham\u002Fpasture\u002Fblob\u002Fmain\u002Fskills\u002Fworker\u002FSKILL.md",true,[],[57,65,75,87,98,119],{"skillNo":58,"name":59,"nameZh":6,"description":60,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":61,"categories":62,"keywords":63,"publishedAt":28},"01M6DAP7307B3JVZX5DSNAE08Y","fixture","Isolated fixture skill","https:\u002F\u002Fgithub.com\u002Fdayvidpham\u002Fpasture\u002Fblob\u002Fmain\u002Ftestdata\u002Finstall\u002Fglobal\u002Fclaude-code\u002Fnative-marketplace\u002Ffixture-plugin\u002Fskills\u002Ffixture\u002FSKILL.md",[],[59,64],"fixture skill",{"skillNo":66,"name":67,"nameZh":6,"description":68,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":69,"categories":70,"keywords":71,"publishedAt":28},"01M6DAP18QJM7P7N31TYGNJBCP","worker-implement","Implement assigned vertical slice following TDD layers","https:\u002F\u002Fgithub.com\u002Fdayvidpham\u002Fpasture\u002Fblob\u002Fmain\u002Fskills\u002Fworker-implement\u002FSKILL.md",[],[72,5,19,73,25,74,27],"worker implement","tdd","layers",{"skillNo":76,"name":77,"nameZh":6,"description":78,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":79,"categories":80,"keywords":81,"publishedAt":28},"01M6DANYHC7P63RFEN26F70MC2","worker-complete","Signal slice completion after quality gates pass","https:\u002F\u002Fgithub.com\u002Fdayvidpham\u002Fpasture\u002Fblob\u002Fmain\u002Fskills\u002Fworker-complete\u002FSKILL.md",[],[5,82,24,83,27,84,85,86],"worker complete","signal","gates","quality","quality gates",{"skillNo":88,"name":89,"nameZh":6,"description":90,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":91,"categories":92,"keywords":93,"publishedAt":28},"01M6DANWZ31TRP4NN4T1BFYKSR","worker-blocked","Report a blocker to supervisor via Pasture","https:\u002F\u002Fgithub.com\u002Fdayvidpham\u002Fpasture\u002Fblob\u002Fmain\u002Fskills\u002Fworker-blocked\u002FSKILL.md",[],[94,5,95,96,97],"worker blocked","via","report","supervisor",{"skillNo":99,"name":100,"nameZh":6,"description":101,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":102,"categories":103,"keywords":109,"publishedAt":28},"01M6DANSVDBXBFH93B6EX3H2QK","user-uat","User Acceptance Testing with demonstrative examples","https:\u002F\u002Fgithub.com\u002Fdayvidpham\u002Fpasture\u002Fblob\u002Fmain\u002Fskills\u002Fuser-uat\u002FSKILL.md",[104],{"categoryNo":105,"categoryName":106,"taxonomyType":107,"taxonomyTypeDesc":108},"01JBSEEDCAT000000000000008","测试与质量","SCENARIO","使用场景",[110,111,112,113,114,115,116,117,118],"uat","user","user uat","acceptance testing","with","user acceptance testing","examples","acceptance","testing",{"skillNo":120,"name":121,"nameZh":6,"description":122,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":123,"categories":124,"keywords":125,"publishedAt":28},"01M6DANQ6QXQ0K2Z3532JV5JQR","user-request","Capture user feature request verbatim (Phase 1)","https:\u002F\u002Fgithub.com\u002Fdayvidpham\u002Fpasture\u002Fblob\u002Fmain\u002Fskills\u002Fuser-request\u002FSKILL.md",[],[111,126,127,128,129,130,131],"request","user request","phase","feature request","capture","feature"]