devrites 3.2.28 → 4.0.0

package/update.sh

@@ -1,8 +1,12 @@
 #!/usr/bin/env bash
-# update.sh - bootstrap shim for the engine-owned DevRites updater.
+# update.sh - acquire a release locally, then hand it to the offline updater.
 set -u
 
-SELF_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" 2>/dev/null && pwd -P)" || SELF_DIR=""
+SELF_DIR=""
+SCRIPT_SOURCE="${BASH_SOURCE[0]:-}"
+if [ -n "$SCRIPT_SOURCE" ] && [ -f "$SCRIPT_SOURCE" ]; then
+  SELF_DIR="$(cd "$(dirname "$SCRIPT_SOURCE")" 2>/dev/null && pwd -P)" || SELF_DIR=""
+fi
 DEVRITES_REPO="${DEVRITES_REPO:-ViktorsBaikers/DevRites}"
 DEVRITES_REF="${DEVRITES_REF:-}"
 
@@ -11,20 +15,12 @@ delegate_bootstrap() {
     echo "error: bootstrap re-exec did not find pack/ - aborting to avoid a loop." >&2
     exit 1
   fi
-  command -v curl >/dev/null 2>&1 || { echo "error: curl is required for the network updater." >&2; exit 1; }
-  if [ -n "$DEVRITES_REF" ]; then
-    ref="$DEVRITES_REF"
-  else
-    ref="$(curl -fsSL "https://api.github.com/repos/$DEVRITES_REPO/releases/latest" 2>/dev/null | sed -n 's/.*"tag_name"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -n1)"
-  fi
-  ref="${ref:-main}"
-  url="https://raw.githubusercontent.com/$DEVRITES_REPO/$ref/install.sh"
-  tmp="$(mktemp 2>/dev/null || echo "${TMPDIR:-/tmp}/devrites-install.$$")"
-  curl -fsSL -o "$tmp" "$url" || { echo "error: could not download DevRites bootstrap from $url" >&2; rm -f "$tmp"; exit 1; }
-  bash "$tmp" update "$@"
-  rc="$?"
-  rm -f "$tmp"
-  exit "$rc"
+  [ -n "$SELF_DIR" ] && [ -f "$SELF_DIR/install.sh" ] || {
+    echo "error: update requires the canonical install bootstrap; run the documented curl command for install.sh." >&2
+    exit 1
+  }
+  bash "$SELF_DIR/install.sh" update "$@"
+  exit "$?"
 }
 
 if [ -z "$SELF_DIR" ] || [ ! -d "$SELF_DIR/pack" ]; then
@@ -35,6 +31,18 @@ INSTALL_LIB="$SELF_DIR/scripts/install-lib.sh"
 [ -f "$INSTALL_LIB" ] || { echo "error: extracted bundle is missing scripts/install-lib.sh" >&2; exit 1; }
 . "$INSTALL_LIB"
 
-ENGINE="$(dr_acquire_engine "$SELF_DIR" update "$DEVRITES_REPO")" || { echo "error: could not acquire devrites-engine." >&2; exit 1; }
+DR_ENGINE_PATH=""; DR_ENGINE_TMP=""
+trap dr_cleanup_engine EXIT
+trap 'exit 1' HUP INT TERM
+dr_acquire_engine "$SELF_DIR" update "$DEVRITES_REPO" || { echo "error: could not acquire a version-compatible devrites-engine${DR_ACQUIRE_FAILURE:+ ($DR_ACQUIRE_FAILURE)}." >&2; exit 1; }
+ENGINE="$DR_ENGINE_PATH"
+PAYLOAD="${DEVRITES_HOST_ARTIFACT_DIR:-$SELF_DIR/pack/generated}"
+if [ ! -d "$PAYLOAD/claude/skills" ] || [ ! -d "$PAYLOAD/codex/skills" ] || [ ! -f "$PAYLOAD/codex/config.toml" ]; then
+  BUILDER="$SELF_DIR/scripts/build-host-artifacts.sh"
+  [ -f "$BUILDER" ] || { echo "error: generated update payload missing at $PAYLOAD and builder missing at $BUILDER" >&2; exit 1; }
+  DEVRITES_HOST_ARTIFACT_DIR="$PAYLOAD" bash "$BUILDER" >/dev/null || { echo "error: could not generate update payload at $PAYLOAD" >&2; exit 1; }
+fi
 export DEVRITES_ENGINE_CLI="$ENGINE"
-exec "$ENGINE" update --source-dir "$SELF_DIR" "$@"
+"$ENGINE" update --source-dir "$SELF_DIR" --payload-dir "$PAYLOAD" "$@"
+rc="$?"
+exit "$rc"

package/docs/engine/agent-contract.md

@@ -1,172 +0,0 @@
-# `devrites-engine` agent contract (`--json`)
-
-An unattended driver, such as the AFK loop, a CI step, or a local script,
-needs a stable result format instead of prose that may change. The read commands
-used by AFK accept `--json` and write a stable envelope to stdout. The flag does
-not change the command's logic or exit code.
-
-## Which commands accept `--json`
-
-An unattended run branches on this set:
-
-`status` · `readiness` · `seal` · `spec-validate` · `evidence-fresh` · `preamble` ·
-`coverage` · `analyze` · `doctor` · `ledger` (`diff` / `validate` / `list` / `show`)
-
-Other subcommands, including hooks, `footprint`, `tick-afk`, and mutating
-commands, do not accept `--json` because drivers do not use their output for a
-decision. Only machine-read decision results expose the flag.
-
-Exception: `snapshot`, `context show --json`, and
-`reviewer-stats report --json` are already direct structured reports, not
-envelopes. `context show --json` emits `root`, `project`, `activeWorkspace`,
-`source`, `hostCommands`, and `status` so wrappers can tell where DevRites will
-act; reviewer stats emits the deterministic per-reviewer dispatch verdicts.
-
-## Envelope
-
-```json
-{
-  "schema": "devrites-command/v1",
-  "command": "spec-validate",
-  "ok": false,
-  "exitCode": 1,
-  "data": { "text": "<the command's verbatim stdout>" },
-  "diagnostics": [
-    {
-      "code": "spec_validate_delta_mismatch",
-      "severity": "error",
-      "message": "Requirement \"Dark mode\" (line 2) is marked ADDED but already exists in ledger capability \"theming\"",
-      "path": ".devrites/work/feat/spec.md",
-      "line": 2
-    }
-  ]
-}
-```
-
-| field | meaning |
-| ----- | ------- |
-| `schema` | `devrites-command/v1` |
-| `command` | the subcommand that ran |
-| `ok` | `exitCode == 0`: the one boolean a driver branches on |
-| `exitCode` | the process exit code (authoritative; see the table below) |
-| `reason_id` | optional rule-owned outcome ID; currently emitted by lifecycle gates |
-| `data.text` | the command's human-readable stdout, verbatim and lossless (omitted when empty) |
-| `diagnostics[]` | one entry per stderr line, classified (omitted when none) |
-
-`data.text` contains the complete text-mode output. Structured consumers read
-`ok`, `exitCode`, and `diagnostics` and ignore `data.text`; human readers can do
-the reverse.
-
-## Diagnostics and reasons
-
-| field | meaning |
-| ----- | ------- |
-| `code` | stable, greppable slug (see catalog) |
-| `severity` | `error` · `warning` · `info` |
-| `message` | the finding, with any `<path>:` prefix and `(line N)` suffix lifted into fields |
-| `path` | source path, when the finding named one |
-| `line` | 1-based line, when the finding named one |
-
-`diagnostics[].code` remains compatible with existing consumers. Some older
-codes are coarse or classified from stderr shape. New automation should prefer
-the top-level `reason_id` when present: its value comes from the rule that made
-the decision, so editing human wording cannot change it.
-
-## Exit-code contract
-
-| code | meaning |
-| ---- | ------- |
-| `0` | ok / gate passed / valid |
-| `1` | a content violation: a grammar or delta error (`spec-validate`, `ledger validate`) |
-| `2` | usage error (bad args, unknown command) |
-| `3` | blocked: a completeness-gate pause or a `doctor` version-skew refuse; a **pause, not a crash** |
-| `5` | a required input is missing (e.g. no `spec.md`) |
-
-Exit `3` is the AFK pause signal: resolve the reported gap and retry.
-
-## Diagnostic-code catalog
-
-Codes are `<command>_<kind>`. v1 is deliberately coarse so consumers can match on
-the prefix while the catalog grows specific kinds:
-
-| code | emitted by | means |
-| ---- | ---------- | ----- |
-| `spec_validate_grammar` | `spec-validate` | a SHALL / WHEN / THEN / Scenario grammar violation |
-| `spec_validate_delta_mismatch` | `spec-validate --against` | an ADDED that already exists, or a MODIFIED/REMOVED that doesn't |
-| `ledger_grammar` | `ledger validate` | a ledger spec fails the grammar |
-| `<command>_error` / `_warning` / `_info` | any | an unclassified stderr line at that severity |
-
-New specific codes append to this table. The `<command>_<severity>` fallback
-represents future stderr lines without a code change.
-`engine/tests/json_contract_test.go` checks every AFK-parsed command so each
-`--json` run remains one parseable JSON document whose `exitCode` and `ok` match
-the process result.
-
-## Execution provenance: `devrites-event/v1`
-
-The engine appends a compact event to the existing `.devrites/timeline.jsonl`.
-When an active workspace exists, it appends the same event to that workspace's
-`events.jsonl`. There is no second store and no migration: older unversioned
-timeline rows remain readable beside v1 rows.
-
-```json
-{
-  "schema": "devrites-event/v1",
-  "ts": "2026-07-23T12:34:56Z",
-  "run_id": "drv-run-v1:0123456789abcdef0123456789abcdef",
-  "boundary": "lifecycle-gate",
-  "root_source": "DEVRITES_ROOT",
-  "workspace": ".devrites/work/auth-tokens",
-  "phase_before": "build",
-  "event": "readiness",
-  "rule_ids": ["DRV-GATE-READINESS-MISSING"],
-  "evidence_paths": [".devrites/work/auth-tokens/test-plan.md"],
-  "phase_after": "build",
-  "execution_mode": "none",
-  "guard_strength": "n/a",
-  "reason_id": "DRV-GATE-READINESS-MISSING",
-  "outcome": "blocked",
-  "host": "engine"
-}
-```
-
-The v1 validator accepts only:
-
-- `execution_mode`: `named` · `generic` · `inline` · `none` (`inline` remains
-  readable for historical telemetry; current specialist dispatch never emits it);
-- `guard_strength`: `enforced` · `observed` · `unavailable` · `bypassed` · `n/a`;
-- `host`: `engine` · `claude` · `codex`;
-- registered `DRV-*` reason and rule IDs;
-- canonical phases and project-relative workspace/evidence paths.
-
-Events never contain prompts, commands, tool or source bodies, answers, free
-text, secrets, usernames, or absolute paths. A bad or unwritable event affects
-metrics only. Root, gate, and hook decisions do not depend on the event write.
-
-The first live boundaries are root selection, readiness/seal, hook guards, and
-destructive-Git policy.
-Hook records distinguish an enforced denial from an observe-only finding, an
-unavailable adapter/input, and an intentional bypass. Forge binding denials and
-the opt-in WebFetch ingestion warning use the same schema.
-
-### Reason registry
-
-`engine/internal/reason` is the Go source of truth. Current lifecycle matrix
-reasons are:
-
-| reason ID | owner |
-| --- | --- |
-| `DRV-GATE-READINESS-PASSED` / `DRV-GATE-READINESS-MISSING` | readiness gate |
-| `DRV-GATE-SEAL-PASSED` / `DRV-GATE-SEAL-MISSING` | seal gate |
-| `DRV-HOOK-STOP-*` | Stop rest-point rules and loop/input handling |
-| `DRV-HOOK-REVIEWER-READONLY-*` | reviewer mutation guard |
-| `DRV-HOOK-A1-*` | main-thread build write guard |
-| `DRV-HOOK-WRIGHT-*` | wright scope and forbidden-operation guard |
-| `DRV-HOOK-FORGE-BINDING-DENIED` | Forge manifest/worker binding |
-| `DRV-HOOK-INGEST-WARNING` | opt-in WebFetch warning trial |
-| `DRV-GIT-AMBIGUOUS-*` / `DRV-GIT-INPUT-TOO-LARGE` | direct-literal Git parser boundary |
-| `DRV-GIT-DESTRUCTIVE-*` | destructive-operation classifier |
-| `DRV-GIT-AUTHORITY-*` / `DRV-GIT-WORKSPACE-UNAVAILABLE` | exact one-shot authority and replay gate |
-| `DRV-AGENT-*` | named/generic execution, historical inline telemetry, and result reconciliation |
-
-Add a reason to that registry before an emitting rule or eval depends on it.

package/docs/extensions.md

@@ -1,178 +0,0 @@
-# Extending DevRites with project extensions and reviewer overrides
-
-DevRites ships a fixed, authored pack of rites, reviewers, and standards. The extension sync
-surface is currently **Claude Code-only**; Codex extension mirrors are not generated. Two project-local
-surfaces let a Claude Code project tune the pack **without forking it**: both live in the data plane
-(`.devrites/`), both are git-diffable, and both are held to the same contracts the shipped pack is.
-
-They answer two different questions:
-
-| Surface | Question it answers | Lives in |
-|---|---|---|
-| **Extensions** | "Add a *new* rite or reviewer / domain." | `.devrites/extensions/<name>/` |
-| **Overrides** | "Reshape a *shipped* reviewer's emphasis." | `.devrites/overrides/<agent>.md` |
-
-The guiding invariant for both: **a shipped gate is never weakened by a customization.** An
-extension earns parity by passing the same validator as the pack; an override may raise the bar,
-never lower it. The deterministic engine gates (`seal`, `review-integrity`, `check-acceptance`, …)
-do not read either surface: they stay authoritative regardless of what a project adds.
-
----
-
-## Extensions: add a rite or reviewer
-
-A project extension is a directory under `.devrites/extensions/`:
-
-```
-.devrites/extensions/<name>/
-  skill/SKILL.md      (optional) a user rite/skill: needs name + description frontmatter
-  agent.md            (optional) a user reviewer agent: needs name + description frontmatter
-  component.yaml      (optional) npx-managed component manifest + safety bounds
-  provenance.json     (optional) source/author/review metadata for shared extensions
-  extension.yaml      (optional) metadata: aliases (prior names, so a rename doesn't orphan)
-```
-
-An extension provides a skill, an agent, or both. It is held to the same schema as the shipped
-pack. DevRites refuses malformed extensions rather than installing part of one.
-
-### Commands
-
-```bash
-devrites-engine extensions list       # enumerate extensions and what each provides
-devrites-engine extensions validate   # schema-check every extension (exit 1 on a violation)
-devrites-engine extensions sync        # mirror valid extensions into .claude/ for Claude Code
-```
-
-- **`validate`** checks each declared skill/agent carries `name:` + `description:` frontmatter, that
-  an extension provides at least one artifact, and that no two extensions claim the same skill/agent
-  name. If `component.yaml` is present, it must declare an npm-managed, project-local component:
-  `distribution: npx-managed`, `scope: project-local`, project-local write roots only, and safety
-  fields that do **not** weaken gates, bypass `type-GO`, or run executables. If `provenance.json`
-  is present it must be valid JSON with `source`, `author`, `created_at`, and optional
-  `confidence` (`0..1`) / `reviewed_by`; `/rite-doctor` warns when an extension ships artifacts
-  without provenance. V2 manifests may
-  also declare `tier`, `requires`, `owns`, and `surface`; dependencies must be acyclic, and anything
-  in `owns` that collides with the first-party `rite-`/`devrites-` namespaces is refused. If a
-  malformed extension declares a review/gate-like surface, validation warns that the surface is
-  inactive until the schema is fixed. Validation remains fail-open, but reports the problem.
-- **`sync`** validates first, then mirrors `skill/` → `.claude/skills/<name>/` and `agent.md` →
-  `.claude/agents/<name>.md`, where the Claude harness discovers them. Idempotent. It refuses to
-  sync a set that fails validation.
-- **`aliases`** (in `extension.yaml`) carry an extension's prior names forward across a rename, so a
-  project's references don't orphan.
-
-### Component manifest
-
-Public schemas live in [`../schemas/`](../schemas/): `extension-component.schema.json` and
-`provenance.schema.json` for extension metadata, plus workspace/hook schemas for editor tooling.
-
-`component.yaml` is DevRites' native extension, preset, and bundle metadata.
-It is **not** a plugin package descriptor; it documents what the npm-installed engine may copy or
-validate inside the current project.
-
-```yaml
-schema_version: "1.1"
-kind: extension
-id: audit-lite              # must match .devrites/extensions/<name>/ when present
-version: 0.1.0
-tier: standard              # core | standard | full
-requires: []                # other local extension ids; acyclic
-owns:
-  skills: [audit-lite]
-  agents: []
-surface:
-  clusters: [review]
-safety:
-  may_weaken_gates: false
-  executable: false
-```
-
-Legacy `component:` / `permissions:` manifests still validate. The validator refuses global homes
-(`~/.claude/**`, `~/.codex/**`), plugin-store distribution names, non-project scopes, unknown/cyclic
-extension dependencies, first-party ownership collisions, and any manifest that claims it can weaken
-a gate, run executables, or bypass `type-GO`.
-
-### Declarative checks
-
-`component.yaml` may declare **checks**: non-executable, one-line instructions the data plane
-surfaces at a lifecycle gate:
-
-```yaml
-checks:
-  - at: seal
-    instruction: Run the license scan and record the result in evidence.md
-    doc: docs/license-scan.md   # optional pointer to the project's own procedure
-```
-
-- A check is an **instruction the in-session model addresses**, never a command the engine runs.
-  The deterministic engine gates still do not read extensions, and `executable: false` still holds.
-- Checks are **additive-only**: they can raise the bar at a gate, never lower one (same rule as
-  overrides). `/rite-seal` treats a declared `at: seal` check that is neither addressed nor
-  skip-justified in `seal.md` as an **Important** finding on the review's completeness.
-- Checks in an extension that fails validation are inactive. `extensions validate`
-  reports the problem without blocking unrelated work.
-
-### Workflow
-
-Use `/rite-customize extension <name>` for guided authoring, or do it by hand:
-
-1. Author the extension under `.devrites/extensions/<name>/`.
-2. `devrites-engine extensions validate` until clean.
-3. `devrites-engine extensions sync` to mirror it into `.claude/`.
-4. `/rite-doctor` validates extensions on every health check and hands you the fix if one regresses.
-
-### Harness scope
-
-`sync` targets the **Claude Code-only** layout (`.claude/skills`, `.claude/agents`), which that host
-auto-discovers. It does not generate Codex mirrors, so project extensions are unavailable to Codex
-unless an operator maintains an equivalent Codex surface independently. The `.md` → `.codex/agents/*.toml` conversion,
-path rewriting, hook/config blocks, and skills-list description stubbing are deliberately limited to
-the generated shipped pack artifacts so extension sync does not become a second Codex generator.
-
----
-
-## Overrides: reshape a shipped reviewer
-
-An override is a single Markdown file named for the agent it targets:
-
-```
-.devrites/overrides/devrites-code-reviewer.md
-.devrites/overrides/devrites-security-auditor.md
-```
-
-Each shipped reviewer, after loading its governing standards, reads
-`.devrites/overrides/<its-name>.md` if present and applies it as project-specific
-emphasis or house rules. For example, a `devrites-code-reviewer.md`
-override that says "always flag any use of the deprecated `legacyClient` as Important."
-
-### The one rule
-
-An override may **add** checks or **raise** weight. It may **never** relax a gate, waive a standard,
-or lower a severity floor. A Critical stays a Critical. Overrides are reviewer *input*, not
-permission. The engine gates don't read them at all, so an override literally cannot disable a gate;
-the linter exists to catch one that *tries to talk a reviewer into it*.
-
-### Commands
-
-Use `/rite-customize override <agent>` for guided authoring, or manage files directly:
-
-```bash
-devrites-engine overrides list       # enumerate override files and the agent each targets
-devrites-engine overrides validate   # flag empty overrides and any that read like a gate waiver (exit 1)
-```
-
-`validate` trips on subversion phrasing ("ignore the gate", "treat any Critical as a Suggestion",
-"waive review") and on an override targeting an agent that isn't installed (an orphan warning).
-`/rite-doctor` runs it on every health check.
-
-### Template overrides
-
-Future template/preset work uses `.devrites/overrides/templates/*.md` as the project-local override
-layer. `devrites-engine overrides validate` already applies the same anti-subversion scan to those
-files and adds required-term checks for high-risk lifecycle templates:
-
-- `seal.md` must still mention `type-GO` and `NO-GO`.
-- `ship.md` must still mention `type-GO`.
-
-This keeps the extension point useful without letting a project template erase the gates that make
-DevRites safe.

package/engine/git_guard.go

@@ -1,187 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"strings"
-
-	"github.com/devrites/devrites/internal/harness"
-	"github.com/devrites/devrites/internal/lib"
-	"github.com/devrites/devrites/internal/orient"
-	drvreason "github.com/devrites/devrites/internal/reason"
-	"github.com/devrites/devrites/internal/toolpolicy"
-)
-
-const gitGuardSuffix = " (devrites-git-guard)"
-
-// hookGitGuard denies ambiguous high-impact Git and requires an exact, fresh,
-// consumed-on-attempt authority record for an unambiguous destructive command.
-func hookGitGuard(h harness.Harness, stdin io.Reader, stdout, stderr io.Writer) int {
-	in := h.ParsePreToolInput(stdin)
-	if !isShellTool(in.ToolName) || strings.TrimSpace(in.Command) == "" {
-		return exitOK
-	}
-
-	classified := toolpolicy.ClassifyGitCommand(in.Command)
-	if classified.Verdict == toolpolicy.VerdictSafe {
-		return exitOK
-	}
-	classifierReasons := gitClassifierReasons(classified)
-	if classified.Verdict == toolpolicy.VerdictAmbiguous {
-		primary := gitReasonID(classified.ReasonID, drvreason.GitAuthorityUnavailable)
-		root, slug := gitGuardWorkspace()
-		recordGitPolicy(root, slug, h, primary, classifierReasons, lib.OutcomeDenied)
-		return emitGitDeny(h, stdout, stderr,
-			fmt.Sprintf("DevRites denied an ambiguous high-impact Git request (%s). %s%s",
-				primary, classified.Remediation, gitGuardSuffix))
-	}
-
-	root, slug := gitGuardWorkspace()
-	if root == "" {
-		return emitGitDeny(h, stdout, stderr,
-			"DevRites cannot authorize destructive Git without an active DevRites workspace ("+
-				string(drvreason.GitWorkspaceUnavailable)+")."+gitGuardSuffix)
-	}
-	if slug == "" {
-		recordGitPolicy(root, "", h, drvreason.GitWorkspaceUnavailable, classifierReasons, lib.OutcomeDenied)
-		return emitGitDeny(h, stdout, stderr,
-			"DevRites cannot authorize destructive Git without an active DevRites workspace ("+
-				string(drvreason.GitWorkspaceUnavailable)+")."+gitGuardSuffix)
-	}
-
-	decision := lib.AuthorizeGitOperation(root, slug, classified.Digest, destructiveClassifierReasons(classified))
-	if decision.Allowed {
-		out, err := h.PreToolAllow("DevRites consumed one fresh exact-operation Git authorization (" +
-			string(decision.ReasonID) + ")." + gitGuardSuffix)
-		if err != nil {
-			recordGitPolicy(root, slug, h, drvreason.GitAuthorityUnavailable, classifierReasons, lib.OutcomeDenied)
-			return exitOK
-		}
-		fmt.Fprintln(stdout, out)
-		recordGitPolicy(root, slug, h, decision.ReasonID, classifierReasons, lib.OutcomeAllowed)
-		return exitOK
-	}
-
-	recordGitPolicy(root, slug, h, decision.ReasonID, classifierReasons, lib.OutcomeDenied)
-	return emitGitDeny(h, stdout, stderr, gitAuthorityDenyMessage(decision))
-}
-
-func gitGuardWorkspace() (string, string) {
-	root, err := orient.ResolveRoot(os.Getenv("DEVRITES_ROOT"))
-	if err != nil {
-		return "", ""
-	}
-	slug, err := orient.ActiveSlug(root)
-	if err != nil {
-		return root, ""
-	}
-	return root, slug
-}
-
-func emitGitDeny(h harness.Harness, stdout, stderr io.Writer, message string) int {
-	out, err := h.PreToolDeny(message)
-	if err != nil {
-		debugf(stderr, "git-guard decision unavailable")
-		return exitOK
-	}
-	fmt.Fprintln(stdout, out)
-	return exitOK
-}
-
-func gitAuthorityDenyMessage(decision lib.GitAuthorityDecision) string {
-	reasonID := string(decision.ReasonID)
-	switch decision.ReasonID {
-	case drvreason.GitAuthorityPending, drvreason.GitAuthorityExpired, drvreason.GitAuthorityReplayed:
-		if decision.QuestionID != "" {
-			return fmt.Sprintf(
-				`DevRites requires one fresh exact-operation Git authorization (%s). Resolve %s with /rite-resolve %s "%s", then retry.%s`,
-				reasonID, decision.QuestionID, decision.QuestionID, lib.GitAuthorityAnswer, gitGuardSuffix)
-		}
-	case drvreason.GitAuthorityRefused:
-		return fmt.Sprintf("DevRites denied this destructive Git operation because its exact authorization was refused (%s).%s",
-			reasonID, gitGuardSuffix)
-	case drvreason.GitAuthorityCorrupt:
-		return fmt.Sprintf("DevRites denied destructive Git because its authority record or consumption ledger "+
-			"is invalid (%s). Repair the workspace authority state before retrying.%s",
-			reasonID, gitGuardSuffix)
-	case drvreason.GitWorkspaceUnavailable:
-		return fmt.Sprintf("DevRites cannot authorize destructive Git without an active DevRites workspace (%s).%s",
-			reasonID, gitGuardSuffix)
-	}
-	return fmt.Sprintf("DevRites could not persist or consume destructive Git authority (%s). Repair the workspace or hook, then retry.%s",
-		reasonID, gitGuardSuffix)
-}
-
-func destructiveClassifierReasons(classified toolpolicy.Result) []toolpolicy.ReasonID {
-	seen := map[toolpolicy.ReasonID]bool{}
-	var out []toolpolicy.ReasonID
-	for _, finding := range classified.Findings {
-		if finding.Verdict != toolpolicy.VerdictDestructive || seen[finding.ReasonID] {
-			continue
-		}
-		seen[finding.ReasonID] = true
-		out = append(out, finding.ReasonID)
-	}
-	return out
-}
-
-func gitClassifierReasons(classified toolpolicy.Result) []drvreason.ID {
-	seen := map[drvreason.ID]bool{}
-	var out []drvreason.ID
-	for _, finding := range classified.Findings {
-		id := gitReasonID(finding.ReasonID, "")
-		if id == "" || seen[id] {
-			continue
-		}
-		seen[id] = true
-		out = append(out, id)
-	}
-	if len(out) == 0 {
-		if id := gitReasonID(classified.ReasonID, ""); id != "" {
-			out = append(out, id)
-		}
-	}
-	return out
-}
-
-func gitReasonID(value toolpolicy.ReasonID, fallback drvreason.ID) drvreason.ID {
-	id, err := drvreason.Parse(string(value))
-	if err != nil {
-		return fallback
-	}
-	return id
-}
-
-func recordGitPolicy(root, slug string, h harness.Harness, primary drvreason.ID, classifier []drvreason.ID, outcome lib.EventOutcome) {
-	if root == "" || !drvreason.Known(primary) {
-		return
-	}
-	ev := lib.NewEventV1(lib.BoundaryGitPolicy, "git-guard", primary)
-	ev.GuardStrength = lib.GuardEnforced
-	ev.Outcome = outcome
-	ev.Host = lib.EventHost(h)
-	if ev.Host != lib.HostClaude && ev.Host != lib.HostCodex {
-		ev.Host = lib.HostEngine
-	}
-	ev.RuleIDs = []drvreason.ID{primary}
-	for _, id := range classifier {
-		if len(ev.RuleIDs) == 16 {
-			break
-		}
-		duplicate := false
-		for _, existing := range ev.RuleIDs {
-			if existing == id {
-				duplicate = true
-				break
-			}
-		}
-		if !duplicate {
-			ev.RuleIDs = append(ev.RuleIDs, id)
-		}
-	}
-	if err := lib.BindEventWorkspace(root, slug, &ev); err != nil {
-		return
-	}
-	_ = lib.AppendEventV1(root, ev)
-}