@oscaner-skills/cdd-engine 4.2.0 → 4.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (55) hide show
  1. package/README.md +38 -9
  2. package/README.zh-CN.md +43 -9
  3. package/dist/contract/completion-criterion.js +351 -0
  4. package/dist/contract/declare.js +181 -43
  5. package/dist/contract/doc.js +84 -271
  6. package/dist/contract/frontmatter.js +2 -1
  7. package/dist/contract/home-extractors.js +49 -316
  8. package/dist/contract/invariants.js +400 -296
  9. package/dist/contract/judge.js +74 -49
  10. package/dist/contract/lint.js +3 -2
  11. package/dist/contract/liveness-signal.js +103 -0
  12. package/dist/contract/markdown-document.js +410 -0
  13. package/dist/contract/markdown-tree-types.js +6 -0
  14. package/dist/contract/markdown-tree.js +137 -0
  15. package/dist/contract/project.js +1 -1
  16. package/dist/contract/rules.js +106 -0
  17. package/dist/contract/selector-engine.js +332 -0
  18. package/dist/contract/selector-spec.js +74 -0
  19. package/dist/contract/skill-anatomy.js +29 -1
  20. package/dist/contract/task-block-grammar.js +285 -0
  21. package/dist/contract/task-blocks.js +65 -0
  22. package/dist/contract/translate.js +21 -0
  23. package/dist/contract/wave-width.js +15 -0
  24. package/dist/face/board-view.js +401 -131
  25. package/dist/face/capsule.js +66 -89
  26. package/dist/face/cli.js +116 -35
  27. package/dist/face/declare.js +36 -18
  28. package/dist/face/gate.js +117 -40
  29. package/dist/face/init.js +1 -1
  30. package/dist/face/lifecycle.js +540 -123
  31. package/dist/face/preview.js +43 -10
  32. package/dist/face/route-render.js +51 -21
  33. package/dist/face/termination.js +135 -261
  34. package/dist/face/words.js +134 -12
  35. package/dist/infra/atomic.js +15 -0
  36. package/dist/infra/git.js +25 -0
  37. package/dist/infra/proc.js +150 -0
  38. package/dist/infra/round-log.js +104 -0
  39. package/dist/infra/runtime.js +16 -4
  40. package/dist/infra/workspace.js +7 -2
  41. package/dist/render/brief.js +15 -17
  42. package/dist/render/skeleton.js +41 -28
  43. package/dist/render/templates.js +128 -84
  44. package/dist/session/faces.js +47 -20
  45. package/dist/session/graph.js +13 -37
  46. package/dist/session/handoff-schema.js +16 -8
  47. package/dist/session/inflight.js +282 -0
  48. package/dist/session/ledger.js +581 -136
  49. package/dist/session/line-identity.js +33 -0
  50. package/dist/session/next.js +138 -80
  51. package/dist/session/preflight.js +276 -68
  52. package/dist/session/round-naming.js +56 -8
  53. package/dist/session/run.js +317 -78
  54. package/dist/session/wave.js +94 -14
  55. package/package.json +13 -3
@@ -15,7 +15,7 @@
15
15
  // placeholder three-way split: the slug-reference key (`program`) emits a `<…>`
16
16
  // scalar on the judge's placeholder-exemption chain; the content keys (`title` ·
17
17
  // `author` · `base` · `slug`) emit `:::fill <key>`; the
18
- // truth keys (`doc-type` · `version` · `date` · `status`) emit true values. The
18
+ // truth keys (`doc-type` · `version` · `date`) emit true values. The
19
19
  // optional `parent-version` key is deliberately NOT emitted — its shape is typed
20
20
  // (`v<n>.<m>`, so a fill or a link scalar would violate the domain) and absence
21
21
  // is legal. The markdown body stays the registry-driven scaffold. render() is a
@@ -48,9 +48,9 @@ const FRONT_MATTER_LINKS = {
48
48
  * `none` issue-ref default; the `[Pending]` design cell — the only pending form
49
49
  * its valuePattern admits, never bare `Pending` — and the bare `Pending` plan
50
50
  * cell, a legal alternative of its domain) and the conforming graph rows (the
51
- * `P1 -> P2` hard edge + the legend line). The head's `status` truth lives in
52
- * the front-matter emission (`status: Draft` — the first legal literal of every
53
- * status enum — via `#frontmatterTruth`, never a body fill). */
51
+ * `P1 -> P2` hard edge + the legend line). The head's enum truth lives in the
52
+ * front-matter emission via `#frontmatterTruth`, never a body fill — the
53
+ * retired `status` field no longer ships a truth key at all. */
54
54
  const TRUTH_LINES = {
55
55
  "Issue ref cell": "none",
56
56
  "Implementation plan cell": "Pending",
@@ -263,7 +263,7 @@ export class SkeletonAssembler {
263
263
  /** One front-matter value — the §4.2 placeholder three-way split over the slot
264
264
  * kind: the link keys a `<…>` placeholder scalar, the content keys a content
265
265
  * fill (`:::fill <key>`), the truth keys (the fixed version/date scaffold and
266
- * the doc-type / status patterns) their true values. */
266
+ * the doc-type pattern) their true values. */
267
267
  #frontmatterValue(slot) {
268
268
  if (slot.slot === "link") {
269
269
  const placeholder = FRONT_MATTER_LINKS[slot.anchor];
@@ -277,9 +277,8 @@ export class SkeletonAssembler {
277
277
  return this.#frontmatterTruth(slot);
278
278
  }
279
279
  /** The true front-matter value of a fixed/patterned front-matter key — the doc
280
- * type from the projection, the injected run date, the fixed first version and
281
- * the first legal status literal (`Draft`, the shared head of every status
282
- * enum domain). An unknown truth key is a registry drift, loud never silent. */
280
+ * type from the projection, the injected run date and the fixed first version.
281
+ * An unknown truth key is a registry drift, loud never silent. */
283
282
  #frontmatterTruth(slot) {
284
283
  switch (slot.anchor) {
285
284
  case "doc-type":
@@ -288,8 +287,6 @@ export class SkeletonAssembler {
288
287
  return "v0.1";
289
288
  case "date":
290
289
  return this.#date;
291
- case "status":
292
- return "Draft";
293
290
  }
294
291
  throw new Error(`no skeleton front-matter truth for the ${slot.anchor} anchor`);
295
292
  }
@@ -385,32 +382,48 @@ export class SkeletonAssembler {
385
382
  return `| v0.1 | ${this.#date} | :::fill summary | :::fill author |`;
386
383
  }
387
384
  /** The first task block — the true-numbered `### Task 1:` heading (the title a
388
- * content fill) plus the seven required task fields: the content markers with
389
- * their values, the Steps field with the checkable step form (§3.2), and the
390
- * `none` DependsOn default. */
385
+ * content fill) plus the seven reserved `#### Key` sections: the content fill of
386
+ * each, the Steps section with two checkable step samples (§3.2), and the `none`
387
+ * DependsOn default. The Steps section shows TWO step samples (the step lines are
388
+ * the task block's only repeatable unit), so the shape reads as a list from the
389
+ * first glance — zero new fields, the reserved key order unchanged. */
391
390
  #taskBlock(probe) {
392
391
  probe.add("### Task N:");
393
392
  probe.add("Task id token");
394
- probe.add("**Objective**");
395
- probe.add("**Files**");
393
+ probe.add("#### Objective");
394
+ probe.add("#### Files");
396
395
  probe.add("File path token");
397
- probe.add("**Consumes**");
398
- probe.add("**Produces**");
399
- probe.add("**Steps**");
396
+ probe.add("#### Consumes");
397
+ probe.add("#### Produces");
398
+ probe.add("#### Steps");
400
399
  probe.add("Step action");
401
400
  probe.add("Step checkable");
402
- probe.add("**Acceptance**");
403
- probe.add("**DependsOn**");
401
+ probe.add("#### Acceptance");
402
+ probe.add("#### DependsOn");
404
403
  return [
405
404
  "### Task 1: :::fill task-title",
406
- "- **Objective**: :::fill objective",
407
- "- **Files**: :::fill file-paths",
408
- "- **Consumes**: :::fill consumes",
409
- "- **Produces**: :::fill produces",
410
- "- **Steps**:",
411
- " - :::fill step-action — checkable: :::fill step-checkable",
412
- "- **Acceptance**: :::fill acceptance",
413
- "- **DependsOn**: none",
405
+ "",
406
+ "#### Objective",
407
+ ":::fill objective",
408
+ "",
409
+ "#### Files",
410
+ ":::fill file-paths",
411
+ "",
412
+ "#### Consumes",
413
+ ":::fill consumes",
414
+ "",
415
+ "#### Produces",
416
+ ":::fill produces",
417
+ "",
418
+ "#### Steps",
419
+ "- :::fill step-action — checkable: :::fill step-checkable",
420
+ "- :::fill step-action-2 — checkable: :::fill step-checkable-2",
421
+ "",
422
+ "#### Acceptance",
423
+ ":::fill acceptance",
424
+ "",
425
+ "#### DependsOn",
426
+ "none",
414
427
  "",
415
428
  ];
416
429
  }
@@ -3,13 +3,14 @@
3
3
  // home PLUS the TemplateAssembler (one module, one renderer). The dispatch prompt
4
4
  // data (the per-mode shell frames · the review variants · the single prose return block ·
5
5
  // the round-context subsets · the token registry · the clause partials) and the
6
- // review criteria (the four-type axes guides — P4, extended to spec/plan by the
7
- // v1.8 review-closeout) are typed constant data here, imported never parsed:
6
+ // review criteria (the per-key axes guides — P4, extended by the v1.8
7
+ // review-closeout and the P22 charter body) are typed constant data here, imported
8
+ // never parsed:
8
9
  //
9
10
  // · TEMPLATE_PROMPT — the rendering data plane the assembler consumes; this
10
11
  // module renders over it (the JSON's $schema/_doc prose plane is gone).
11
- // · REVIEWS — the four-type review criteria (task/branch axes guides + the
12
- // spec/plan URC prose, migrated from the dispatch table — their single typed
12
+ // · REVIEWS — the per-type review criteria (task/branch axes guides + the
13
+ // document shapes' URC prose, migrated from the dispatch table — their single typed
13
14
  // home, P4). P5 lands here: the "no parallel sub-agents" phrase is deleted.
14
15
  //
15
16
  // T15 v1.8 (the mode dispatch table — §3.5) restructures the prompt from "one all-mode
@@ -19,10 +20,10 @@
19
20
  // prefix (its instruction shell + the injected writable-subset schema at the
20
21
  // shell's tail — byte-identical for every dispatch of the mode, so the prompt-
21
22
  // cache prefix groups by mode) + the mode's REDUCED round-context subset.
22
- // · REVIEW_VARIANTS — the review mode's four per-type rows (task/branch/spec/plan):
23
- // the criteria + lens text are FIXED PREFIX content (folded into each variant's
24
- // shell — they are per-type constants, so they never ride the dynamic tail; the
25
- // INPUT_CRITERIA / INPUT_LENS round-context tokens are gone) and each variant's
23
+ // · REVIEW_VARIANTS — the review mode's per-target rows, one per target type:
24
+ // the criteria + lens text are FIXED PREFIX content (folded into each row's
25
+ // shell — the body is selected per target, so they never ride the dynamic tail;
26
+ // the INPUT_CRITERIA / INPUT_LENS round-context tokens are gone) and each row's
26
27
  // fixed prefix is byte-stable — a review dispatch's cache prefix groups by type.
27
28
  // · the normalized token vocabulary (§3.5): INPUT_* (read-side) / OUTPUT_* (write-
28
29
  // side) / WORKSPACE_* (environment) / BASE_BRANCH (the branch review's scope
@@ -60,6 +61,18 @@ const FRAME_ITEMS = [
60
61
  * evidence file's concrete name rides the injected schema's preamble (per-family
61
62
  * prefix), never this fixed text. */
62
63
  const EVIDENCE_ITEM = "**Evidence gate:** write the test-evidence file at the prescribed `OUTPUT_EVIDENCE` path per the `test-evidence` schema in `## Handoff schema` — `command`/`exit_code`/`passed`/`warnings_count` + `typecheck` (`command`/`exit_code`/`passed`); `behavior_change` when applicable. Update the round's report after verification. Missing or schema-violating evidence → the engine rewrites the draft to `status: BLOCKED`. Reports, test output, diffs: files only, never the return.";
64
+ /** The work plane's ONE capability declaration (design spec §7.3) — a dispatched
65
+ * implement / fix / docs-fix round may amend the spec and plan CONTENT face,
66
+ * because the document authoring right is a prompt slot, never a carrier slot (it
67
+ * is not in `CARRIER`, not in `PLANE_REQUIRED`, not in the frame and not in
68
+ * `progress.json` — the gate judges the result, never the declaration). The
69
+ * structure face (the plan's Task id set and any task's `DependsOn` set) belongs to
70
+ * the orchestrator: the engine snapshots both faces at dispatch and compares them at
71
+ * the close, so a round-internal structure edit judges the round hard. The docs-fix
72
+ * row carries it too — a fix round on a spec / plan line IS docs-fix, so this is the
73
+ * row the authorization has to reach. The review variants declare nothing — a review
74
+ * is read-only. */
75
+ const WORK_CAPABILITY = "**Capability — `capability: may.amend = content`:** this round may amend the spec's and the plan's content face (facts, file lists, steps, acceptance detail, cited line numbers). The structure face — the plan's Task id set and any task's `DependsOn` set — belongs to the orchestrator: the engine snapshots it at dispatch and compares it at the close, so changing it inside this round judges the round hard.";
63
76
  /** The discipline-clause cells shared by every shell (the `{{> cl:…}}` partials
64
77
  * resolve from the single clause container — the same bytes, one per shell). */
65
78
  const LICENSE_ITEMS = [
@@ -73,6 +86,7 @@ const LICENSE_ITEMS = [
73
86
  "- {{> cl:plan-freeze}}",
74
87
  "- {{> cl:atomic-commit}}",
75
88
  "- {{> cl:self-validate}}",
89
+ "- {{> cl:no-secret-access}}",
76
90
  "- {{> cl:sync-completion}}",
77
91
  ];
78
92
  /** The `## Handoff schema` section — the injected writable-subset fence at every
@@ -86,6 +100,7 @@ const IMPLEMENT_SHELL = [
86
100
  "## Instructions",
87
101
  "",
88
102
  ...FRAME_ITEMS,
103
+ WORK_CAPABILITY,
89
104
  `**implement:** read \`INPUT_WAVE_BRIEF\` (the complete plan mirror — every \`### Task N:\` of the wave + the plan's \`## Constraints\` section, fresh-extracted at dispatch). \`WAVE\` = this round's wave (the task list); implement ALL tasks of the wave, never a subset. \`CONFIRMED_SEAMS\` in the brief → apply as-is; else propose test boundaries in the report, then invoke **\`${DISPATCH.implement}\`**. Write the handoff draft at \`OUTPUT_HANDOFF\` per \`## Handoff schema\` BEFORE the return block: \`status\` (APPROVED once applied, else BLOCKED + the reason in \`notes\`) and \`artifacts\` (the prescribed \`OUTPUT_REPORT\`/\`OUTPUT_EVIDENCE\` paths from the round context — the \`{family}-{key}-\` canonical names, zero free naming).`,
90
105
  EVIDENCE_ITEM,
91
106
  ...LICENSE_ITEMS,
@@ -103,8 +118,10 @@ const FIX_SHELL = [
103
118
  "## Instructions",
104
119
  "",
105
120
  ...FRAME_ITEMS,
121
+ WORK_CAPABILITY,
106
122
  ...FIX_TYPED_INSTRUCTIONS,
107
123
  "**fix:** read `INPUT_REVIEWS` (open findings) + the plan context (`INPUT_WAVE_BRIEF` on a wave line — the complete plan mirror; `INPUT_PLAN` on the plan/branch lines — the plan document; `INPUT_SPEC` on the spec line — the spec document). Fix ALL findings (blocker/warn/nit), verifying against `INPUT_REVIEWS` none remain open. Fix + write the draft at `OUTPUT_HANDOFF` per `## Handoff schema` in one process; draft write failure → `status: BLOCKED`; retry = full re-run (idempotent).",
124
+ '**Dispositions:** every requested finding needs a disposition keyed by its own summary text (verbatim), valued `{ "status": "fixed" | "rejected", "reason"?: "…" }` — a missing or mis-keyed disposition fails the round.',
108
125
  EVIDENCE_ITEM,
109
126
  ...LICENSE_ITEMS,
110
127
  // T5 (v0.3) — The work plane's ONE strict-schema sentence: every top-level draft
@@ -117,14 +134,17 @@ const FIX_SHELL = [
117
134
  ...SCHEMA_SECTION,
118
135
  ];
119
136
  /** The docs-fix row's fixed prefix — header + instructions (no evidence — the
120
- * docs-fix round writes no evidence file). */
137
+ * docs-fix round writes no evidence file). It carries the shared work capability
138
+ * declaration: the fix face's spec / plan dispatch lands on this row. */
121
139
  const DOCS_FIX_SHELL = [
122
140
  "# CDD dispatch — docs-fix round",
123
141
  "",
124
142
  "## Instructions",
125
143
  "",
126
144
  ...FRAME_ITEMS,
145
+ WORK_CAPABILITY,
127
146
  "**docs-fix:** apply `INPUT_REVIEWS` (all severities) directly to the judged doc — `INPUT_PLAN` on a plan-doc line, `INPUT_SPEC` on a spec-doc line — removing fixed findings; record the path in `artifacts.doc` and report the round in `status` (APPROVED once every finding is applied, else BLOCKED + the reason in `notes`). Fix + write the draft at `OUTPUT_HANDOFF` per `## Handoff schema` in one process; retry = full re-run (idempotent).",
147
+ '**Dispositions:** every requested finding needs a disposition keyed by its own summary text (verbatim), valued `{ "status": "fixed" | "rejected", "reason"?: "…" }` — a missing or mis-keyed disposition fails the round.',
128
148
  ...LICENSE_ITEMS,
129
149
  // The generic strict-schema sentence — the SAME one the work shells carry: the
130
150
  // injected declaration is the draft's single field source, zero per-mode field
@@ -215,58 +235,88 @@ const MODE_PROMPTS = {
215
235
  ],
216
236
  },
217
237
  };
218
- /** The four-type review criteria — the review prompts' fixed criteria body (P4; the
219
- * spec/plan URC rows migrated from the dispatch table at the v1.8 closeout — their
220
- * single typed home). */
238
+ /** The two slots of the severity rubric — the reviewed artifact's name and the
239
+ * audience whose expectation judges the artifact's silence. The values are the
240
+ * literal placeholder spellings the fragment carries. */
241
+ export const SEVERITY_RUBRIC_SLOTS = {
242
+ artifact: "{artifact}",
243
+ audience: "{audience}",
244
+ };
245
+ /** The severity rubric — the ONE calibration fragment every review axes guide
246
+ * shares: the four blocker questions, the warn/nit tiers, the same-grade
247
+ * consistency duty, the vision (silence-is-not-permission) sentence with its two
248
+ * slots, the set-aside ledger and the closing acknowledgement. */
249
+ export const SEVERITY_RUBRIC = "Calibrate findings by real severity — not everything is a blocker. A finding is a blocker when any one of these holds: (a) the declared acceptance gate, contract or prompt is violated; (b) a legal input escapes the declared failure face (a blank input returns 500, an unknown id is not a 404); (c) the gate fails or the suite can never go red (an inert grep · a dead guard · an unconditional skip); (d) a security or privacy defect. Debt inside the contract is a warn (duplicated policy · stale docstring · a missing coverage case). Style, naming and line-wrapping is a nit. Within one run, a defect already graded in the same class keeps that grade; crossing grades names its reason in the finding. The reviewed {artifact} is a vision, not an exhaustive enumeration — behavior it is silent on is judged by what a reasonable {audience} would expect; its silence is not permission, and a finding's severity grades that expectation, not whether the text mentions the trigger. Before your verdict, list every behavior you considered and set aside as outside the reviewed scope — one line each with the reason; nothing set aside is dropped silently; an empty list means you set nothing aside. Acknowledge what was done well before listing findings (accurate praise earns the rest of the report trust).";
250
+ /** The slot values per criteria body — the ONE registry the filled fragment reads.
251
+ * `{artifact}` = the reviewed product's name; `{audience}` = the subject whose
252
+ * expectation judges the artifact's silence. The two spec-shaped targets share the
253
+ * ONE `spec` row, so their shared narrative body can never fork its vocabulary;
254
+ * the charter's own wording rides its criteria body (the `REVIEWS.overall` row),
255
+ * never a second vocabulary minted here. */
256
+ export const REVIEW_BODY_TEXT = {
257
+ wave: { artifact: "artifact", audience: "user" },
258
+ branch: { artifact: "artifact", audience: "user" },
259
+ spec: { artifact: "spec", audience: "downstream author" },
260
+ plan: { artifact: "plan", audience: "implementer" },
261
+ overall: { artifact: "spec", audience: "downstream author" },
262
+ };
263
+ /** The filled severity rubric of one criteria body — the shared fragment with that
264
+ * body's two slot values substituted. The parameter domain IS the `REVIEWS` key
265
+ * domain, so a consumer derives the guide from the same key. */
266
+ export const reviewGuideOf = (key) => {
267
+ const text = REVIEW_BODY_TEXT[key];
268
+ return SEVERITY_RUBRIC.replaceAll(SEVERITY_RUBRIC_SLOTS.artifact, text.artifact).replaceAll(SEVERITY_RUBRIC_SLOTS.audience, text.audience);
269
+ };
270
+ /** The spec-shaped documents' narrative criteria body — the phase-spec line's URC
271
+ * + its program-conformance clause, the ONE body both spec-shaped target rows
272
+ * select (the filled rubric is what differs per row). The charter's own criteria
273
+ * body is `docCharterAxes` — never a second narrative copy alongside this one. */
274
+ const docNarrativeAxes = (guide) => `Follow URC: single-cycle, lens-tagged findings (completeness/consistency/clarity) + the writing-plans self-check + verification evidence — the reviewer runs the repository's typecheck and test commands and self-reports the dual evidence + Claimed→pin: every behavior claim (usage-line attribution · semantic contract · byte face) must cite a colocated pin (path:line + the assertion face) — the review checks every claim against its pin, claim by claim; a pinless claim is a lens-tagged finding + program conformance — judge the phase against its parent overall at \`INPUT_OVERALL\` (the charter its \`program:\` names): the phase must sit inside the scope the overall's Phase inventory registered for it, and a phase that reaches beyond it is a completeness finding. ${guide}`;
275
+ /** The charter's criteria body — the six things a program charter owns, and only
276
+ * those. It carries none of the implementation-face evidence duty the narrative
277
+ * body carries (running the repository's commands, pinning every claim): a charter
278
+ * is judged on the program's shape, never on a phase's code. */
279
+ const docCharterAxes = (guide) => `Follow URC: single-cycle, lens-tagged findings (scope/inventory/dependency/acceptance/boundary) — judge the charter as a program charter, on six criteria and nothing it does not own. (1) Scope is a program increment — every phase's Scope names what the PROGRAM gains there (a capability, a boundary, a contract), never implementation detail such as a file list or a step-by-step walkthrough; a scope that descends to code is a scope finding. (2) Inventory, graph and order agree — every Phase inventory row has a Dependency graph node and every node a row, each edge is marked hard or soft and matches the row's Dependency cell, and the documented execution order is one the edges allow: a soft edge that hides a serial dependency, or an order no edge set permits, is a dependency finding. (3) Acceptance cells are phase-judgeable — each row's acceptance names an outcome a reviewer can decide when that phase closes, never a placeholder (TBD, a restated goal, a criterion only the program's end can settle); an undecidable cell is an acceptance finding. (4) Non-goals fence the program — every registered phase sits inside the boundary the Non-goals draw, and a non-goal drawn so loosely that it excludes nothing is a boundary finding. (5) The change record is a decision record — each entry states what was decided and why (its decision id where the program keeps one), never a work log of rounds and dispatches; a diary entry is an inventory finding. (6) Ledger and reality agree — a phase the tree shows closed is marked Done, a phase still in flight is not, and work no registered phase carries never appears as a delivered increment; a drift between the inventory and the tree is an inventory finding. ${guide}`;
280
+ /** The per-key review criteria — the review prompts' fixed criteria body (P4; the
281
+ * document shapes' URC rows migrated from the dispatch table at the v1.8 closeout —
282
+ * their single typed home; the charter body lands here at P22). The shared
283
+ * calibration tail rides `reviewGuideOf` (one fragment per row), never a per-key
284
+ * copy. */
221
285
  export const REVIEWS = {
222
286
  wave: {
223
287
  lensEnum: ["standards", "spec", "buildability"],
224
- axesGuide: "Standards axis (repo coding standards + code-review smell baseline) + Spec axis (wave brief / plan requirements) + Buildability axis (the reviewer explicitly runs the repository's typecheck command — `tsc --noEmit`, or the repo equivalent — AND its test command; every buildability finding self-reports the dual evidence, both commands ran) + Scope axis (changed-surface reasonableness): run `git diff origin/<BASE_BRANCH>..HEAD` yourself (BASE_BRANCH as named in the round context; on a missing artifact judge the working tree) — every changed file must fall within the wave brief's file surface (`**Files:**` seams) or be attributable to the plan / reviewed intent; an unattributable changed file is a candidate finding (severity by your judgment). The reviewer is the changed-surface judge — the engine reconciles nothing. The reviewed artifact is a vision, not an exhaustive enumeration — behavior it is silent on is judged by what a reasonable user would expect; its silence is not permission, and a finding's severity grades that expectation, not whether the text mentions the trigger. Before your verdict, list every behavior you considered and set aside as outside the reviewed scope — one line each with the reason; nothing set aside is dropped silently; an empty list means you set nothing aside. Calibrate findings by real severity — not everything is a blocker — and acknowledge what was done well before listing findings (accurate praise earns the rest of the report trust).",
288
+ axesGuide: `Standards axis (repo coding standards + code-review smell baseline) + Spec axis (wave brief / plan requirements) + Buildability axis (the reviewer explicitly runs the repository's typecheck command — \`tsc --noEmit\`, or the repo equivalent — AND its test command; every buildability finding self-reports the dual evidence, both commands ran) + Scope axis (changed-surface reasonableness): run \`git diff origin/<BASE_BRANCH>..HEAD\` yourself (BASE_BRANCH as named in the round context; on a missing artifact judge the working tree) — every changed file must fall within the wave brief's file surface (\`**Files:**\` seams) or be attributable to the plan / reviewed intent; an unattributable changed file is a candidate finding (severity by your judgment). The reviewer is the changed-surface judge — the engine reconciles nothing. ${reviewGuideOf("wave")}`,
225
289
  },
226
290
  branch: {
227
291
  lensEnum: ["standards", "spec", "buildability"],
228
- axesGuide: "Same four axes as task (branch-wide health: run `git diff origin/<BASE_BRANCH>..HEAD` + plan conformance) + Buildability axis (the reviewer explicitly runs the repository's typecheck command — `tsc --noEmit`, or the repo equivalent — AND its test command; every buildability finding self-reports the dual evidence, both commands ran) + Scope axis (changed-surface reasonableness): branch review IS the full diff — every changed file must be attributable to a finding, a plan requirement, or the reviewed intent; unrelated surface = candidate finding (severity by your judgment), normal finding → fix loop. The reviewed artifact is a vision, not an exhaustive enumeration — behavior it is silent on is judged by what a reasonable user would expect; its silence is not permission, and a finding's severity grades that expectation, not whether the text mentions the trigger. Before your verdict, list every behavior you considered and set aside as outside the reviewed scope — one line each with the reason; nothing set aside is dropped silently; an empty list means you set nothing aside. Calibrate findings by real severity — not everything is a blocker — and acknowledge what was done well before listing findings (accurate praise earns the rest of the report trust). Three things a green run cannot show you: design — does the changed structure fit this codebase and is it the simplest structure that solves the plan's problem (over-engineering is a finding, not a preference); test adequacy — would these tests fail if the code broke (a run that cannot go red is not evidence); migration — does every breaking change name the path a not-yet-migrated consumer takes.",
292
+ axesGuide: `Same four axes as task (branch-wide health: run \`git diff origin/<BASE_BRANCH>..HEAD\` + plan conformance) + Buildability axis (the reviewer explicitly runs the repository's typecheck command — \`tsc --noEmit\`, or the repo equivalent — AND its test command; every buildability finding self-reports the dual evidence, both commands ran) + Scope axis (changed-surface reasonableness): branch review IS the full diff — every changed file must be attributable to a finding, a plan requirement, or the reviewed intent; unrelated surface = candidate finding (severity by your judgment), normal finding → fix loop. ${reviewGuideOf("branch")} Three things a green run cannot show you: design — does the changed structure fit this codebase and is it the simplest structure that solves the plan's problem (over-engineering is a finding, not a preference); test adequacy — would these tests fail if the code broke (a run that cannot go red is not evidence); migration — does every breaking change name the path a not-yet-migrated consumer takes.`,
229
293
  },
230
294
  spec: {
231
295
  lensEnum: ["completeness", "consistency", "clarity"],
232
- axesGuide: "Follow URC: single-cycle, lens-tagged findings (completeness/consistency/clarity) + the writing-plans self-check + verification evidence — the reviewer runs the repository's typecheck and test commands and self-reports the dual evidence + Claimed→pin: every behavior claim (usage-line attribution · semantic contract · byte face) must cite a colocated pin (path:line + the assertion face) — the review checks every claim against its pin, claim by claim; a pinless claim is a lens-tagged finding + program conformance — judge the phase against its parent overall at `INPUT_OVERALL` (the charter its `program:` names): the phase must sit inside the scope the overall's Phase inventory registered for it, and a phase that reaches beyond it is a completeness finding + The reviewed spec is a vision, not an exhaustive enumeration — behavior it is silent on is judged by what a reasonable downstream author would expect; its silence is not permission, and a finding's severity grades that expectation, not whether the text mentions the trigger. Before your verdict, list every behavior you considered and set aside as outside the reviewed scope — one line each with the reason; nothing set aside is dropped silently; an empty list means you set nothing aside. Calibrate findings by real severity — not everything is a blocker — and acknowledge what was done well before listing findings (accurate praise earns the rest of the report trust).",
296
+ axesGuide: docNarrativeAxes(reviewGuideOf("spec")),
297
+ },
298
+ overall: {
299
+ lensEnum: ["scope", "inventory", "dependency", "acceptance", "boundary"],
300
+ axesGuide: docCharterAxes(reviewGuideOf("overall")),
233
301
  },
234
302
  plan: {
235
303
  lensEnum: ["completeness", "decomposition", "buildability"],
236
- axesGuide: "Follow URC: single-cycle, lens-tagged findings (completeness/decomposition/buildability) + spec conformance — the plan is judged against its design spec at `INPUT_SPEC` (the plan's `spec` front-matter target): every spec requirement must map to a task, and a spec requirement with no owning task is a completeness finding + the writing-plans self-check + verification evidence — the reviewer runs the repository's typecheck and test commands and self-reports the dual evidence + Claimed→pin: every behavior claim (usage-line attribution · semantic contract · byte face) must cite a colocated pin (path:line + the assertion face) — the review checks every claim against its pin, claim by claim; a pinless claim is a lens-tagged finding + The reviewed spec is a vision, not an exhaustive enumeration — behavior it is silent on is judged by what a reasonable implementer would expect; its silence is not permission, and a finding's severity grades that expectation, not whether the text mentions the trigger. Before your verdict, list every behavior you considered and set aside as outside the reviewed scope — one line each with the reason; nothing set aside is dropped silently; an empty list means you set nothing aside. Calibrate findings by real severity — not everything is a blocker — and acknowledge what was done well before listing findings (accurate praise earns the rest of the report trust).",
304
+ axesGuide: `Follow URC: single-cycle, lens-tagged findings (completeness/decomposition/buildability) + spec conformance — the plan is judged against its design spec at \`INPUT_SPEC\` (the plan's \`spec\` front-matter target): every spec requirement must map to a task, and a spec requirement with no owning task is a completeness finding + the writing-plans self-check + verification evidence — the reviewer runs the repository's typecheck and test commands and self-reports the dual evidence + Claimed→pin: every behavior claim (usage-line attribution · semantic contract · byte face) must cite a colocated pin (path:line + the assertion face) — the review checks every claim against its pin, claim by claim; a pinless claim is a lens-tagged finding. ${reviewGuideOf("plan")}`,
237
305
  },
238
306
  };
239
- /** The per-type facts the review variants compose at module-const time (the lens
240
- * vocabularies + the criteria bodies — single data references, never restates). */
241
- const REVIEWS_WAVE_LENS = REVIEWS.wave.lensEnum.join(" | ");
242
- const REVIEWS_BRANCH_LENS = REVIEWS.branch.lensEnum.join(" | ");
243
- const REVIEWS_SPEC_LENS = REVIEWS.spec.lensEnum.join(" | ");
244
- const REVIEWS_PLAN_LENS = REVIEWS.plan.lensEnum.join(" | ");
245
- const REVIEW_WAVE_AXES = REVIEWS.wave.axesGuide;
246
- const REVIEW_BRANCH_AXES = REVIEWS.branch.axesGuide;
247
- const REVIEW_SPEC_URC = REVIEWS.spec.axesGuide;
248
- const REVIEW_PLAN_URC = REVIEWS.plan.axesGuide;
249
- /** The review mode's four per-type rows (§3.7) — each variant's fixed prefix folds
250
- * its criteria + lens INLINE (the `INPUT_CRITERIA`/`INPUT_LENS` round-context
251
- * tokens are gone), and shares the REVIEW_CONTEXT dynamic tail. */
252
- const REVIEW_VARIANTS = {
253
- wave: {
254
- mode: "review",
255
- shell: [
256
- "# CDD dispatch — review round",
257
- "",
258
- "## Instructions",
259
- "",
260
- ...FRAME_ITEMS,
261
- REVIEW_ITEM,
262
- `**Lens labels:** one of \`${REVIEWS_WAVE_LENS}\` — every finding MUST carry its \`lens\`.`,
263
- `**Criteria — wave:** ${REVIEW_WAVE_AXES}`,
264
- ...LICENSE_ITEMS,
265
- ...SCHEMA_SECTION,
266
- ],
267
- roundContext: REVIEW_CONTEXT,
268
- },
269
- branch: {
307
+ /** The criteria-body selection — the ONE target → criteria map. Four targets select
308
+ * the body of their own name; the two spec-shaped document targets share the ONE
309
+ * narrative body (`spec`). Keeping the mapping here (never in the row literals)
310
+ * means a target cannot silently drift onto another target's criteria. */
311
+ export const reviewBodyOf = (type) => type === "phase-spec" || type === "single-spec" ? "spec" : type;
312
+ /** One review variant row (§3.7) — the fixed prefix folds the SELECTED criteria
313
+ * body + its lens INLINE (the `INPUT_CRITERIA`/`INPUT_LENS` round-context tokens
314
+ * are gone) and shares the REVIEW_CONTEXT dynamic tail. The target word labels the
315
+ * criteria line, so the row speaks the same vocabulary the CLI's `--type`
316
+ * declares while the body comes from the criteria selection. */
317
+ const reviewRow = (type) => {
318
+ const criteria = REVIEWS[reviewBodyOf(type)];
319
+ return {
270
320
  mode: "review",
271
321
  shell: [
272
322
  "# CDD dispatch — review round",
@@ -275,45 +325,22 @@ const REVIEW_VARIANTS = {
275
325
  "",
276
326
  ...FRAME_ITEMS,
277
327
  REVIEW_ITEM,
278
- `**Lens labels:** one of \`${REVIEWS_BRANCH_LENS}\` — every finding MUST carry its \`lens\`.`,
279
- `**Criteria — branch:** ${REVIEW_BRANCH_AXES}`,
328
+ `**Lens labels:** one of \`${criteria.lensEnum.join(" | ")}\` — every finding MUST carry its \`lens\`.`,
329
+ `**Criteria — ${type}:** ${criteria.axesGuide}`,
280
330
  ...LICENSE_ITEMS,
281
331
  ...SCHEMA_SECTION,
282
332
  ],
283
333
  roundContext: REVIEW_CONTEXT,
284
- },
285
- spec: {
286
- mode: "review",
287
- shell: [
288
- "# CDD dispatch — review round",
289
- "",
290
- "## Instructions",
291
- "",
292
- ...FRAME_ITEMS,
293
- REVIEW_ITEM,
294
- `**Lens labels:** one of \`${REVIEWS_SPEC_LENS}\` — every finding MUST carry its \`lens\`.`,
295
- `**Criteria — spec:** ${REVIEW_SPEC_URC}`,
296
- ...LICENSE_ITEMS,
297
- ...SCHEMA_SECTION,
298
- ],
299
- roundContext: REVIEW_CONTEXT,
300
- },
301
- plan: {
302
- mode: "review",
303
- shell: [
304
- "# CDD dispatch — review round",
305
- "",
306
- "## Instructions",
307
- "",
308
- ...FRAME_ITEMS,
309
- REVIEW_ITEM,
310
- `**Lens labels:** one of \`${REVIEWS_PLAN_LENS}\` — every finding MUST carry its \`lens\`.`,
311
- `**Criteria — plan:** ${REVIEW_PLAN_URC}`,
312
- ...LICENSE_ITEMS,
313
- ...SCHEMA_SECTION,
314
- ],
315
- roundContext: REVIEW_CONTEXT,
316
- },
334
+ };
335
+ };
336
+ /** The review mode's six per-target rows — one per `TargetType` (§3.7). */
337
+ const REVIEW_VARIANTS = {
338
+ wave: reviewRow("wave"),
339
+ branch: reviewRow("branch"),
340
+ "phase-spec": reviewRow("phase-spec"),
341
+ overall: reviewRow("overall"),
342
+ plan: reviewRow("plan"),
343
+ "single-spec": reviewRow("single-spec"),
317
344
  };
318
345
  /** The `## Return` zone — the single plain-prose contract block (P11: the child
319
346
  * narrates the round in prose; nothing downstream parses its stdout — the handoff
@@ -364,9 +391,26 @@ export const CLAUSES = {
364
391
  "cl:plan-freeze": "Approved plan/spec files are frozen — zero modification authority; any change needed is reported to the orchestrator through findings, never edited in place.",
365
392
  "cl:atomic-commit": "Commit each round's change as one atomic conventional commit scoped to the round — no mixed or out-of-scope content, no AI-generation trailers.",
366
393
  "cl:self-validate": "Self-validate before returning: run the validation/checks your change requires and record the evidence (command + exit code + result) in the report.",
394
+ "cl:no-secret-access": "Never read, print, or derive a user secret — no keychain access (`security find-generic-password` / `security dump-keychain` / `login.keychain-db`), no `~/.ssh/*`, `~/.aws/credentials`, `~/.netrc`, no host CLI credential store, and no token-bearing environment variable (`*_TOKEN` / `*_API_KEY` / `*_SECRET`). A missing or failing credential is never yours to obtain: report it as `status: BLOCKED` on a work round or as a finding on a review round, then continue with the rest. A secret that reaches a report, evidence file, handoff draft, commit, or issue body has leaked — if one is already visible in your inputs, redact it as `[REDACTED]` and never echo its value.",
367
395
  "cl:sync-completion": "This dispatch is one-shot and non-interactive: end your turn with anything still running and the process exits — the work and the handoff die with it. So do not end your turn — a background command, a background subagent, or any yield-and-wait path such as `bg_run` / `bg_delegate` — before the handoff draft is written. Finish nested work in this same turn: complete it synchronously in this process turn, then write the handoff and finish.",
368
396
  };
369
- /** The dispatch-prompt data plane — the typed template-contract surface. $version 16
397
+ /** The dispatch-prompt data plane — the typed template-contract surface. $version 20
398
+ * gives the charter its own review criteria body (the six charter criteria, with
399
+ * none of the implementation-face evidence duty) and makes the criteria-body
400
+ * selection explicit — the two spec-shaped document targets share the ONE narrative
401
+ * body under the `spec` key, so the `overall` row's fixed prefix changed. $version 19
402
+ * extends the work plane's ONE capability declaration (`capability: may.amend =
403
+ * content`) to the docs-fix row as well: the fix face's spec / plan dispatch IS
404
+ * docs-fix, so the authorization (and the structure-face ban that rides with it)
405
+ * must reach the one row that edits those documents. $version 18
406
+ * adds the work plane's ONE capability declaration (`capability: may.amend =
407
+ * content` — an implement / fix round may amend the spec's and plan's content face,
408
+ * never the structure face the engine snapshots and judges at the close; the review
409
+ * variants declare nothing). $version 17
410
+ * adds the no-secret-access discipline clause (issue #390 — a dispatched child holds
411
+ * the harness's full authority, so the fixed prefix bar it from user credentials:
412
+ * keychain / credential files / token env vars; a missing credential is reported as
413
+ * BLOCKED or a finding, never self-acquired). $version 16
370
414
  * unifies the handoff carrier on one op-derived plane (work / judge — implement /
371
415
  * fix author a status-bearing work carrier, review a findings-only judge carrier)
372
416
  * and gives the docs-fix round a `status` to report its outcome in. $version 15
@@ -392,7 +436,7 @@ export const CLAUSES = {
392
436
  * prose return contract (`RETURN_PROSE` — nothing downstream parses the child's
393
437
  * stdout), and the per-type review criterion shells. */
394
438
  export const TEMPLATE_PROMPT = {
395
- $version: 16,
439
+ $version: 20,
396
440
  modes: MODE_PROMPTS,
397
441
  reviews: REVIEW_VARIANTS,
398
442
  return: RETURN_ZONE,
@@ -1,30 +1,28 @@
1
1
  // packages/cdd-engine/src-next/session/faces.ts
2
2
  // T8 — the target-type faces data table (design spec §3.3: the parameterized single
3
- // lifecycle). The three old near-isomorphic lifecycles (task / branch / docs)
4
- // converge into ONE lifecycle class whose per-type variance lives in this table:
5
- // each target type (task | branch | spec | plan) carries its audit target, the
6
- // product face (the review-lead round mode) and the next-hop consumption semantics.
7
- // The lifecycle reads the row through the same class — a new target type is a table
8
- // row, never a lifecycle edit.
3
+ // lifecycle). The old near-isomorphic lifecycles (task / branch / docs) converge into
4
+ // ONE lifecycle class whose per-type variance lives in this table: each target type
5
+ // carries its audit target, the product face (the review-lead round mode) and the
6
+ // next-hop consumption semantics. The lifecycle reads the row through the same class —
7
+ // a new target type is a table row, never a lifecycle edit.
9
8
  //
10
- // Module-level exports are types / the table const — zero behavior-carrying bare
11
- // functions (the plan's zero-bare-function discipline).
12
- /** The four target-type faces — one row per CLI `--type` value (the single table). */
9
+ // P22 D73 — ONE target vocabulary end to end: the type words below ARE the CLI
10
+ // `--type` value domain and the pipeline row keys. The document shapes carry their
11
+ // declared `doc-type:` spelling (`phase-spec` / `overall` / `plan` / `single-spec`),
12
+ // so the retired `spec ⇄ phase-spec` translation class has no home here.
13
+ //
14
+ // Module-level exports are types / the table const / its read face class — zero
15
+ // behavior-carrying bare functions (the plan's zero-bare-function discipline).
16
+ /** The six target-type faces — one row per CLI `--type` value (the single table). */
13
17
  export const targetFaces = {
14
- wave: {
15
- type: "wave",
16
- audit: { kind: "task-graph" },
18
+ "phase-spec": {
19
+ type: "phase-spec",
20
+ audit: { kind: "doc-path" },
17
21
  product: { reviewLead: "review" },
18
- nextSemantics: { batch: true },
19
- },
20
- branch: {
21
- type: "branch",
22
- audit: { kind: "branch-tree" },
23
- product: { reviewLead: "branch-review" },
24
22
  nextSemantics: { batch: false },
25
23
  },
26
- spec: {
27
- type: "spec",
24
+ overall: {
25
+ type: "overall",
28
26
  audit: { kind: "doc-path" },
29
27
  product: { reviewLead: "review" },
30
28
  nextSemantics: { batch: false },
@@ -35,4 +33,33 @@ export const targetFaces = {
35
33
  product: { reviewLead: "review" },
36
34
  nextSemantics: { batch: false },
37
35
  },
36
+ "single-spec": {
37
+ type: "single-spec",
38
+ audit: { kind: "doc-path" },
39
+ product: { reviewLead: "review" },
40
+ nextSemantics: { batch: false },
41
+ },
42
+ wave: {
43
+ type: "wave",
44
+ audit: { kind: "task-graph" },
45
+ product: { reviewLead: "review" },
46
+ nextSemantics: { batch: true },
47
+ },
48
+ branch: {
49
+ type: "branch",
50
+ audit: { kind: "branch-tree" },
51
+ product: { reviewLead: "branch-review" },
52
+ nextSemantics: { batch: false },
53
+ },
38
54
  };
55
+ /** The faces table's read face — the ONE "is a document shape" predicate the lifecycle
56
+ * and pre-flight call sites share: a document shape is a row whose audit target
57
+ * resolves a doc PATH (the node shapes resolve a task graph / the live tree). A new
58
+ * target type lands as a table row and this predicate follows it — no call site
59
+ * re-spells the type set. */
60
+ // biome-ignore lint/complexity/noStaticOnlyClass: the doc-shape read face — the zero-bare-function discipline admits no standalone predicate functions.
61
+ export class TargetFaceTable {
62
+ static isDocShape(type) {
63
+ return targetFaces[type].audit.kind === "doc-path";
64
+ }
65
+ }
@@ -18,8 +18,7 @@
18
18
  // Module-level exports are types / the class — zero behavior-carrying bare
19
19
  // functions (the plan's zero-bare-function discipline).
20
20
  var _a;
21
- import { declaredRegistries } from "../contract/declare.js";
22
- import { Projector } from "../contract/project.js";
21
+ import { PlanTaskBlocksReader } from "../contract/task-blocks.js";
23
22
  /**
24
23
  * The task graph — nodes are the plan's task ids, one declared edge per block.
25
24
  * The task-base consumption, the six-class validate, the batch waves and the
@@ -38,13 +37,11 @@ export class TaskGraph {
38
37
  #reduced;
39
38
  /** The run's completed task ids — the ExecutionState carrier (markDone). */
40
39
  #done = new Set();
41
- /** The derived `DependsOn id` value pattern (whole-token — the declared-edge
42
- * values; the SAME derived pattern the reference lint reads, so both edge
43
- * consumers share one task-id token domain, never a re-typed literal). */
44
- #depIdToken;
40
+ /** The ONE task-block parse face the edge values are read through (P21 §7) — the
41
+ * SAME reader the registry's `taskBlocks` delegate uses, never a second grammar. */
42
+ #reader = new PlanTaskBlocksReader();
45
43
  /** Build from a shared plan parse — the same instance the dispatch and the lint read. */
46
44
  constructor(parsed) {
47
- this.#depIdToken = new RegExp(_a.#valuePatternOf(new Projector(declaredRegistries).reference().plan.entries, "DependsOn id"));
48
45
  this.#nodes = parsed.taskBlocks.map((block) => block.id).sort((a, b) => a - b);
49
46
  const edges = new Map();
50
47
  for (const block of parsed.taskBlocks) {
@@ -256,38 +253,17 @@ export class TaskGraph {
256
253
  #depsOf(task) {
257
254
  return this.#reduced.get(task) ?? [];
258
255
  }
259
- /** One block's declared edge record — the `**DependsOn**` field's numeric list,
260
- * taken from the field's VALUE PREFIX only (the first `(`/`(` truncates: the
261
- * trailing parenthetical rationale is prose — zero participation, §3.8's value
262
- * domain contract; a round number in the rationale can never become a phantom
263
- * dependency). The extraction layer DEDUPES (a repeated declaration is
264
- * normalized away — the author's literal is never adjudicated, §3.8 the
265
- * normalization chain). `none`/empty carries zero edges; the field's absence is
266
- * recorded separately for the missing-edge class. */
256
+ /** One block's declared edge record — the `DependsOn` value read through the ONE
257
+ * block reader (`PlanTaskBlocksReader#dependsOn`: the value prefix only, the
258
+ * declared id-token domain, dedupe + sort). The reader normalizes both block
259
+ * shapes, so a legacy plan and a heading plan derive the same edges. `none` /
260
+ * empty carries zero edges; the section's absence is recorded separately for the
261
+ * missing-edge class. */
267
262
  #edgeOf(block) {
268
- const field = block.fields.find((entry) => entry.key === "DependsOn");
269
- if (field === undefined)
263
+ const declared = block.fields.some((entry) => entry.key === "DependsOn");
264
+ if (!declared)
270
265
  return { declared: false, deps: [] };
271
- const deps = [];
272
- for (const line of field.lines) {
273
- const prefix = line.split(/[((]/)[0];
274
- for (const token of prefix.split(/[,\s]+/)) {
275
- const candidate = token.trim();
276
- if (this.#depIdToken.test(candidate))
277
- deps.push(Number(candidate));
278
- }
279
- }
280
- return { declared: true, deps: [...new Set(deps)].sort((a, b) => a - b) };
281
- }
282
- /** The value pattern of a registered reference entry — a lookup that fails
283
- * loudly when the declaration renames an anchor the graph consumes (the same
284
- * loud-lookup contract the reference lint's edge scan keeps). */
285
- static #valuePatternOf(entries, anchor) {
286
- const entry = entries.find((row) => row.anchor === anchor);
287
- if (entry === undefined) {
288
- throw new Error(`task graph requires the registered reference entry "${anchor}"`);
289
- }
290
- return entry.valuePattern ?? "";
266
+ return { declared: true, deps: [...this.#reader.dependsOn(block)] };
291
267
  }
292
268
  /** One constructed issue (the single message/fix assembly point of the graph). */
293
269
  #issue(kind, task, message, fix) {