scar-cli 0.25.0__tar.gz → 0.26.0__tar.gz

scar_cli-0.26.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.26.0"
+}

scar_cli-0.26.0/.scars/0012-firing-log-readers-need-blanket-guards.landmine.md

@@ -0,0 +1,42 @@
+---
+id: 12
+type: landmine
+title: firing-log.jsonl has one reader: read through read_firing_log_records, never hand-roll, distrust slice math
+severity: high
+confidence: 0.85
+created: 2026-07-02
+authors: ["claude-code", "kibukx"]
+anchors:
+  - path: src/scar/firing_log.py
+  - path: src/scar/gc.py
+  - pattern: "firing_log_path\("
+violation: "except \((KeyError|TypeError|ValueError|AttributeError|IndexError)[^)]*\)"
+evidence:
+  - pr: 122
+  - issue: 124
+  - issue: 312
+expires:
+  condition: "the shared reader validates field types (ts is a string, scar_ids is a list), not only row shape, so callers stop re-guarding fields"
+  review_after: 2027-03-01
+status: active
+---
+
+The firing log is append-only JSONL written best-effort from a hook that must
+never fail, so ANY line shape can and will appear: `null`, `[]`, numbers,
+truncated JSON, non-string `ts`, non-list `scar_ids`. Three bugs shipped from
+that fact in two days (PR #122, issue #124):
+
+1. Narrow per-line except tuples let `ts: null` (TypeError) and bare `null`
+   lines (AttributeError at `rec.get`) escape a reader into precheck's outer
+   fail-open, killing injection silently and PERMANENTLY.
+2. `lines[-max_firings:]` with 0 is `[-0:]`, the whole list, while the report
+   arithmetic claimed everything was dropped (issue #124).
+
+Since #312 both rules live in ONE place: `read_firing_log_records` in
+`src/scar/firing_log.py` (blanket `except Exception` per line, `tail == 0`
+special-cased, negative tail refused). Rule now: every new reader calls it.
+Do not parse the log by hand anywhere else. When editing the reader itself,
+keep the blanket guard. It checks row SHAPE only (dicts kept), so callers
+must still treat every field as untrusted. `gc.py` counts and truncates raw
+lines on purpose (a malformed line still counts); keep its slice math
+special-casing 0, and verify report numbers against the file, not arithmetic.

scar_cli-0.26.0/.scars/candidates/violation-evidence-must-not-persist-raw-edits.md

@@ -0,0 +1,28 @@
+---
+id: 0
+type: fence
+title: Violation evidence omits raw edits deliberately because excerpts can contain secrets
+severity: high
+confidence: 0.9
+created: 2026-11-05
+authors: ["codex"]
+anchors:
+  - path: src/scar/violation_evidence.py
+  - path: src/scar/hooks.py
+evidence:
+  - issue: 317
+expires:
+  condition: "a reviewed capture design can retain original edits without exposing arbitrary secrets"
+status: candidate
+---
+
+The display excerpt is arbitrary edited content, not safe log text (#317).
+Truncating to 120 characters can retain an entire credential. The shared
+verdict writer therefore persists a bounded summary, never the raw excerpt
+or violation regex. Do not add either string to make the log more readable.
+Capture positions and fingerprints from the original regex match; searching
+the truncated excerpt again can miss the actual match on a long line.
+Hashes still permit guessing low-entropy content, so the log remains sensitive.
+A summary needs an independently retained edit for review; it is not a
+confirmed true positive. Old rows without evidence must stay unknown, never
+be backfilled from current files or current scar definitions.

{scar_cli-0.25.0 → scar_cli-0.26.0}/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [0.26.0](https://github.com/Daily-Nerd/Scar/compare/v0.25.1...v0.26.0) (2026-11-06)
+
+
+### Features
+
+* **firing-log:** capture bounded violation evidence at match time ([#349](https://github.com/Daily-Nerd/Scar/issues/349)) ([9789b37](https://github.com/Daily-Nerd/Scar/commit/9789b370d78e3590abed69bee249db42e0baa2b0))
+* **lint:** opt-in --fail-partial-rot gate ([#355](https://github.com/Daily-Nerd/Scar/issues/355)) ([aa0346b](https://github.com/Daily-Nerd/Scar/commit/aa0346b3ed18f9968df27619d53b9bf766f5d344)), closes [#353](https://github.com/Daily-Nerd/Scar/issues/353)
+
+
+### Bug Fixes
+
+* **promote:** derive the active filename from one shared slug normaliser ([#356](https://github.com/Daily-Nerd/Scar/issues/356)) ([04e8def](https://github.com/Daily-Nerd/Scar/commit/04e8defd70b59f135e6cf0a0d3c90ba99efa9805)), closes [#352](https://github.com/Daily-Nerd/Scar/issues/352)
+
+## [0.25.1](https://github.com/Daily-Nerd/Scar/compare/v0.25.0...v0.25.1) (2026-10-07)
+
+
+### Bug Fixes
+
+* **lint:** name a flow-style anchors list as the cause, and list the four anchor kinds in the unsupported-kind warning ([#344](https://github.com/Daily-Nerd/Scar/issues/344)) ([#346](https://github.com/Daily-Nerd/Scar/issues/346)) ([03c632c](https://github.com/Daily-Nerd/Scar/commit/03c632cf1e92415d2c3e052deaf34194e4d311de))
+* **orphan:** report a dead symbol anchor as partial rot when another anchor is still live ([#345](https://github.com/Daily-Nerd/Scar/issues/345)) ([4d26d61](https://github.com/Daily-Nerd/Scar/commit/4d26d6120e7b46b3c273a23c6b827a22d2833cab)), closes [#343](https://github.com/Daily-Nerd/Scar/issues/343)
+
 ## [0.25.0](https://github.com/Daily-Nerd/Scar/compare/v0.24.0...v0.25.0) (2026-10-06)
 
 

{scar_cli-0.25.0 → scar_cli-0.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: scar-cli
-Version: 0.25.0
+Version: 0.26.0
 Summary: SCAR — version control for negative knowledge (deadends, fences, landmines)
 License: MIT
 License-File: LICENSE
@@ -118,6 +118,7 @@ CI without pre-commit:
 - uses: Daily-Nerd/Scar@main   # or pin a tag, e.g. @v0.11.0 (release-please)
   with:
     fail-orphans: 'true'   # default; set 'false' to only fail on parse errors
+    fail-partial-rot: 'false'   # opt in; also fail when a scar has a dead anchor among live ones
     version: ''             # empty = latest scar-cli from PyPI; or pin e.g. '0.11.0'
     args: ''                # extra args appended to `scar lint`
 ```

{scar_cli-0.25.0 → scar_cli-0.26.0}/README.md

@@ -103,6 +103,7 @@ CI without pre-commit:
 - uses: Daily-Nerd/Scar@main   # or pin a tag, e.g. @v0.11.0 (release-please)
   with:
     fail-orphans: 'true'   # default; set 'false' to only fail on parse errors
+    fail-partial-rot: 'false'   # opt in; also fail when a scar has a dead anchor among live ones
     version: ''             # empty = latest scar-cli from PyPI; or pin e.g. '0.11.0'
     args: ''                # extra args appended to `scar lint`
 ```

{scar_cli-0.25.0 → scar_cli-0.26.0}/SCAR-FORMAT.md

@@ -13,10 +13,14 @@ remove or re-type the fields below.
 ├── template.md                    # copy-me — not a scar (status: template)
 ├── NNNN-<slug>.<type>.md          # active/archived scars, NNNN zero-padded
 └── candidates/
-    ├── <slug>.md                  # proposed scars awaiting human review
-    └── fp-log.txt                 # self-reported false triggers (free text)
+    └── <slug>.md                  # proposed scars awaiting human review
 ```
 
+Self-reported false triggers (free text, one dated line each) are not repo
+content. The reference tool keeps them per machine in its state directory,
+`<state dir>/fp-log-<sha1 of the resolved repo path>.txt`; `scar gc` prints
+the exact path.
+
 Files named `README.md`/`template.md` (case-insensitive) or prefixed `_` are
 never parsed as scars. The directory is `.scars` — plural, exactly.
 

{scar_cli-0.25.0 → scar_cli-0.26.0}/SPEC.md

@@ -75,7 +75,7 @@ Four anchor classes, used in combination:
 
 1. **Path anchors** — file or directory prefixes. A directory with a trailing slash or a file path both work; wildcards are not expanded. Cheap, survive content change, die on rename (mitigated by git rename tracking during re-anchor).
 2. **Symbol anchors** — function/class/method names resolved via tree-sitter. Survive moves within and across files in the same repo. Primary anchor class for fences.
-   For orphan detection (#337) a symbol anchor is live while its definition resolves: `path::name` in that file, a bare name in any tracked file the `[symbols]` extra can parse. Without the extra it cannot be checked, so it holds the scar alive the way a command anchor does, and `scar lint` prints one `symbols-unchecked` hint per run.
+   For orphan detection (#337) a symbol anchor is live while its definition resolves: `path::name` in that file, a bare name in any tracked file the `[symbols]` extra can parse. Without the extra it cannot be checked, so it holds the scar alive the way a command anchor does, and `scar lint` prints one `symbols-unchecked` hint per run. A symbol anchor that resolves nowhere is also reported as partial rot (#343) when another anchor of the same scar is still live, and `scar lint --json` lists it in `partial_rot[].dead_symbol_anchors`.
 3. **Pattern anchors** — regex/AST patterns over *new* code (diff-scoped, not whole-repo). The only anchor class that can catch a dead end being re-attempted in a brand-new file. Powers `deadend` enforcement.
 4. **Command anchors** (#175) — regexes over a *shell command about to execute* (`PreToolUse:Bash` and `scar inject --command`). The only anchor class with a firing surface for run-a-command mistakes — knowledge like "bare `uv sync` strips extras" has no edit to anchor to. Never matched against paths or content (structurally immune to self-match/partial-rot) and exempt from content liveness; `review_after` is the freshness mechanism.
 
@@ -137,6 +137,7 @@ candidate ──promote──▶ active ──challenge──▶ challenged
 - Confidence is a static, human-authored ranking weight (0..1); the tool does not currently mutate it. Dynamic confidence — decay toward a floor without confirmations, an uphold bump on a survived challenge, and an explicit `scar confirm <id>` — is deferred until scar volume and confirmation data can calibrate a decay policy without unvalidated constants (issue #95).
 - `review_after` forces periodic human contact with old scars; CI can warn on overdue reviews.
 - `review_after_firings` is the count-based sibling of `review_after`: once a scar has fired N times *since the last commit that touched its file*, `scar status` and `scar lint` escalate it from an ambient warning to an explicit review flag. Revising the scar re-affirms it and restarts the count; archiving it silences the flag because archived scars do not fire. Absent ⇒ per-type default (`landmine` 10, `fence` 15, `deadend` disabled); `0` ⇒ never escalate. Advisory by default — `scar lint --fail-firing-review` opts into a non-zero exit. Escalation reports only; it never archives or challenges a scar (ADR-4 keeps lifecycle transitions human).
+- Partial rot (a dead anchor on a scar whose other anchors still live) is advisory by default. `scar lint --fail-partial-rot` opts into a non-zero exit when any is found, and the GitHub Action exposes it as the `fail-partial-rot` input (default `false`). It is independent of `--fail-orphans`: neither implies the other. Partial rot is computed from git, so when git is unavailable the list is empty and the gate passes, matching `--fail-orphans` (#91).
 - When the reset point cannot be determined (untracked scar file, or no git history), the count reported is a **lifetime** count and says so. A since-revision count and a lifetime count are different quantities and must never share one label.
 - Archive keeps everything: SCAR's own history is negative knowledge.
 
@@ -231,7 +232,7 @@ Top-level keys, and the keys of each object inside the listed arrays.
 | `sweep` | `files` int (tracked files swept), `skipped` int (tracked files with no readable content: oversized or binary), `scars` int (scars armed on at least one swept file), `hits` array | `hits[]`: `id` int, `type`, `severity`, `title`, `source` (scar file, repo-relative), `path`, `line` int (1-based), `excerpt` |
 | `why` | `path` str, `records` array | `records[]`: `id`, `type`, `status`, `title`, `file`, `body` |
 | `stats` | `repo` str, `total_firings` int, `per_scar` array, `most_fired` int, `last_fired` str, `never_fired` array of int, `demotions` int, `demotions_path_only` int, `demotions_cooldown` int, `demotions_reason_unknown` int, `census_known` int, `census_unknown` int, `cofires_per_edit` float **or null**, `edits_multi_fire` int, `path_only_ratio` float **or null**, `edits_observed` int, `injection_rate` float **or null**, `retrieval_misses` int **or null**, `instrument_disconnected` bool, `posttool_silent` bool, `last_fired_age_days` int, `armed_firings` int, `armed_unknown` int, `verdicts_expected` int, `verdicts_observed` int, `verdicts_unresolved` int, `verdicts_unplaceable` int, `firings_block_capable` int, `firings_advisory` int, `firings_block_unknown` int, `all_firings_advisory` bool, `firings_context_known` int, `firings_context_unknown` int, `command_firings` int, `firings_kind_unknown` int, `advisories` array. `window` object **only when `--since`/`--until` is given** | `per_scar[]`: `id`, `count`, `violations`. `window`: `since`, `until`, `excluded_undated` |
-| `gc` | `removed_markers` int, `dropped_firings` int, `dry_run` bool, `candidates` array, `fp_log` object | `candidates[]`: `name`, `age_days`. `fp_log`: `present`, `size`, `lines` |
+| `gc` | `removed_markers` int, `dropped_firings` int, `dry_run` bool, `candidates` array, `fp_log` object | `candidates[]`: `name`, `age_days`. `fp_log`: `present`, `size`, `lines`, `path` (the state-dir log, #341), `legacy` (`null`, or `path` + `lines` of a leftover `.scars/candidates/fp-log.txt`) |
 | `orphan` | `orphan_detected`, `partial_rot` arrays | — |
 | `reanchor` | `proposals`, `pattern_diagnostics` arrays | — |
 | `draft-check` | `triggered` bool, `revert_language`, `revert_commits`, `reset_hard`, `churn` ints. `message` str **only when `triggered` is true** | — |
@@ -239,6 +240,13 @@ Top-level keys, and the keys of each object inside the listed arrays.
 `gc` mutates state. A consumer that only wants to observe MUST pass
 `--dry-run`; `dry_run` echoes back which mode ran.
 
+`stats` also guarantees integer `violation_evidence_summarized` and
+`violation_evidence_unknown` keys, including in each `--all-repos` group.
+They count individual violations, not rows: a row with two violated scars
+contributes two. Summarized means a valid write-time summary exists; unknown
+means missing, malformed, or an unsupported summary format. Neither means
+adjudicated. See §9.11 for the capture policy and its limits.
+
 `stats.armed_firings` counts firings on scars that carried a `violation:`
 tripwire at the moment they fired; `armed_unknown` counts firings on log rows
 written before that was recorded. A scar with no tripwire can never be recorded
@@ -496,3 +504,53 @@ ones that reach `main` wrong.
 `scar hook install` and `scar skill install` without `--runtime` detect hosts (claude, codex, windsurf, cursor, opencode) by config directory or binary on PATH, and resolve for each the channel that already serves it: `settings` (Scar's own entries in the host's hook file), `plugin` (the scar marketplace plugin installed and not disabled), or `none`. windsurf is repo-scoped: its hooks file is written into the working repo, so the binary on PATH counts only when that repo is inside a git repository. On a terminal, one question per present, wirable, unserved host, default no. Without a terminal, exactly one such host is installed; zero or several means the commands are printed and nothing is written. Zero detected hosts says so, rather than naming the plugin. `--all` wires every such host. `--runtime claude` on a Claude Code already served by the plugin refuses unless `--force`. `--all` and `--force` apply to `install` only, and `--force` applies to `--runtime claude` only. A missing or unreadable plugin registry never counts as `plugin`.
 
 Two rules differ for the skill kind. windsurf is not repo-scoped there: its global skills live under home (`~/.codeium/windsurf/skills`), so the binary on PATH counts on its own, with no git-repo guard. And `scar skill install --runtime <host>` refuses, exit 1, when detection does not find that host on the machine, rather than creating a skill directory nothing reads. Every destination resolves through the same home the detection pass used, and the Codex destination honours `$CODEX_HOME`, so a reported success always names a directory the detected host actually reads.
+
+### 9.11 Violation evidence is captured at match time
+
+Claude Code, Codex, and Windsurf use one verdict writer. New verdict rows
+carry `violation_evidence`, keyed by the string scar id, alongside the existing
+`violation_ids`. Each violated scar contributes one bounded `summary-v1`
+object describing its first regex match on that edited target:
+
+| Field | Meaning |
+|---|---|
+| `format` | `summary-v1`; consumers must not interpret an unknown format as this one |
+| `pattern_sha256` | SHA-256 of the exact violation regex used at capture time |
+| `match_sha256` | SHA-256 of the full matched substring, even when it falls outside the display excerpt |
+| `excerpt_sha256` | SHA-256 of the same at-most-120-character line prefix used for display |
+| `line`, `column` | 1-based character position of the match start in the adapter's scanned edit buffer |
+| `match_chars`, `excerpt_chars` | Character lengths, not byte lengths; zero-length regex matches are valid |
+| `excerpt_truncated` | Whether that line in the scanned buffer exceeded 120 characters |
+
+The evidence is derived from the same regex match as the verdict, not from a
+second search on a truncated excerpt or a later read of the target. The matcher
+scans at most the first 65,536 characters, as before. Positions describe that
+buffer, **not file line numbers**: adapters combine edits or patch additions,
+and may insert joining whitespace. Truncation describes only the captured
+buffer, not text beyond the scan cap. Digests use UTF-8 with `surrogatepass`
+for lone surrogate characters accepted from JSON payloads.
+
+**Privacy tradeoff:** no edited text or regex text is persisted in the summary.
+The display excerpt can contain credentials, and limiting it to 120 characters
+is not redaction. This implementation deliberately chooses structured summaries
+instead of claiming an incomplete secret filter makes arbitrary source safe.
+Hashes are not encryption or anonymization: low-entropy values can be guessed
+and compared. The machine-global log still contains repository and target paths;
+it remains sensitive local state and must not be published unreviewed.
+
+**Audit limit:** a reviewer with an independently retained edit and regex can
+compare their hashes and positions with the captured summary. A summary alone
+cannot recover the source or decide whether a match was a real violation, a
+quoted example, or another false positive. `violation_evidence_summarized`
+therefore never means "adjudicated" or "confirmed violation". Stats report the
+summarized and unknown counts separately, with this limitation in human output.
+
+Clean observed verdicts carry an empty evidence object. Legacy rows without
+evidence remain unknown for every recorded violation; missing or malformed
+per-scar entries are also unknown. Reads never backfill from present-day code,
+Git history, or current scar definitions. Old rows and existing violation counts
+remain unchanged. Codex multi-file edits retain a separate verdict and evidence
+map for each target. Files under `.scars/` remain eligible for matching other
+scars; there is no blanket directory exclusion. Logging remains best-effort:
+failure to append cannot block an edit, and a failed write does not claim that
+evidence was recorded.

{scar_cli-0.25.0 → scar_cli-0.26.0}/action.yml

@@ -7,6 +7,10 @@ inputs:
     description: "Exit non-zero when any scar is orphan-detected (passes --fail-orphans)."
     required: false
     default: 'true'
+  fail-partial-rot:
+    description: "Exit non-zero when any scar has a dead anchor among live ones (passes --fail-partial-rot). Passes when git is unavailable."
+    required: false
+    default: 'false'
   version:
     description: "scar-cli version to install (PyPI version specifier, e.g. '0.11.0'). Empty = latest."
     required: false
@@ -40,6 +44,9 @@ runs:
         if [ "${{ inputs.fail-orphans }}" = "true" ]; then
           set -- "$@" --fail-orphans
         fi
+        if [ "${{ inputs.fail-partial-rot }}" = "true" ]; then
+          set -- "$@" --fail-partial-rot
+        fi
         if [ -n "${{ inputs.args }}" ]; then
           set -- "$@" ${{ inputs.args }}
         fi

{scar_cli-0.25.0 → scar_cli-0.26.0}/plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "scar",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "description": "SCAR — version control for negative knowledge (deadends, fences, landmines)",
   "hooks": {
     "PreToolUse": [

{scar_cli-0.25.0/src/scar → scar_cli-0.26.0/plugin}/skills/scar-authoring/SKILL.md

@@ -75,6 +75,9 @@ A file without `---`-fenced YAML frontmatter is **not a scar at all** — it nev
 fires. Minimum valid block: `type`, `title`, `severity`, `confidence`,
 `created`, `authors`, at least one `anchors` entry, and `status: candidate`.
 
+Write `anchors` as a block list, one `- kind: value` line per anchor. A flow-style
+list (`anchors: [...]`) is not read, so the scar loads with no anchors.
+
 ## Anti-Over-Escape (the #1 silent failure)
 
 Prefer a `path:` anchor — it cannot self-match and needs no escaping. If you

{scar_cli-0.25.0 → scar_cli-0.26.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "scar-cli"
-version = "0.25.0"
+version = "0.26.0"
 description = "SCAR — version control for negative knowledge (deadends, fences, landmines)"
 readme = "README.md"
 requires-python = ">=3.10"

{scar_cli-0.25.0 → scar_cli-0.26.0}/src/scar/cli.py

@@ -51,7 +51,8 @@ from .reanchor import (
 )
 from .render import injection_context, label_line, rule_line
 from .renames import apply_anchor_rewrite, apply_rename_fix
-from .store import ScarStore, init_scars
+from .store import ScarStore, init_scars, sanitize_signal_text, slugify
+from .violation_evidence import is_violation_summary
 from . import output
 
 
@@ -124,9 +125,8 @@ def _dead_anchor_summary(finding) -> str:
             _dead_path_text(finding, p) for p in finding.dead_path_anchors))
     if finding.dead_pattern_anchors:
         dead.append("patterns: " + ", ".join(f"/{p}/" for p in finding.dead_pattern_anchors))
-    # Symbol anchors that resolve nowhere (#337). getattr: only OrphanFinding
-    # carries the field, partial rot does not check symbols.
-    dead_symbols = getattr(finding, "dead_symbol_anchors", None)
+    # Symbol anchors that resolve nowhere (#337, #343 for partial rot).
+    dead_symbols = finding.dead_symbol_anchors
     if dead_symbols:
         dead.append("symbols: " + ", ".join(
             f"{s} no longer resolves" for s in dead_symbols))
@@ -155,7 +155,7 @@ def _orphan_reason(finding) -> str:
     """Human description of why a finding is an orphan — distinguishes a scar
     with NO anchors (protects nothing) from one whose every anchor went dead."""
     if (not finding.dead_path_anchors and not finding.dead_pattern_anchors
-            and not getattr(finding, "dead_symbol_anchors", None)):
+            and not finding.dead_symbol_anchors):
         return "no anchors — scar protects nothing"
     return ("all anchors dead (" + _dead_anchor_summary(finding) + ")"
             + _violation_migration_hint(finding))
@@ -476,12 +476,32 @@ def _gc_rich(data: dict, *, days: int, max_firings: int, state_dir: Path) -> Non
     else:
         console.print("[dim]0 candidates pending review[/]")
 
-    fp_log = data["fp_log"]
+    from rich.markup import escape
+
+    for line in _fp_log_lines(data["fp_log"]):
+        # soft_wrap: the path and the mv hint must stay copy-pasteable.
+        console.print(f"[dim]{escape(line)}[/]", soft_wrap=True)
+
+
+def _fp_log_lines(fp_log: dict) -> list[str]:
+    """The fp-log lines `scar gc` prints, shared by plain and rich output:
+    count plus path (#341), then a move hint while a pre-#341 in-repo file
+    is still around. gc never moves it; the human runs the command."""
+    import shlex
+
     if fp_log["present"]:
-        console.print(f"[dim]fp-log.txt: {fp_log['lines']} line(s), {fp_log['size']} byte(s) "
-                      "— drafter-precision instrument data, not auto-cleaned[/]")
+        lines = [f"fp-log: {fp_log['lines']} line(s), {fp_log['size']} byte(s) "
+                 f"in {fp_log['path']}: drafter-precision instrument data, "
+                 "not auto-cleaned"]
     else:
-        console.print("[dim]fp-log.txt: not present[/]")
+        lines = [f"fp-log: not present ({fp_log['path']})"]
+    # TODO(#341): drop the legacy hint one release after 0.25.x.
+    legacy = fp_log.get("legacy")
+    if legacy:
+        lines.append(f"legacy fp-log.txt ({legacy['lines']} line(s)) is still in the "
+                     f"repo; move it: mv {shlex.quote(legacy['path'])} "
+                     f"{shlex.quote(fp_log['path'])}")
+    return lines
 
 
 def _orphan_rich(findings, partial) -> None:
@@ -726,7 +746,9 @@ def _cmd_lint(args) -> int:
         "findings": [{"file": rel, "level": fi.level, "message": fi.message}
                      for rel, fs in findings_by_file for fi in fs],
         "orphans": [{"scar_id": of.scar_id, "reason": _orphan_reason(of)} for of in orphans],
-        "partial_rot": [{"scar_id": pr.scar_id, "reason": _partial_rot_reason(pr)} for pr in partial],
+        "partial_rot": [{"scar_id": pr.scar_id, "reason": _partial_rot_reason(pr),
+                         "dead_symbol_anchors": list(pr.dead_symbol_anchors)}
+                        for pr in partial],
         "symbol_drift": [{"scar_id": d.scar_id, "symbol": d.symbol,
                           "sha": d.sha, "similarity": d.similarity} for d in drift],
         "revivals": [{"scar_id": r.scar_id, "predicate": r.predicate} for r in revivals],
@@ -749,7 +771,8 @@ def _cmd_lint(args) -> int:
         for of in orphans:
             print(f"WARNING orphan-detected: scar #{of.scar_id} — {_orphan_reason(of)}")
         # partial rot (#35): firing scars with a dead anchor among live ones.
-        # Advisory only — never a blocking gate, even under --fail-orphans.
+        # Advisory by default; --fail-partial-rot opts into a blocking gate.
+        # --fail-orphans does not imply it (the two gates are independent).
         for pr in partial:
             print(f"HINT partial-rot: scar #{pr.scar_id} — {_partial_rot_reason(pr)} "
                   "— re-anchor to restore full coverage")
@@ -793,6 +816,8 @@ def _cmd_lint(args) -> int:
         return 1
     if orphans and getattr(args, "fail_orphans", False):
         return 1
+    if partial and getattr(args, "fail_partial_rot", False):
+        return 1
     if reviews and getattr(args, "fail_firing_review", False):
         return 1
     return 0
@@ -1657,6 +1682,7 @@ STAGE_KEYS = frozenset({"retrieval_misses", "demotions",
                         "edits_observed", "injection_rate",
                         "command_firings", "firings_kind_unknown",
                         "armed_firings", "armed_unknown",
+                        "violation_evidence_summarized", "violation_evidence_unknown",
                         "firings_block_capable", "firings_advisory",
                         "firings_block_unknown", "all_firings_advisory",
                         "firings_context_known", "firings_context_unknown"})
@@ -1778,6 +1804,12 @@ def _stage_lines(block: dict, per_scar: list[dict], total_firings: int) -> list[
     if cap_unknown:
         enforcement += (f", {cap_unknown} of unknown capability (logged "
                         "before it was recorded)")
+    evidence_summarized = block.get("violation_evidence_summarized", 0)
+    evidence_unknown = block.get("violation_evidence_unknown", 0)
+    if evidence_summarized or evidence_unknown:
+        enforcement += (f"; evidence: {evidence_summarized} summarized (no raw text), "
+                        f"{evidence_unknown} unknown (missing or invalid evidence); "
+                        "summaries alone cannot adjudicate violations")
     # #284: what the demotions are EVIDENCE of. A path-only demotion is a
     # near-miss on the file, a cooldown demotion is a content hit we chose not
     # to repeat; one blended number hides which precision story this repo
@@ -1841,6 +1873,8 @@ def _aggregate_firings(records: list[dict]) -> dict:
     from .hooks import DEMOTED_COOLDOWN, DEMOTED_PATH_ONLY  # one spelling, both sides
     counts: dict[int, int] = {}
     violations: dict[int, int] = {}
+    violation_evidence_summarized = 0
+    violation_evidence_unknown = 0
     # (scar_id, target) -> earliest firing ts, for the retrieval-miss check.
     fired_on: dict[tuple[int, str], str] = {}
     pending_violations: list[tuple[int, str, str]] = []
@@ -2022,12 +2056,18 @@ def _aggregate_firings(records: list[dict]) -> dict:
                 if isinstance(vid, int):
                     pending_violations.append((vid, target, ts_rec))
         if isinstance(vids, list):
+            evidence = rec.get("violation_evidence")
             # Guard: violation_ids might be garbage in corrupted records —
             # skip the whole record unless it's a list, and skip any
             # non-int element within it, rather than coercing or crashing.
             for vid in vids:
                 if isinstance(vid, int):
                     violations[vid] = violations.get(vid, 0) + 1
+                    summary = evidence.get(str(vid)) if isinstance(evidence, dict) else None
+                    if is_violation_summary(summary):
+                        violation_evidence_summarized += 1
+                    else:
+                        violation_evidence_unknown += 1
         # `last_fired` means LAST FIRED. Only records where a scar actually
         # fired may move it — not posttool violation records, not zero-hit
         # precheck passes. Otherwise a repo with zero firings still reports a
@@ -2108,6 +2148,8 @@ def _aggregate_firings(records: list[dict]) -> dict:
             "firings_kind_unknown": firings_kind_unknown,
             "armed_firings": armed_firings,
             "armed_unknown": armed_unknown,
+            "violation_evidence_summarized": violation_evidence_summarized,
+            "violation_evidence_unknown": violation_evidence_unknown,
             # #277: the posttool half's own liveness. `posttool_silent` is
             # ONE-DIRECTIONAL like every other health field here — it can show
             # the half is dead, and observing a verdict never certifies it
@@ -2324,9 +2366,11 @@ def _cmd_gc(args) -> int:
     """Clean machine state (~/.claude/scar-state/ or SCAR_STATE_DIR), report
     repo hygiene. Posture (#115): machine state is regenerable, so gc ACTS on
     it (deletes stale drafted-* markers, truncates firing-log.jsonl); .scars/
-    is human-gated, so gc only ever REPORTS on it — candidate ages, fp-log.txt
-    presence — never writes there (same ethos as promote/reanchor)."""
-    from .hooks import _state_dir, firing_log_path
+    is human-gated, so gc only ever REPORTS on it: candidate ages and a
+    leftover pre-#341 fp-log.txt; never writes there (same ethos as
+    promote/reanchor). The fp-log itself is state-dir data since #341 and is
+    reported, never pruned."""
+    from .hooks import _state_dir, firing_log_path, fp_log_path
     from . import gc as gc_mod
 
     store = _require_store()
@@ -2339,7 +2383,7 @@ def _cmd_gc(args) -> int:
     dropped_firings = gc_mod.truncate_firing_log(
         firing_log_path(), args.max_firings, dry_run=dry_run)
     candidates = gc_mod.candidate_ages(store)
-    fp_log = gc_mod.fp_log_report(store)
+    fp_log = gc_mod.fp_log_report(store, fp_log_path(store))
 
     data = {
         "removed_markers": len(removed_markers),
@@ -2361,11 +2405,8 @@ def _cmd_gc(args) -> int:
             print(f"    {c['name']} — {c['age_days']}d old")
         if candidates:
             print("    review with `scar promote <path>` or delete rejected files")
-        if fp_log["present"]:
-            print(f"  fp-log.txt: {fp_log['lines']} line(s), {fp_log['size']} byte(s) "
-                  "— drafter-precision instrument data, not auto-cleaned")
-        else:
-            print("  fp-log.txt: not present")
+        for line in _fp_log_lines(fp_log):
+            print(f"  {line}")
 
     output.render(data=data, json_flag=getattr(args, "json", False),
                   tty=lambda: _gc_rich(data, days=args.days,
@@ -2633,26 +2674,8 @@ _WRITE_SCAR_TYPES = {"reverts": "deadend", "deleted_components": "deadend",
                      "flapping": "fence", "comments": "fence"}
 
 
-def _sanitize_signal_text(s: str) -> str:
-    """Mined git text (revert subjects, squash-merge subjects) can carry
-    markdown links, emphasis markers, and bare URLs; leaked into a candidate
-    they make the title unreadable and a URL eats the whole slug budget (#159)."""
-    import re as _re
-    s = _re.sub(r"\[([^\]]*)\]\([^)]*\)", r"\1", s)  # [text](url) -> text
-    s = _re.sub(r"https?://\S+", "", s)
-    s = _re.sub(r"[*_`]+", "", s)
-    return " ".join(s.split())
-
-
 def _write_slug(title: str) -> str:
-    import re as _re
-    s = _re.sub(r"[^a-z0-9]+", "-", _sanitize_signal_text(title).lower()).strip("-")
-    if len(s) > 60:
-        cut = s[:60]
-        if s[60] != "-" and "-" in cut:  # sliced mid-token: drop the fragment
-            cut = cut.rsplit("-", 1)[0]
-        s = cut.rstrip("-")
-    return s or "signal"
+    return slugify(title, fallback="signal")
 
 
 def _write_anchors(repo: Path, section: str, c: dict, tracked: set[str]) -> list[str]:
@@ -2679,7 +2702,7 @@ def _write_title(section: str, c: dict) -> str:
         raw = f"Flapping value {c['key']} in {c['file']}"
     else:
         raw = "Keep-out comment in " + c["location"].split(":", 1)[0]
-    return _sanitize_signal_text(raw)
+    return sanitize_signal_text(raw)
 
 
 def _write_evidence(section: str, c: dict) -> str:
@@ -3087,6 +3110,9 @@ def build_parser() -> argparse.ArgumentParser:
     p = _add(sub, "lint", _cmd_lint, help="validate every scar and candidate")
     p.add_argument("--fail-orphans", action="store_true",
                    help="exit non-zero when any scar is orphan-detected")
+    p.add_argument("--fail-partial-rot", action="store_true",
+                   help="exit non-zero when any scar has a dead anchor among live "
+                        "ones (passes when git is unavailable, like --fail-orphans)")
     p.add_argument("--fail-firing-review", action="store_true",
                    help="exit non-zero when any scar has crossed its "
                         "review_after_firings threshold")

{scar_cli-0.25.0 → scar_cli-0.26.0}/src/scar/draftcheck.py

@@ -32,14 +32,13 @@ GitError distinction between "no signal" and "git itself is broken").
 
 from __future__ import annotations
 
-import hashlib
 import re
 import subprocess
 import time
 from dataclasses import dataclass, field
 from pathlib import Path
 
-from .hooks import REVERT_RE
+from .hooks import REVERT_RE, fp_log_path, repo_key
 from .store import ScarStore
 
 ONE_DAY_SECONDS = 86400
@@ -96,8 +95,9 @@ def marker_key(repo: Path) -> str:
     """Stable per-repo id for marker filenames. The firing log (hooks.py
     #106) keys by a ``repo`` field inside each JSON line, not by filename —
     there's no such record here (draft-check has no log to key), so the
-    marker file itself is keyed by hashing the resolved repo path."""
-    return hashlib.sha1(str(repo.resolve()).encode("utf-8")).hexdigest()
+    marker file itself is keyed by hashing the resolved repo path. The hash
+    lives in ``hooks.repo_key`` so the per-repo fp-log (#341) shares it."""
+    return repo_key(repo)
 
 
 def lastcheck_marker(state_dir: Path, repo: Path) -> Path:
@@ -235,7 +235,8 @@ def analyze(state_dir: Path, repo: Path) -> DraftCheckResult | None:
 def contract_text(store: ScarStore, result: DraftCheckResult) -> str:
     """Mirrors ``hooks.stop_drafter``'s contract text (hooks.py ~194-225):
     same two-branch instruction (write a candidate, or log a false
-    positive), same <=15 line cap, same template/candidates paths. Adapted:
+    positive), same <=15 line cap, same template/candidates paths, same
+    state-dir fp-log path (``hooks.fp_log_path``, #341). Adapted:
     no transcript signals (git evidence instead) and the fp-log branch tells
     the agent to tag its line ``draft-check`` so drafter-precision data keeps
     the two trigger sources (transcript vs git) separable."""
@@ -251,7 +252,7 @@ def contract_text(store: ScarStore, result: DraftCheckResult) -> str:
         "mandatory, status: candidate); it stays a candidate until a human "
         "reviews it. (2) If nothing was actually abandoned (false trigger), "
         f"append one line — date + one-phrase reason — to "
-        f"{candidates}/fp-log.txt, tagged `draft-check` (e.g. '2026-07-01 "
+        f"{fp_log_path(store)}, tagged `draft-check` (e.g. '2026-07-01 "
         "draft-check: <reason>') so drafter-precision data stays separated "
         "by trigger source. Do exactly one of the two; do not ask the user."
     )