scar-cli 0.3.0__tar.gz → 0.4.0__tar.gz

{scar_cli-0.3.0 → scar_cli-0.4.0}/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.4.0](https://github.com/Daily-Nerd/Scar/compare/v0.3.0...v0.4.0) (2026-06-12)
+
+
+### Features
+
+* **format:** reserve optional receipt_id field ([#29](https://github.com/Daily-Nerd/Scar/issues/29)) ([47ce933](https://github.com/Daily-Nerd/Scar/commit/47ce933cde02fa1155d0474e98101804cb7b1a80))
+
+
+### Bug Fixes
+
+* **hooks:** expose lifecycle commands ([#31](https://github.com/Daily-Nerd/Scar/issues/31)) ([dba2c0d](https://github.com/Daily-Nerd/Scar/commit/dba2c0d1c1bd8a0f73880bfab0ff17187eec2fb9)), closes [#30](https://github.com/Daily-Nerd/Scar/issues/30)
+
+
+### Documentation
+
+* **roadmap:** truth pass — gates resolved, Phase 1 shipped, Phase 2 in progress ([#26](https://github.com/Daily-Nerd/Scar/issues/26)) ([7701a97](https://github.com/Daily-Nerd/Scar/commit/7701a97610f470e7726e7f5fc86932a5101eb255))
+
 ## [0.3.0](https://github.com/Daily-Nerd/Scar/compare/v0.2.0...v0.3.0) (2026-06-12)
 
 

{scar_cli-0.3.0 → scar_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scar-cli
-Version: 0.3.0
+Version: 0.4.0
 Summary: SCAR — version control for negative knowledge (deadends, fences, landmines)
 License: MIT
 License-File: LICENSE
@@ -84,6 +84,15 @@ Wiring the Claude Code hook (auto-injects scars before any agent edit):
 
 ```bash
 scar hook install
+scar hook status
+```
+
+Hooks are advisory and are installed only by this explicit user command. To
+stop all automatic injection and drafting while keeping the repository's
+`.scars/` records:
+
+```bash
+scar hook uninstall
 ```
 
 Wiring MCP-capable agents:

{scar_cli-0.3.0 → scar_cli-0.4.0}/README.md

@@ -75,6 +75,15 @@ Wiring the Claude Code hook (auto-injects scars before any agent edit):
 
 ```bash
 scar hook install
+scar hook status
+```
+
+Hooks are advisory and are installed only by this explicit user command. To
+stop all automatic injection and drafting while keeping the repository's
+`.scars/` records:
+
+```bash
+scar hook uninstall
 ```
 
 Wiring MCP-capable agents:

scar_cli-0.4.0/ROADMAP.md

@@ -0,0 +1,48 @@
+# SCAR — Roadmap
+
+Restructured after the adversarial review (see [STRESS-TEST.md](STRESS-TEST.md)): **validation before construction**. Every phase had a kill gate decided in advance. Phase 0 and Phase 1 are complete; Phase 2 is in progress. Strategy note (2026-06-11): SCAR is published as **OSS-as-gift** — personal infrastructure shared openly, no product promises. Product work only happens if organic stranger traction appears; that decision retired gate 0.5.
+
+## Phase 0 — Kill-gate experiments ✅ complete
+
+| # | Experiment | Gate (pass/kill) | Result |
+|---|-----------|------------------|--------|
+| 0.1 | Prototype `scar harvest` (reverts, add-then-remove deps, reopened issues, comment archaeology); run on 5 real aging repos | ≥1 "I'd forgotten that" reaction per repo from someone who knows it; harvest precision subjectively >50% | ✅ **PASSED 2026-06-09** on a 7-year-old personal infra repo — owner had forgotten a service-placement deadend the harvest resurfaced; 12/12 curated candidates correct. Raw precision 13% → ranking layer remains a requirement (Phase 2). |
+| 0.2 | Prototype anchors (tree-sitter symbols + content fingerprints); replay real historical refactor commits against them | ≥80% anchor survival across rename + file-split refactors | ✅ **PASSED 2026-06-09** — 94.8% single-commit, 88.0% at 200-commit zero-maintenance horizon; naive path+line baseline 0.0% ([results](experiments/anchor-survival/RESULTS.md)) |
+| 0.3 | **Fence honor test**: hand-write fences on a real repo, wire a PreToolUse hook, A/B agent sessions hook-on vs hook-off on tasks that tempt fence-bulldozing | Hook measurably reduces fence violations without degrading task completion | ✅ **PASSED 2026-06-09** — 6/6 control violations vs 0/6 treatment ([results](experiments/fence-honor/RESULTS.md)) |
+| 0.4 | Auto-authorship trial: 2 weeks of normal agent-assisted work with the stop-hook drafting `deadend` candidates | ≥5 human-kept scars; false-positive rate <15% (skeptic's bar, adopted) | ✅ **PASSED 2026-06-11**, closed day 3 of 14 — 13 keepable agent-authored scars across 3 repos, 0% rejected. One agent-authored scar caught a real parser bug and fired on the exact edit that fixed it. Drafter *trigger* precision was tuned separately (revert-language-only) after 3 of 6 firings proved false. |
+| 0.5 | Survey 50 Claude Code / Cursor users re: Copilot Memory | Meaningful segment says no + wants repo-resident, reviewable knowledge | ⛔ **RETIRED 2026-06-11** — the OSS-as-gift decision removed the product hypothesis this gate validated. If stranger traction ever reopens the product question, this survey reopens with it. |
+| 0.6 | Implement Lore trailers on the same repo as 0.3; compare agent behavior vs scar injection | SCAR injection outperforms history-walk over trailers on latency and compliance | ⏸ **Deprioritized** — no longer gating anything; optional research. |
+
+## Phase 1 — Format + CLI (OSS) ✅ shipped
+
+Public at [github.com/Daily-Nerd/Scar](https://github.com/Daily-Nerd/Scar), `scar-cli` on PyPI. Honest deltas from the original plan:
+
+- ✅ `SCAR-FORMAT.md` v0.1 published; one parser/serializer (`model.py`), one renderer (`render.py`)
+- ✅ CLI: `init, lint, status, promote, check, why, challenge, archive, harvest, hook, mcp, agent, inject` — lifecycle commands (`challenge`/`archive`, expiry review surfacing) shipped beyond the original plan
+- ✅ Claude Code plugin: PreToolUse injection + stop-hook candidate drafting, both field-validated (gates 0.3, 0.4)
+- ⚠️ **Python, not Go/Rust** — zero-dependency stdlib hits the goal the compiled binary was chasing (~20ms hook startup, trivial install via `uv tool install scar-cli`); a rewrite is not planned unless profiling says otherwise
+- ❌ No `add` command — copy `template.md` + `scar promote` covers authoring; revisit only on user friction
+- ❌ Lore trailer ingestion in `harvest` — moved to Phase 2, optional
+- ✅ Dogfooding: 6 repos, including this one (the repo's own scars caught its own release-process bug)
+
+## Phase 2 — Ecosystem 🔄 in progress
+
+- ✅ **MCP server** (`scar_query`, `scar_why`, `scar_draft`) — shipped v0.3.0, dependency-free stdio, drafts gated to candidates/. First non-Claude agent (Codex) arrived and contributed the implementation — the deferral condition resolving itself.
+- ✅ Multi-agent surface: committed `AGENTS.md`, `scar inject --diff`, `scar agent doctor/config` for Codex, Cursor, Windsurf, opencode (v0.3.0)
+- 🔶 CI surface: expiry warnings shipped (`lint`/`status`, v0.2.0); **orphan detection is the next milestone** — content-fingerprint drift → `orphaned` status, loud in CI (principle 3 is not yet enforced by code)
+- ⬜ Harvest ranking layer (gate 0.1 verdict: required — raw precision 13% without it)
+- ⬜ Re-anchoring agent workflow: orphaned scar + orphaning diff → proposed new anchors as a PR
+- ⬜ Editor surfaces (VS Code gutter marks, LSP code lens) — fences visible to humans, not only agents
+- ⬜ Lint warning on evidence commit SHAs unreachable from HEAD (scar #5's expiry condition)
+
+## Phase 3 — The org graph ⏸ parked by design
+
+The commercial hypothesis (cross-repo aggregation, recurrence analytics, policy, managed harvest) is **parked under the OSS-as-gift decision**, not killed: it reopens only on organic adoption signal — external repos with active scars, inbound interest from strangers. "SCAR remains a free standard" was declared in advance as an acceptable ending, and it is the current operating assumption.
+
+## Non-negotiable principles carried from the stress test
+
+1. Advisory by default, forever. Blocking is opt-in, per-scar-severity, in CI only.
+2. Max 3 scars / ~120 words each injected per edit. The fatigue budget is a format-level guarantee, not a tuning knob (enforced in `render.py`).
+3. Rot must be loud. No scar ever disappears silently; orphaning is a visible state. *(Lifecycle transitions enforce this for human decisions; orphan detection — the code-drift half — is Phase 2's next milestone.)*
+4. Assume zero ongoing human maintenance; design for graceful visible decay.
+5. The format stays open and vendor-neutral even if a company forms. Platform absorption of the format = success, not failure.

{scar_cli-0.3.0 → scar_cli-0.4.0}/SCAR-FORMAT.md

@@ -47,6 +47,17 @@ is deliberate: consumers in hook hot-paths parse with zero dependencies.
 | `expires.condition` | recommended | quoted string | what change obsoletes this scar |
 | `expires.review_after` | recommended | ISO date | forces periodic freshness contact |
 | `status` | yes | `candidate` \| `active` \| `challenged` \| `archived` \| `orphaned` \| `template` | lifecycle §5 |
+| `receipt_id` | reserved | string ref | **reserved — not yet parsed.** Optional pointer to a cryptographic provenance receipt; see note below. |
+
+`receipt_id` is a forward-compatibility reservation, not a live field. Scar's
+trust model is social by design (git history, `authors`, evidence-by-reference);
+that is sufficient within one repo or org. It does **not** carry across orgs that
+share no git history — the future cross-org / org-graph layer where "this dead end
+hit N teams" must be attributable. `receipt_id` reserves the slot for a signed,
+content-addressed receipt (e.g. [veritrail](https://github.com/Daily-Nerd/veritrail))
+bound to an authorship (`scar_draft`) or promotion event. No tool emits, requires,
+or validates it today, and the line-wise parser ignores it like any unknown key —
+so existing scars are unaffected. It will not become required in v0.x.
 
 Body: prose after the frontmatter, 5–15 lines. What happened, why, what a
 future editor must do instead — written for a reader with zero context.

scar_cli-0.4.0/hook/scar-hooks.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+"""Backward-compatible wrapper for the packaged hook lifecycle commands."""
+
+import sys
+
+from scar.installer import find_scar, install, status, uninstall
+
+
+if __name__ == "__main__":
+    args = sys.argv[1:]
+    dry = "--dry-run" in args
+    cmd = next((a for a in args if not a.startswith("-")), "status")
+    sys.exit({"install": lambda: install(dry=dry),
+              "uninstall": lambda: uninstall(dry=dry),
+              "status": status}.get(cmd, status)())

{scar_cli-0.3.0 → scar_cli-0.4.0}/pyproject.toml

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

{scar_cli-0.3.0 → scar_cli-0.4.0}/src/scar/cli.py

@@ -201,6 +201,15 @@ def _cmd_agent(args) -> int:
     return 0
 
 
+def _cmd_hook_lifecycle(args) -> int:
+    from .installer import install, status, uninstall
+    if args.kind == "install":
+        return install(dry=args.dry_run)
+    if args.kind == "uninstall":
+        return uninstall(dry=args.dry_run)
+    return status()
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(prog="scar",
                                      description="version control for negative knowledge")
@@ -233,8 +242,11 @@ def main(argv: list[str] | None = None) -> int:
     p = sub.add_parser("harvest", help="mine git history for candidate scars")
     p.add_argument("repo", nargs="?", default=".")
 
-    p = sub.add_parser("hook", help="Claude Code hook handlers (payload on stdin)")
-    p.add_argument("kind", choices=["precheck", "session-notice", "stop-drafter"])
+    p = sub.add_parser("hook", help="install, remove, inspect, or run Claude Code hooks")
+    p.add_argument("kind", choices=["install", "uninstall", "status",
+                                    "precheck", "session-notice", "stop-drafter"])
+    p.add_argument("--dry-run", action="store_true",
+                   help="show lifecycle changes without writing settings")
 
     sub.add_parser("mcp", help="run the SCAR MCP stdio server")
 
@@ -256,6 +268,8 @@ def main(argv: list[str] | None = None) -> int:
         from .mcp import serve
         return serve()
     if args.command == "hook":
+        if args.kind in ("install", "uninstall", "status"):
+            return _cmd_hook_lifecycle(args)
         from .hooks import HANDLERS  # hot path: imports nothing beyond library
         return HANDLERS[args.kind]()
     if args.command in ("challenge", "archive"):

scar_cli-0.3.0/hook/scar-hooks.py → scar_cli-0.4.0/src/scar/installer.py

@@ -1,24 +1,15 @@
-#!/usr/bin/env python3
-"""SCAR hook lifecycle manager: install, uninstall, status.
+"""Claude Code hook lifecycle management.
 
-Registers the three SCAR hooks in ~/.claude/settings.json as `scar hook
-<kind>` commands (absolute path to the scar binary — hook environments do not
-guarantee PATH). Migrates installs from the legacy standalone-script era:
-their settings entries and ~/.claude/hooks/ copies are removed on install.
-
-Run BY THE USER, never by an agent (see scar 0002): consent is the execution.
-
-Usage:
-  python3 scar-hooks.py install   [--dry-run]
-  python3 scar-hooks.py uninstall [--dry-run]
-  python3 scar-hooks.py status
+The user invokes these commands explicitly. SCAR never installs global hooks
+as a side effect of package installation, ``scar init``, or an agent action.
 """
 
+from __future__ import annotations
+
 import json
 import os
 import re
 import shutil
-import sys
 import time
 from pathlib import Path
 
@@ -42,36 +33,40 @@ HOOKS = [
 
 
 def find_scar() -> str | None:
-    # scar 0003: never bind hooks to a venv shim — it dies with the venv.
-    # With $VIRTUAL_ENV active its bin/ shadows PATH, so search without it.
+    # scar 0003: never bind hooks to a venv shim that may disappear.
     venv = os.environ.get("VIRTUAL_ENV")
     if not venv:
         return shutil.which("scar")
-    venv = Path(venv).resolve()
+    venv_path = Path(venv).resolve()
     dirs = [d for d in os.environ.get("PATH", "").split(os.pathsep)
-            if d and not Path(d).resolve().is_relative_to(venv)]
+            if d and not Path(d).resolve().is_relative_to(venv_path)]
     return shutil.which("scar", path=os.pathsep.join(dirs))
 
 
-def load_settings():
+def load_settings() -> dict:
     return json.loads(SETTINGS.read_text(encoding="utf-8")) if SETTINGS.exists() else {}
 
 
-def save_settings(settings, dry):
+def save_settings(settings: dict, dry: bool) -> None:
     if dry:
         return
-    backup = SETTINGS.with_name(f"settings.json.scar-backup-{int(time.time())}")
-    shutil.copy2(SETTINGS, backup)
+    CLAUDE_DIR.mkdir(parents=True, exist_ok=True)
+    if SETTINGS.exists():
+        backup = SETTINGS.with_name(f"settings.json.scar-backup-{int(time.time())}")
+        shutil.copy2(SETTINGS, backup)
+        backup_note = f" (backup: {backup.name})"
+    else:
+        backup_note = ""
     SETTINGS.write_text(json.dumps(settings, indent=2) + "\n", encoding="utf-8")
-    print(f"  settings.json written (backup: {backup.name})")
+    print(f"  settings.json written{backup_note}")
 
 
-def is_ours(group) -> bool:
+def is_ours(group: dict) -> bool:
     return any(OURS_RE.search(h.get("command", ""))
                for h in group.get("hooks", []) if isinstance(h, dict))
 
 
-def _entry(spec, scar_path):
+def _entry(spec: dict, scar_path: str) -> dict:
     hook = {"type": "command", "command": f"{scar_path} hook {spec['kind']}",
             "timeout": spec["timeout"], "statusMessage": spec["status"]}
     group = {"hooks": [hook]}
@@ -80,23 +75,23 @@ def _entry(spec, scar_path):
     return group
 
 
-def _remove_legacy_scripts(dry):
+def _remove_legacy_scripts(dry: bool) -> None:
     for name in LEGACY_SCRIPTS:
-        f = HOOKS_DIR / name
-        if f.exists():
-            print(f"[migrate] remove legacy script {f}")
+        path = HOOKS_DIR / name
+        if path.exists():
+            print(f"[migrate] remove legacy script {path}")
             if not dry:
-                f.unlink()
+                path.unlink()
 
 
-def install(dry):
+def install(dry: bool = False) -> int:
     scar_path = find_scar()
     if not scar_path:
         print("scar binary not found on PATH.")
         if os.environ.get("VIRTUAL_ENV"):
             print("Note: an active venv is ignored on purpose — hooks must "
                   "bind to a stable install, not a venv shim (scar 0003).")
-        print("Install it first:  cd <scar-repo> && uv tool install -e .")
+        print("Install it first: uv tool install scar-cli")
         return 1
     settings = load_settings()
     hooks_cfg = settings.setdefault("hooks", {})
@@ -123,7 +118,7 @@ def install(dry):
     return 0
 
 
-def uninstall(dry):
+def uninstall(dry: bool = False) -> int:
     settings = load_settings()
     hooks_cfg = settings.get("hooks", {})
     changed = False
@@ -144,24 +139,16 @@ def uninstall(dry):
     return 0
 
 
-def status():
+def status() -> int:
     scar_path = find_scar()
-    print(f"scar binary: {scar_path or 'NOT FOUND (uv tool install -e .)'}")
+    print(f"scar binary: {scar_path or 'NOT FOUND (uv tool install scar-cli)'}")
     hooks_cfg = load_settings().get("hooks", {})
     for spec in HOOKS:
         ours = [g for g in hooks_cfg.get(spec["event"], []) if is_ours(g)]
-        cmds = [h.get("command", "") for g in ours for h in g.get("hooks", [])]
-        legacy = any(any(s in c for s in LEGACY_SCRIPTS) for c in cmds)
+        commands = [h.get("command", "") for g in ours for h in g.get("hooks", [])]
+        legacy = any(any(script in command for script in LEGACY_SCRIPTS)
+                     for command in commands)
         state = ("legacy (run install to migrate)" if legacy
                  else "installed" if ours else "not installed")
         print(f"{spec['kind']:16} {spec['event']:13} {state}")
     return 0
-
-
-if __name__ == "__main__":
-    args = sys.argv[1:]
-    dry = "--dry-run" in args
-    cmd = next((a for a in args if not a.startswith("-")), "status")
-    sys.exit({"install": lambda: install(dry),
-              "uninstall": lambda: uninstall(dry),
-              "status": status}.get(cmd, status)())

{scar_cli-0.3.0 → scar_cli-0.4.0}/tests/test_installer.py

@@ -12,6 +12,9 @@ from pathlib import Path
 
 import pytest
 
+from scar import installer
+from scar.cli import main
+
 _SPEC = importlib.util.spec_from_file_location(
     "scar_hooks", Path(__file__).parent.parent / "hook" / "scar-hooks.py")
 scar_hooks = importlib.util.module_from_spec(_SPEC)
@@ -64,3 +67,38 @@ def test_install_explains_venv_shadowing_when_no_global_scar(
     assert scar_hooks.install(dry=True) == 1
     out = capsys.readouterr().out
     assert "VIRTUAL_ENV" in out or "venv" in out
+
+
+@pytest.fixture
+def isolated_settings(tmp_path, monkeypatch):
+    claude = tmp_path / ".claude"
+    monkeypatch.setattr(installer, "CLAUDE_DIR", claude)
+    monkeypatch.setattr(installer, "HOOKS_DIR", claude / "hooks")
+    monkeypatch.setattr(installer, "SETTINGS", claude / "settings.json")
+    monkeypatch.setattr(installer, "find_scar", lambda: "/stable/bin/scar")
+    return claude / "settings.json"
+
+
+def test_cli_hook_install_then_uninstall(isolated_settings, capsys):
+    assert main(["hook", "install"]) == 0
+    settings = isolated_settings.read_text(encoding="utf-8")
+    assert settings.count("/stable/bin/scar hook") == 3
+
+    assert main(["hook", "uninstall"]) == 0
+    settings = isolated_settings.read_text(encoding="utf-8")
+    assert "/stable/bin/scar hook" not in settings
+    assert "Scars themselves (.scars/ in repos) are untouched" in capsys.readouterr().out
+
+
+def test_cli_hook_dry_run_does_not_create_settings(isolated_settings):
+    assert main(["hook", "install", "--dry-run"]) == 0
+    assert not isolated_settings.exists()
+
+
+def test_cli_hook_status_reports_each_hook(isolated_settings, capsys):
+    assert main(["hook", "status"]) == 0
+    out = capsys.readouterr().out
+    assert "precheck" in out
+    assert "session-notice" in out
+    assert "stop-drafter" in out
+    assert out.count("not installed") == 3

scar_cli-0.3.0/ROADMAP.md

@@ -1,46 +0,0 @@
-# SCAR — Roadmap
-
-Restructured after the adversarial review (see [STRESS-TEST.md](STRESS-TEST.md)): **validation before construction**. Every phase has a kill gate decided in advance. No product-company work happens before Phase 2 gates pass.
-
-## Phase 0 — Kill-gate experiments (≈4-6 weeks, no product code beyond throwaway prototypes)
-
-| # | Experiment | Gate (pass/kill) | Cost |
-|---|-----------|------------------|------|
-| 0.1 | Prototype `scar harvest` (reverts, add-then-remove deps, reopened issues, comment archaeology); run on 5 real aging repos | ≥1 "I'd forgotten that" reaction per repo from someone who knows it; harvest precision subjectively >50% | ✅ **PASSED 2026-06-09** on a 2-year-old personal infra repo — owner had forgotten a service-placement deadend the harvest resurfaced; 12/12 curated candidates correct. Raw precision 13% → ranking layer is a v0 requirement. 4 more repos pending for full gate. |
-| 0.2 | Prototype anchors (tree-sitter symbols + content fingerprints); replay real historical refactor commits against them | ≥80% anchor survival across rename + file-split refactors | ✅ **PASSED 2026-06-09** — 94.8% single-commit, 88.0% at 200-commit zero-maintenance horizon; naive path+line baseline 0.0% ([results](experiments/anchor-survival/RESULTS.md)) |
-| 0.3 | **Fence honor test**: hand-write fences on a real repo, wire a PreToolUse hook, A/B agent sessions hook-on vs hook-off on tasks that tempt fence-bulldozing | Hook measurably reduces fence violations without degrading task completion | ✅ **PASSED 2026-06-09** — 6/6 control violations vs 0/6 treatment ([results](experiments/fence-honor/RESULTS.md)) |
-| 0.4 | Auto-authorship trial: 2 weeks of normal agent-assisted work with the stop-hook drafting `deadend` candidates | ≥5 human-kept scars; false-positive rate <15% (skeptic's bar, adopted) | 2 weeks, overlaps |
-| 0.5 | Survey 50 Claude Code / Cursor users: "Has Copilot Memory solved re-tried dead ends / bulldozed fences for you?" | Meaningful segment says no + wants repo-resident, reviewable knowledge | 3 days |
-| 0.6 | Implement Lore trailers on the same repo as 0.3; compare agent behavior vs scar injection | SCAR injection outperforms history-walk over trailers on latency and compliance | 1 week |
-
-**Any of 0.2, 0.3, 0.4 failing = stop and rethink the architecture. 0.5 failing = the wedge is gone; archive the project with its own deadend scar.** (The repo eating its own dog food on the way out.)
-
-## Phase 1 — Format + CLI (OSS), only after Phase 0 passes
-
-- `SCAR-FORMAT.md` v0.1 published as a spec independent of the tool — the format is the long-term bet.
-- `scar` CLI: `init`, `add`, `check`, `why`, `status`, `harvest`, `inject` (Go or Rust; single static binary; <150ms `inject` budget with incremental index under `.git/scar-index`).
-- Claude Code plugin: PreToolUse injection + stop-hook candidate drafting.
-- Lore trailer ingestion in `harvest` (interop, per stress-test response C).
-- Dogfood on this repo and 2-3 friendly real projects.
-
-## Phase 2 — Ecosystem
-
-- MCP server (`scar_query`, `scar_why`, `scar_draft`).
-- CI surface: orphan/expiry warnings; opt-in `--strict` for `critical` scars.
-- Re-anchoring agent workflow: orphaned scar + orphaning diff → proposed new anchors as a PR.
-- Editor surfaces (VS Code gutter marks, LSP code lens) — fences visible to humans, not only agents.
-- **Gate to Phase 3:** organic adoption signal (external repos with active scars, inbound interest) + 10 ICP interviews validating org-level pain at a price point. Skeptic risk #5 stands until then.
-
-## Phase 3 — The org graph (commercial hypothesis, explicitly unproven)
-
-- Cross-repo scar aggregation: "this dead end has been hit by 4 teams."
-- Recurrence analytics; policy ("payment-path changes must acknowledge fences"); managed harvest.
-- Only if Phase 2's gate passed. Otherwise SCAR remains a free standard, and that is a declared-in-advance acceptable ending.
-
-## Non-negotiable principles carried from the stress test
-
-1. Advisory by default, forever. Blocking is opt-in, per-scar-severity, in CI only.
-2. Max 3 scars / ~120 words each injected per edit. The fatigue budget is a format-level guarantee, not a tuning knob.
-3. Rot must be loud. No scar ever disappears silently; orphaning is a visible state.
-4. Assume zero ongoing human maintenance; design for graceful visible decay.
-5. The format stays open and vendor-neutral even if a company forms. Platform absorption of the format = success, not failure.