@dzhechkov/skills-feature-adr 1.3.66 → 1.3.67

package/.dz-manifest.json

@@ -13,7 +13,7 @@
       },
       {
         "path": "README.md",
-        "sha256": "5cca2d4a5337177ee9a072d49d14f73386af75398f52d907d757d4c052afdf81"
+        "sha256": "1d123dcb15ac44b9adfe8266cb72d2dc69d5086f54003540795296c36e06e1b2"
       },
       {
         "path": "bin/cli.js",
@@ -25,7 +25,7 @@
       },
       {
         "path": "package.json",
-        "sha256": "b76f1b1d1ce3d8b22be0c2354fe3bd22833513da8b418c7c93423ae75f4018ae"
+        "sha256": "31de034ec7534b585ee99a2dac0105bc4e43dca0c5b419076e66c43e797509d3"
       },
       {
         "path": "scripts/sync-templates.js",
@@ -121,7 +121,7 @@
       },
       {
         "path": "templates/.claude/skills/feature-adr/SKILL.md",
-        "sha256": "02d2a081e4bc9e7f5d42e55a4e21a68484af8b45216ff74fe5fc4322cb689a96"
+        "sha256": "bdedfed69d985eb6969f158a72d92f63c6b1b993008c3661f7ffc2c6a7ccfbae"
       },
       {
         "path": "templates/.claude/skills/feature-adr/examples/sample-feature-output.md",
@@ -133,31 +133,31 @@
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/01-requirements.md",
-        "sha256": "7b599efd3122be7ce2247bba1c9204e1b3c09322ad56ed4cedcbd4dd471ed41e"
+        "sha256": "e6ea3a224b555d5b7410cf2ddf02a3fb8d009fa01109463353e2b993c318270c"
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/02-research.md",
-        "sha256": "55099189082d872d08a9d40b11782d8d08256955cbea617aa457756eb9fa1a07"
+        "sha256": "e2506e42251c74485188473acc4586f841afbec3ae7c5eaa8a3d8f73f6e14cc5"
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/03-adr.md",
-        "sha256": "742f1d362fd4d1b1b731fe81b7aa794886aa58126005ad67ef0a27775c80f082"
+        "sha256": "ea03eee136c89267888b8034baa1a1cb0057314a2e745df71654a9ebee5d46b6"
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/03.5-ideation-swarm.md",
-        "sha256": "220e06d0d67643f09df868df32d1ec3acdc205653a5ef977d171791d9ce77b74"
+        "sha256": "d48a8d6eebf9760cc8f1a4f19df0e6afc31fcc1284b5eacfb604ad8ced6a0b53"
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/04-ddd.md",
-        "sha256": "c6cf98ab0dd80183ad507aca12edf164ee79a5fb60eee84d674cf73fe3a68646"
+        "sha256": "e9504cf1183bc0105167dc06108860882941fcf1b5be79d1978d8212c410ffbb"
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/05-architecture.md",
-        "sha256": "227ec469154348afc414ef4751cc34ea5bb87ecb063cf196eff254615a6b5e00"
+        "sha256": "2ef7cf316903f0cbb1fabe1f0e1770c22b2cb3a11a4118cac0529c25074b5e8a"
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/06-implementation-plan.md",
-        "sha256": "443043f6f3a3c2ebdcc4d40f9d13d799581056fb37890a2bb1fa61662825229b"
+        "sha256": "c8fdd1877d8d9515ab29f52c3db49ddd9612b5797bc071e6208def860c02e6f2"
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/07-code.md",
@@ -321,7 +321,7 @@
       },
       {
         "path": "templates/.claude/workflows/feature-adr.js",
-        "sha256": "4904cf2040f024647c561fb5bd11aab5c7c0b70190dc4505b1bd69572cf25072"
+        "sha256": "d9cda8df501188c894d083c5c44c240c9ebe9ba7e2d418302c448d73b089e051"
       },
       {
         "path": "templates/lib/memory-protocol.md",
@@ -349,5 +349,5 @@
       }
     ]
   },
-  "signature": "nKR64NSSz41u0CCXl4HdsXqTmS5QUqIIYZdRn4xVoEj/wuzF7Vb7X21mte94etpLINVimxi1pTdUQYOO5GlyCw=="
+  "signature": "ZnkOOhYGfaIEp1W5L/Gphs0uniT0FieL/yn5KPl6cZ3zQeXkZcqDjfOta9b6zmPEgztZAclspZ0yf82VnjeHBQ=="
 }

package/README.md

@@ -878,3 +878,38 @@ them inside the package's own monorepo is almost never what you want anyway.
 - **npm:** [https://www.npmjs.com/package/@dzhechkov/skills-feature-adr](https://www.npmjs.com/package/@dzhechkov/skills-feature-adr)
 - **Keysarium:** [https://www.npmjs.com/package/@dzhechkov/keysarium](https://www.npmjs.com/package/@dzhechkov/keysarium)
 - **BTO:** [https://www.npmjs.com/package/@dzhechkov/skills-bto](https://www.npmjs.com/package/@dzhechkov/skills-bto)
+
+## Write discipline — why the writing steps now build a skeleton first
+
+MEASURED in the field on 2026-08-19 and 2026-08-20, two independent runs of the canonical pipeline
+against a ~130-file repository: the steps that must produce a document — Step 5 (Architecture) and
+Step 6 (Plan) — **never reached a write**. 18 attempts, zero file writes in every one. They died in
+the READING phase: a shell result returns, the agent thinks about its next move, stays silent past
+the runtime's 180-second inactivity watchdog, and is killed. One run cost ~4M tokens and 1h54m.
+
+The failure is **deterministic, not unlucky**: thinking time grows with accumulated history, so on a
+large enough repository unbounded exploration guarantees the kill. And the cause was in the
+instructions, not the runtime — every writing step said, in effect, *"read the code, write the
+document"*, with no reading budget and no order of operations. An agent obeying literally reads
+until it dies.
+
+The owner's control experiment is the whole evidence base, and it is n=1: same slice, same inputs,
+same model, ONE added paragraph about write discipline → a 10-section skeleton on disk 8 minutes in,
+first attempt, after six consecutive deaths.
+
+So every document-producing step now carries:
+
+1. the FIRST file write happens within the first ~12 tool calls — a skeleton of section headings
+   with one line of intent under each;
+2. then fill it **one section per edit**, no edit longer than ~120 lines;
+3. never go more than 2 minutes without a tool call;
+4. when unsure whether to read more or to write — **write**.
+
+**What this does not do**, stated plainly: it does not stop the deaths. The watchdog is unchanged.
+It changes what survives one — previously nothing, now a skeleton on disk that the next attempt can
+continue. The `~12` and `~120` are chosen parameters, not measured optima. Two possible regressions
+were named by an independent reviewer and are **not measured**: an early skeleton may anchor a
+structure chosen before understanding, and section-per-edit raises tool-call overhead.
+
+Steps whose deliverable is a returned verdict rather than a document (the complexity router) are
+deliberately excluded — "skeleton first" is nonsense there.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/skills-feature-adr",
-  "version": "1.3.66",
+  "version": "1.3.67",
   "description": "Adaptive Feature Development skill pack for Claude Code — 11-step pipeline with Complexity Router (S/M/L/XL), ADR-driven architecture, 15 agentic-qe skills, multi-agent fleet QE. Supports --full-qe, --full-qe-extended, --with-learning, and --knowledge-extractor modes.",
   "bin": {
     "skills-feature-adr": "./bin/cli.js"

package/sbom.json

@@ -35,7 +35,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "5cca2d4a5337177ee9a072d49d14f73386af75398f52d907d757d4c052afdf81"
+          "content": "1d123dcb15ac44b9adfe8266cb72d2dc69d5086f54003540795296c36e06e1b2"
         }
       ]
     },
@@ -65,7 +65,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "b76f1b1d1ce3d8b22be0c2354fe3bd22833513da8b418c7c93423ae75f4018ae"
+          "content": "31de034ec7534b585ee99a2dac0105bc4e43dca0c5b419076e66c43e797509d3"
         }
       ]
     },
@@ -305,7 +305,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "02d2a081e4bc9e7f5d42e55a4e21a68484af8b45216ff74fe5fc4322cb689a96"
+          "content": "bdedfed69d985eb6969f158a72d92f63c6b1b993008c3661f7ffc2c6a7ccfbae"
         }
       ]
     },
@@ -335,7 +335,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "7b599efd3122be7ce2247bba1c9204e1b3c09322ad56ed4cedcbd4dd471ed41e"
+          "content": "e6ea3a224b555d5b7410cf2ddf02a3fb8d009fa01109463353e2b993c318270c"
         }
       ]
     },
@@ -345,7 +345,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "55099189082d872d08a9d40b11782d8d08256955cbea617aa457756eb9fa1a07"
+          "content": "e2506e42251c74485188473acc4586f841afbec3ae7c5eaa8a3d8f73f6e14cc5"
         }
       ]
     },
@@ -355,7 +355,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "742f1d362fd4d1b1b731fe81b7aa794886aa58126005ad67ef0a27775c80f082"
+          "content": "ea03eee136c89267888b8034baa1a1cb0057314a2e745df71654a9ebee5d46b6"
         }
       ]
     },
@@ -365,7 +365,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "220e06d0d67643f09df868df32d1ec3acdc205653a5ef977d171791d9ce77b74"
+          "content": "d48a8d6eebf9760cc8f1a4f19df0e6afc31fcc1284b5eacfb604ad8ced6a0b53"
         }
       ]
     },
@@ -375,7 +375,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "c6cf98ab0dd80183ad507aca12edf164ee79a5fb60eee84d674cf73fe3a68646"
+          "content": "e9504cf1183bc0105167dc06108860882941fcf1b5be79d1978d8212c410ffbb"
         }
       ]
     },
@@ -385,7 +385,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "227ec469154348afc414ef4751cc34ea5bb87ecb063cf196eff254615a6b5e00"
+          "content": "2ef7cf316903f0cbb1fabe1f0e1770c22b2cb3a11a4118cac0529c25074b5e8a"
         }
       ]
     },
@@ -395,7 +395,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "443043f6f3a3c2ebdcc4d40f9d13d799581056fb37890a2bb1fa61662825229b"
+          "content": "c8fdd1877d8d9515ab29f52c3db49ddd9612b5797bc071e6208def860c02e6f2"
         }
       ]
     },
@@ -805,7 +805,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "4904cf2040f024647c561fb5bd11aab5c7c0b70190dc4505b1bd69572cf25072"
+          "content": "d9cda8df501188c894d083c5c44c240c9ebe9ba7e2d418302c448d73b089e051"
         }
       ]
     },

package/templates/.claude/skills/feature-adr/SKILL.md

@@ -226,6 +226,14 @@ Execute protocol
 → Checkpoint N
 ```
 
+**Write discipline — applies to EVERY step that produces a document.** Open the step's artifact within
+your first ~12 tool calls as a SKELETON (its section headings, one line of intent each), then fill it one
+section per edit, no edit longer than ~120 lines. Never go more than 2 minutes without a tool call, and
+when you are unsure whether to read more or to write, WRITE. Reason: an executor silent for 180 seconds is
+killed by the runtime, and thinking time grows with accumulated history — so unbounded exploration before
+the first write is a deterministic death on a large repo, not bad luck. Each module restates this under
+its own `## Write discipline (the 180-second rule)` heading.
+
 ### 4. Final Verification
 After Step 8 (or Step 9 for L/XL) completes, verify:
 - All mandatory artifacts exist per tier
@@ -616,6 +624,7 @@ npx @dzhechkov/skills-feature-adr init --with-learning --knowledge-extractor
 | Ignore NO-GO verdict | Proceed despite Step 3.5 NO-GO | BLOCK — rework required |
 | Skip gap loop | No gap detection in Step 8 | Missing requirements coverage check |
 | Skip fleet QE for L/XL | No Step 9 for large features | BLOCK — fleet assessment mandatory |
+| Unbounded reading before the first write | The step's artifact still does not exist after ~12 tool calls | BLOCK — write the skeleton now; a silent executor is killed at 180 s |
 
 ## Checkpoint Format
 

package/templates/.claude/skills/feature-adr/modules/01-requirements.md

@@ -77,6 +77,32 @@ Explicitly state:
 - **Dependencies:** What must exist before this feature works
 - **Dependents:** What will break if this feature changes
 
+## Write discipline (the 180-second rule)
+
+An executor that returns from a tool call and then thinks in silence past **180 seconds** is killed by the
+runtime. Thinking time grows with the history already accumulated, so on a large repo "read everything,
+then write the document" is not a risk — it is a deterministic death, and nothing survives it, because
+nothing was ever on disk.
+
+MEASURED on this harness: the writing steps died **18 times out of 18** in the reading phase without ever
+writing a file. The control — same slice, same model, one added instruction to write a skeleton early —
+landed the skeleton 8 minutes in, on the first attempt, after six consecutive deaths.
+
+So, in this step:
+
+1. **Skeleton first — inside your first ~12 tool calls.** Write `features/<slug>/01_requirements.md` containing only the headings this step
+   requires (Stakeholders · Functional requirements · Non-functional requirements · Constraints ·
+   Scope boundaries · Open questions), one line of intent under each. (S-tier is inline and has no
+   file — this section does not apply to it.)
+2. **Then fill it one section per edit.** No single edit longer than ~120 lines. Every edit leaves the
+   file readable; none of them is allowed to wait for the section after it.
+3. **Never go more than 2 minutes without a tool call.** A thought that is getting long is the signal to
+   stop and write what you have — an edit is a checkpoint, not an interruption.
+4. **When you are unsure whether to read more or to write, WRITE.** A thin section refined later survives;
+   a perfect section you never reached does not.
+
+The skeleton is not a draft to apologise for. It is the artifact, opened early.
+
 ## Output
 
 ### For S-tier (inline)

package/templates/.claude/skills/feature-adr/modules/02-research.md

@@ -73,6 +73,32 @@ Alternative considered: [Y], rejected because [reasons].
 
 After both complete, synthesize results sequentially.
 
+## Write discipline (the 180-second rule)
+
+An executor that returns from a tool call and then thinks in silence past **180 seconds** is killed by the
+runtime. Thinking time grows with the history already accumulated, so on a large repo "read everything,
+then write the document" is not a risk — it is a deterministic death, and nothing survives it, because
+nothing was ever on disk.
+
+MEASURED on this harness: the writing steps died **18 times out of 18** in the reading phase without ever
+writing a file. The control — same slice, same model, one added instruction to write a skeleton early —
+landed the skeleton 8 minutes in, on the first attempt, after six consecutive deaths.
+
+So, in this step:
+
+1. **Skeleton first — inside your first ~12 tool calls.** Write `features/<slug>/02_research.md` containing only the headings this step
+   requires (Codebase patterns · External patterns · Library evaluation · Anti-patterns ·
+   Recommended approach), one line of intent under each — before the research agents report back,
+   not after.
+2. **Then fill it one section per edit.** No single edit longer than ~120 lines. Every edit leaves the
+   file readable; none of them is allowed to wait for the section after it.
+3. **Never go more than 2 minutes without a tool call.** A thought that is getting long is the signal to
+   stop and write what you have — an edit is a checkpoint, not an interruption.
+4. **When you are unsure whether to read more or to write, WRITE.** A thin section refined later survives;
+   a perfect section you never reached does not.
+
+The skeleton is not a draft to apologise for. It is the artifact, opened early.
+
 ## Output
 
 Create `features/<slug>/02_research.md` with:

package/templates/.claude/skills/feature-adr/modules/03-adr.md

@@ -167,6 +167,32 @@ Each ADR must trace back to specific requirements:
 | Placeholder text | Template hints or TODOs remain | Remove or fill before checkpoint |
 | Supersession in-place | Existing ADR rewritten | Mint a new ADR and link it |
 
+## Write discipline (the 180-second rule)
+
+An executor that returns from a tool call and then thinks in silence past **180 seconds** is killed by the
+runtime. Thinking time grows with the history already accumulated, so on a large repo "read everything,
+then write the document" is not a risk — it is a deterministic death, and nothing survives it, because
+nothing was ever on disk.
+
+MEASURED on this harness: the writing steps died **18 times out of 18** in the reading phase without ever
+writing a file. The control — same slice, same model, one added instruction to write a skeleton early —
+landed the skeleton 8 minutes in, on the first attempt, after six consecutive deaths.
+
+So, in this step:
+
+1. **Skeleton first — inside your first ~12 tool calls.** For each decision you have identified, write
+   `features/<slug>/03_adr/NNN-{decision-slug}.md` containing only the invariant-core headings
+   (Status · Context · Decision Drivers · Considered Options · Decision · Rationale · Consequences ·
+   Confirmation), one line of intent under each. A named-but-empty option beats an unwritten ADR.
+2. **Then fill it one section per edit.** No single edit longer than ~120 lines. Every edit leaves the
+   file readable; none of them is allowed to wait for the section after it.
+3. **Never go more than 2 minutes without a tool call.** A thought that is getting long is the signal to
+   stop and write what you have — an edit is a checkpoint, not an interruption.
+4. **When you are unsure whether to read more or to write, WRITE.** A thin section refined later survives;
+   a perfect section you never reached does not.
+
+The skeleton is not a draft to apologise for. It is the artifact, opened early.
+
 ## Output
 
 Create `features/<slug>/03_adr/` directory with:

package/templates/.claude/skills/feature-adr/modules/03.5-ideation-swarm.md

@@ -154,6 +154,31 @@ AM-N (source): <change>. Confirmation: <property> → test `test_name` (fails if
   an existence test and never fires in production.
 - A cheap lint holds the shape: every `AM-N` line must contain a `→ test ` token naming a test that exists.
 
+## Write discipline (the 180-second rule)
+
+An executor that returns from a tool call and then thinks in silence past **180 seconds** is killed by the
+runtime. Thinking time grows with the history already accumulated, so on a large repo "read everything,
+then write the document" is not a risk — it is a deterministic death, and nothing survives it, because
+nothing was ever on disk.
+
+MEASURED on this harness: the writing steps died **18 times out of 18** in the reading phase without ever
+writing a file. The control — same slice, same model, one added instruction to write a skeleton early —
+landed the skeleton 8 minutes in, on the first attempt, after six consecutive deaths.
+
+So, in this step:
+
+1. **Skeleton first — inside your first ~12 tool calls.** Write `features/<slug>/03.5_ideation_report.md` containing only the eight
+   section headings of §5 (Executive summary … Amendments), one line of intent under each — while
+   the swarm is still running, not after every agent has returned.
+2. **Then fill it one section per edit.** No single edit longer than ~120 lines. Every edit leaves the
+   file readable; none of them is allowed to wait for the section after it.
+3. **Never go more than 2 minutes without a tool call.** A thought that is getting long is the signal to
+   stop and write what you have — an edit is a checkpoint, not an interruption.
+4. **When you are unsure whether to read more or to write, WRITE.** A thin section refined later survives;
+   a perfect section you never reached does not.
+
+The skeleton is not a draft to apologise for. It is the artifact, opened early.
+
 ## Output
 
 Create `features/<slug>/03.5_ideation_report.md` with full QCSD report.

package/templates/.claude/skills/feature-adr/modules/04-ddd.md

@@ -92,6 +92,31 @@ Check that proposed domain model is compatible with existing code:
 - Can aggregates be implemented with existing ORM/framework?
 - Do relationships align with existing data access patterns?
 
+## Write discipline (the 180-second rule)
+
+An executor that returns from a tool call and then thinks in silence past **180 seconds** is killed by the
+runtime. Thinking time grows with the history already accumulated, so on a large repo "read everything,
+then write the document" is not a risk — it is a deterministic death, and nothing survives it, because
+nothing was ever on disk.
+
+MEASURED on this harness: the writing steps died **18 times out of 18** in the reading phase without ever
+writing a file. The control — same slice, same model, one added instruction to write a skeleton early —
+landed the skeleton 8 minutes in, on the first attempt, after six consecutive deaths.
+
+So, in this step:
+
+1. **Skeleton first — inside your first ~12 tool calls.** Write `features/<slug>/04_domain_model.md` containing only the headings this step
+   requires (Bounded context map · Ubiquitous language · Aggregates/Entities/VOs · Relationships ·
+   Codebase mapping), one line of intent under each.
+2. **Then fill it one section per edit.** No single edit longer than ~120 lines. Every edit leaves the
+   file readable; none of them is allowed to wait for the section after it.
+3. **Never go more than 2 minutes without a tool call.** A thought that is getting long is the signal to
+   stop and write what you have — an edit is a checkpoint, not an interruption.
+4. **When you are unsure whether to read more or to write, WRITE.** A thin section refined later survives;
+   a perfect section you never reached does not.
+
+The skeleton is not a draft to apologise for. It is the artifact, opened early.
+
 ## Output
 
 Create `features/<slug>/04_domain_model.md` with:

package/templates/.claude/skills/feature-adr/modules/05-architecture.md

@@ -118,6 +118,32 @@ GET /api/v1/{resource}/:id
   Errors: 401, 404
 ```
 
+## Write discipline (the 180-second rule)
+
+An executor that returns from a tool call and then thinks in silence past **180 seconds** is killed by the
+runtime. Thinking time grows with the history already accumulated, so on a large repo "read everything,
+then write the document" is not a risk — it is a deterministic death, and nothing survives it, because
+nothing was ever on disk.
+
+MEASURED on this harness: the writing steps died **18 times out of 18** in the reading phase without ever
+writing a file. The control — same slice, same model, one added instruction to write a skeleton early —
+landed the skeleton 8 minutes in, on the first attempt, after six consecutive deaths.
+
+So, in this step:
+
+1. **Skeleton first — inside your first ~12 tool calls.** Write `features/<slug>/05_architecture.md` containing only the headings this step
+   requires at your tier (C4 Context · C4 Container · C4 Component · Sequence flows · Data & storage ·
+   API design), one line of intent under each. An empty `mermaid` fence with a caption is a
+   heading; fill it later.
+2. **Then fill it one section per edit.** No single edit longer than ~120 lines. Every edit leaves the
+   file readable; none of them is allowed to wait for the section after it.
+3. **Never go more than 2 minutes without a tool call.** A thought that is getting long is the signal to
+   stop and write what you have — an edit is a checkpoint, not an interruption.
+4. **When you are unsure whether to read more or to write, WRITE.** A thin section refined later survives;
+   a perfect section you never reached does not.
+
+The skeleton is not a draft to apologise for. It is the artifact, opened early.
+
 ## Output
 
 ### M-tier

package/templates/.claude/skills/feature-adr/modules/06-implementation-plan.md

@@ -135,6 +135,32 @@ Before finalizing the plan, validate completeness:
 
 This gap-check loop ensures the implementation plan is complete before coding begins.
 
+## Write discipline (the 180-second rule)
+
+An executor that returns from a tool call and then thinks in silence past **180 seconds** is killed by the
+runtime. Thinking time grows with the history already accumulated, so on a large repo "read everything,
+then write the document" is not a risk — it is a deterministic death, and nothing survives it, because
+nothing was ever on disk.
+
+MEASURED on this harness: the writing steps died **18 times out of 18** in the reading phase without ever
+writing a file. The control — same slice, same model, one added instruction to write a skeleton early —
+landed the skeleton 8 minutes in, on the first attempt, after six consecutive deaths.
+
+So, in this step:
+
+1. **Skeleton first — inside your first ~12 tool calls.** Write `features/<slug>/06_implementation_plan.md` containing only the headings
+   this step requires (Goal state · Tasks · Dependency order · Parallel groups · Checkpoints · Risk
+   assessment · Amendments · `EXPECTED_CODE_TARGETS:`), one line of intent under each. The K2 gate
+   reads this file — a plan that lives only in the conversation cannot pass it.
+2. **Then fill it one section per edit.** No single edit longer than ~120 lines. Every edit leaves the
+   file readable; none of them is allowed to wait for the section after it.
+3. **Never go more than 2 minutes without a tool call.** A thought that is getting long is the signal to
+   stop and write what you have — an edit is a checkpoint, not an interruption.
+4. **When you are unsure whether to read more or to write, WRITE.** A thin section refined later survives;
+   a perfect section you never reached does not.
+
+The skeleton is not a draft to apologise for. It is the artifact, opened early.
+
 ## Output
 
 ### S-tier (minimal file — NOT inline-only)

package/templates/.claude/workflows/feature-adr.js

@@ -44,6 +44,20 @@ function absolutizeRepo(raw, cwd) {
 }
 const ABSOLUTE_PATH_NOTE = ' All artifact paths in this prompt are ABSOLUTE. Read and write them exactly as given; do not cd first and do not re-relativize them.'
 
+// WRITE DISCIPLINE — the anti-watchdog clause for every step whose DELIVERABLE IS A DOCUMENT.
+// MEASURED (field report P14, two independent runs, agent journals on disk): Steps 5 and 6 never
+// reached a single write — 18/18 attempts ended with FILE_WRITES=0, all of them killed inside the
+// READING phase after >180 s of silence between tool calls; ~4M tokens and 1h54m per run bought
+// nothing. Thinking time grows with accumulated history, so on a large repo this is DETERMINISTIC,
+// not unlucky. The prompts said 'READ the code. Write <file>' with no reading budget and no order of
+// operations, and the executor obeyed literally. Control experiment (owner, same slice/inputs/model,
+// ONE added paragraph on write discipline): a 10-section skeleton landed 8 minutes in, on the FIRST
+// attempt, after six consecutive deaths. One variable changed, opposite outcome. NOT CLAIMED: that
+// this removes the watchdog class — it is a layer-4 prompt instruction, so it is probabilistic by
+// construction; the deterministic half is the layer-1 test that this clause is PRESENT in every
+// writing-step prompt (harness-core/test/feature-adr-write-discipline.test.ts).
+const WRITE_DISCIPLINE = ' WRITE DISCIPLINE (mandatory, not advice). 1. Your FIRST file write must happen within your first 12 tool calls: create the SKELETON of the artifact — every section heading plus one line of intent under each. 2. Then fill it in ONE SECTION PER EDIT; no single edit longer than ~120 lines. 3. Never go more than 2 minutes without a tool call. 4. If you are unsure whether to read more or to write, WRITE. Reason: an executor that shows no activity for 180 seconds is KILLED by the runtime, so unbounded exploration before the first write makes the step die having written nothing at all.'
+
 const UNSAFE_PATH_CHARS = /[\u0000-\u001f\u007f]/
 const DOT_DOT_SEGMENT = /(^|\/)\.\.(\/|$)/
 function hasUnsafePathChars(p) { return UNSAFE_PATH_CHARS.test(String(p)) }
@@ -1450,19 +1464,19 @@ modelsUsed.ddd = modelLabel(archOpts)
 // record the exact input each design agent received. designPairMeta[i] aligns with designThunks[i],
 // which aligns with design[i] in the parallel result — one pair per design sub-stage.
 const designPairMeta = []
-const reqPromptText = 'Step 1 (Requirements)' + (isLplus ? ' + Step 2 (Research)' : '') + ' of /feature-adr for "' + DESC + '" (tier ' + tier + ', slug ' + SLUG + '). Code: ' + CODE_HINT + '. APPLY these Step-0 recalled LEARNED PATTERNS (fold the applicable ones into requirements/constraints - the loop paying off): ' + LEARNED + '. Write ' + FDIR + '/01_requirements.md (functional + non-functional requirements, acceptance criteria, constraints, and an "Applied learned patterns" note).' + reqExtra + ' Return wrote[] + a 1-line summary.' + PS_GUIDANCE('design')
+const reqPromptText = 'Step 1 (Requirements)' + (isLplus ? ' + Step 2 (Research)' : '') + ' of /feature-adr for "' + DESC + '" (tier ' + tier + ', slug ' + SLUG + '). Code: ' + CODE_HINT + '. APPLY these Step-0 recalled LEARNED PATTERNS (fold the applicable ones into requirements/constraints - the loop paying off): ' + LEARNED + '. Write ' + FDIR + '/01_requirements.md (functional + non-functional requirements, acceptance criteria, constraints, and an "Applied learned patterns" note).' + reqExtra + ' Return wrote[] + a 1-line summary.' + PS_GUIDANCE('design') + WRITE_DISCIPLINE
 designThunks.push(() => designStage(reqPromptText, reqOpts, FDIR + '/01_requirements.md', 'requirements'))
 // the requirements prompt is where the Step-0 recalled lessons are INJECTED — recorded per pair
 designPairMeta.push({ role: 'design:requirements', prompt: reqPromptText, model: modelLabel(reqOpts), lessons: (LEARNED && LEARNED !== 'none recalled') ? [String(LEARNED)] : [] })
 if (isMplus) {
-  const adrPromptText = 'Step 3 (ADR + shift-left testability) of /feature-adr for "' + DESC + '" (' + SLUG + '). READ the actual code (' + CODE_HINT + ') to ground it. ' + ADR_TEMPLATE_GUIDE + ' Write ' + FDIR + '/03_adr/001-' + SLUG + '.md as a MADR-structured ADR that PASSES the Step-8 ADR fitness checklist (do NOT emit the legacy shape). Emit ALL of these sections, in order: a decision-shaped # Title (present-tense imperative verb — the auto-filename tracks the feature slug, so the IMPERATIVE signal lives in the title); ## Status (proposed/accepted/rejected/deprecated/superseded + a reversibility/revisit clause); ## Context (neutral, problem-first, BEFORE the Decision); ## Decision Drivers (ranked/weighted D1, D2, …); ## Considered Options (frame the CHOSEN approach as one option ALONGSIDE the rejected ones, each with symmetric Pros:/Cons:); ## Decision (concrete/testable — exact names, versions, paths, commands); ## Rationale (map each point to a driver Dn + why the losers lost); ## Consequences (Positive + Negative/Accepted Downsides + Follow-up ADRs + After-action Review with owner + date); a REQUIRED ## Confirmation stanza with Method:, Monitoring:, Success metric:, Owner:, Load-bearing property:, and Required automated check: `<test file>` NAMING the load-bearing property that MUST have a Step-8 test (the recurring lesson: the key safety property is often the untested one); and a ## Links traceability block (requirements, driving use case, related ADRs). Add a one-line provenance note (model-generated, edited for clarity) and, for a long ADR, a top-of-file table of contents. Do NOT use an "Alternatives considered" or "Testability/shift-left" heading in place of Considered Options / Confirmation. When creating ADDITIONAL ADRs, name them 03_adr/NNN-{decision-slug}.md with a lowercase-kebab, present-tense imperative, dateless, ticketless slug. Return wrote[] + summary.'
+  const adrPromptText = 'Step 3 (ADR + shift-left testability) of /feature-adr for "' + DESC + '" (' + SLUG + '). READ the actual code (' + CODE_HINT + ') to ground it. ' + ADR_TEMPLATE_GUIDE + ' Write ' + FDIR + '/03_adr/001-' + SLUG + '.md as a MADR-structured ADR that PASSES the Step-8 ADR fitness checklist (do NOT emit the legacy shape). Emit ALL of these sections, in order: a decision-shaped # Title (present-tense imperative verb — the auto-filename tracks the feature slug, so the IMPERATIVE signal lives in the title); ## Status (proposed/accepted/rejected/deprecated/superseded + a reversibility/revisit clause); ## Context (neutral, problem-first, BEFORE the Decision); ## Decision Drivers (ranked/weighted D1, D2, …); ## Considered Options (frame the CHOSEN approach as one option ALONGSIDE the rejected ones, each with symmetric Pros:/Cons:); ## Decision (concrete/testable — exact names, versions, paths, commands); ## Rationale (map each point to a driver Dn + why the losers lost); ## Consequences (Positive + Negative/Accepted Downsides + Follow-up ADRs + After-action Review with owner + date); a REQUIRED ## Confirmation stanza with Method:, Monitoring:, Success metric:, Owner:, Load-bearing property:, and Required automated check: `<test file>` NAMING the load-bearing property that MUST have a Step-8 test (the recurring lesson: the key safety property is often the untested one); and a ## Links traceability block (requirements, driving use case, related ADRs). Add a one-line provenance note (model-generated, edited for clarity) and, for a long ADR, a top-of-file table of contents. Do NOT use an "Alternatives considered" or "Testability/shift-left" heading in place of Considered Options / Confirmation. When creating ADDITIONAL ADRs, name them 03_adr/NNN-{decision-slug}.md with a lowercase-kebab, present-tense imperative, dateless, ticketless slug. Return wrote[] + summary.' + WRITE_DISCIPLINE
   designThunks.push(() => designStage(adrPromptText, adrOpts, FDIR + '/03_adr/001-' + SLUG + '.md', 'adr'))
   designPairMeta.push({ role: 'design:adr', prompt: adrPromptText, model: modelLabel(adrOpts), lessons: [] })
-  const qcsdPromptText = 'Step 3.5 (QCSD ideation swarm - HTSM quality criteria + SFDIPOT risk) of /feature-adr for "' + DESC + '" (' + SLUG + '). Assess quality criteria + product-factors risk. Write ' + FDIR + '/03.5_ideation_report.md with a GO/CONDITIONAL/NO-GO verdict + top quality risks for QE. On a CONDITIONAL verdict, write each condition as an amendment row in a `## Amendments` section. ' + AMENDMENT_RULE + ' Return wrote[] + summary.'
+  const qcsdPromptText = 'Step 3.5 (QCSD ideation swarm - HTSM quality criteria + SFDIPOT risk) of /feature-adr for "' + DESC + '" (' + SLUG + '). Assess quality criteria + product-factors risk. Write ' + FDIR + '/03.5_ideation_report.md with a GO/CONDITIONAL/NO-GO verdict + top quality risks for QE. On a CONDITIONAL verdict, write each condition as an amendment row in a `## Amendments` section. ' + AMENDMENT_RULE + ' Return wrote[] + summary.' + WRITE_DISCIPLINE
   designThunks.push(() => designStage(qcsdPromptText, qcsdOpts, FDIR + '/03.5_ideation_report.md', 'qcsd'))
   designPairMeta.push({ role: 'design:qcsd', prompt: qcsdPromptText, model: modelLabel(qcsdOpts), lessons: [] })
   const archExtra = isLplus ? ' Also ' + FDIR + '/04_domain_model.md (DDD).' : ''
-  const archPromptText = (isLplus ? 'Step 4 (DDD) + ' : '') + 'Step 5 (Architecture) of /feature-adr for "' + DESC + '" (' + SLUG + '). READ the code. Write ' + FDIR + '/05_architecture.md (components, data flow, integration points, the emit/merge/wiring shape).' + archExtra + ' Return wrote[] + summary.'
+  const archPromptText = (isLplus ? 'Step 4 (DDD) + ' : '') + 'Step 5 (Architecture) of /feature-adr for "' + DESC + '" (' + SLUG + '). READ the code. Write ' + FDIR + '/05_architecture.md (components, data flow, integration points, the emit/merge/wiring shape).' + archExtra + ' Return wrote[] + summary.' + WRITE_DISCIPLINE
   designThunks.push(() => designStage(archPromptText, archOpts, FDIR + '/05_architecture.md', 'architecture'))
   designPairMeta.push({ role: 'design:architecture', prompt: archPromptText, model: modelLabel(archOpts), lessons: [] })
 }
@@ -1487,7 +1501,7 @@ if (design) await capturePairs('design', 'Design', designPairMeta.map(function (
 // unavailable/errors — the pipeline never blocks on Codex.
 phase('Plan')
 await usageProbe('Plan')
-const planPrompt = 'Step 6 (SPARC-GOAP implementation plan) of /feature-adr for "' + DESC + '" (' + SLUG + ', tier ' + tier + '). Given the requirements + ADR + architecture in ' + FDIR + ', decompose into milestones + concrete tasks with success metrics. Write ' + FDIR + '/06_implementation_plan.md. END the plan with a trailing `EXPECTED_CODE_TARGETS:` block listing, one per line as `- <repo-relative path>`, EVERY production/test/config/doc file Step 7 is expected to create or modify. This block is machine-read by the Step-7.5 landing barrier: only paths it ESTABLISHES can ever count as landed, so an absent or unpollable block makes the barrier verdict INCONCLUSIVE. List only real targets outside features/, .dz/, .agentic-qe/ and roam/. If any corrections from Step 3.5 (a CONDITIONAL verdict) or other sources are folded into this plan, carry them in a `## Amendments` section. ' + AMENDMENT_RULE + ' Return wrote[] + summary.' + ABSOLUTE_PATH_NOTE
+const planPrompt = 'Step 6 (SPARC-GOAP implementation plan) of /feature-adr for "' + DESC + '" (' + SLUG + ', tier ' + tier + '). Given the requirements + ADR + architecture in ' + FDIR + ', decompose into milestones + concrete tasks with success metrics. Write ' + FDIR + '/06_implementation_plan.md. END the plan with a trailing `EXPECTED_CODE_TARGETS:` block listing, one per line as `- <repo-relative path>`, EVERY production/test/config/doc file Step 7 is expected to create or modify. This block is machine-read by the Step-7.5 landing barrier: only paths it ESTABLISHES can ever count as landed, so an absent or unpollable block makes the barrier verdict INCONCLUSIVE. List only real targets outside features/, .dz/, .agentic-qe/ and roam/. If any corrections from Step 3.5 (a CONDITIONAL verdict) or other sources are folded into this plan, carry them in a `## Amendments` section. ' + AMENDMENT_RULE + ' Return wrote[] + summary.' + ABSOLUTE_PATH_NOTE + WRITE_DISCIPLINE
 // Resolve the plan model. args.models.plan wins; else the planner:'codex' knob (via routingRequested +
 // DEFAULT_MODELS/coder-fold) or the DEFAULT_MODELS.plan ('sonnet') under routing; else {} (BC).
 const planModel = resolveStageModel('plan')