scar-cli 0.25.1__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.1 → scar_cli-0.26.0}/CHANGELOG.md

@@ -1,5 +1,18 @@
 # 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)
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: scar-cli
-Version: 0.25.1
+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.1 → 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.1 → scar_cli-0.26.0}/SPEC.md

@@ -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.
 
@@ -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.1 → 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.1 → scar_cli-0.26.0}/plugin/plugin.json

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "scar-cli"
-version = "0.25.1"
+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.1 → 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
 
 
@@ -770,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")
@@ -814,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
@@ -1678,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"})
@@ -1799,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
@@ -1862,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]] = []
@@ -2043,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
@@ -2129,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
@@ -2653,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]:
@@ -2699,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:
@@ -3107,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.1 → scar_cli-0.26.0}/src/scar/hooks.py

@@ -374,6 +374,8 @@ def _log_violation_firing(store: ScarStore, target: str, violations: list,
             "repo": str(store.root),
             "target": target,
             "violation_ids": [v.scar.id for v in violations],
+            "violation_evidence": {str(violation.scar.id): violation.evidence
+                                   for violation in violations},
             "count": len(violations),
             "runtime": runtime,
             # The posttool half ran and reached a verdict on this edit.

{scar_cli-0.25.1 → scar_cli-0.26.0}/src/scar/match.py

@@ -15,6 +15,7 @@ from pathlib import Path
 
 from .model import Scar
 from .store import ScarStore
+from .violation_evidence import summarize_match
 
 SEVERITY_WEIGHT = {"low": 1, "medium": 2, "high": 3, "critical": 4}
 DEFAULT_TOP_K = 3
@@ -409,13 +410,14 @@ class Violation:
     source: Path      # scar file relative to root
     path: str         # edited file that tripped it
     excerpt: str      # line containing the first match (trimmed ~120 chars)
+    evidence: dict
 
 
-def _violation_excerpt(pattern: str, text: str) -> str | None:
-    """First line of `text` matching `pattern`, trimmed to ~120 chars.
-    Searches the whole capped text for the pattern, then extracts the line
-    containing the match. Invalid regex -> None (lint's job; never crash the
-    read path — mirrors _pattern_anchor_matches)."""
+def _violation_details(pattern: str, text: str) -> tuple[str, dict] | None:
+    """Display excerpt and evidence from the same first match in capped text.
+
+    Invalid regex returns None, matching _pattern_anchor_matches.
+    """
     try:
         rx = re.compile(pattern, re.IGNORECASE)
     except re.error:
@@ -424,20 +426,15 @@ def _violation_excerpt(pattern: str, text: str) -> str | None:
     m = rx.search(capped)
     if m is None:
         return None
-    # Extract the line containing the match
-    line_start = capped.rfind("\n", 0, m.start()) + 1
-    line_end = capped.find("\n", m.start())
-    if line_end == -1:
-        line_end = len(capped)
-    return capped[line_start:line_end][:120]
+    return summarize_match(m)
 
 
 def _violation_lines(pattern: str, text: str) -> list[tuple[int, str]]:
     """Every (1-based line number, trimmed line) where `pattern` matches.
     Each line is reported once however many times it matches. Invalid regex ->
-    [] (lint's job; mirrors _violation_excerpt).
+    [] (lint's job; mirrors _violation_details).
 
-    Scans the WHOLE text, unlike _violation_excerpt: the 64 KiB bound belongs to
+    Scans the WHOLE text, unlike _violation_details: the 64 KiB bound belongs to
     the edit hot path, and the sweep reads files offline that are already capped
     at MAX_CONTENT_BYTES (same reasoning as _pattern_anchor_live). The ReDoS
     defense stays lint._is_redos_prone() at the gate (landmine #11)."""
@@ -495,11 +492,12 @@ def _violations_for_target(firing: list, root: Path, rel_path: str,
                            new_content: str) -> list["Violation"]:
     out: list[Violation] = []
     for scar, rel_source in _armed_candidates(firing, root, rel_path):
-        excerpt = _violation_excerpt(scar.violation, new_content)
-        if excerpt is None:
+        details = _violation_details(scar.violation, new_content)
+        if details is None:
             continue
+        excerpt, evidence = details
         out.append(Violation(scar=scar, source=rel_source,
-                             path=rel_path, excerpt=excerpt))
+                             path=rel_path, excerpt=excerpt, evidence=evidence))
     return out
 
 

{scar_cli-0.25.1 → scar_cli-0.26.0}/src/scar/mcp.py

@@ -7,7 +7,6 @@ MCP hosts can launch it with `scar mcp`.
 from __future__ import annotations
 
 import json
-import re
 import sys
 import time
 from pathlib import Path
@@ -16,7 +15,7 @@ from typing import Any
 from .lint import lint_text
 from .match import rank_matches_for_diff, rank_matches_for_paths
 from .model import Scar
-from .store import ScarStore
+from .store import ScarStore, slugify
 
 
 def _version() -> str:
@@ -95,8 +94,7 @@ def _scar_from_args(args: dict[str, Any]) -> Scar:
 
 
 def _slug(title: str) -> str:
-    slug = re.sub(r"[^a-z0-9]+", "-", title.lower()).strip("-")
-    return slug[:60] or "scar-candidate"
+    return slugify(title, fallback="scar-candidate")
 
 
 def _draft(args: dict[str, Any]) -> dict[str, Any]:

{scar_cli-0.25.1 → scar_cli-0.26.0}/src/scar/store.py

@@ -6,11 +6,51 @@ embedded so `scar init` works from a bare install with no data files.
 
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass
 from pathlib import Path
 
 from .lint import lint_text
-from .model import ParseError, Scar, parse_scar_text
+from .model import TYPES, ParseError, Scar, parse_scar_text
+
+SLUG_MAX = 60
+_TYPE_EXT_CHAIN = re.compile(r"(?:\.(?:%s))+$" % "|".join(TYPES))
+
+
+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)."""
+    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 slugify(text: str, fallback: str = "scar") -> str:
+    """The one slug normaliser (#352): every writer of a scar filename (promote,
+    the MCP draft tool, harvest --write) goes through here so the rules cannot
+    drift apart. Sanitise (#159), lowercase, collapse non-alnum to '-', cap at
+    SLUG_MAX without leaving a sliced-mid-token fragment."""
+    s = re.sub(r"[^a-z0-9]+", "-", sanitize_signal_text(text).lower()).strip("-")
+    if len(s) > SLUG_MAX:
+        cut = s[:SLUG_MAX]
+        if s[SLUG_MAX] != "-" and "-" in cut:
+            cut = cut.rsplit("-", 1)[0]
+        s = cut.rstrip("-")
+    return s or fallback
+
+
+def active_slug(stem: str, scar_type: str) -> str:
+    """Candidate stem -> slug for the active `NNNN-<slug>.<type>.md` name.
+    A trailing `.{type}` chain (any type) is the extension leaking into the
+    stem; a trailing `-{type}` is redundant only for the scar's own type."""
+    stem = _TYPE_EXT_CHAIN.sub("", stem)
+    slug = slugify(stem, fallback="scar")
+    suffix = "-" + scar_type
+    if slug.endswith(suffix):
+        slug = slug[: -len(suffix)] or slug
+    return slug
 
 SKIP_NAMES = {"readme.md", "template.md"}
 
@@ -268,8 +308,11 @@ class ScarStore:
         # like promoted_by itself: whatever the candidate carried here was
         # never a real vouch either.
         scar.promoted_by_source = reviewer_source if reviewer else None
-        slug = candidate.stem
+        slug = active_slug(candidate.stem, scar.type)
         new_path = self.scars_dir / f"{scar.id:04d}-{slug}.{scar.type}.md"
+        if new_path.exists():  # #352: never clobber an existing active scar
+            raise ValueError(
+                f"refusing to promote, active file already exists: {new_path.name}")
         new_path.write_text(scar.to_text(), encoding="utf-8")
         candidate.unlink()
         return new_path

scar_cli-0.26.0/src/scar/violation_evidence.py

@@ -0,0 +1,55 @@
+"""Bounded, text-free evidence captured from the original regex match."""
+
+from __future__ import annotations
+
+import hashlib
+import re
+
+
+SUMMARY_FORMAT = "summary-v1"
+EXCERPT_CHARS = 120
+
+
+def summarize_match(match: re.Match[str]) -> tuple[str, dict]:
+    """Return the display excerpt and its persistable summary, not raw text."""
+    text = match.string
+    start = match.start()
+    line_start = text.rfind("\n", 0, start) + 1
+    line_end = text.find("\n", start)
+    if line_end == -1:
+        line_end = len(text)
+    excerpt = text[line_start:line_end][:EXCERPT_CHARS]
+
+    def digest(value: str) -> str:
+        return hashlib.sha256(value.encode("utf-8", errors="surrogatepass")).hexdigest()
+
+    return excerpt, {
+        "format": SUMMARY_FORMAT,
+        "pattern_sha256": digest(match.re.pattern),
+        "match_sha256": digest(match.group()),
+        "excerpt_sha256": digest(excerpt),
+        "line": text.count("\n", 0, start) + 1,
+        "column": start - line_start + 1,
+        "match_chars": match.end() - start,
+        "excerpt_chars": len(excerpt),
+        "excerpt_truncated": line_end - line_start > EXCERPT_CHARS,
+    }
+
+
+def is_violation_summary(value: object) -> bool:
+    """Validate persisted evidence without consulting present-day source files."""
+    if not isinstance(value, dict) or value.get("format") != SUMMARY_FORMAT:
+        return False
+    for key in ("pattern_sha256", "match_sha256", "excerpt_sha256"):
+        digest = value.get(key)
+        if not isinstance(digest, str) or re.fullmatch(r"[0-9a-f]{64}", digest) is None:
+            return False
+    for key, minimum in (("line", 1), ("column", 1), ("match_chars", 0),
+                         ("excerpt_chars", 0)):
+        count = value.get(key)
+        if type(count) is not int or count < minimum:
+            return False
+    return (value["excerpt_chars"] <= EXCERPT_CHARS
+            and type(value.get("excerpt_truncated")) is bool
+            and (not value["excerpt_truncated"]
+                 or value["excerpt_chars"] == EXCERPT_CHARS))

{scar_cli-0.25.1 → scar_cli-0.26.0}/tests/test_action_yml.py

@@ -34,6 +34,7 @@ def test_action_declares_expected_inputs_with_defaults():
 
     expected_defaults = {
         "fail-orphans": "'true'",
+        "fail-partial-rot": "'false'",
         "version": "''",
         "args": "''",
     }
@@ -64,6 +65,12 @@ def test_action_uses_fail_orphans_input_conditionally():
     assert "--fail-orphans" in text
 
 
+def test_action_uses_fail_partial_rot_input_conditionally():
+    text = _text()
+    assert "inputs.fail-partial-rot" in text
+    assert "--fail-partial-rot" in text
+
+
 def test_action_forwards_extra_args_input():
     text = _text()
     assert "inputs.args" in text