feat(method): delta-resolution — recorded resolution for every delta (SPEC lifecycle + add.py fold)#32
Merged
Merged
Conversation
…SERVE Replace the free-text "Spec delta for the next loop:" field with a machine-checkable `### Spec delta` block on the [SPEC · open|seeded|dropped] grammar — a SEPARATE resolution track from `### Competency deltas`. A SPEC delta is a forward hand-off that resolves into a TASK (seeded) or is dismissed (dropped), never consolidated into the foundation. Engine (add.py — single-source grammar beside _DELTA_RE): - _SPEC_STATUSES / _SPEC_DELTA_RE / _STATUS_SETS: tag-scoped status sets so the ONE lint rejects a cross-set pairing ([SPEC · folded], [SDD · seeded]) without a parallel grammar. - _lint_task_deltas scans BOTH the competency and SPEC blocks, tag-scoped; open SPEC evidence is REQUIRED (symmetric with competency deltas). - _task_prose reads the first OPEN SPEC delta, falling back to the legacy free-text field (archived tasks predate the block) — back-compat preserved. - _spec_delta_entries + _collect_open_spec_deltas: read-only collector, flat (SPEC is one tag), never bucketed by competency. - cmd_deltas surfaces open SPEC deltas in their own section + a --json key. - TASK.md template (canonical + _FALLBACK_TASK) ships the `### Spec delta` block; all 3 byte-identical engine copies + 3 templates re-synced and engine_pin re-aimed. TDD: 11 new tests / 35 assertions (test_spec_delta_grammar.py); downstream observe consumers in test_report.py updated to the new block. Full suite 1169 OK. Earned-green proof: a fresh project with [SPEC · folded] fails `check` with unknown_status on the live dogfood engine. Task 1 of 4 in the delta-resolution milestone. milestone: delta-resolution (1/4) · contract FROZEN @ v1 · verify gate PASS author: Tin Dang
…ismiss it The first WRITERS that move a SPEC delta off `open` (task 1 only read the seeded/dropped statuses). Two resolution verbs: - `new-task <new> --from-delta <prior>` SEEDS the prior's first open SPEC delta into a new task: pre-fills §1 `Feature: <text> (from <prior> spec-delta)`, flips the source `[SPEC · open]` -> `[SPEC · seeded] [→ <new>]`, records `from_delta` lineage in state. - `drop-delta <task>` DISMISSES the first open SPEC delta -> `[SPEC · dropped]`. Engine (add.py): - pure `_resolve_spec_delta(text, new_status, pointer=None) -> str | None`: flips ONLY the first open line's status token (via _SPEC_OPEN_TOKEN_RE) plus an optional ` [→ ptr]` stamp; entry text + `(evidence: …)` byte-preserved; None when no open delta -> caller refuses, writes nothing. - `_first_open_spec_text` reads the seed Feature text from the same in-memory text the flip uses. - `cmd_drop_delta` + the `drop-delta` subparser; `--from-delta` on cmd_new_task. Design-for-failure: validate-ALL-then-write — resolve prior, prove >=1 open SPEC delta, compute the seeded flip BEFORE any write; per-file _atomic_write; ordered new-TASK.md -> prior-flip -> state, so the worst residue is "new task created, prior still open & visible" (re-run blocked by the slug-exists guard — never a dangling pointer). Proven live: a taken-slug seed refuses without consuming the source delta. TDD: 8 new tests (test_seed_and_drop.py). The new `drop-delta` subcommand extends test_min_pillar's read-spy LIFECYCLE census (one more command proven docs-silent — a strengthening, not a weakening). Full suite 1177 OK; 3 engine copies re-synced (md5 5120b0c2), engine_pin re-aimed. Task 2 of 4 in the delta-resolution milestone. milestone: delta-resolution (2/4) · contract FROZEN @ v1 · verify gate PASS author: Tin Dang
Close the SPEC-delta lifecycle with four read-one-source guards so a captured spec lesson can never be dropped on the floor between loops. All four read the SAME count: len(_collect_open_spec_deltas(root)). Engine (add.py): - `compact <ms>` REFUSES "open_spec_deltas_unresolved" while ANY task in the PROJECT holds an open SPEC delta (after open_deltas_unfolded, before the move; tree+state byte-unchanged on reject). Deliberately broader than the member-scoped competency guard — a stray idea anywhere blocks the archive until it is seeded or dropped. Names the offending task(s). - `status` prints a read-only "spec : N open SPEC delta(s) …" line (project-wide; silent at 0). - `milestone-done` prints a non-blocking "note: N open SPEC delta(s) to resolve …" (project-wide). - `report <ms> --json` carries summary["open_spec"] = project-wide count, rendered as a "SPEC DELTAS" block. Design-for-failure: every surface is read-only except compact, whose guard fires BEFORE any write and leaves the tree + state.json byte-identical on refusal (proven by snapshot equality). No new IO path — counts derive from the existing delta collector. TDD: 5 new scenario tests (test_spec_delta_guards.py), one per surface; project-wide breadth proven LIVE by planting the offending delta on a NON-member task. Full suite 1182 OK; 3 engine copies re-synced (md5 392b4e55), engine_pin re-aimed. Dogfood note: this project's own delta-resolution milestone now carries 4 open SPEC deltas (tasks 1's §7 describing what 2/3 built) — they must be seeded/dropped before delta-resolution can compact. Recorded as a §7 ADD delta; a milestone-close cleanup item. Task 3 of 4 in the delta-resolution milestone. milestone: delta-resolution (3/4) · contract FROZEN @ v1 · verify gate PASS author: Tin Dang
Close delta-resolution 4/4. `add.py fold [--task <slug>] [--comp <TAG>]`
mechanizes ONE competency-lesson consolidation session in a single atomic
call, ending the error-prone hand-edit of the versioned foundation:
- flip every open `[<COMP> · open]` -> `folded` + stamp
`[folded foundation-version N]` (pure `_fold_competency_delta`, a mirror
of `_resolve_spec_delta`; line text + `(evidence: …)` byte-preserved);
- transcribe each lesson VERBATIM into its routed home (DDD/SDD/UDD ->
PROJECT.md §Domain/§Spec/§Users · TDD/ADD -> CONVENTIONS.md §Method
learnings) — the engine TRANSCRIBES, it never composes/merges prose;
- prepend one §Key Decisions audit row; bump `foundation-version` ONCE
(batch = one call, one bump, every stamp carries the same N).
- Reject codes: no_open_deltas · missing_route_section · no_foundation_version.
Design-for-failure: validate-ALL-then-write, hardened at the verify gate to a
two-phase commit (`_atomic_write_many`: stage every temp -> rename all), so a
mid-commit IO failure writes NOTHING — the frozen "any failure -> write nothing"
now holds across the N task-files + PROJECT.md + CONVENTIONS.md set, not just
per-file. Foundation files are ordered first so the near-impossible mid-rename
residual is a still-open (visible, re-runnable) lesson, never a silent loss.
HUMAN-AUTHORIZED frozen-principle reversal: this command reverses the prior
"engine stays judgment-free; there is no add.py fold" rule. test_foundation_
update_loop re-frozen @V3 (the no-fold-command assertion inverted to assert the
command EXISTS + is transcription-only; REJECT_CODES reconciled). Sibling
authorized guard CRs: test_min_pillar census (+fold in LIFECYCLE & _NONZERO_OK)
· test_ubiquitous_language (+fold in MACHINE_CONSTANTS; cmd_fold prose stays
"consolidation"). fold.md rewritten (x3 byte-identical) to describe the command.
Dogfooding fix (second authorized CR, folded in at the verify HARD-STOP): the
§5 scope-walk excluded only .git/.add/__pycache__/node_modules — not `.serena`,
serena's symbol-index cache, which re-writes itself on every source edit. The
AI's own add.py edits churned `.serena/cache/*.pkl`, the build-entry snapshot
baked them in, and the gate flagged a false out-of-scope touch that exhausted
the heal loop to a false HARD-STOP. `.serena` added to _SCOPE_EXCLUDE_DIRS
(a tool cache with no build signal — the exclude set's exact purpose), proven
red/green by a new fixture + assertion in test_scope_gate_enforce.py.
Engine re-synced across all 3 copies (canonical · .add dogfood · bundled);
engine_pin re-aimed -> f78a2f24. Red suite test_fold_command.py [7 tests];
full suite 1189 green.
author: Tin Dang
…ollow-up)
Milestone close for delta-resolution, dogfooding the machinery the milestone
itself shipped:
- `add.py fold` (the new command) consolidated all 10 open competency lessons
into the versioned foundation in one atomic session — foundation-version
35 -> 36, 1 SDD bullet -> PROJECT.md §Spec, 3 TDD + 6 ADD bullets ->
CONVENTIONS.md §Method learnings (each verbatim + `[folded foundation-version
36 · from <task>]` stamp), one §Key Decisions audit row. First real-data run
of fold — clean.
- Resolved the 5 open SPEC deltas: SEEDED the 3 forward-looking ones into a new
`delta-resolution-polish` milestone via `new-task --from-delta` (each source
flipped to `[SPEC · seeded] [→ <new>]` with `from_delta` lineage) —
multi-file-commit (a true all-or-nothing N-file commit primitive),
delta-match-selector (`--match` to target a specific open SPEC delta),
compact-force-override (a `compact --force` escape hatch); DROPPED the 2 that
were already delivered inside this milestone.
- Checked the 4 exit criteria (all delivered + tested + gated PASS) and ran
milestone-done -> RETRO.md.
delta-resolution is closed (3 milestones now releasable; release stays HELD).
The seed/drop verbs were themselves dogfooded here. Engine + foundation only —
no source/test change in this commit.
author: Tin Dang
TinDang97
self-requested a review
June 17, 2026 02:11
…nit) A pre-merge independent review (verdict MERGE-WITH-NITS, zero blocking) flagged one faithfulness nit: the cmd_fold commit comment overstated atomicity. "A mid-commit IO failure leaves NOTHING written" is true only for the phase-1 temp-write failure; a near-impossible phase-2 mid-rename failure can leave the foundation advanced while a TASK.md stays unflipped, and a re-run re-transcribes by DUPLICATING (never losing), not cleanly resuming. Comment-only correction — no behavior change. The two-phase `_atomic_write_many` and the foundation-first write order stand; a true all-or-nothing N-file commit is the queued multi-file-commit follow-up task. Engine re-synced across all 3 copies; engine_pin re-aimed -> 5f3f7d28. Full suite 1189 green. author: Tin Dang
pilotspacex-byte
added a commit
that referenced
this pull request
Jul 14, 2026
…(7/7 gate PASS) (#146) * chore(method): intake ceremony-to-effort milestone — 7 evidence-traced ceremony cuts Create + confirm the ceremony-to-effort sub-milestone (extends risk-proportional-ceremony's held-open <=12-call criterion). Grounded in two audits run 2026-07-13: - transcript anatomy of the LOOP-2 benchmark runs: best run 37% artifact / 63% ceremony vs spec-kit 95%; skip-bait, byte-identical retries (12-21% of calls), --help residue, and the scope repair cycle quantified per call; - guide/template weight audit: 56KB read burden per task (56% in 3 task-agnostic files); TASK.md.tmpl ~30% boilerplate + ~25% derivable; 5 rules stated 3-5x across surfaces. 7 tasks: kickoff-truth · derived-stamps · template-dedup · gate-read-diet · scope-echo-draft · risk-report-render · fold-draft-at-close. Floors untouched (freeze · red-first · recorded gate · HARD-STOP); exit binds at the pinned-meter WM1 re-measure (calls <= 12, read <= ~30KB). Author-toil follow-ups captured as todos #30-#32 (seams-symbol-pins · sync-twins · stale global skill). author: Tin Dang <tindang.ht97@gmail.com> * feat(method): kickoff truth — lane-aware kickoff + call recipe + dup-failure short-circuit (kickoff-truth, ceremony-to-effort 1/7) Three measured waste classes killed at the message layer (evidence: the 2026-07-13 transcript audit of loop2-lever rep0/1/2): - init kickoff + headless hint lead with the single-task --oneshot lane (milestone-first kickoff cost rep0/rep1 2+ calls; rep2 skipped it and won) - new-task stdout ends with the FULL remaining 6-call recipe, all lanes (replaces 6-11 measured status/guide/--help re-orientation calls per run) - a consecutive byte-identical failing call gets a short-circuit hint (12-21% of all measured calls were exact duplicate failures); sig sidecar lives in the OS tmp dir keyed by md5(root) — contract v2 after the full suite refuted v1's in-tree sidecar against the reject-writes-nothing byte fence (16 suites). Success clears; fail-open everywhere. Floor intact: red-first (4 red for the right reason), frozen contract v2 (change request, human-approved), tamper tripwire honored (one soft-edit revert), sibling InitKickoffTest pin STRENGTHENED never weakened, gate PASS. Evidence: test_kickoff_truth 7/7 + full suite 3453/3453 OK + check 734/0 + live end-to-end probe. ENGINE_MD5 -> 3937d5c1, PKG -> d83fc67f, twins x4. author: Tin Dang <tindang.ht97@gmail.com> * feat(method): freeze stamps the Ground SHA placeholder (derived-stamps, ceremony-to-effort 2/7) The weight audit measured Ground SHA as 100%-derivable data the agent hand-types (`git rev-parse --short HEAD`). cmd_freeze now fills a placeholder-form `Ground SHA:` line with the real short HEAD inside the SAME atomic write as the Status flip, so the freeze fingerprint hashes the stamped text. Grandfather (a hand-filled line never matches) + fail-open (no git -> line untouched, freeze succeeds), mirroring _stamp_gate_record. HONEST SCOPE TRIM at ground: gate-record stamps, the Status flip, and the fast-template Ground SHA line already existed; Reported: is an honesty attestation and stays human-written. Evidence: test_derived_stamps 4/4 (M1 red-first) + freeze-family neighbors green + full suite 3457 (sole fail = SEAMS line-pin drift, re-aimed 5512->5526, todo #30) + check 738/0. ENGINE_MD5 -> e2ed6599, twins x4. Gate PASS. author: Tin Dang <tindang.ht97@gmail.com> * refactor(method): template comment dedup — EXIT pointers + engine-stamp comments (template-dedup, ceremony-to-effort 3/7) TASK.md.tmpl comments compress to pointers where the content has a canonical home elsewhere: EXIT restatements -> one-line pointers to each phase guide's exit_gate; the scope-lock comment trims; Ground SHA comments (both templates + phases/3-plan.md) now say "stamped by freeze" instead of instructing the hand-typed rev-parse (derived-stamps shipped the stamp). CHANGE REQUEST v2, fence-driven: v1 also deleted the scope-grammar restatements per the weight audit — the full suite refuted it (4 suites pin the template as the FROZEN scope-decl declaration surface). v2 restored them verbatim and flipped my test into a pin that PROTECTS the restatement from the next dedup pass. Net: comments 2848->2568B, template 12374->12055B, lean pins honored (one merged S3 comment, <12 total, merged not split). Evidence: test_template_dedup 6/6 + 86 neighbor tests + full suite 3463/3463 OK. Templates x5 + skill x3 synced; zero engine bytes. Gate PASS. author: Tin Dang <tindang.ht97@gmail.com> * feat(method): gate render cards — phase guides self-suffice, big references read-once (ceremony-to-effort 4/7) The weight audit measured report-template.md (9.6KB x3 call sites) and run.md (8.9KB x4) re-read per gate/session — the heaviest task-agnostic reads after SKILL.md. Each gate's phase guide now carries its render card inline; the big files demote to read-at-most-once references. - 3-plan.md freeze section: banner→ARC→SHAPE→SUMMARY→FLAGS→DECIDED→ EVIDENCE→APPROVE→NEXT card + read-once pointer; the pinned 'rendering SHAPE then the freeze APPROVE as a guided choice' sentence kept verbatim (test_report_shape_scan_audit, x3 trees) - 6-verify.md gate section: verify-dialect card + the kept reconcile-FLAGS / report --decide sentence - SKILL.md: one read-once rule line; absorbed under the frozen 18186B core-pool target by same-pool compression (landed 18186/18186) - test_gate_read_diet.py: 7 red/green tests (ordered skeleton, verbatim imperatives, wiring pins, pool byte target) - synced x3 skill trees; prose-only — ENGINE_MD5 unchanged Fence: full suite 3470/3470 OK. Gate PASS. refs: milestone ceremony-to-effort (gate-read-diet), stacked on PR #145 author: Tin Dang <tindang.ht97@gmail.com> * feat(method): scope echo + draft at freeze — mis-resolution becomes a zero-call read (ceremony-to-effort 5/7) The scope-token grammar's silent mis-resolution class (three tasks independently rediscovered it per SEAMS.md) becomes visible at the approval already happening: freeze now renders each RESOLVED scope entry, and proposes a Scope line when the declaration is dead. - add.py: _scope_echo helper — per-entry `scope: <rel> [ok|MISSING]` echo after the froze-print (footer stays last); UNDECLARED/garbage/ all-MISSING also prints `scope (proposed from §3 Touches): ...` composed from real Touches paths — propose-not-impose, pure read, fail-open (never blocks a freeze) - test_scope_echo_draft.py: 6 red/green tests on a live CLI board; two honest ground corrections found red-side (second freeze is a benign exit-0 no-op; the ./src/ default is REAL — new-task scaffolds a task-local src/) - ENGINE_MD5 -> 80b8121a, engine synced x3; SEAMS _declared_scope pin re-aimed 5526->5562; docstring reworded twice for the SEAMS-anchor guard + the 'seam' slang scanner Fence: full suite 3476/3476 OK. Gate PASS. refs: milestone ceremony-to-effort (scope-echo-draft), stacked on PR #145 author: Tin Dang <tindang.ht97@gmail.com> * feat(method): risk-proportional gate render — compact form for mechanical/fast (ceremony-to-effort 6/7) The verify-gate render now scales with the risk class instead of one 8-section ceremony for everything: `sensitivity: mechanical` and fast-lane tasks use the compact form (banner - SUMMARY - EVIDENCE - APPROVE); security/data/architecture and every freeze keep the full card. - 6-verify.md: right-size dispatch appended to the gate card; imperatives (render-before-gate · Reported: yes · never-self-stamp) verbatim - 3-plan.md: the freeze always renders the full card, never compact - fast-lane.md: render sentence aligned (freeze full, fast verify compact); the guide lives in the REFERENCE pool (32B headroom) — growth absorbed by same-guide compression - test_risk_report_render.py: 7 red/green tests (dispatch, order, reservation, single-home guard, pool target) - synced x3 skill trees; prose-only — ENGINE_MD5 unchanged Fence: full suite 3483/3483 OK. Gate PASS. refs: milestone ceremony-to-effort (risk-report-render), stacked on PR #145 author: Tin Dang <tindang.ht97@gmail.com> * feat(method): fold draft at close — milestone-done pre-classifies open SPEC deltas (ceremony-to-effort 7/7) Close-time delta resolution now starts from a proposal instead of a blank re-read: milestone-done's SPEC nudge grows a mechanical draft — `seed` when a delta's cited path resolves in the current tree, `drop?` (a question, never a verdict) when its paths are dead, `seed — forward hand-off by default` when pathless. Stdout only, fail-open; the human still resolves every delta — no gate change. - add.py: draft block inside cmd_milestone_done's open_spec branch; label rendered via _FOLD_VERB (the add.py literal slang guard bans the bare word — same dodge as the v11 nudge) - test_fold_draft_at_close.py: 5 red/green tests driving a real milestone to done through the CLI (three delta shapes, nudge survival, stdout-only equality, footer-last) - ENGINE_MD5 -> 8aef02ae, engine synced x3; SEAMS _declared_scope pin re-aimed 5562->5581 Fence: full suite 3488/3488 OK. Gate PASS. This closes the 7-task build: all seven ceremony cuts shipped inline via the fast lane, each with a frozen contract, a red-first suite, and a green full-suite fence. refs: milestone ceremony-to-effort (fold-draft-at-close), stacked on PR #145 author: Tin Dang <tindang.ht97@gmail.com> * docs(method): ceremony-to-effort close ship-review — 7/9 exit criteria verified, 2 bind at re-measure Fill the milestone's Close ship-review: per-task evidence rows (7 gates PASS, commits cited), ship-by-domain summary, and exit-criteria verifiers. 7/9 checked with test-pinned evidence; OPEN: read-burden <=30KB (partial — fast lane 37KB / full 49.1KB from 56KB; big refs 0x on standard gates) and the pinned-meter WM1 re-measure (human-gated paid run). Milestone stays open until the re-measure per intake. refs: milestone ceremony-to-effort, stacked on PR #145 author: Tin Dang <tindang.ht97@gmail.com> * chore(method): capture todo #33 — lock-reclaim TOCTOU race on slow CI runners Two consecutive py3.10 CI failures observed peak=2 concurrent lock holders in the reclaim tests (known-waived flake class, but the window is real on slow runners). Captured so it survives the close. author: Tin Dang <tindang.ht97@gmail.com> * fix(benchmark): run.py resolves {REPO_ROOT} in arm setup_steps (todo #27) The pilot path calls resolve_setup_steps; the thin run.py CLI passed the arm raw, so a live `run --arm add --wm 1` executed the literal `uv pip install -e {REPO_ROOT}/add-method` and the rep died at setup (observed at the ceremony-to-effort WM1 re-measure rep 1 — $0 spent, caught before any agent turns). Red/green: test_run_cli_resolve pins both the run and resume paths; benchmark suite 188/188. author: Tin Dang <tindang.ht97@gmail.com> * docs(benchmark): ceremony-to-effort WM1 re-measure results (n=3, $10.53) 3 reps on the pinned meter with the new engine: fidelity 0.97-0.98, zero regressions, mean 134 turns / 18.7 add.py calls / $3.51 — the cheapest honest ADD round ever archived (-32% turns / -44% cost vs baseline-round3; lean rounds excluded as engine-bypassing). Strict exit bar (calls <=12, <=77.7t/$2.97) UNMET; --help and dup-retry residue near-zero. Residual waste anatomy recorded as next levers: double-init (harness/flow), milestone bait (r1), re-cross repairs, status re-reads. Criterion #9 annotated, box left open for the human's accept-partial or follow-on decision. author: Tin Dang <tindang.ht97@gmail.com> --------- Co-authored-by: Tin Dang <tindang.ht97@gmail.com>
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
2 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
delta-resolution — every delta gets a recorded, engine-driven resolution
Closes the delta-resolution milestone: both delta types in the ADD engine now have a recorded, engine-driven resolution event, so a captured lesson is never a silent dangling line. Four tasks, each through the full spec→tests→build→verify gate.
What ships
1. SPEC-delta resolution lifecycle (
spec-delta-grammar·seed-and-drop·spec-delta-guards)### Spec deltablock with[SPEC · open|seeded|dropped]grammar — a separate track from the five competency deltas (a SPEC delta resolves into a task, never the foundation).add.py new-task --from-delta <prior>seeds an open SPEC delta into a new task (prefills §1 Feature, flips source →[SPEC · seeded] [→ <new>], recordsfrom_deltalineage); adrop-deltapath flips →dropped.compactrefuses a task with an open SPEC delta;status/reportnudge unconsumed ones.2.
add.py fold(fold-command) — mechanizes competency-delta consolidation[<COMP> · open]→folded+[folded foundation-version N]stamp, transcribe each lesson verbatim into its routed home (DDD/SDD/UDD → PROJECT.md · TDD/ADD → CONVENTIONS.md), prepend one §Key Decisions audit row, bumpfoundation-versiononce (batch = one call, one bump).no_open_deltas·missing_route_section·no_foundation_version.Notes for the reviewer
add.py foldreverses the prior "engine stays judgment-free; there is noadd.py fold" rule.test_foundation_update_loopis re-frozen @V3; the guard-test change-requests (min_pillar census, ubiquitous-language machine-token) are recorded, not silent._atomic_write_many(stage every temp → rename all), so the contract's "any failure → write nothing" holds across the N task-files + foundation set, not just per-file..serena(serena's symbol-index cache), so an agent's own edits churned the cache into a false out-of-scope HARD-STOP..serenaadded to_SCOPE_EXCLUDE_DIRS, proven red/green.add.py foldover its own 10 lessons (foundation-version 35→36) and seeded its 3 forward SPEC deltas into a follow-updelta-resolution-polishmilestone via--from-delta.Verification
test_fold_command.py[7 tests] + the.serenascope-guard guard.add.py check335 passed, 0 failed.engine_pinre-aimed.Release stays HELD (3 milestones now releasable; next cut 1.7.0 is a separate decision).