@zalom/plastic 1.7.0 → 1.8.0

package/scripts/end-intent

@@ -63,6 +63,10 @@
 #      (git status itself failed: corrupt index, git missing, not a repo);
 #      refused before removal; pass --discard-worktree-changes to override
 #      deliberately.
+#   6  the doctor per-intent structure gate refused (checklist incomplete,
+#      links out of projection, intent-file malformed, or a lifecycle artifact
+#      missing/placeholder); named reasons on stderr; authors nothing
+#      (intent 222).
 
 require "fileutils"
 require "date"
@@ -71,6 +75,7 @@ require "pathname"
 require_relative "lib/bridge"
 require_relative "lib/lock"
 require_relative "lib/intent_validator"
+require_relative "lib/outcome_guard"
 
 DISPOSITIONS = %w[delivered abandoned].freeze
 
@@ -143,33 +148,69 @@ def resolve_intent_dir(store, id)
   matches.first
 end
 
-# --- outcome.md guard (D2 step 1a) ------------------------------------------
+# --- structure gate helper (intent 222) -------------------------------------
 #
-# Returns nil when the guard PASSES, or a reason String to refuse with exit 2.
-# Read-only: authors nothing regardless of outcome. Refuses a missing file, a
-# still-placeholder file (first line is the sentinel), or a disposition that
-# does not exactly equal the requested one (this is what naturally refuses a
-# freshly scaffolded outcome.md, whose disposition is the literal
-# "delivered|abandoned" string, not one of the two real values).
-def outcome_guard_reason(intent_dir, disposition)
-  path = File.join(intent_dir, "outcome.md")
-  return "outcome.md is missing at #{path}" unless File.exist?(path)
-
-  content = File.read(path)
-  first_line = content.each_line.first.to_s.chomp
-  if first_line == Bridge::PLACEHOLDER_SENTINEL
-    return "outcome.md is still the scaffold placeholder (first line is the sentinel)"
+# Derive the TRUE plastic_home and this intent's store scope key from the --store
+# directory end-intent was given, so the per-intent doctor gate (below) sees the SAME
+# multi-store universe doctor.rb itself would (needed for its links-projection sub-check,
+# which resolves cross-store refs). --store is either the global store
+# (<plastic_home>/store) or a project store (<plastic_home>/projects/<slug>/store); the two
+# shapes are told apart by whether store's grandparent directory is literally named
+# "projects" (the StoreDiscovery convention, scripts/lib/store_discovery.rb), never by
+# hardcoding ".plastic" as a name.
+def resolve_plastic_home_and_scope(store)
+  parent = File.dirname(store)
+  grandparent = File.dirname(parent)
+  if File.basename(grandparent) == "projects"
+    slug = File.basename(parent)
+    [File.dirname(grandparent), "project:#{slug}"]
+  else
+    [parent, "global"]
   end
+end
 
-  fm = IntentValidator.parse_frontmatter_text(content)
-  actual = fm.is_a?(Hash) ? fm["disposition"] : nil
-  unless DISPOSITIONS.include?(actual) && actual == disposition
-    return "outcome.md frontmatter disposition is #{actual.inspect}, expected #{disposition.inspect}"
+# Doctor's per-intent structure gate (intent 222), a pre-write step: FAIL refuses the close
+# (exit 6, authors nothing), WARN prints an advisory note and proceeds, PASS proceeds
+# silently, and an unexpected exception from the gate call itself is rescued and treated as
+# a skipped gate (fail-open on a crash: a broken gate must never wedge a close).
+#
+# `gate:` is an injected seam (mirrors run_disarm's own bridge_reader:/disarm: pattern
+# below) defaulting to the real Doctor.new(...).run_intent_check(...) call; tests load this
+# script in-process (as test/end_intent_disarm_toctou_test.rb already does for run_disarm)
+# and inject a raising stub to prove the fail-open contract, with no eval/ENV/global seam.
+#
+# Disposition is deliberately NOT passed to the real gate call (intent 222 executor
+# decision): the existing outcome-only guard immediately following this call already owns
+# disposition-matching (exit 2), and intent_lifecycle_artifacts unconditionally checks
+# outcome.md PRESENCE via Bridge.stage_file_present? regardless of disposition, so passing
+# it here would make this gate re-check the SAME disposition match the old guard already
+# owns, needlessly widening which exit-2 fixtures become exit-6. doctor.rb --intent called
+# directly (with --disposition) still exercises the fold-in per D2/acceptance criteria.
+def run_structure_gate(id, store:, gate: ->(gate_home, gate_scope) {
+  require_relative "doctor"
+  Doctor.new(plastic_home: gate_home).run_intent_check(id, store: gate_scope)
+})
+  gate_home, gate_scope = resolve_plastic_home_and_scope(store)
+  gate_verdict = gate.call(gate_home, gate_scope)
+  case gate_verdict[:status]
+  when "fail"
+    gate_verdict[:checks].select { |c| c[:status] == "fail" }.each do |c|
+      detail = Array(c[:details]).any? ? " (#{Array(c[:details]).join("; ")})" : ""
+      warn "end-intent: structure gate refused: #{c[:name]}: #{c[:message]}#{detail}"
+    end
+    exit 6
+  when "warn"
+    gate_verdict[:checks].select { |c| c[:status] == "warn" }.each do |c|
+      detail = Array(c[:details]).any? ? " (#{Array(c[:details]).join("; ")})" : ""
+      warn "end-intent: structure gate warning (proceeding): #{c[:name]}: #{c[:message]}#{detail}"
+    end
   end
-
-  nil
+rescue StandardError => e
+  warn "end-intent: structure gate crashed (#{e.message}); proceeding without it"
 end
 
+# outcome.md guard: see OutcomeGuard.reason (scripts/lib/outcome_guard.rb, extracted intent 222)
+
 # --- intent-file `## Outcome` summary stamp (D2 step 1b) --------------------
 #
 # Replace the body of the intent file's `## Outcome` section with `summary`,
@@ -580,7 +621,9 @@ def main(argv)
     exit 4
   end
 
-  reason = outcome_guard_reason(intent_dir, disposition)
+  run_structure_gate(id, store: store)
+
+  reason = OutcomeGuard.reason(intent_dir, disposition)
   if reason
     warn "end-intent: #{reason}"
     exit 2

package/scripts/lib/installer_core.rb

@@ -358,7 +358,7 @@ class InstallerCore
       "scripts/update.rb" => "scripts/update.rb",
       "scripts/uninstall.rb" => "scripts/uninstall.rb",
       "scripts/rollback.rb" => "scripts/rollback.rb",
-      "scripts/lib/legacy_bookend_amnesty.rb" => "scripts/lib/legacy_bookend_amnesty.rb",
+      "scripts/lib/outcome_guard.rb" => "scripts/lib/outcome_guard.rb",
       "scripts/doctor.rb" => "scripts/doctor.rb",
       "scripts/dashboard.rb" => "scripts/dashboard.rb",
       "scripts/skill-lint" => "scripts/skill-lint",

package/scripts/lib/maintenance_git.rb

@@ -73,7 +73,8 @@ module MaintenanceGit
     run_git!(root, "-c", "user.name=Plastic", "-c", "user.email=plastic@localhost",
              "commit", "--quiet", "-m", commit_message)
     checkout!(root, base)
-    run_git!(root, "merge", "--quiet", "--no-ff", "-m", "Merge #{branch_name} into #{base}", branch_name)
+    run_git!(root, "-c", "user.name=Plastic", "-c", "user.email=plastic@localhost",
+             "merge", "--quiet", "--no-ff", "-m", "Merge #{branch_name} into #{base}", branch_name)
     delete_branch(root, branch_name)
 
     { changed: changed, committed: true, merged: true, branch: branch_name }

package/scripts/lib/outcome_guard.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require_relative "bridge"
+require_relative "intent_validator"
+
+# OutcomeGuard - the single definition of "is outcome.md real and disposition-matched for
+# THIS close" (intent 222). Extracted verbatim from scripts/end-intent's own
+# outcome_guard_reason (intent 161/188) so end-intent's existing exit-2 path and doctor's new
+# per-intent check (intent_lifecycle_artifacts) can never independently drift on what counts
+# as a valid outcome.md. Pure, read-only: authors nothing regardless of outcome.
+module OutcomeGuard
+  module_function
+
+  DISPOSITIONS = %w[delivered abandoned].freeze
+
+  # Returns nil when the guard PASSES, or a reason String to refuse with. Refuses a missing
+  # file, a still-placeholder file (first line is the sentinel), or a disposition that does
+  # not exactly equal the requested one.
+  def reason(intent_dir, disposition)
+    path = File.join(intent_dir, "outcome.md")
+    return "outcome.md is missing at #{path}" unless File.exist?(path)
+
+    content = File.read(path)
+    first_line = content.each_line.first.to_s.chomp
+    if first_line == Bridge::PLACEHOLDER_SENTINEL
+      return "outcome.md is still the scaffold placeholder (first line is the sentinel)"
+    end
+
+    fm = IntentValidator.parse_frontmatter_text(content)
+    actual = fm.is_a?(Hash) ? fm["disposition"] : nil
+    unless DISPOSITIONS.include?(actual) && actual == disposition
+      return "outcome.md frontmatter disposition is #{actual.inspect}, expected #{disposition.inspect}"
+    end
+
+    nil
+  end
+end

package/scripts/maintenance-run

@@ -14,6 +14,7 @@
 #   maintenance-run --tool project-links --intent <id> [--store <key>] [--plastic-home PATH] [--apply]
 #   maintenance-run --tool rebuild-graph [--plastic-home PATH] [--apply]
 #   maintenance-run --tool restore-intent-v1 <id> --at <ref> [--plastic-home PATH] [--apply] [--skip-links]
+#   maintenance-run --tool rebuild-savepoint --intent <id> [--store <key>] [--plastic-home PATH] [--apply]
 #
 # project-links here is ALWAYS single-intent: --intent is required. A store-wide
 # project-links sweep is the rare, owner-approved batch exception (D2) and is run directly
@@ -35,6 +36,8 @@ require "time"
 require_relative "lib/store_discovery"
 require_relative "lib/lock"
 require_relative "lib/maintenance_git"
+require_relative "lib/bridge"
+require_relative "lib/revisions_writer"
 
 DEFAULT_HOME = File.join(Dir.home, ".plastic")
 
@@ -217,9 +220,58 @@ def run_restore_intent_v1(home, id, at, store, apply, skip_links)
   report_result(result)
 end
 
+def run_rebuild_savepoint(home, intent, store, apply)
+  abort_loud("--tool rebuild-savepoint requires --intent <id>") unless intent
+
+  discovery = StoreDiscovery.discover(home)
+  dir = resolve_dir_for_id(discovery, intent, store: store)
+  abort_loud("intent #{intent} not found under #{home}#{store ? " (--store #{store})" : ""}") unless dir
+  check_not_fresh!(dir, intent)
+
+  outcome_path = File.join(dir, "outcome.md")
+  unless Bridge.stage_file_present?(outcome_path)
+    abort_loud("intent #{intent}'s outcome.md is missing or a placeholder; the 124a recipe " \
+               "requires a real disposition to echo, and 219 D6 forbids ever inventing one", 1)
+  end
+
+  frontmatter = File.read(outcome_path)[/\A---\n(.*?)\n---/m, 1].to_s
+  disposition = frontmatter[/^disposition:\s*(\S+)/, 1]
+  abort_loud("intent #{intent}'s outcome.md has no disposition: frontmatter field", 1) unless disposition
+
+  unless apply
+    puts "maintenance-run: DRY RUN, would reconstruct savepoint.md for #{intent} " \
+         "(Bridge.rebuild_savepoint + Done #{disposition} echo)"
+    exit 0
+  end
+
+  begin
+    result = MaintenanceGit.run_scoped(
+      repo_dir: home, branch_name: "maintenance/rebuild-savepoint-#{intent}-#{stamp}",
+      commit_message: "chore: maintenance - rebuild-savepoint #{intent}"
+    ) do
+      Bridge.rebuild_savepoint(dir)
+      Bridge.append_terminal_savepoint(dir, disposition)
+      RevisionsWriter.append!(
+        dir,
+        why: "reconstruct missing operational savepoint.md (generic operational-gap predicate)",
+        rule: "savepoint-operational-reconstruction",
+        prior_location: "#{intent}/savepoint.md",
+        change: "savepoint.md rebuilt from disk (Bridge.rebuild_savepoint) plus Done " \
+                "#{disposition} echo appended (Bridge.append_terminal_savepoint); disposition " \
+                "read from outcome.md's own frontmatter, never invented"
+      )
+    end
+  rescue MaintenanceGit::DirtyWorkingTree, MaintenanceGit::NotAGitRepo => e
+    abort_loud(e.message, 4)
+  rescue RuntimeError => e
+    abort_loud(e.message, 3)
+  end
+  report_result(result)
+end
+
 def main(argv)
   opts = parse_argv(argv)
-  abort_loud("--tool is required (project-links|rebuild-graph|restore-intent-v1)") unless opts[:tool]
+  abort_loud("--tool is required (project-links|rebuild-graph|restore-intent-v1|rebuild-savepoint)") unless opts[:tool]
 
   case opts[:tool]
   when "project-links"
@@ -227,9 +279,11 @@ def main(argv)
   when "rebuild-graph" then run_rebuild_graph(opts[:plastic_home], opts[:apply])
   when "restore-intent-v1"
     run_restore_intent_v1(opts[:plastic_home], opts[:id], opts[:at], opts[:store], opts[:apply], opts[:skip_links])
+  when "rebuild-savepoint"
+    run_rebuild_savepoint(opts[:plastic_home], opts[:intent], opts[:store], opts[:apply])
   else
     abort_loud("unknown --tool #{opts[:tool].inspect} " \
-               "(expected project-links|rebuild-graph|restore-intent-v1)")
+               "(expected project-links|rebuild-graph|restore-intent-v1|rebuild-savepoint)")
   end
 end
 

package/skills/auto/SKILL.md

@@ -343,10 +343,11 @@ During initial project creation, all decisions are non-destructive by definition
    non-zero exit needs attention before moving on: 4 means a live foreign session holds the
    lock (back off), 5 means the code worktree is dirty (commit/stash first, or pass
    `--discard-worktree-changes` deliberately), 3 means disarm ran but the lock is still
-   present (run `/plastic-doctor check the lock status`). Only Step 6 (QMD reindex, async,
-   last) remains a separate action after this call succeeds. Never leave an orphaned
-   worktree; run `git worktree prune` on a stale reference. If any of this ever needs to
-   change, change `plastic-intent-ending`, not this skill.
+   present (run `/plastic-doctor check the lock status`), 6 means the structure gate refused
+   (see the named reason on stderr; fix via the owning tool named above, then re-run). Only
+   Step 6 (QMD reindex, async, last) remains a separate action after this call succeeds.
+   Never leave an orphaned worktree; run `git worktree prune` on a stale reference. If any of
+   this ever needs to change, change `plastic-intent-ending`, not this skill.
 7. Notify user (Done briefing): brief per `references/human-report-contract.md`
     (State: the delivered impact; Risk: residual risk; Call: the decision left to you, merge,
     release, or accept). See `outcome.md` for details.

package/skills/doctor/SKILL.md

@@ -16,36 +16,67 @@ Doctor has three scopes. Pick the right one for the situation:
 | Store check | `--store [global\|<slug>]` | Dashboard load, `plastic-project-continuing` | Three-state: pass / warn / fail |
 | Full check | (no flag) | After every update (automatic), or `/plastic-doctor` | Three-state: pass / warn / fail |
 
-### `--core` (binary, manifest-backed)
+### `--core` (binary, operational-readiness only)
 
-Verifies that every core file is present and content-matches what the installed
-version shipped. It checks two install manifests:
+Checks ONLY that Plastic is loaded and ready for work: agent registration (skills,
+subagents, hooks/harnesses present and registered), core files (manifest-backed
+presence/hash checks, excluding `agent_model_drift`, which is a non-boot
+config-honoring check, never run at core), manifest sync (global + agent manifest
+SHA256), every registered project's path resolving to a real, existing directory,
+and the global store being reachable (`INDEX.md` present; no orphan/ghost content
+scanning). Result is binary: exit 0 on pass, non-zero on error. It never produces
+warnings, and it never scans store content.
+
+It checks two install manifests as part of core files and manifest sync:
 
 - `~/.plastic/manifest.json` (global manifest, covers PLASTIC.md and global scripts)
 - `~/.claude/plastic/manifest.json` (agent-side manifest, covers agent scripts and hooks)
 
-Each manifest maps a file path to its SHA256. The core check also confirms hooks
-are registered, scripts are present and executable, and the installed version
-matches. Result is binary: exit 0 on pass, non-zero on error. It never produces
-warnings.
+Each manifest maps a file path to its SHA256.
 
-### `--store [global|<slug>]`
+**On failure**, the report states this guided route, in order:
 
-Checks store state: intents are well-formed, INDEX sections are present, conventions
-are followed, and links are valid. Scope options:
+1. Run `plastic doctor --fix` (the Fix all / Select individually / Skip router from
+   Step 4-5 below).
+2. If that does not resolve it, roll back to the last known-good version via
+   `plastic-rollback` (restores from the local, append-only `versions.json` ledger of
+   versions actually run).
+3. Optionally report the issue via the feedback command (`scripts/feedback-report`,
+   backing the `plastic-feedback` skill), which composes a local report plus a
+   prefilled GitHub issue URL and never holds a credential or contacts GitHub
+   directly.
 
-- No argument: checks all stores (global and all projects)
-- `global`: checks only the global store
-- A project slug (e.g. `--store plastic`): checks only that project's store
+### `--store [global|<slug>]`
 
-Produces three-state results (pass / warn / fail) and is run per-scope at dashboard
-load time: the global board uses `--store global`, a project board uses `--store <slug>`.
+Checks the operations Plastic itself depends on in one store: QMD search reachability (scoped
+to that store's own collection; global uses `plastic-global`, a project slug uses
+`plastic-<slug>`), sources/chain resolution, cross-store resolution, INDEX parsing, and links
+projection. A project slug also checks tool readiness (Serena, Enola): each is a pass whether
+present or absent, present naming it available, absent noting it as an optional integration
+never installed by doctor. Scope options:
+
+- No argument (`:all`): checks all stores (global and all project stores), QMD reachability
+  unscoped across every collection.
+- `global`: checks only the global store, QMD scoped to `plastic-global`, no tool-readiness
+  checks (code-navigation tools have no meaning against the global store).
+- A project slug (e.g. `--store plastic`): checks only that project's store, QMD scoped to
+  `plastic-<slug>`, plus Serena/Enola readiness for that project.
+
+Produces three-state results (pass / warn / fail) and is run per-scope at dashboard load time:
+the global board uses `--store global`, a project board uses `--store <slug>`. **This IS the
+load-time full project check** named by 219's doctrine: no separate mechanism exists or is
+needed, since a project slug's scan already carries every per-project finding scoped to that
+project alone.
 
 ### Full doctor (no flag)
 
-Runs core plus all store checks plus deprecation checks. This is what `/plastic-doctor`
-invokes. It also runs automatically after every `plastic-update` (informational,
-does not block or revert the update).
+Runs the install-wide surface: agent registration, core files (including config-honoring
+drift), manifest sync is core-only and not part of this run, deprecation checks, config-ask
+checks, install-integrity checks, skill-lint (advisory), QMD reachability (unscoped, every
+collection), and the global store's own conventions/done-signals content. **Never carries a
+per-project finding**; that is `--store <slug>`'s job (see above). This is what
+`/plastic-doctor` invokes, and it also runs automatically after every `plastic-update`
+(informational, does not block or revert the update).
 
 ## When to Use
 
@@ -125,6 +156,7 @@ Use the `fix_hint` value to determine the correct action:
 | "Inject the missing required frontmatter field(s)" | Edit the intent's `{ID}--{slug}.md` frontmatter to add the missing key (e.g. `chain: []`) without touching other keys |
 | "Run: provision-project-store {slug}" | Run `provision-project-store <slug>` (or invoke the `plastic-store-provisioning` skill) to create the missing store |
 | "Re-run installer" | Run `npx -y @zalom/plastic@<channel> install --agent <agent>` (channel: -alpha->@alpha, -beta->@beta, else @latest) |
+| "Run the Plastic installer to bootstrap the store" | Run `npx -y @zalom/plastic@<channel> install --agent <agent>` (channel: -alpha->@alpha, -beta->@beta, else @latest) to restore the global store's plastic_home directory or INDEX.md |
 | "Dispatch plastic-store-curating ... revisions.md ..." | Invoke the `plastic-store-curating` (or the agent) to relocate the flagged section or ref into the intent's `revisions.md` via move-and-record (one dated, `[rule: <tag>]`-tagged entry per item), per PLASTIC.md > Structural maintenance and revisions.md. For a missing required section, restore or reproject it instead. |
 | "Run scripts/project-links ... PRESERVES ... --drop-unbacked-links" | Run `ruby ~/.plastic/scripts/maintenance-run --tool project-links --intent <id> --apply` for the one flagged id (never run bare `project-links` against a real store outside the rare owner-approved batch exception, D2) |
 

package/skills/intent-ending/SKILL.md

@@ -52,9 +52,18 @@ for orchestrator-owned or completion-tracking items.
    the gate.
 2. Confirm every acceptance criterion in spec.md is verifiable (tests pass,
    or the manual check described in its HOW line was actually run).
-3. If checklist.md still has an unchecked box, stop here. Finish it first
-   (tick it if the described work is actually done, or do the remaining
-   work); do not attempt outcome.md and fight the gate's deny.
+3. The structure gate (intent 222) now enforces this: `scripts/end-intent`
+   refuses with exit 6 and names the exact unchecked box (or any other
+   structural gap: intent-file validity, lifecycle-artifact presence,
+   `## Links` projection). On a refusal, fix via the OWNING tool, never a
+   hand edit of the check's own output:
+   - checklist/outcome content - finish it yourself, the same as before.
+   - links projection - `scripts/project-links --intent <id> --apply` via
+     `maintenance-run`.
+   - a savepoint issue - advisory only (WARN, never blocks): run
+     `plastic-intent-savepoint` to rebuild via `Bridge.rebuild_savepoint` if
+     you want it clean, but it never refuses the close on its own.
+   Then re-run `scripts/end-intent`.
 
 ### Step 1-5. Run `scripts/end-intent`
 
@@ -78,9 +87,10 @@ ruby ~/.plastic/scripts/end-intent \
   --index-note "<rich Completed/Abandoned entry description>"
 ```
 
-This does all of steps 1-5 in order: guards outcome.md (refuses a missing,
-still-placeholder, or wrong-disposition file with exit 2 and authors
-nothing), stamps the intent file's `## Outcome` section, moves the INDEX.md
+This does all of steps 1-5 in order: guards outcome.md (a missing or
+still-placeholder file is caught by the structure gate first and exits 6; a
+wrong-disposition file exits 2; either way it authors nothing), stamps the
+intent file's `## Outcome` section, moves the INDEX.md
 line from `## Active` to `## Completed` or `## Abandoned` (dated today,
 idempotent, accepting either a real em dash or a plain hyphen as the id/
 title separator on read while always emitting the real em dash on write)

package/templates/agents.md

@@ -7,6 +7,14 @@
 
 You are working on this project as part of a strategic intent. Your governing intent is tracked in the global Plastic store at `~/.plastic/store/`.
 
+## Tools
+
+Plastic detects the tools it can use to work faster on this project: QMD (search this
+project's intent store instead of grep), and Serena or Enola (symbolic code navigation
+instead of grep). None is required. Whichever are present, their readiness is checked every
+time this project loads (`doctor --store <slug>`), so working through Plastic on this project
+means preferring a detected tool's own search or navigation over a generic file scan.
+
 ## How to Work
 
 1. **Check active tactical intents** in `.plastic/store/` — these are your current tasks

package/scripts/lib/legacy_bookend_amnesty.rb

@@ -1,35 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-# Intent 170a - A2 cutoff amnesty for the legacy savepoint Done-bookend gap.
-#
-# Frozen 2026-07-10. Pre-161 terminal intents predate
-# Bridge.append_terminal_savepoint, so their savepoint.md never got a
-# `Done delivered|abandoned` line. This list grandfathers exactly those,
-# keyed by store scope plus intent id, so doctor's signals_complete check
-# stops counting them as gaps. Every intent NOT on this list still warns if
-# its savepoint lacks the Done bookend, including any new terminal intent
-# going forward. This is a frozen historical snapshot: it must never grow.
-# Regenerating it requires re-running the exact predicate below against the
-# real store and reviewing the diff, never appending ad hoc.
-#
-# Predicate used to build this list (2026-07-10): for each store in
-# Doctor#done_signal_stores(nil), each dir in index_sections_by_dir(index),
-# terminal = the dir's INDEX section is Completed or Abandoned, gap =
-# savepoint.md exists AND does not match
-# /\bDone\b.*\b(delivered|abandoned)\b/.
-#
-# This does NOT grandfather the separate outcome.md completeness gap
-# (checked independently at scripts/doctor.rb:603-607); some of these ids
-# may still warn on that axis.
-module LegacyBookendAmnesty
-  LIST = {
-    "global" => %w[1a 1a2 23].freeze,
-    "project:plastic" => %w[
-      1 11 121a 124 128 13 13b 15 158 158a 159 160 163 1a 1b1a3 22 30a1a 34
-      36a 36a1 37 38 39 45 45a 49 4a 4a1 4a1c1 50 52 54 55 56 58 59 60b 65
-      66 66a 66b 66c 66c1 67 68 71 72 73b 73c 73c1 73c2 73c3 74 77 79 80 83
-      84 85a 9
-    ].freeze,
-  }.freeze
-end