design-playbook 0.20.0 → 0.20.2

package/examples/dogfood/run/shaping/shaping-log.jsonl

@@ -2,7 +2,7 @@
 {"event": "answered", "question_id": "Q1", "answer": "运行状态跨页可查、全局控制可用、失败可批量治理", "ts": "2026-08-14T09:02:00Z"}
 {"event": "asked", "question_id": "Q9", "batch": 2, "tier": "T3", "text": "顶栏计数区升级为全局运行控制台——视觉方向（构成级）？", "impact": "D3 decision-report（成形只登记路由，D3 裁决）", "ts": "2026-08-14T09:03:00Z"}
 {"event": "assumption_staged", "field": "sim.control_scope", "tier": "T2", "reason": "全局暂停的作用范围未答", "risk": "误伤手动单次重试", "fallback": "全局暂停/恢复不作用于手动单次重试", "ts": "2026-08-14T09:04:00Z"}
-{"event": "confirm_presented", "batch": "CP-A", "kind": "intent", "items": ["l1.goal 修订（supersedes D-0001）", "l6.c4-c6 表述"], "ts": "2026-08-14T09:08:00Z"}
+{"event": "confirm_presented", "batch": "CP-A", "kind": "intent", "items": [{"field": "l1.goal", "value": "修订（supersedes D-0001）"}, "l6.c4", "l6.c5", "l6.c6"], "ts": "2026-08-14T09:08:00Z"}
 {"event": "confirm_presented", "batch": "CP-C", "kind": "assumption", "items": ["sim.control_scope"], "ts": "2026-08-14T09:08:00Z"}
 {"event": "item_confirmed", "batch": "CP-A", "field": "l1.goal", "ts": "2026-08-14T09:12:00Z"}
 {"event": "item_confirmed", "batch": "CP-A", "field": "l6.c4", "ts": "2026-08-14T09:12:00Z"}

package/examples/export-entry/run/evidence/L6.1-usertest-notes.md

@@ -1,15 +1,10 @@
-# User-test session notes — L6.1 supplementary (quarantined)
+# Synthetic user-test example — not evidence
 
-Round 1 usability session, 2026-08-14. Facilitated weekly-report export
-task with 3 operations participants (convenience sample).
+Schema/example material only. No real human-subject session occurred, no
+participant observations or personal data are represented, and this file is
+not registered in `manifest.jsonl`.
 
-Observed behavior: 2 of 3 participants first looked for the export entry
-in the global toolbar, then used the inline batch export after a hint.
-
-Status: **unusable as evidence** — the session ran before the consent /
-anonymisation / retention record was completed, so the manifest entry
-carries `method: user-test` with `population` but no `ethics` key. Per the
-method-semantics gate this entry is quarantined as blocked evidence: it
-cannot support any judgment (the L6.1 pass rests on
-`L6.1-export-trace.json`, not on these notes). Complete the ethics record
-in a newer manifest entry to make the session citable.
+The scenario illustrates what a user-test note might look like during method
+semantics testing. It must not support a run judgment or any claim about user
+behavior. Tests that exercise missing `ethics` construct their own temporary
+manifest entry rather than treating this file as evidence.

package/examples/export-entry/run/evidence/manifest.jsonl

@@ -5,4 +5,3 @@
 {"criterion": "L6.2", "capture": {"type": "a11y tree", "provider": "manual", "state": "cap-blocked-r2", "actions": ["select over-cap range", "open export dialog (post R4 fix)"], "schemaVersion": 1, "request": {"schemaVersion": 1, "viewport": {"width": 1280, "height": 800, "devicePixelRatio": 1.0, "colorScheme": "light"}, "freeze": {"enabled": true, "waitFonts": true, "networkIdle": false}}}, "artifact": "L6.2-a11y-tree-r2.json", "observed_state": "cap-blocked-r2", "result": "captured", "ts": "2026-08-14T11:04:30Z", "request": {"schemaVersion": 1, "viewport": {"width": 1280, "height": 800, "devicePixelRatio": 1.0, "colorScheme": "light"}, "freeze": {"enabled": true, "waitFonts": true, "networkIdle": false}}, "method": "runtime-observation", "observation": "toast 节点带 role=alert 与可读名称（含超限数值 200,000）", "interpretation": "R4 修复后的 a11y 附接证据，印证 L6.2 pass（ADR-0016 附接到既有 user-risk 判据）", "scope": "单次运行, viewport 1280x800, 数据集 week-2026-32", "population": null, "ethics": null}
 {"criterion": "L6.2", "capture": {"type": "screenshot", "provider": "manual", "state": "cap-blocked-r2", "actions": ["select over-cap range", "open export dialog (post R4 fix)"], "schemaVersion": 1, "request": {"schemaVersion": 1, "viewport": {"width": 1280, "height": 800, "devicePixelRatio": 1.0, "colorScheme": "light"}, "freeze": {"enabled": true, "waitFonts": true, "networkIdle": false}}}, "artifact": "L6.2-cap-error-r2.png", "observed_state": "cap-blocked-r2", "result": "captured", "ts": "2026-08-14T11:05:00Z", "request": {"schemaVersion": 1, "viewport": {"width": 1280, "height": 800, "devicePixelRatio": 1.0, "colorScheme": "light"}, "freeze": {"enabled": true, "waitFonts": true, "networkIdle": false}}, "method": "runtime-observation", "observation": "提示含「超出 200,000 行上限」与「按周导出」收窄建议（重评 r2）", "interpretation": "满足 c2 的 Then 子句（剩余量与收窄建议）；依赖 assumed 字段 export.row_cap 成立", "scope": "单次运行, viewport 1280x800, 数据集 week-2026-32", "population": null, "ethics": null}
 {"criterion": "L6.3", "capture": {"type": "interaction trace", "provider": "manual", "state": "return-visible", "actions": ["start export", "navigate away", "navigate back", "read progress and result"], "schemaVersion": 1, "request": {"schemaVersion": 1, "viewport": {"width": 1280, "height": 800, "devicePixelRatio": 1.0, "colorScheme": "light"}, "freeze": {"enabled": true, "waitFonts": true, "networkIdle": false}}}, "artifact": "L6.3-return-trace.json", "observed_state": "return-visible", "result": "captured", "ts": "2026-08-14T11:10:00Z", "request": {"schemaVersion": 1, "viewport": {"width": 1280, "height": 800, "devicePixelRatio": 1.0, "colorScheme": "light"}, "freeze": {"enabled": true, "waitFonts": true, "networkIdle": false}}, "method": "runtime-observation", "observation": "导出中离开 main-list 后返回，exporting 进度态可见，完成后结果可获知（R5 修订 capture plan 后重采）", "interpretation": "满足 c3 的 Then 子句（进度与结果仍可获知）；首轮跨导航 session 丢失记 blocked 已按 invalidated 块登记", "scope": "单次运行, viewport 1280x800, 数据集 week-2026-32", "population": null, "ethics": null}
-{"criterion": "L6.1", "capture": {"type": "session notes", "provider": "manual", "state": "usertest-round1", "actions": ["facilitate weekly-report export task", "record participant behavior"], "schemaVersion": 1, "request": {"schemaVersion": 1, "viewport": {"width": 1280, "height": 800, "devicePixelRatio": 1.0, "colorScheme": "light"}, "freeze": {"enabled": true, "waitFonts": true, "networkIdle": false}}}, "artifact": "L6.1-usertest-notes.md", "observed_state": "usertest-round1", "result": "captured", "ts": "2026-08-14T10:50:00Z", "request": {"schemaVersion": 1, "viewport": {"width": 1280, "height": 800, "devicePixelRatio": 1.0, "colorScheme": "light"}, "freeze": {"enabled": true, "waitFonts": true, "networkIdle": false}}, "method": "user-test", "observation": "3 名运营参与者完成周报导出任务；其中 2 人先在全局工具栏寻找导出入口，经提示后使用行内入口", "interpretation": null, "scope": "单次会话, 3 名运营参与者, 便利抽样", "population": "3 名运营角色参与者（周报任务，便利抽样）", "ethics": null}

package/examples/export-entry/run/point-back.md

@@ -67,7 +67,7 @@ face:     subjective
 basis:    agent-judgment
 confidence: low
 disposition: advisory
-evidence:  rendered 走查（agent-judgment, method=expert-review）；非用户证据——涉人记录见 evidence/L6.1-usertest-notes.md（ethics 缺失，已隔离不可采信）
+evidence:  rendered 走查（agent-judgment, method=expert-review）；非用户证据——evidence/L6.1-usertest-notes.md 仅为合成 schema 示例，未登记到 Manifest，不能支持判断
 ```
 
 ## Positive findings
@@ -107,7 +107,7 @@ evidence:  evidence/L6.1-export-trace.json（跨层：交互轨迹 + 度量计
 ## Limitations statement
 
 - 判断类 advisory：术语适配（task-organization 主观面，agent-judgment 非用户证据，confidence=low，advisory 不阻 verdict）
-- 用户代表性：本 run 无可用 user-test 证据（L6.1-usertest-notes.md 因 ethics 缺失被隔离为 blocked 证据），全部结论不构成任何「用户会」断言
+- 用户代表性：本 run 无真实 user-test evidence；合成 notes 未登记到 Manifest，全部结论不构成任何「用户会」断言
 - pass 范围：L6.1/L6.2/L6.3 pass 限单 viewport 1280x800 / 单数据集 week-2026-32 / 单次运行
 - assumed 依赖：L6.2 pass 依赖 export.row_cap 假设成立
 - 机器面证明声明与事实一致，不证明体验良好

package/examples/export-entry/run/shaping/shaping-log.jsonl

@@ -8,8 +8,8 @@
 {"event": "assumption_staged", "field": "export.row_cap", "tier": "T1", "reason": "规模上限未答（队列满，转显式风险确认）", "risk": "上限过低阻断真实导出或过高拖垮同步窗口", "fallback": "50000 行", "ts": "2026-08-14T09:34:00Z"}
 {"event": "assumption_staged", "field": "export.sync_window", "tier": "T2", "reason": "同步导出限时未逐字确认", "risk": "超时体验未定义", "fallback": "60 秒", "ts": "2026-08-14T09:34:00Z"}
 {"event": "assumption_staged", "field": "export.column_scope", "tier": "T4", "reason": "文件命名与列范围为局部实现选择", "risk": "隐藏列误出", "fallback": "当前视图列（不含隐藏列）", "ts": "2026-08-14T09:34:00Z"}
-{"event": "confirm_presented", "batch": "CP-A", "kind": "intent", "items": ["l1.goal", "l1.target_user", "l6.c1-c3 表述", "l1.non_goals"], "ts": "2026-08-14T09:40:00Z"}
-{"event": "confirm_presented", "batch": "CP-B", "kind": "structural", "items": ["入口 IA 两案：A 全局工具栏 / B 主列表行内批量"], "ts": "2026-08-14T09:40:00Z"}
+{"event": "confirm_presented", "batch": "CP-A", "kind": "intent", "items": ["l1.goal", "l1.target_user", "l6.c1", "l6.c2", "l6.c3", "l1.non_goals"], "ts": "2026-08-14T09:40:00Z"}
+{"event": "confirm_presented", "batch": "CP-B", "kind": "structural", "items": [{"field": "l2.entry_choice", "value": "入口 IA 两案：A 全局工具栏 / B 主列表行内批量"}], "ts": "2026-08-14T09:40:00Z"}
 {"event": "confirm_presented", "batch": "CP-C", "kind": "assumption", "items": ["export.row_cap", "export.sync_window", "export.column_scope", "l1.scenes"], "ts": "2026-08-14T09:40:00Z"}
 {"event": "item_confirmed", "batch": "CP-A", "field": "l1.goal", "ts": "2026-08-14T09:52:00Z"}
 {"event": "item_confirmed", "batch": "CP-A", "field": "l1.target_user", "ts": "2026-08-14T09:52:00Z"}

package/examples/export-pointfix-upgrade/run/shaping/shaping-log.jsonl

@@ -1,6 +1,6 @@
 {"event": "asked", "question_id": "Q1", "batch": 1, "tier": "T1", "text": "「只导出选中列」的完成判据如何表述？", "impact": "l6.c4", "ts": "2026-08-14T12:41:00Z"}
 {"event": "answered", "question_id": "Q1", "answer": "Given 运营在主列表圈选 2 列 When 触发行内导出 Then CSV 仅含圈选列且顺序与列表一致（证据：交互记录）", "ts": "2026-08-14T12:42:00Z"}
-{"event": "confirm_presented", "batch": "CP-A", "kind": "intent", "items": ["l6.c4 表述"], "ts": "2026-08-14T12:43:00Z"}
+{"event": "confirm_presented", "batch": "CP-A", "kind": "intent", "items": ["l6.c4"], "ts": "2026-08-14T12:43:00Z"}
 {"event": "item_confirmed", "batch": "CP-A", "field": "l6.c4", "ts": "2026-08-14T12:44:00Z"}
 {"event": "projected", "ts": "2026-08-14T12:45:00Z", "order": ["promote_fields", "append_decision", "apply_decisions", "spec", "bind_first"], "decisions": ["D-0101"], "assumed": [], "mappings": [{"decision": "D-0101", "field": "l6.c4", "spec_section": "L6"}]}
 {"event": "archived", "ts": "2026-08-14T12:46:00Z"}

package/examples/export-upgrade/run/shaping/shaping-log.jsonl

@@ -2,7 +2,7 @@
 {"event": "answered", "question_id": "Q1", "answer": "任务全程可见、跨页保持、结果可获知", "ts": "2026-08-14T10:44:00Z"}
 {"event": "asked", "question_id": "Q9", "batch": 2, "tier": "T3", "text": "导出进行中的状态呈现——视觉方向（构成级）？", "impact": "D3 decision-report（成形只登记路由，D3 裁决）", "ts": "2026-08-14T10:46:00Z"}
 {"event": "assumption_staged", "field": "export.task_persist_ttl", "tier": "T2", "reason": "状态条目保留时长未答", "risk": "条目堆积或过早消失", "fallback": "run 内持久（≤10 条）", "ts": "2026-08-14T10:47:00Z"}
-{"event": "confirm_presented", "batch": "CP-A", "kind": "intent", "items": ["l1.goal 修订（supersedes D-0001）", "l6.c4-c6 表述"], "ts": "2026-08-14T10:50:00Z"}
+{"event": "confirm_presented", "batch": "CP-A", "kind": "intent", "items": [{"field": "l1.goal", "value": "修订（supersedes D-0001）"}, "l6.c4", "l6.c5", "l6.c6"], "ts": "2026-08-14T10:50:00Z"}
 {"event": "confirm_presented", "batch": "CP-C", "kind": "assumption", "items": ["export.task_persist_ttl"], "ts": "2026-08-14T10:50:00Z"}
 {"event": "item_confirmed", "batch": "CP-A", "field": "l1.goal", "ts": "2026-08-14T10:55:00Z"}
 {"event": "item_confirmed", "batch": "CP-A", "field": "l6.c4", "ts": "2026-08-14T10:55:00Z"}

package/mcp/evidence/capture_runtime.py

@@ -256,13 +256,12 @@ def _action_wait_for_state(page: Any, action: dict, index: int, do: str) -> None
     if not isinstance(state, str) or not state:
         raise ValueError(f"actions[{index}].state required for wait_for_state")
     selector = action.get("selector")
-    if isinstance(selector, str) and selector:
-        page.wait_for_selector(selector, timeout=10_000)
-    else:
-        page.wait_for_selector(
-            f'[data-state="{state}"]',
-            timeout=10_000,
-        )
+    target = (
+        f'{selector}[data-state="{state}"]'
+        if isinstance(selector, str) and selector
+        else f'[data-state="{state}"]'
+    )
+    page.wait_for_selector(target, timeout=10_000)
 
 
 def _action_wait(page: Any, action: dict, index: int, do: str) -> None:

package/mcp/evidence/test_server_stdio.py

@@ -121,9 +121,37 @@ def _structured(call_response: dict) -> dict:
     return json.loads(text)
 
 
+class _RecordingPage:
+    def __init__(self) -> None:
+        self.waits: list[tuple[str, int]] = []
+
+    def wait_for_selector(self, selector: str, *, timeout: int) -> None:
+        self.waits.append((selector, timeout))
+
+
 class EvidencePurePathTests(unittest.TestCase):
     """No-chromium transport and direct runtime-interface tests."""
 
+    def test_wait_for_state_combines_selector_and_state(self) -> None:
+        page = _RecordingPage()
+        capture_runtime._action_wait_for_state(
+            page,
+            {"do": "wait_for_state", "selector": "body", "state": "ready"},
+            0,
+            "wait_for_state",
+        )
+        self.assertEqual(page.waits, [('body[data-state="ready"]', 10_000)])
+
+    def test_wait_for_state_without_selector_targets_any_matching_state(self) -> None:
+        page = _RecordingPage()
+        capture_runtime._action_wait_for_state(
+            page,
+            {"do": "wait_for_state", "state": "ready"},
+            0,
+            "wait_for_state",
+        )
+        self.assertEqual(page.waits, [('[data-state="ready"]', 10_000)])
+
     def test_parse_capture_contract_requires_schema_and_viewport(self) -> None:
         from design_playbook.mcp.evidence import capture_contract
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "design-playbook",
-  "version": "0.20.0",
+  "version": "0.20.2",
   "description": "Design I/O for coding agents: controllable UI generation via declarations (spec/domain/craft/design/components/template) and contracts (skill/evaluator). Use for product UI—console, dashboard, agent-ops, CJK-first apps.",
   "keywords": [
     "pi-package",

package/scripts/dd_entries.py

@@ -43,7 +43,20 @@ stay protocol-side. Gate policy lives in ``g10_design_decisions.py``.
 
 Flow-map values inside ``- {k: v, ...}`` items may not contain ASCII commas
 or braces (use full-width punctuation in prose values); this is the declared
-shape, same contract style as the seven-column audit rows.
+shape, same contract style as the seven-column audit rows. Items may fold
+across lines (issue #44): a ``- {`` item that does not close its brace on
+the marker line continues on the following lines until the braces balance —
+single-line items parse exactly as before. Folds break at commas (the
+schema example's shape): a break that does not end the accumulated text
+with a comma (or the opening brace) would merge the next key into the
+previous value, so the join records a :class:`FoldIssue` and G10 reports it
+(:code:`G10.fold_break_not_comma`); a fold that never balances by the end
+of the block records :code:`G10.fold_unterminated` (fail-closed, with the
+remaining shape errors still firing).
+
+``dd:`` is the R3 challenge channel, never an observation link: values
+carried by positive (S0) findings are excluded from the challenge face and
+reported as structural errors by G10 (issue #44).
 """
 from __future__ import annotations
 
@@ -51,6 +64,8 @@ import re
 from dataclasses import dataclass, field
 from typing import Any
 
+from design_playbook.scripts.g2_g4_pointback import _findings
+
 # --- closed enums (design-prototype 4.1 machine face) -----------------------
 
 DD_TIERS = frozenset({"record", "compare", "explore"})
@@ -120,6 +135,7 @@ class DDEntry:
     supersedes: str = ""
     stale: str = ""
     stale_review: dict[str, str] = field(default_factory=dict)
+    fold_issues: tuple["FoldIssue", ...] = ()
     block: str = ""
 
     # -- convenience accessors ------------------------------------------
@@ -168,6 +184,23 @@ class DDEntry:
         return [item.get("id", "") for item in self.candidates]
 
 
+@dataclass(frozen=True)
+class FoldIssue:
+    """A fold defect found while joining folded flow-map items.
+
+    ``kind`` is ``"break_not_comma"`` (the accumulated fold text did not end
+    with a comma — or the opening brace — when a continuation was appended,
+    so the next key merges into the previous value) or ``"unterminated"``
+    (the braces never balanced before the block ended). ``line`` is the
+    1-based line of the fold-opening marker inside the entry block;
+    ``tail`` carries the offending text tail for the error face.
+    """
+
+    kind: str
+    line: int
+    tail: str = ""
+
+
 @dataclass(frozen=True)
 class ESignals:
     """Machine-judgeable E-criterion signals gathered from run artifacts."""
@@ -208,6 +241,55 @@ def _flow_map(item: str) -> dict[str, str]:
     return {"value": _scalar(item)}
 
 
+def _join_folded_flow_maps(
+        lines: list[str]) -> tuple[list[str], tuple[FoldIssue, ...]]:
+    """Join folded ``- {...}`` flow-map items onto their marker line.
+
+    Issue #44: an item that opens a ``{`` without closing it on the marker
+    line continues on the following lines (the fold the entry schema
+    example already shows) until its braces balance; continuation text is
+    appended to the marker line so the rest of the parser sees one logical
+    line. Values never contain ASCII commas or braces (declared shape), so
+    brace balance is an unambiguous fold terminator. Folds break at commas:
+    a continuation appended to accumulated text that does not end with a
+    comma (or the opening brace) would silently merge the next key into the
+    previous value, so the break is recorded as a :class:`FoldIssue`
+    (fail-closed; G10 reports it). An unterminated fold stays joined and
+    records its own issue plus the downstream shape checks (fail-closed).
+    Returns ``(joined lines, fold issues)``.
+    """
+    out: list[str] = []
+    issues: list[FoldIssue] = []
+    fold: str | None = None
+    fold_line = 0
+    for lineno, raw_line in enumerate(lines, 1):
+        stripped = raw_line.strip()
+        if fold is not None:
+            if not fold.rstrip().endswith((",", "{")):
+                issues.append(FoldIssue(
+                    kind="break_not_comma",
+                    line=fold_line,
+                    tail=fold.strip()[-60:],
+                ))
+            fold = fold.rstrip() + " " + stripped
+            if fold.count("{") <= fold.count("}"):
+                out.append(fold)
+                fold = None
+            continue
+        if (
+            stripped.startswith("- ")
+            and stripped.count("{") > stripped.count("}")
+        ):
+            fold = raw_line.rstrip()
+            fold_line = lineno
+            continue
+        out.append(raw_line)
+    if fold is not None:
+        issues.append(FoldIssue(kind="unterminated", line=fold_line))
+        out.append(fold)
+    return out, tuple(issues)
+
+
 def _entry_blocks(text: str) -> list[tuple[str, str]]:
     """Split the report into (id, body) blocks by DD entry heading."""
     matches = list(DD_HEADING.finditer(text))
@@ -231,7 +313,8 @@ def _parse_entry(entry_id: str, body: str) -> DDEntry:
     current_section: str | None = None
     current_list_key: str | None = None
 
-    for raw_line in block.splitlines():
+    joined, fold_issues = _join_folded_flow_maps(block.splitlines())
+    for raw_line in joined:
         stripped = raw_line.strip()
         if not stripped or stripped.startswith("```"):
             continue
@@ -307,6 +390,7 @@ def _parse_entry(entry_id: str, body: str) -> DDEntry:
         supersedes=fields.get("supersedes", ""),
         stale=fields.get("stale", ""),
         stale_review=_scalars("stale_review"),
+        fold_issues=fold_issues,
         block=block,
     )
 
@@ -319,20 +403,74 @@ def parse_dd_entries(text: str) -> list[DDEntry]:
     ]
 
 
+# ``none`` value token for the verbatim top block: a trailing same-line
+# note after the token is tolerated commentary, never a declared change
+# (issue #44). The token must end at whitespace or punctuation so values
+# like ``nonempty`` and ``none_x`` stay fail-closed non-none (underscore
+# joins the lookalike continuation class with ``-``, e.g. ``none-such``).
+NONE_VALUE = re.compile(r"none(?=$|[^0-9A-Za-z_-])", re.I)
+
+
 def top_block_baseline_change(text: str) -> bool:
-    """True when the verbatim top block declares ``baseline-changes != none``."""
+    """True when the verbatim top block declares ``baseline-changes != none``.
+
+    ``none`` may carry a trailing same-line note (anything after the value
+    token); notes never turn ``none`` into a declared change. Substantive
+    commentary belongs on its own line.
+    """
     match = re.search(r"^baseline-changes:[ \t]*(\S.*)$", text, re.M)
     if match is None:
         return False
-    return match.group(1).strip().casefold() != "none"
+    return NONE_VALUE.match(match.group(1).strip()) is None
+
+
+def is_positive_finding(parsed: dict[str, list[str]]) -> bool:
+    """True when a parsed point-back finding sits on the S0 (info) axis."""
+    values = parsed.get("severity") or [""]
+    return values[0].strip().casefold() == "s0"
+
+
+def positive_dd_refs(
+        text: str) -> tuple[tuple[int, tuple[str, ...]], ...]:
+    """``(finding index, dd refs)`` for every positive finding carrying ``dd:``.
+
+    Issue #44: ``dd:`` is the R3 challenge channel and never rides a
+    positive observation. These are structural errors G10 reports
+    (fail-closed) instead of silently reading them as challenges.
+    """
+    out: list[tuple[int, tuple[str, ...]]] = []
+    for index, parsed in enumerate(_findings(text), 1):
+        refs = tuple(
+            value.strip().rstrip(",") for value in parsed.get("dd", [])
+            if value.strip())
+        if refs and is_positive_finding(parsed):
+            out.append((index, refs))
+    return tuple(out)
+
+
+def _positive_dd_block(block: str) -> bool:
+    return any(
+        parsed.get("dd") and is_positive_finding(parsed)
+        for parsed in _findings(block)
+    )
 
 
 def dd_refs_in_pointback(text: str) -> tuple[str, ...]:
-    """Collect ``dd:`` targets from finding field lines / invalidated rows."""
+    """Collect ``dd:`` challenge targets from finding field lines.
+
+    Issue #44: ``dd:`` values carried by positive (S0) findings record
+    observation links, not challenges — their paragraphs are skipped so a
+    positive observation can never fire a false re-entry / E3 signal.
+    Paragraphs that are not findings (e.g. a bare ``dd:`` line) keep the
+    legacy raw face.
+    """
     targets: list[str] = []
-    for match in re.finditer(r"^dd:[ \t]*(\S+)", text, re.I | re.M):
-        ref = match.group(1).strip().rstrip(",")
-        targets.append(ref)
+    for block in re.split(r"\n\s*\n", text):
+        if _positive_dd_block(block):
+            continue
+        for match in re.finditer(r"^dd:[ \t]*(\S+)", block, re.I | re.M):
+            ref = match.group(1).strip().rstrip(",")
+            targets.append(ref)
     return tuple(targets)
 
 

package/scripts/escalation_signals.py

@@ -41,6 +41,7 @@ import re
 from dataclasses import dataclass
 
 from design_playbook.scripts._diagnostics import Finding, finding
+from design_playbook.scripts.dd_entries import is_positive_finding
 from design_playbook.scripts.g2_g4_pointback import _findings
 from design_playbook.scripts.repair_rounds import is_blocking
 
@@ -167,9 +168,16 @@ def check_routes(text: str) -> list[Finding]:
 
 
 def dd_targets(text: str) -> tuple[str, ...]:
-    """dd: references carried by findings (R3 challenge face)."""
+    """dd: references carried by findings (R3 challenge face).
+
+    Issue #44: positive (S0) findings carry observation links, not
+    challenges — their ``dd:`` values never fire E3 (G10 reports the
+    misuse as a structural error instead).
+    """
     targets: list[str] = []
     for parsed in _findings(text):
+        if is_positive_finding(parsed):
+            continue
         targets.extend(value.strip() for value in parsed.get("dd", [])
                        if value.strip())
     return tuple(targets)

package/scripts/g10_design_decisions.py

@@ -6,8 +6,9 @@ declared by the protocol — entry completeness, tier/status enums, tier
 recording obligations (R one-line rationale / C trade-off record / E user
 confirmation), supersedes existence + acyclicity, registry rule-reference
 cross-check, preview transaction linkage (decision_id), R3 re-entry
-resolution (dd: challenges must end invalidated with an E-tier revision),
-and the baseline-drift stale review (three exits: keep / revise / escalate).
+resolution (dd: challenges must end invalidated with an E-tier revision;
+``dd:`` on a positive finding is a shape error, issue #44), and the
+baseline-drift stale review (three exits: keep / revise / escalate).
 
 Comparison-matrix quality, trade-off sufficiency, and tier-grading
 judgement calls (composition change, identity drift beyond declared
@@ -35,6 +36,7 @@ from design_playbook.scripts.dd_entries import (
     is_cross_run_ref,
     local_dd_id,
     parse_dd_entries,
+    positive_dd_refs,
 )
 
 # rules.md ships inside the package (read-only protocol consumption, the
@@ -102,6 +104,11 @@ def _entry_checks(entries: list[DDEntry]) -> list[Finding]:
             ))
         seen[label] = index
 
+        # fold defects first (issue #44 follow-up): a named unterminated /
+        # comma-less fold error outranks the indirect missing_* findings it
+        # causes downstream, so the error face points at the real defect.
+        errs += _fold_checks(entry)
+
         for key in ("id", "tier", "question", "status"):
             if not entry.fields.get(key, "").strip():
                 errs.append(finding(
@@ -143,6 +150,45 @@ def _entry_checks(entries: list[DDEntry]) -> list[Finding]:
     return errs
 
 
+def _fold_checks(entry: DDEntry) -> list[Finding]:
+    """Fold defects on ``- {…}`` items (issue #44 follow-up, fail-closed).
+
+    A fold break without a comma merges the next key into the previous
+    value (the parse alone would accept it silently); a fold that never
+    balances swallows the rest of the block and only indirect missing_*
+    errors would fire. Both get a named error up front, with the block line
+    of the fold-opening marker; the remaining shape errors still fire.
+    """
+    errs: list[Finding] = []
+    for issue in entry.fold_issues:
+        if issue.kind == "unterminated":
+            errs.append(finding(
+                "G10.fold_unterminated",
+                f"G10 decisions: {entry.id} opens a folded flow-map item at "
+                f"block line {issue.line} that never closes its brace — the "
+                "fold swallowed the rest of the entry block",
+                owner=_fmt(entry.id),
+                expected="braces balance inside the entry block",
+                actual=f"unterminated fold from block line {issue.line}",
+                repair="Close the brace, or unfold to the canonical "
+                       "single-line item",
+            ))
+        else:
+            errs.append(finding(
+                "G10.fold_break_not_comma",
+                f"G10 decisions: {entry.id} folds a flow-map item at block "
+                f"line {issue.line} without a comma at the break — the next "
+                "key merges into the previous value",
+                owner=_fmt(entry.id),
+                expected="fold breaks end with a comma (or the opening "
+                         "brace)",
+                actual=f"break after {issue.tail!r}",
+                repair="End the folded line with a comma before continuing "
+                       "the item on the next line",
+            ))
+    return errs
+
+
 def _candidate_checks(entry: DDEntry) -> list[Finding]:
     errs: list[Finding] = []
     label = entry.id
@@ -669,6 +715,31 @@ def _reentry_checks(
     return errs
 
 
+def _positive_dd_checks(pointback_text: str | None) -> list[Finding]:
+    """``dd:`` on a positive (S0) finding is a shape error (issue #44).
+
+    ``dd:`` is the R3 challenge channel; riding it on a positive
+    observation reads as a challenge downstream. Fail closed with a
+    precise error instead of silently ignoring the line.
+    """
+    if not pointback_text:
+        return []
+    errs: list[Finding] = []
+    for index, refs in positive_dd_refs(pointback_text):
+        errs.append(finding(
+            "G10.dd_on_positive_finding",
+            f"G10 decisions: positive finding {index} carries "
+            f"dd: {', '.join(refs)} — dd: is the R3 challenge channel and "
+            "never rides a positive observation",
+            owner=f"point-back.md#finding.{index}",
+            expected="dd: only on non-positive (S1-S3) findings",
+            actual="dd: on severity S0",
+            repair="Drop the dd: line and record the observation link as "
+                   "prose (e.g. an evidence note line)",
+        ))
+    return errs
+
+
 def _preview_link_checks(
         entries: list[DDEntry],
         preview_dir: Path | None) -> list[Finding]:
@@ -929,6 +1000,7 @@ def check_g10(
         report_text=report_text,
     )
     errs += _reentry_checks(entries, signals.dd_targets)
+    errs += _positive_dd_checks(pointback_text)
     errs += _preview_link_checks(entries, preview_dir)
     errs += _stale_checks(entries, baseline_state)
     errs += _signal_checks(entries, signals, run_profile_tier)

package/scripts/g8_run_registry.py

@@ -37,7 +37,10 @@ if str(_PKG_ROOT) not in sys.path:
 from design_playbook.scripts import rules_registry  # noqa: E402
 from design_playbook.scripts._diagnostics import Finding, finding  # noqa: E402
 from design_playbook.scripts.rules_registry import RegistryError  # noqa: E402
-from design_playbook.scripts.run_profile import parse_run_profile  # noqa: E402
+from design_playbook.scripts.run_profile import (  # noqa: E402
+    parse_run_profile,
+    validate_run_profile,
+)
 
 REGISTRY_PATH = (
     Path(__file__).resolve().parents[1] / "skills" / "design-playbook"
@@ -144,9 +147,16 @@ def main(argv: list[str]) -> int:
         try:
             profile = parse_run_profile(
                 plan_path.read_text(encoding="utf-8"))
-            tier = profile.tier if profile is not None else None
-        except (OSError, UnicodeError):
-            tier = None
+        except (OSError, UnicodeError) as exc:
+            print(f"G8 INVALID: cannot read {plan_path}: {exc}", file=sys.stderr)
+            return 2
+        profile_errors = validate_run_profile(profile) if profile is not None else []
+        if profile_errors:
+            print("G8 INVALID:")
+            for error in profile_errors:
+                print(f"  FAIL  run-profile invalid: {error}")
+            return 1
+        tier = profile.tier if profile is not None else None
     findings = check_g8_run(craft_text, entries, tier)
     if not findings:
         print("G8 OK: craft audit rows satisfy the run-level registry gate")

package/scripts/learning_candidates.py

@@ -36,9 +36,9 @@ from design_playbook.scripts.g2_g4_pointback import FIELD_LINE
 MIN_DISTINCT_RUNS = 3
 MIN_DISTINCT_CONTEXTS = 2
 MAX_UNEXPLAINED_FALSE_POSITIVES = 0
-# Positive observations (S0) are not defect signals — the derivation
-# never lets them enter the candidate queue.
-EXCLUDED_SEVERITIES = frozenset({"S0"})
+# Candidate derivation fails closed: only defect severities enter history.
+# S0 is a positive observation; blank, legacy, and unknown values are invalid.
+CANDIDATE_SEVERITIES = frozenset({"S3", "S2", "S1"})
 
 UNSPECIFIED_CONTEXT = "(unspecified)"
 
@@ -134,8 +134,8 @@ def derive_candidates(
     """
     groups: dict[str, list[Occurrence]] = {}
     for occurrence in occurrences:
-        if occurrence.severity.strip() in EXCLUDED_SEVERITIES:
-            continue  # positive observations are not defect signals
+        if occurrence.severity.strip() not in CANDIDATE_SEVERITIES:
+            continue
         key = normalize(occurrence.issue)
         if key:
             groups.setdefault(key, []).append(occurrence)