@oscaner-skills/cdd-engine 4.1.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.
- package/README.md +39 -9
- package/README.zh-CN.md +44 -9
- package/dist/contract/completion-criterion.js +351 -0
- package/dist/contract/declare.js +181 -43
- package/dist/contract/doc.js +84 -271
- package/dist/contract/frontmatter.js +2 -1
- package/dist/contract/home-extractors.js +49 -316
- package/dist/contract/invariants.js +400 -296
- package/dist/contract/judge.js +74 -49
- package/dist/contract/lint.js +3 -2
- package/dist/contract/liveness-signal.js +103 -0
- package/dist/contract/markdown-document.js +410 -0
- package/dist/contract/markdown-tree-types.js +6 -0
- package/dist/contract/markdown-tree.js +137 -0
- package/dist/contract/project.js +1 -1
- package/dist/contract/rules.js +106 -0
- package/dist/contract/selector-engine.js +332 -0
- package/dist/contract/selector-spec.js +74 -0
- package/dist/contract/skill-anatomy.js +29 -1
- package/dist/contract/task-block-grammar.js +285 -0
- package/dist/contract/task-blocks.js +65 -0
- package/dist/contract/translate.js +21 -0
- package/dist/contract/wave-width.js +15 -0
- package/dist/face/board-view.js +401 -131
- package/dist/face/capsule.js +66 -89
- package/dist/face/cli.js +174 -48
- package/dist/face/declare.js +59 -23
- package/dist/face/gate.js +117 -40
- package/dist/face/host.js +9 -35
- package/dist/face/init.js +108 -0
- package/dist/face/lifecycle.js +540 -123
- package/dist/face/plugins.js +73 -0
- package/dist/face/preview.js +43 -10
- package/dist/face/projection.js +3 -3
- package/dist/face/route-render.js +51 -21
- package/dist/face/termination.js +135 -261
- package/dist/face/words.js +134 -12
- package/dist/infra/atomic.js +15 -0
- package/dist/infra/git.js +25 -0
- package/dist/infra/proc.js +150 -0
- package/dist/infra/round-log.js +104 -0
- package/dist/infra/runtime.js +16 -4
- package/dist/infra/workspace.js +7 -2
- package/dist/render/brief.js +15 -17
- package/dist/render/skeleton.js +41 -28
- package/dist/render/templates.js +128 -84
- package/dist/session/faces.js +47 -20
- package/dist/session/graph.js +13 -37
- package/dist/session/handoff-schema.js +16 -8
- package/dist/session/inflight.js +282 -0
- package/dist/session/ledger.js +581 -136
- package/dist/session/line-identity.js +33 -0
- package/dist/session/next.js +138 -80
- package/dist/session/preflight.js +276 -68
- package/dist/session/round-naming.js +56 -8
- package/dist/session/run.js +317 -78
- package/dist/session/wave.js +94 -14
- package/package.json +13 -3
- package/dist/infra/process.js +0 -22
package/dist/render/skeleton.js
CHANGED
|
@@ -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`
|
|
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
|
|
52
|
-
*
|
|
53
|
-
* status
|
|
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
|
|
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
|
|
281
|
-
*
|
|
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
|
|
389
|
-
*
|
|
390
|
-
*
|
|
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("
|
|
395
|
-
probe.add("
|
|
393
|
+
probe.add("#### Objective");
|
|
394
|
+
probe.add("#### Files");
|
|
396
395
|
probe.add("File path token");
|
|
397
|
-
probe.add("
|
|
398
|
-
probe.add("
|
|
399
|
-
probe.add("
|
|
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("
|
|
403
|
-
probe.add("
|
|
401
|
+
probe.add("#### Acceptance");
|
|
402
|
+
probe.add("#### DependsOn");
|
|
404
403
|
return [
|
|
405
404
|
"### Task 1: :::fill task-title",
|
|
406
|
-
"
|
|
407
|
-
"
|
|
408
|
-
"
|
|
409
|
-
"
|
|
410
|
-
"
|
|
411
|
-
"
|
|
412
|
-
"
|
|
413
|
-
"
|
|
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
|
}
|
package/dist/render/templates.js
CHANGED
|
@@ -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
|
|
7
|
-
//
|
|
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
|
|
12
|
-
//
|
|
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
|
|
23
|
-
// the criteria + lens text are FIXED PREFIX content (folded into each
|
|
24
|
-
// shell —
|
|
25
|
-
// INPUT_CRITERIA / INPUT_LENS round-context tokens are gone) and each
|
|
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
|
|
219
|
-
*
|
|
220
|
-
*
|
|
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:
|
|
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:
|
|
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:
|
|
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:
|
|
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
|
|
240
|
-
*
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
const
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
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 \`${
|
|
279
|
-
`**Criteria —
|
|
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
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
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
|
|
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:
|
|
439
|
+
$version: 20,
|
|
396
440
|
modes: MODE_PROMPTS,
|
|
397
441
|
reviews: REVIEW_VARIANTS,
|
|
398
442
|
return: RETURN_ZONE,
|
package/dist/session/faces.js
CHANGED
|
@@ -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
|
|
4
|
-
//
|
|
5
|
-
//
|
|
6
|
-
//
|
|
7
|
-
//
|
|
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
|
-
//
|
|
11
|
-
//
|
|
12
|
-
|
|
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
|
-
|
|
15
|
-
type: "
|
|
16
|
-
audit: { kind: "
|
|
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
|
-
|
|
27
|
-
type: "
|
|
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
|
+
}
|
package/dist/session/graph.js
CHANGED
|
@@ -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 {
|
|
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
|
|
42
|
-
*
|
|
43
|
-
|
|
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
|
|
260
|
-
*
|
|
261
|
-
*
|
|
262
|
-
*
|
|
263
|
-
*
|
|
264
|
-
*
|
|
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
|
|
269
|
-
if (
|
|
263
|
+
const declared = block.fields.some((entry) => entry.key === "DependsOn");
|
|
264
|
+
if (!declared)
|
|
270
265
|
return { declared: false, deps: [] };
|
|
271
|
-
|
|
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) {
|