@chrono-meta/fh-gate 1.4.73 → 1.4.75

package/scripts/below_floor_scan.sh

@@ -0,0 +1,91 @@
+#!/usr/bin/env bash
+# below_floor_scan.sh — standing consumer for below-floor adversarial markers
+#
+# The pre-commit hook accepts a below-floor Axis-2 pass when an operator ack is
+# present, on the promise that "the weekly audit re-queues below-floor markers
+# for floor-tier re-run" (§Floor governance, multi_model_sidecar_strategy.md).
+# This script IS that consumer: it enumerates below-floor markers and reports
+# which ones still await floor-tier re-validation. Read-only, zero side effects.
+#
+# Resolution protocol (append to the marker after acting — machine-greppable):
+#   floor-rerun: <YYYY-MM-DD> <model> PASS|FAIL   ← Axis 2 re-run at >= floor
+#   floor-writeoff: <YYYY-MM-DD> <one-line reason> ← operator writes the ack off
+#
+# Usage: bash scripts/below_floor_scan.sh [repo_root]
+# Exit:  0 = no pending below-floor markers; 1 = pending re-runs found
+#        (manual weekly-audit step — Phase 1.5; exit 1 = raise the pending
+#        items as S-tier. No automated caller is wired yet.)
+
+set -uo pipefail
+
+REPO_ROOT="${1:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"
+MARKER_DIR="$REPO_ROOT/tracks/_meta"
+PENDING=0
+TOTAL=0
+
+echo "── below-floor marker scan: $MARKER_DIR ──"
+
+if [ ! -d "$MARKER_DIR" ]; then
+  echo "   (no tracks/_meta directory — nothing to scan)"
+  exit 0
+fi
+
+SONNET_PENDING=0
+for m in "$MARKER_DIR"/.axes_23_passed_*.marker; do
+  [ -e "$m" ] || continue
+  # sonnet-floor lane (Sonnet-Floor Doctrine 2026-07-10): anchored Sonnet passes are
+  # first-class at commit time but provisional for judged depth — queued here as
+  # R-tier (advisory re-validation), distinct from below-floor's S-tier hard queue.
+  if grep -qE '^[[:space:]]*floor-status:[[:space:]]*sonnet-floor' "$m"; then
+    name=$(basename "$m")
+    rerun=$(grep -m1 -E '^[[:space:]]*floor-rerun:' "$m" \
+            | sed -E 's/^[[:space:]]*floor-rerun:[[:space:]]*//' || true)
+    writeoff=$(grep -m1 -E '^[[:space:]]*floor-writeoff:' "$m" \
+               | sed -E 's/^[[:space:]]*floor-writeoff:[[:space:]]*//' || true)
+    if [ -n "$rerun" ]; then
+      echo "✅ RESOLVED (re-run)   $name — floor-rerun: $rerun"
+    elif [ -n "$writeoff" ]; then
+      echo "✅ RESOLVED (writeoff) $name — floor-writeoff: $writeoff"
+    else
+      SONNET_PENDING=$((SONNET_PENDING + 1))
+      anchor=$(grep -m1 -E '^[[:space:]]*axis2-anchor:' "$m" \
+               | sed -E 's/^[[:space:]]*axis2-anchor:[[:space:]]*//' || true)
+      echo "🟨 R-tier re-validate  $name (sonnet-floor)"
+      echo "     axis2-anchor: ${anchor:-<missing>}"
+      echo "     action: re-run judged depth at >= opus or via sidecar dispatch when"
+      echo "             available, append 'floor-rerun: ...' — or 'floor-writeoff: ...'"
+    fi
+    continue
+  fi
+  grep -qE '^[[:space:]]*floor-status:[[:space:]]*below-floor' "$m" || continue
+  TOTAL=$((TOTAL + 1))
+  name=$(basename "$m")
+  model=$(grep -m1 -E '^[[:space:]]*axis2-model:' "$m" \
+          | sed -E 's/^[[:space:]]*axis2-model:[[:space:]]*//' || true)
+  ack=$(grep -m1 -E '^[[:space:]]*below-floor-ack:' "$m" \
+        | sed -E 's/^[[:space:]]*below-floor-ack:[[:space:]]*//' || true)
+  rerun=$(grep -m1 -E '^[[:space:]]*floor-rerun:' "$m" \
+          | sed -E 's/^[[:space:]]*floor-rerun:[[:space:]]*//' || true)
+  writeoff=$(grep -m1 -E '^[[:space:]]*floor-writeoff:' "$m" \
+             | sed -E 's/^[[:space:]]*floor-writeoff:[[:space:]]*//' || true)
+
+  if [ -n "$rerun" ]; then
+    echo "✅ RESOLVED (re-run)   $name — floor-rerun: $rerun"
+  elif [ -n "$writeoff" ]; then
+    echo "✅ RESOLVED (writeoff) $name — floor-writeoff: $writeoff"
+  else
+    PENDING=$((PENDING + 1))
+    echo "🟥 PENDING re-run      $name"
+    echo "     axis2-model: ${model:-<missing>} | ack: ${ack:-<missing>}"
+    echo "     action: re-run Axis 2 at >= floor (opus), append 'floor-rerun: ...'"
+    echo "             or operator writes off: append 'floor-writeoff: ...'"
+  fi
+done
+
+echo "── below-floor markers: $TOTAL total, $PENDING pending (S-tier) ──"
+echo "── sonnet-floor markers pending re-validation: $SONNET_PENDING (R-tier, advisory) ──"
+# Exit semantics unchanged: only below-floor (S-tier) hard-fails the scan.
+# sonnet-floor pendings are advisory — reported, never exit-blocking (doctrine:
+# Sonnet base is first-class; the queue exists so residuals terminate, not decorate).
+[ "$PENDING" -gt 0 ] && exit 1
+exit 0

package/scripts/chamber_run.sh

@@ -0,0 +1,184 @@
+#!/usr/bin/env bash
+# chamber_run.sh — chamber run orchestrator (the runner the skeleton's gaps G1-forcing/G2/G4/STATUS all
+# hung on). GLUE ONLY: it wires the pieces that already exist (workspace convention · budget gate notion ·
+# the isolated persona agents · the Emission Gate · the G4 ledger) into one intent-driven, resumable flow
+# so a chamber run can be *completed by intent* rather than hand-followed from the skeleton doc.
+#
+# What it MECHANIZES: workspace + INTENT/BUDGET templates · STATUS stamping (resumable — re-run to advance) ·
+# the budget-entry gate (G2: blocks step 4 until an ESTIMATE is recorded — no uncapped run) · the step-4
+# isolation gate (G1-forcing: blocks step 5 until SIM_NOTES has ≥3 blind persona sections) · the Emission
+# Gate verdict capture · actual-cost record · and the G4 ledger auto-append (idempotent).
+#
+# What it CANNOT mechanize (honest muscle boundary, documented in CHAMBER_RUN_SKELETON.md): bash cannot
+# spawn the isolated Agents itself. Step 4 PRINTS the exact dispatch and GATES on the ≥3 persona artifact —
+# the human/Claude does the actual `fh-meta:{beginner,challenger,main-player}` dispatch. Isolation stays a
+# salience+artifact gate, not a spawn. Budget/cost numbers calibrate only across real runs (muscle, not wiring).
+#
+# Usage:  bash scripts/chamber_run.sh <candidate-slug>          # create/advance the run (idempotent)
+#         bash scripts/chamber_run.sh <candidate-slug> status    # show where the run is
+#   exit 0 = advanced or already complete · exit 1 = blocked on a missing artifact (message says which)
+#   exit 2 = harness error (FH root / bad slug)
+
+set -uo pipefail
+
+FH="$(cd "$(dirname "$0")/.." && pwd)"
+if [ ! -d "$FH/tracks" ] || [ ! -d "$FH/plugins" ]; then
+  echo "❌ FH root not found at '$FH' — run from the FH repo." >&2; exit 2
+fi
+
+SLUG="${1:-}"
+[ -z "$SLUG" ] && { echo "usage: chamber_run.sh <candidate-slug> [status]" >&2; exit 2; }
+# slug charset: [A-Za-z0-9-] only, no leading dash. Rejecting regex metachars (`.` `+` `[` `*`) is
+# load-bearing — $SLUG is interpolated raw into an ERE idempotency grep below; `a.b` would let `.` match
+# any char (idempotency mismatch → duplicate ledger row), `a+b` would break the ERE (Axis-2 LOW-5).
+case "$SLUG" in -*) echo "❌ bad slug '$SLUG' (no leading dash)" >&2; exit 2 ;; esac
+case "$SLUG" in *[!A-Za-z0-9-]*) echo "❌ bad slug '$SLUG' (allowed: letters, digits, hyphen)" >&2; exit 2 ;; esac
+CMD="${2:-advance}"
+
+WS="$FH/tracks/_chamber/$SLUG"
+LEDGER="$FH/tracks/_chamber/INDEX.md"
+STATUS_F="$WS/STATUS"
+TODAY="$(date +%Y-%m-%d)"
+
+_status() { [ -f "$STATUS_F" ] && cat "$STATUS_F" || echo "step-0"; }
+_stamp()  { printf '%s\n' "$1" > "$STATUS_F"; }
+
+if [ "$CMD" = "status" ]; then
+  echo "chamber run '$SLUG' → STATUS: $(_status)"
+  [ -d "$WS" ] && ls -1 "$WS" 2>/dev/null | sed 's/^/    /'
+  exit 0
+fi
+
+echo "── chamber run: $SLUG (STATUS: $(_status)) ──"
+
+# STEP 1 — workspace
+if [ ! -d "$WS" ]; then
+  mkdir -p "$WS" 2>/dev/null || { echo "❌ cannot create workspace $WS" >&2; exit 2; }
+  echo "  ✓ step 1: workspace created ($WS)"
+fi
+_stamp "step-1-done"
+
+# STEP 2 — INTENT.md (template if absent; block until it has real content)
+if [ ! -f "$WS/INTENT.md" ]; then
+  cat > "$WS/INTENT.md" <<EOF
+# INTENT — $SLUG (chamber run)
+
+## Candidate intent
+<one line: the capability/project to incubate>
+
+## Success conditions (each with a check class: mandatory-pass / measured / judged)
+1.
+2.
+
+## Failure cost (blast radius AND reinvention risk)
+-
+
+## Chamber metadata
+- entry reason: <uncertain | exploratory | failure-expensive | high-reinvention-risk>
+- date: $TODAY
+EOF
+  echo "  ⛔ step 2 BLOCKED: fill in $WS/INTENT.md (template written), then re-run."; exit 1
+fi
+if grep -q '<one line: the capability' "$WS/INTENT.md"; then
+  echo "  ⛔ step 2 BLOCKED: $WS/INTENT.md still has the placeholder — fill it, then re-run."; exit 1
+fi
+# gate (a) is "artifact exists WITH real content", not just "placeholder removed" (Axis-2 LOW-6): require
+# at least one non-empty numbered success condition so a gutted INTENT.md doesn't pass.
+if ! awk '/^## Success conditions/{f=1;next} /^## /{f=0} f && /^[0-9]+\.[[:space:]]*[^[:space:]]/{print; exit}' "$WS/INTENT.md" | grep -q .; then
+  echo "  ⛔ step 2 BLOCKED: $WS/INTENT.md has no filled success condition (need a numbered line with content), re-run."; exit 1
+fi
+_stamp "step-2-done"; echo "  ✓ step 2: INTENT.md present"
+
+# STEP 3 — budget-entry gate (G2). Cannot invoke goal-quench from bash; MECHANICALLY require a recorded
+# estimate before any (expensive) simulation runs. No ESTIMATE = no run — that IS the entry cap.
+if [ ! -f "$WS/BUDGET.md" ]; then
+  cat > "$WS/BUDGET.md" <<EOF
+# BUDGET — $SLUG (chamber run)
+
+# Route through goal-quench's budget gate for an expensive run, then record here.
+# Demo-scale runs may self-cap — but an ESTIMATE line is mandatory (this is the entry cap).
+ESTIMATE: <e.g. ~3 persona dispatches, demo-scale, self-capped  |  or a token budget>
+ACTUAL:   <filled at step 6>
+EOF
+  echo "  ⛔ step 3 BLOCKED: record an ESTIMATE in $WS/BUDGET.md (budget-entry gate G2), then re-run."; exit 1
+fi
+if grep -qE '^ESTIMATE:[[:space:]]*<' "$WS/BUDGET.md" || ! grep -qE '^ESTIMATE:[[:space:]]*\S' "$WS/BUDGET.md"; then
+  echo "  ⛔ step 3 BLOCKED: $WS/BUDGET.md ESTIMATE is empty/placeholder (G2 entry cap), then re-run."; exit 1
+fi
+_stamp "step-3-done"; echo "  ✓ step 3: budget ESTIMATE recorded (entry cap satisfied)"
+
+# STEP 4 — persona simulation (G1-forcing gate). Dispatch is human/Claude-side (bash can't spawn Agents);
+# gate on the ≥3 blind persona artifact. Isolation is the mechanism — the runner enforces the artifact, not the spawn.
+if [ ! -f "$WS/SIM_NOTES.md" ]; then
+  echo "  ⛔ step 4 BLOCKED: dispatch 3 BLIND ISOLATED Agents and record each in $WS/SIM_NOTES.md:"
+  echo "        Agent fh-meta:beginner      → first-contact friction"
+  echo "        Agent fh-meta:main-player   → daily-use / target-user value"
+  echo "        Agent fh-meta:challenger    → skeptic: emit value? failure cost? what's invisible?"
+  echo "     Each as '## <persona> ...' section. (sim-conductor fills persona_container_schema's 6 slots.)"
+  exit 1
+fi
+# count DISTINCT personas (not raw lines — 3×"## beginner" must NOT satisfy the 3-blind-persona gate).
+NPERS=0
+for _p in beginner main-player challenger; do
+  grep -iqE "^##[[:space:]].*$_p" "$WS/SIM_NOTES.md" 2>/dev/null && NPERS=$((NPERS+1))
+done
+if [ "$NPERS" -lt 3 ]; then
+  echo "  ⛔ step 4 BLOCKED: SIM_NOTES.md has $NPERS/3 DISTINCT blind persona sections (need all of beginner + main-player + challenger)."; exit 1
+fi
+_stamp "step-4-done"; echo "  ✓ step 4: $NPERS blind persona sections present (isolation-gate satisfied)"
+
+# STEP 5 — Emission Gate. Require a VERDICT: EMIT | PARTIAL-EMIT | KILL.
+if [ ! -f "$WS/EMISSION_VERDICT.md" ]; then
+  cat > "$WS/EMISSION_VERDICT.md" <<EOF
+# Emission Gate Verdict — $SLUG (chamber run)
+
+VERDICT: <EMIT | PARTIAL-EMIT | KILL>
+
+## Judged: does the simulation hold?  (+ mechanical anchor: overlap grep / gate verdicts / reproduced flows)
+
+## Carry-forward (what compounds into the next run)
+-
+EOF
+  echo "  ⛔ step 5 BLOCKED: decide WITH the operator (HITL), record VERDICT in $WS/EMISSION_VERDICT.md, re-run."; exit 1
+fi
+# PARTIAL-EMIT listed FIRST in every alternation so it is never mis-extracted as its EMIT substring.
+VERDICT=$(grep -ioE '^VERDICT:[[:space:]]*(PARTIAL-EMIT|EMIT|KILL)' "$WS/EMISSION_VERDICT.md" 2>/dev/null | head -1 | grep -ioE 'PARTIAL-EMIT|EMIT|KILL' | head -1 | tr 'a-z' 'A-Z')
+# a bare "## Verdict:" prose line (run #3 style) also counts if it names KILL/EMIT
+[ -z "$VERDICT" ] && VERDICT=$(grep -ioE 'VERDICT[: *]+\**(PARTIAL-EMIT|EMIT|KILL)' "$WS/EMISSION_VERDICT.md" 2>/dev/null | grep -ioE 'PARTIAL-EMIT|EMIT|KILL' | head -1 | tr 'a-z' 'A-Z')
+if [ -z "$VERDICT" ]; then
+  echo "  ⛔ step 5 BLOCKED: no VERDICT (EMIT|PARTIAL-EMIT|KILL) found in $WS/EMISSION_VERDICT.md, re-run."; exit 1
+fi
+_stamp "step-5-done"; echo "  ✓ step 5: Emission Gate verdict = $VERDICT"
+
+# STEP 6 — actual cost / carry-forward record.
+if grep -qE '^ACTUAL:[[:space:]]*<' "$WS/BUDGET.md" || ! grep -qE '^ACTUAL:[[:space:]]*\S' "$WS/BUDGET.md"; then
+  echo "  ⛔ step 6 BLOCKED: record ACTUAL cost in $WS/BUDGET.md (actual-vs-estimate calibration), re-run."; exit 1
+fi
+_stamp "step-6-done"; echo "  ✓ step 6: actual cost recorded"
+
+# STEP 7 — terminus + G4 ledger auto-append (idempotent).
+if [ ! -f "$LEDGER" ]; then
+  echo "  ⚠ step 7: no ledger at $LEDGER — skipping auto-append (fail-visible)."
+elif grep -qE "^\|[^|]*\|[^|]*\|[^|]*\`$SLUG\`" "$LEDGER"; then
+  echo "  ✓ step 7: ledger already has a row for '$SLUG' (idempotent — no duplicate append)."
+else
+  NEXT=$(grep -oE '^\|[[:space:]]*#([0-9]+)' "$LEDGER" | grep -oE '[0-9]+' | sort -n | tail -1)
+  NEXT=$(( ${NEXT:-0} + 1 ))
+  CARRY=$(grep -A2 -iE '^##[[:space:]]*Carry-forward' "$WS/EMISSION_VERDICT.md" 2>/dev/null | grep -E '^-[[:space:]]*\S' | head -1 | sed 's/^-[[:space:]]*//; s/|/·/g')
+  [ -z "$CARRY" ] && CARRY="see $SLUG/EMISSION_VERDICT.md"
+  printf '| #%s | %s | `%s` | **%s** | %s | `%s/` |\n' "$NEXT" "$TODAY" "$SLUG" "$VERDICT" "$CARRY" "$SLUG" >> "$LEDGER"
+  echo "  ✓ step 7: appended run #$NEXT ($VERDICT) to the G4 ledger."
+fi
+_stamp "step-7-done"
+
+echo ""
+case "$VERDICT" in
+  EMIT) echo "TERMINUS (EMIT): route by class — field harness → Full-Harness Mode (auto_project_mapping.md §6);"
+        echo "                 FH-internal utility → New-Skill Pre-Commit gate + asset-placement-gate." ;;
+  PARTIAL-EMIT) echo "TERMINUS (PARTIAL-EMIT): the standing candidate is killed; fold the surviving sliver into an"
+                echo "                 existing asset / the skeleton (no new asset). Workspace stays as evidence." ;;
+  KILL) echo "TERMINUS (KILL): first-class success — a cheap run prevented a speculative/reinvention build."
+        echo "                 No emit. Workspace stays as the evidence record; seen-filter will skip re-listing it." ;;
+esac
+echo "chamber run '$SLUG' COMPLETE (STATUS: step-7-done, verdict $VERDICT)."
+exit 0

package/scripts/degrade_direction_scan.sh

@@ -150,9 +150,24 @@ for f in "${FILES[@]}"; do
     # S5 — the pipefail-fallback disarm: `... | grep -c ... || echo 0` appends a SECOND line under
     #   `set -o pipefail`, so the later `-gt` integer test becomes a bash error (= false) and the guard
     #   passes silently, with the error going only to stderr. Measured class, 2026-07-26.
+    #
+    # NARROWED 2026-07-28 after hand-verifying all 9 hits this repo produced: 9/9 were false
+    # positives, i.e. the probe was pure noise for its own class, and 100% FP trains dismissal of
+    # the one hit that will matter. Two distinct causes, both mechanically reproduced:
+    #   (a) `a || b || echo 0` was read as a pipeline — the old regex could anchor its `\|` on the
+    #       SECOND bar of the first `||`. No pipe exists, so no second line can ever be produced.
+    #       (Every `_mtime() { stat -c %Y … || stat -f %m … || echo 0; }` in the tree was flagged.)
+    #   (b) a real pipeline whose failing stage emits NOTHING (`… | jq -r … || echo 0`) — the
+    #       fallback then supplies the only line, which is exactly the intended behavior.
+    # The disarm needs BOTH a real pipe AND a final stage that emits regardless of upstream failure
+    # — a counter (`grep -c`, `wc`). That is the measured shape: `find … | grep -c . || echo 0`
+    # yields "9\n0" and the `-gt` guard goes silent. Verified as a known pair (both directions) in
+    # scripts/test_degrade_scan_shell_probes.sh; narrowing without that anchor would just trade a
+    # noisy probe for a blind one.
     while IFS= read -r m; do
-      emit "$f" "${m%%:*}" "S5:pipefail-fallback(sh)" "\`|| echo 0\` fallback on a pipeline — under \`set -o pipefail\` this yields a multi-line value whose integer comparison errors out and silently passes the guard; split the pipeline and sanitize to an integer"
-    done < <(grep -nE '\|[^|]+\|\|[[:space:]]*echo[[:space:]]+[\"'"'"']?0' "$f" 2>/dev/null \
+      emit "$f" "${m%%:*}" "S5:pipefail-fallback(sh)" "\`|| echo 0\` fallback on a pipeline ending in a counter (grep -c/wc) — that stage emits even when an upstream stage fails, so under \`set -o pipefail\` the value gains a SECOND line, the integer comparison errors out, and the guard passes silently; split the pipeline and sanitize to an integer"
+    done < <(grep -nE '[^|]\|[[:space:]]*([a-z]+[[:space:]]+)*(grep[^|]*-c|wc)[^|]*\|\|[[:space:]]*echo[[:space:]]+[\"'"'"']?0' "$f" 2>/dev/null \
+             | grep -vE '^[0-9]+:[[:space:]]*#' \
              | grep -vE '#[[:space:]]*noqa[:[:space:]]*degrade')
   fi
 

package/scripts/fh_env_delta_scan.sh

@@ -0,0 +1,108 @@
+#!/usr/bin/env bash
+# fh_env_delta_scan.sh — Mode D SessionStart ENVIRONMENT-DELTA detector (mechanical).
+#
+# WHY: FH's "undeployed-asset discovery + auto-mapping" (CLAUDE.md claim ②) works ONLY when a skill
+# is explicitly invoked. The AUTONOMOUS half — "the environment changed (a new sibling repo pulled,
+# a task-first session opened in an unmapped project) → detect it and propose setup" — did NOT exist
+# in code. It was suppressed by the onboarding guards (metadata-is-not-intent, task-first skip), which
+# are correct (they stop FALSE onboarding from branch-name metadata) but also silence GENUINE
+# env-change setup. (Measured miss 2026-07-06: pulling pmh in the company env was not self-detected.
+# Cross-family confirmed 2026-07-06: Claude workflow + codex both rated ② PARTIAL/THEATER, biggest 허풍.)
+#
+# WHAT: this is the SIBLING of scripts/fh_session_load.sh. That hook closes the companion-store
+# FRESHNESS gap ("did the store change?"); THIS hook closes the CAPABILITY-SURFACE gap ("did the
+# environment change?"). It scans the projects root for git repos that are neither mapped
+# (tracks/{name}/ — the is-mapped signal, feedback_tracks_dir_is_mapped_signal) nor wizard-done
+# (~/.cc_sentinels/{name}_wizard_done), and emits a ONE-LINE proposal into turn-0 context. It fires
+# BEFORE the first user turn regardless of what the user types — so it closes the task-first salience
+# gap mechanically, exactly as fh_session_load.sh does for freshness.
+#
+# INVARIANTS:
+#  - PROPOSE, never auto-act. Detection is mechanical; mapping/install stays approval-gated (HITL).
+#    The hook emits a proposal line; the agent decides whether to surface/act. (metadata-is-not-intent:
+#    a mechanical fs delta is a proposal input, not an executed mapping.)
+#  - ONE-LINE proposal, NOT the onboarding menu. The guards suppress menus for a reason; this is a
+#    targeted delta, not a door skeleton.
+#  - Silent no-op when nothing is new (no repos, or all mapped/wizard-done). Majority path = quiet.
+#  - Offline-safe / fast: pure local filesystem, no network, maxdepth-1 scan.
+#  - Non-Mode-D public users: harmless — it only ever PROPOSES /install-wizard --dry-run, which is
+#    itself read-only. Still, gate on the hub being present so a bare plugin install stays silent.
+
+set -u
+
+# FH = the HUB, derived from THIS script's location ($FH/scripts/fh_env_delta_scan.sh → ../ = hub) —
+# NOT from CLAUDE_PROJECT_DIR. (codex cross-family review 2026-07-06 [HIGH]: defaulting FH to
+# CLAUDE_PROJECT_DIR made a hook run inside a new FIELD repo resolve FH to that field repo → the
+# `tracks` guard failed → the hook silently did NOT fire in exactly the new-project scenario it exists
+# for. Deriving from $0 makes FH correct wherever invoked.) HUB_DIR override still wins for tests.
+FH="${HUB_DIR:-$(CDPATH= cd -- "$(dirname -- "$0")/.." 2>/dev/null && pwd)}"
+FH="${FH:-$HOME/projects/forge-harness}"
+ROOT="${FH_PROJECTS_ROOT:-$(dirname "$FH")}"
+BE="${BE_DIR:-}"                          # companion store — never a mapping candidate
+SENT="${CC_SENTINEL_DIR:-$HOME/.cc_sentinels}"
+
+# Only operate where the hub actually exists (keeps bare-plugin installs silent).
+[ -d "$FH/tracks" ] || exit 0
+[ -d "$ROOT" ] || exit 0
+
+_abspath() { CDPATH= cd -- "$1" 2>/dev/null && pwd; }
+FH_ABS="$(_abspath "$FH")"
+BE_ABS=""; [ -n "$BE" ] && BE_ABS="$(_abspath "$BE")"
+
+# _candidate DIR → echoes basename if DIR is an unmapped mapping candidate, else nothing + returns 1.
+# ONE predicate for BOTH sibling-scan and current-cwd (codex [MED]×2: cwd previously had weaker
+# exclusions + ignored the skip sentinel → could propose the hub/companion/hidden repo and re-nag a
+# skipped repo). [LOW]: `-e .git` (not `-d`) so git worktrees/submodules (`.git` is a file) count.
+_candidate() {
+  local d abs name
+  abs="$(_abspath "$1")" || return 1
+  [ -n "$abs" ] || return 1
+  [ -e "$abs/.git" ] || return 1                       # real repo (dir OR file .git = worktree)
+  name="$(basename "$abs")"
+  [ "$abs" = "$FH_ABS" ] && return 1                   # not the hub
+  [ -n "$BE_ABS" ] && [ "$abs" = "$BE_ABS" ] && return 1   # not the companion store
+  case "$name" in _*|.*) return 1 ;; esac              # not underscore/hidden
+  [ -d "$FH/tracks/$name" ] && return 1                # mapped (is-mapped signal)
+  [ -f "$SENT/${name}_wizard_done" ] && return 1       # wizard already run
+  [ -f "$SENT/${name}_mapping_skipped" ] && return 1   # operator skipped → mechanical no-re-nag
+  printf '%s' "$name"
+}
+
+CANDIDATES=""
+COUNT=0
+for d in "$ROOT"/*/; do
+  [ -d "$d" ] || continue
+  name="$(_candidate "$d")" || continue
+  [ -n "$name" ] || continue
+  COUNT=$((COUNT + 1))
+  [ "$COUNT" -le 6 ] && CANDIDATES="${CANDIDATES}${name}, "
+done
+
+# Current cwd itself an unmapped project? (the pmh-pull / task-first-in-new-project case) — SAME
+# predicate, so identical exclusions + skip-sentinel apply.
+CWD_UNMAPPED="$(_candidate "${CLAUDE_PROJECT_DIR:-$PWD}")" || CWD_UNMAPPED=""
+
+# Nothing new → silent no-op (majority path).
+[ "$COUNT" -eq 0 ] && [ -z "$CWD_UNMAPPED" ] && exit 0
+
+# Emit the delta proposal (one block, imperative). Trim trailing ", ".
+LIST="${CANDIDATES%, }"
+# Emit: keep it LOW-NOISE (target-tier sim 2026-07-06 [noise finding]: naming irrelevant repos on a
+# task-first entry reads as a nag). The current-cwd case is the high-signal one (the pmh-pull scenario
+# = you are working IN an unmapped project right now); siblings collapse to a count + a single
+# actionable (/install-wizard --dry-run), not a named list.
+{
+  echo "⚙️ [FH env-delta] capability-surface change detected (mechanically, even on task-first entry):"
+  if [ -n "$CWD_UNMAPPED" ]; then
+    echo "  • ★ current cwd '$CWD_UNMAPPED' is an UNMAPPED project — you are working in it now; propose mapping it (auto_project_mapping, HITL)."
+  fi
+  if [ "$COUNT" -gt 0 ]; then
+    echo "  • $COUNT unmapped sibling repo(s) under $ROOT — run \`/install-wizard --dry-run\` to review + map (HITL); skip via touch \"$SENT/<name>_mapping_skipped\" (mechanical, no re-nag)."
+  fi
+  # Honest scope (target-tier sim [surfacing residual]): this hook mechanizes the CONTEXT-INJECTION
+  # half of claim ② — the env-change now reliably REACHES turn-0 context. It does NOT mechanize the
+  # SURFACING half (whether the model mentions it to the operator), which stays salience-dependent —
+  # a model cannot be mechanically forced to emit. Surface this in ONE line if the cwd is unmapped;
+  # for siblings-only, mention at most once and never derail an explicit task.
+}
+exit 0

package/scripts/memory_link_check.py

@@ -0,0 +1,237 @@
+#!/usr/bin/env python3
+"""memory_link_check.py — wikilink integrity over the memory graph.
+
+WHY THIS EXISTS (measured 2026-07-28, 872 links across 210 notes)
+
+`memory_intent_recall.md` makes the memory store a GRAPH: nodes are files, edges are `[[links]]`,
+and recall walks one hop from an index hit. That doctrine is only as good as the edges. Nothing
+checked them, and the first measurement found **50 edges pointing at a note that exists under a
+different separator** (`[[feedback-pmh-issue-routing]]` while the file is
+`feedback_pmh_issue_routing.md`) plus **22 pointing at nothing at all**. A 1-hop walk across a dead
+edge returns nothing and looks exactly like "there is nothing related" — the failure is silent, and
+it degrades the one mechanism that is supposed to surface a forgotten lesson.
+
+Absorbed from obsidian-mind's `wikilinks.ts` (MIT, breferrari) — the concern, not the code.
+
+TWO INSTRUMENT RULES LEARNED WHILE WRITING IT, both from wrong first numbers:
+
+  1. RESOLVE ACROSS EVERY STORE THE AUTHOR CAN LINK INTO. A first pass scanned only the memory
+     directory and reported 39 "missing". 17 of those resolve in the hub repo or the companion
+     store — legitimate cross-store edges. Counting them as broken would have overstated the
+     defect by 44% and sent someone hunting for files that are exactly where they belong.
+  2. EXCLUDE THE DOC TEMPLATE. `[[link]]` / `[[name]]` appear inside prose that DESCRIBES the
+     convention. Scoring the instructions as defects is the "probe flags its own remedy" class.
+
+CLASSES (a link is exactly one)
+  ok            resolves in the memory store as written
+  ambiguous     two notes share a normalized name — NEVER auto-fixed, a human picks
+  separator     resolves after -/_ normalization — mechanically repairable, and the only class
+                `--fix-separators` will touch
+  cross-store   resolves in the hub repo or companion store — reported, never "fixed"
+  placeholder   the convention's own example text
+  dangling      resolves nowhere. A human decides: write the note, or drop the edge.
+
+DEGRADE DIRECTION: advisory. This is a reversible surface (a memory edit is re-editable), so it
+reports and never blocks. `--fix-separators` writes, and only for the one class where the target is
+proven to exist.
+
+Usage:
+  python3 scripts/memory_link_check.py [--memory DIR] [--fix-separators] [--quiet]
+Exit: 0 = scanned (always, unless the extractor itself broke) · 2 = extractor found no notes
+"""
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from collections import Counter
+from pathlib import Path
+
+LINK_RE = re.compile(r"\[\[([^\]|#]+)")
+# Fenced blocks are QUOTED CONTENT — a `[[wrong-form]]` inside one is usually an example of the
+# convention, and "fixing" it destroys the documentation that teaches the rule. Skipped on the
+# write path only; they are still COUNTED, because a reader deserves to know they exist.
+#
+# Inline backticks are deliberately NOT skipped. Measured on this corpus (2026-07-28): 25 of the
+# 150 repaired links sat inside inline code and every one was a real link the author had merely
+# styled with backticks — that is this store's citation convention. Fenced-block changes in the
+# same run: 0. So the two spans are not the same thing here, and treating them alike would either
+# damage examples (skip nothing) or leave a quarter of the dead edges dead (skip both).
+FENCE_RE = re.compile(r"```.*?```", re.S)
+PLACEHOLDERS = {"link", "name", "their-name"}
+def default_memory() -> Path | None:
+    """Locate this project's Claude-Code memory dir WITHOUT hard-coding a username or path.
+
+    Claude Code stores per-project memory under ~/.claude/projects/<encoded-abs-path>/memory, and
+    the encoding maps path separators to '-', so it differs per user and per OS. Globbing the
+    encoded tail (parent + project folder) is portable AND keeps an operator's real home path out
+    of a public file — the confidentiality gate rejected the first draft of this line for exactly
+    that reason, which is the gate working.
+    """
+    root = Path(__file__).resolve().parents[1]
+    tail = f"{root.parent.name}-{root.name}"
+    base = Path.home() / ".claude/projects"
+    if not base.is_dir():
+        return None
+    for d in sorted(base.glob(f"*{tail}")):
+        if (d / "memory").is_dir():
+            return d / "memory"
+    return None
+
+
+def extra_roots() -> list[Path]:
+    """Other stores an author may legitimately link into.
+
+    The hub itself, plus any sibling store named by MEMORY_LINK_EXTRA_ROOTS (colon-separated).
+    A private companion store is NOT named here: its name is operator configuration, not a
+    property of this tool, and embedding it would publish a private repo name.
+    """
+    import os
+    roots = [Path(__file__).resolve().parents[1]]
+    for raw in filter(None, os.environ.get("MEMORY_LINK_EXTRA_ROOTS", "").split(":")):
+        roots.append(Path(raw).expanduser())
+    return [r for r in roots if r.is_dir()]
+
+
+def norm(s: str) -> str:
+    return s.replace("-", "_").lower()
+
+
+# Normalized keys whose bucket holds MORE THAN ONE distinct memory note. Auto-fixing these would
+# pick whichever file sorted first and silently reroute an edge to the wrong note — and the reroute
+# is permanent, because the rewritten link then resolves exactly and no later run flags it.
+# Cross-family review (gpt-5.5, 2026-07-29) supplied the reachable input: `alpha-beta.md` and
+# `alpha_beta.md` both exist, a note links `[[Alpha_Beta]]` meaning the underscore one, and case
+# drift alone is enough to send it to the hyphen one. Reported as ambiguous, never rewritten.
+AMBIGUOUS: set[str] = set()
+
+
+def build_index(memory: Path) -> dict[str, tuple[str, str]]:
+    idx: dict[str, tuple[str, str]] = {}
+    AMBIGUOUS.clear()
+    seen: dict[str, str] = {}
+    for p in sorted(memory.glob("*.md")):
+        k = norm(p.stem)
+        if k in seen and seen[k] != p.name:
+            AMBIGUOUS.add(k)
+        seen[k] = p.name
+        idx.setdefault(k, ("memory", p.name))
+    for root in extra_roots():
+        for p in root.rglob("*.md"):
+            if ".git" in p.parts:
+                continue
+            idx.setdefault(norm(p.stem), (root.name, str(p.relative_to(root))))
+    return idx
+
+
+def classify(target: str, memory: Path, idx: dict) -> str:
+    t = target.strip()
+    if t in PLACEHOLDERS:
+        return "placeholder"
+    if (memory / f"{t}.md").exists():
+        return "ok"
+    k = norm(t)
+    hit = idx.get(k)
+    if hit is None:
+        return "dangling"
+    if hit[0] == "memory":
+        return "ambiguous" if k in AMBIGUOUS else "separator"
+    return "cross-store"
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--memory", type=Path, default=None)
+    ap.add_argument("--fix-separators", action="store_true",
+                    help="rewrite ONLY the separator class, whose target is proven to exist")
+    ap.add_argument("--quiet", action="store_true")
+    a = ap.parse_args()
+
+    memory = a.memory or default_memory()
+    if memory is None or not memory.is_dir():
+        print(f"memory-link-check: SKIP (no memory dir at {memory})")
+        return 0
+    notes = sorted(memory.glob("*.md"))
+    if not notes:
+        # Impossible-zero guard: a store with no notes means the path or glob broke. A scan that
+        # cannot see its subject must not report a clean graph.
+        print("memory-link-check: FAIL — 0 notes found; the scan broke, it did not pass", file=sys.stderr)
+        return 2
+
+    idx = build_index(memory)
+    counts: Counter[str] = Counter()
+    dangling: list[tuple[str, str]] = []
+    ambiguous: list[tuple[str, str]] = []
+    seps: list[tuple[Path, str, str]] = []
+
+    for p in notes:
+        text = p.read_text(encoding="utf-8", errors="ignore")
+        for raw in LINK_RE.findall(text):
+            t = raw.strip()
+            k = classify(t, memory, idx)
+            counts[k] += 1
+            if k == "dangling":
+                dangling.append((p.name, t))
+            elif k == "ambiguous":
+                ambiguous.append((p.name, t))
+            elif k == "separator":
+                seps.append((p, t, idx[norm(t)][1][:-3]))
+
+    total = sum(counts.values())
+    if not a.quiet:
+        print(f"memory-link-check: {len(notes)} notes · {total} links")
+        for k in ("ok", "separator", "ambiguous", "cross-store", "placeholder", "dangling"):
+            print(f"  {k:12s} {counts[k]}")
+        if counts["ambiguous"]:
+            print("\n  ambiguous — two notes share a normalized name; a human must pick, the fixer will not:")
+            for t, n in Counter(t for _, t in ambiguous).most_common():
+                print(f"    {n}x  [[{t}]]")
+        if dangling:
+            print("\n  dangling (nothing on disk answers these — write the note, or drop the edge):")
+            for t, n in Counter(t for _, t in dangling).most_common():
+                print(f"    {n}x  [[{t}]]")
+
+    if a.fix_separators and seps:
+        touched, skipped, fixed = 0, 0, 0
+        for p in {s[0] for s in seps}:
+            text = p.read_text(encoding="utf-8")
+            # Split on fenced blocks and rewrite only the parts OUTSIDE them, then rejoin. Doing it
+            # by span keeps the fence contents byte-identical instead of relying on the replacement
+            # string being unique.
+            parts, last, out = [], 0, []
+            for m in FENCE_RE.finditer(text):
+                parts.append((text[last:m.start()], True))
+                parts.append((m.group(0), False))
+                last = m.end()
+            parts.append((text[last:], True))
+            for chunk, editable in parts:
+                if editable:
+                    for _, wrong, right in [s for s in seps if s[0] == p]:
+                        # Rewrite the TARGET only, leaving whatever follows it intact — an anchor
+                        # (`#section`), an alias (`|shown as`), or nothing.
+                        #
+                        # An earlier version enumerated the closing forms by hand (`]]` and `|`)
+                        # and therefore silently skipped `[[target#anchor]]`: the link was still
+                        # COUNTED as repairable, so every later run flagged it again (idempotence
+                        # broken) and the summary reported more fixes than it had made. Found by a
+                        # cross-family reviewer and confirmed by execution before being accepted.
+                        pat = re.compile(r"\[\[" + re.escape(wrong) + r"(?=[\]|#])")
+                        chunk, n = pat.subn(f"[[{right}", chunk)
+                        fixed += n
+                else:
+                    skipped += sum(chunk.count(f"[[{s[1]}") for s in seps if s[0] == p)
+                out.append(chunk)
+            p.write_text("".join(out), encoding="utf-8")
+            touched += 1
+        # Report what was ACTUALLY rewritten, not what was eligible. The two diverged once and the
+        # summary over-reported; a fixer that miscounts its own writes cannot be checked by reading
+        # its output.
+        print(f"\n  fixed {fixed} separator link(s) across {touched} file(s)"
+              + (f"; left {skipped} inside fenced blocks (quoted examples)" if skipped else ""))
+    elif seps and not a.quiet:
+        print(f"\n  {len(seps)} separator link(s) are mechanically repairable → --fix-separators")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())