@junghanacs/entwurf 0.14.2 → 0.15.1

package/scripts/copilot-statusline-config.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+"""Stateful Copilot statusLine settings adapter; stdlib only.
+
+Owns the whole ``statusLine`` subtree and the one prerequisite leaf
+``footer.showCustom``.  It adopts regular settings.json files, refuses symlinks,
+and records first-install preimages for an honest inverse.
+"""
+
+import datetime
+import json
+import os
+import sys
+import tempfile
+
+STATE_SCHEMA_VERSION = 1
+STATUSLINE_KEY = "statusLine"
+FOOTER_KEY = "footer"
+SHOW_CUSTOM_KEY = "showCustom"
+
+
+def die(code: int, message: str) -> "None":
+    sys.stderr.write(message.rstrip("\n") + "\n")
+    raise SystemExit(code)
+
+
+def load_object(path: str, label: str) -> dict:
+    try:
+        with open(path, "r", encoding="utf-8") as handle:
+            raw = handle.read()
+    except OSError as error:
+        die(4, f"copilot-statusline: cannot read {label} {path}: {error}")
+    if not raw.strip():
+        return {}
+    try:
+        value = json.loads(raw)
+    except json.JSONDecodeError as error:
+        die(4, f"copilot-statusline: {label} {path} is not valid JSON: {error}")
+    if not isinstance(value, dict):
+        die(4, f"copilot-statusline: {label} {path} top-level must be a JSON object")
+    return value
+
+
+def atomic_write(path: str, value: dict) -> None:
+    directory = os.path.dirname(os.path.abspath(path))
+    os.makedirs(directory, exist_ok=True)
+    fd, temporary = tempfile.mkstemp(dir=directory, prefix=".copilot-statusline-", suffix=".json")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            json.dump(value, handle, indent=2)
+            handle.write("\n")
+        os.replace(temporary, path)
+    except BaseException:
+        try:
+            os.unlink(temporary)
+        except FileNotFoundError:
+            pass
+        raise
+
+
+def now() -> str:
+    return datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def checked_state(state_path: str) -> dict:
+    state = load_object(state_path, "install-state")
+    required = (
+        "managedSettingsPath",
+        "settingsExistedBefore",
+        "statusLineExisted",
+        "statusLinePreimage",
+        "footerExisted",
+        "showCustomExisted",
+        "showCustomPreimage",
+    )
+    if state.get("schemaVersion") != STATE_SCHEMA_VERSION or any(key not in state for key in required):
+        die(4, f"copilot-statusline: install-state {state_path} has an unsupported shape")
+    return state
+
+
+def prior_state(state_path: str, settings_path: str) -> dict | None:
+    if not os.path.exists(state_path):
+        return None
+    state = checked_state(state_path)
+    return state if state["managedSettingsPath"] == os.path.abspath(settings_path) else None
+
+
+def install(settings_path: str, command: str, state_path: str) -> None:
+    if os.path.islink(settings_path):
+        die(3, f"copilot-statusline: refusing to adopt {settings_path} — symlink to {os.readlink(settings_path)} (someone else's SSOT)")
+
+    existed = os.path.exists(settings_path)
+    settings = load_object(settings_path, "settings") if existed else {}
+    footer_existed = FOOTER_KEY in settings
+    footer = settings.get(FOOTER_KEY) if footer_existed else {}
+    if not isinstance(footer, dict):
+        die(4, f"copilot-statusline: {settings_path} footer must be a JSON object")
+
+    prior = prior_state(state_path, settings_path)
+    if prior is None:
+        state = {
+            "schemaVersion": STATE_SCHEMA_VERSION,
+            "managedSettingsPath": os.path.abspath(settings_path),
+            "command": command,
+            "detectMode": "adopt-regular-file" if existed else "created-new",
+            "settingsExistedBefore": existed,
+            "statusLineExisted": STATUSLINE_KEY in settings,
+            "statusLinePreimage": settings.get(STATUSLINE_KEY),
+            "footerExisted": footer_existed,
+            "showCustomExisted": SHOW_CUSTOM_KEY in footer,
+            "showCustomPreimage": footer.get(SHOW_CUSTOM_KEY),
+            "installedAt": now(),
+        }
+    else:
+        state = prior
+
+    settings[STATUSLINE_KEY] = {"command": command}
+    footer[SHOW_CUSTOM_KEY] = True
+    settings[FOOTER_KEY] = footer
+    atomic_write(settings_path, settings)
+    atomic_write(state_path, state)
+    sys.stdout.write(f"{state['detectMode']} {os.path.abspath(settings_path)}\n")
+
+
+def uninstall(state_path: str) -> None:
+    if not os.path.exists(state_path):
+        die(2, f"copilot-statusline: no install-state at {state_path} — nothing to undo")
+    state = checked_state(state_path)
+    settings_path = state.get("managedSettingsPath")
+    if not isinstance(settings_path, str) or not os.path.isabs(settings_path):
+        die(4, f"copilot-statusline: install-state {state_path} has no absolute managedSettingsPath")
+    if os.path.islink(settings_path):
+        die(3, f"copilot-statusline: refusing to uninstall — {settings_path} became a symlink (someone else's SSOT)")
+
+    if os.path.exists(settings_path):
+        settings = load_object(settings_path, "settings")
+        if state.get("statusLineExisted"):
+            settings[STATUSLINE_KEY] = state.get("statusLinePreimage")
+        else:
+            settings.pop(STATUSLINE_KEY, None)
+
+        footer = settings.get(FOOTER_KEY)
+        if not isinstance(footer, dict):
+            die(4, f"copilot-statusline: {settings_path} footer changed to a non-object; refusing to guess")
+        if state.get("showCustomExisted"):
+            footer[SHOW_CUSTOM_KEY] = state.get("showCustomPreimage")
+        else:
+            footer.pop(SHOW_CUSTOM_KEY, None)
+        if footer or state.get("footerExisted"):
+            settings[FOOTER_KEY] = footer
+        else:
+            settings.pop(FOOTER_KEY, None)
+
+        created = state.get("detectMode") == "created-new" and state.get("settingsExistedBefore") is False
+        if created and not settings:
+            os.remove(settings_path)
+        else:
+            atomic_write(settings_path, settings)
+
+    os.remove(state_path)
+    sys.stdout.write(f"uninstalled {settings_path}\n")
+
+
+def doctor_static(settings_path: str, command: str) -> None:
+    if os.path.islink(settings_path):
+        sys.stdout.write("symlink\n")
+        return
+    if not os.path.exists(settings_path):
+        sys.stdout.write("file-absent\n")
+        return
+    try:
+        settings = load_object(settings_path, "settings")
+    except SystemExit:
+        sys.stdout.write("invalid-json\n")
+        return
+    status_line = settings.get(STATUSLINE_KEY)
+    if not isinstance(status_line, dict) or status_line.get("command") != command:
+        sys.stdout.write("not-ours\n")
+        return
+    footer = settings.get(FOOTER_KEY)
+    if not isinstance(footer, dict) or footer.get(SHOW_CUSTOM_KEY) is not True:
+        sys.stdout.write("custom-disabled\n")
+        return
+    sys.stdout.write(f"configured {command}\n")
+
+
+def main(argv: list[str]) -> None:
+    if len(argv) < 2:
+        die(5, "usage: copilot-statusline-config.py <install|uninstall|doctor-static> ...")
+    match argv[1]:
+        case "install" if len(argv) == 5:
+            install(argv[2], argv[3], argv[4])
+        case "uninstall" if len(argv) == 3:
+            uninstall(argv[2])
+        case "doctor-static" if len(argv) == 4:
+            doctor_static(argv[2], argv[3])
+        case _:
+            die(5, "usage: copilot-statusline-config.py <install settings command state|uninstall state|doctor-static settings command>")
+
+
+if __name__ == "__main__":
+    main(sys.argv)

package/scripts/copilot-statusline.sh

@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+# copilot-statusline — Copilot custom footer: garden id only.
+#
+# Copilot already draws directory/branch/model/context/quota. This fills the
+# custom slot with the garden id. Vocabulary matches Claude and agy
+# (ready / ? / !); rail `cop`. Fail-quiet: nonzero blanks the slot (bundle Fxi).
+# Bare bin: entwurf-copilot-statusline. No cache, no git, no ANSI.
+# Reads session_id only — any other envelope key is Copilot's, not ours.
+set -euo pipefail
+
+# Copilot silently blanks a nonzero statusline, so a read failure degrades to ready.
+input=$(cat || true)
+if ! command -v python3 >/dev/null 2>&1; then
+  printf '🪛 ? cop'
+  exit 0
+fi
+output="$(STATUSLINE_INPUT="$input" python3 - <<'PY'
+import json, os, sys
+from pathlib import Path
+
+def load_input():
+    raw = os.environ.get("STATUSLINE_INPUT", "")
+    try:
+        data = json.loads(raw) if raw.strip() else {}
+    except Exception:
+        return {}
+    return data if isinstance(data, dict) else {}
+
+def meta_sessions_dir():
+    override = os.environ.get("ENTWURF_META_SESSIONS_DIR")
+    if override:
+        return Path(override).expanduser().resolve()
+    agent = os.environ.get("PI_CODING_AGENT_DIR")
+    if agent:
+        return Path(agent).expanduser().resolve() / "meta-sessions"
+    return Path.home() / ".pi" / "agent" / "meta-sessions"
+
+def garden_lookup(native_session_id):
+    if not native_session_id:
+        return "ready"
+    root = meta_sessions_dir()
+    if not root.exists():
+        return "?"
+    matches = []
+    try:
+        entries = sorted(root.glob("*.meta.json"))
+    except Exception:
+        return "?"
+    for file in entries:
+        try:
+            record = json.loads(file.read_text(encoding="utf-8"))
+        except Exception:
+            continue
+        if isinstance(record, dict) and record.get("nativeSessionId") == native_session_id:
+            garden = record.get("gardenId")
+            matches.append(garden if isinstance(garden, str) and garden else "!")
+    if len(matches) == 1:
+        return matches[0]
+    if len(matches) > 1:
+        return "!"
+    return "?"
+
+data = load_input()
+sid = data.get("session_id")
+sys.stdout.write(f"🪛 {garden_lookup(sid if isinstance(sid, str) else '')} cop")
+PY
+)" || output='🪛 ? cop'
+printf '%s' "$output"

package/scripts/dev-bin.sh

@@ -7,11 +7,13 @@
 # each recorded in its OWN checkout-OUTSIDE install-state (<name>.install-state.json) for an
 # honest inverse.
 #
-# Managed bins (both are BARE names that configs record — no repo/checkout path is EVER written
-# into any config; this only makes the bare name RESOLVE in a dev checkout):
+# Managed bins (all are BARE names — no repo/checkout path is EVER written into a harness
+# config; this only makes each package command RESOLVE in a dev checkout):
+#   entwurf                 -> run.sh                          (operator command / managed Copilot runtime)
 #   entwurf-bridge          -> mcp/entwurf-bridge/start.sh    (agy mcp_config command)
 #   entwurf-agy-statusline  -> scripts/agy-statusline.sh      (agy settings.statusLine command)
 #   entwurf-agy-imprint     -> scripts/agy-imprint.sh         (agy PreInvocation birth hook)
+#   entwurf-copilot-statusline -> scripts/copilot-statusline.sh (copilot settings.statusLine command)
 #
 # Ownership discipline (mirrors the agy adopt/refuse rule, 봉인 7), applied PER BIN:
 #   - create/refresh ONLY a link that is OURS — absent, or a symlink into our target, or the
@@ -26,15 +28,20 @@
 # name on a later expose is re-reported (drift visibility).
 #
 #   expose [name]   create/refresh managed link(s) (idempotent; REFUSE foreign → exit 3).
-#                   no name = all managed bins.
+#                   no name = all managed bins, each attempted INDEPENDENTLY (#86 C1): one
+#                   foreign refusal no longer aborts the loop, the trailing summary reports
+#                   attempted/ok/refused truthfully, and any refusal still exits 3.
 #   remove [name]   honest inverse from state (remove only OUR link; REFUSE if it became foreign).
 #                   no name = all managed bins.
+#   verify <name>   require OUR symlink → target and that exact link as the PATH winner.
 #
 # Overridable for the isolated smoke:
-#   ENTWURF_DEV_BIN_DIR            link location (default: ~/.local/bin — where agy itself lives)
+#   ENTWURF_DEV_BIN_DIR           link location (default: ~/.local/bin — where agy itself lives)
+#   ENTWURF_OPERATOR_TARGET       entwurf target (default: $REPO/run.sh)
 #   ENTWURF_BRIDGE_TARGET         entwurf-bridge target (default: $REPO/mcp/entwurf-bridge/start.sh)
 #   ENTWURF_AGY_STATUSLINE_TARGET entwurf-agy-statusline target (default: $REPO/scripts/agy-statusline.sh)
 #   ENTWURF_AGY_IMPRINT_TARGET    entwurf-agy-imprint target (default: $REPO/scripts/agy-imprint.sh)
+#   ENTWURF_COPILOT_STATUSLINE_TARGET entwurf-copilot-statusline target (default: $REPO/scripts/copilot-statusline.sh)
 #   XDG_DATA_HOME                 state root (states under $XDG_DATA_HOME/entwurf/dev-bin/)
 set -euo pipefail
 
@@ -45,7 +52,7 @@ BIN_DIR="${ENTWURF_DEV_BIN_DIR:-$HOME/.local/bin}"
 STATE_DIR="${XDG_DATA_HOME:-$HOME/.local/share}/entwurf/dev-bin"
 LEGACY_STATE="$STATE_DIR/install-state.json"   # pre-multi-bin single state == entwurf-bridge
 
-MANAGED_BINS="entwurf-bridge entwurf-agy-statusline entwurf-agy-imprint"
+MANAGED_BINS="entwurf entwurf-bridge entwurf-agy-statusline entwurf-agy-imprint entwurf-copilot-statusline"
 
 log()  { printf '%s\n' "$*"; }
 warn() { printf '%s\n' "$*" >&2; }
@@ -53,9 +60,11 @@ fail() { printf 'FAIL: %s\n' "$*" >&2; exit 1; }
 
 bin_target() {  # $1 = name → prints target path (env-overridable for smoke)
   case "$1" in
+    entwurf)                echo "${ENTWURF_OPERATOR_TARGET:-$REPO_DIR/run.sh}" ;;
     entwurf-bridge)         echo "${ENTWURF_BRIDGE_TARGET:-$REPO_DIR/mcp/entwurf-bridge/start.sh}" ;;
     entwurf-agy-statusline) echo "${ENTWURF_AGY_STATUSLINE_TARGET:-$REPO_DIR/scripts/agy-statusline.sh}" ;;
     entwurf-agy-imprint)    echo "${ENTWURF_AGY_IMPRINT_TARGET:-$REPO_DIR/scripts/agy-imprint.sh}" ;;
+    entwurf-copilot-statusline) echo "${ENTWURF_COPILOT_STATUSLINE_TARGET:-$REPO_DIR/scripts/copilot-statusline.sh}" ;;
     *) return 1 ;;
   esac
 }
@@ -136,7 +145,9 @@ PY
   fi
 }
 
-expose_one() {  # $1 = name
+expose_one() {  # $1 = name; a foreign link RETURNS 3 (no exit) so the no-arg
+                # composition can attempt every unit independently (#86 C1) —
+                # a broken checkout (missing/unknown target) still fails loud.
   local name="$1" target link sf detect
   target="$(bin_target "$name")" || fail "unknown managed bin: $name"
   link="$BIN_DIR/$name"; sf="$(state_file_for "$name")"
@@ -146,7 +157,7 @@ expose_one() {  # $1 = name
   [ -x "$target" ] || fail "target is not an executable file: $target (is this a dev checkout?)"
   if ! link_is_ours "$link" "$target" "$sf"; then
     warn "[dev-bin] REFUSE ($name): $link exists and is NOT ours (a foreign file/symlink — e.g. a real npm consumer bin). Not clobbering someone else's SSOT."
-    exit 3
+    return 3
   fi
   detect="created-new"; [ -L "$link" ] && detect="refresh-ours"
   mkdir -p "$BIN_DIR"
@@ -158,6 +169,21 @@ expose_one() {  # $1 = name
   fi
 }
 
+verify_one() {  # $1 = name
+  local name="$1" target link resolved
+  target="$(bin_target "$name")" || fail "unknown managed bin: $name"
+  link="$BIN_DIR/$name"
+  resolved="$(command -v "$name" 2>/dev/null || true)"
+  if [ ! -L "$link" ] || [ "$(readlink "$link" 2>/dev/null || true)" != "$target" ] || [ "$resolved" != "$link" ]; then
+    warn "[dev-bin] FAIL ($name): source command is not the PATH winner owned by this checkout."
+    warn "  expected: $link -> $target"
+    warn "  resolved: ${resolved:-<none>}"
+    warn "  fix: remove a foreign/shadowing bin or put $BIN_DIR on PATH, then re-run setup."
+    return 1
+  fi
+  log "[dev-bin verify] $name → $target (PATH winner: $link)"
+}
+
 remove_one() {  # $1 = name
   local name="$1" target link sf recorded
   target="$(bin_target "$name")" || fail "unknown managed bin: $name"
@@ -182,7 +208,24 @@ remove_one() {  # $1 = name
 
 do_expose() {  # $1 = optional bin name
   migrate_legacy
-  if [ -n "${1:-}" ]; then expose_one "$1"; else for b in $MANAGED_BINS; do expose_one "$b"; done; fi
+  if [ -n "${1:-}" ]; then expose_one "$1"; return $?; fi
+  # No-arg = the setup composition. Attempt EVERY unit independently (#86 C1):
+  # the old loop stopped at the first foreign refusal while the caller's warning
+  # claimed only that one bin was left as-is — units after it were never
+  # attempted. Now each refusal is recorded, later units still run, and the
+  # summary line reports attempted/ok/refused so no caller can claim less than
+  # what happened. Any refusal keeps the loop's exit 3 contract.
+  local attempted=0 exposed=0 refused="" rc b
+  for b in $MANAGED_BINS; do
+    attempted=$((attempted + 1))
+    rc=0; expose_one "$b" || rc=$?
+    if [ "$rc" -eq 0 ]; then exposed=$((exposed + 1)); else refused="$refused $b"; fi
+  done
+  if [ -n "$refused" ]; then
+    warn "[dev-bin expose] summary: attempted=$attempted ok=$exposed refused=$((attempted - exposed)):$refused (every unit was attempted independently)"
+    return 3
+  fi
+  log "[dev-bin expose] summary: attempted=$attempted ok=$exposed refused=0"
 }
 do_remove() {  # $1 = optional bin name
   if [ -n "${1:-}" ]; then remove_one "$1"; else for b in $MANAGED_BINS; do remove_one "$b"; done; fi
@@ -191,5 +234,6 @@ do_remove() {  # $1 = optional bin name
 case "${1:-}" in
   expose) shift; do_expose "${1:-}" ;;
   remove) shift; do_remove "${1:-}" ;;
-  *) echo "usage: dev-bin.sh <expose|remove> [bin-name]" >&2; exit 2 ;;
+  verify) shift; [ -n "${1:-}" ] || fail "verify requires one managed bin name"; verify_one "$1" ;;
+  *) echo "usage: dev-bin.sh <expose|remove> [bin-name] | verify <bin-name>" >&2; exit 2 ;;
 esac

package/scripts/fake-copilot-vendor.sh

@@ -0,0 +1,67 @@
+#!/usr/bin/env bash
+# fake-copilot-vendor.sh — ONE factory for the stateful fake Copilot CLI the
+# aggregate-setup gates drive (#86 C3b). Two consumers share it so their fakes
+# cannot drift: smoke-setup-verdict's copilot-present cell and check-pack-install's
+# installed copilot-present consumer row. The answer shapes are the MEASURED CLI's
+# (copilot 1.0.80, 2026-08-27) — the same shapes check-copilot-birth-hook.ts bakes
+# into its own TS fake: `plugin list` prints qualified ids with a `(vX)` suffix,
+# `plugin marketplace list` prints `<name> (Local: <abs path>)`, and `--force`
+# anywhere is refused loudly (the real `marketplace remove --force` uninstalls that
+# marketplace's plugins as a side effect; no entwurf surface may reach for it).
+#
+# This factory models the SUCCESS host only. A failing-list vendor is two lines and
+# stays inline in the cell that needs it (check-setup-qualification Cell D).
+#
+# usage: bash scripts/fake-copilot-vendor.sh <dir> <plugin_json>
+#
+# EXECUTE this file; do not source it. `_check_pack_install_impl` holds a
+# `trap … RETURN` around its temp roots, and bash fires a RETURN trap when a
+# `.`/`source` finishes too — sourcing this factory there deleted the whole
+# npm sandbox mid-gate (measured 2026-08-27). A child process cannot.
+#
+#   Writes <dir>/copilot (executable) plus its state files into <dir>:
+#     installed.txt      qualified ids `plugin install` appended
+#     marketplaces.txt   `<name>\t<path>` rows `plugin marketplace add` appended
+#     calls.log          every argv line the fake answered
+#   The advertised version is read from <plugin_json> (the same file the real
+#   installer reads), so the post-install exact-row check joins on one SSOT.
+set -euo pipefail
+
+make_fake_copilot() { # $1 = dir, $2 = plugin.json path
+	local dir="$1" plugin_json="$2" ver
+	ver="$(python3 -c 'import json,sys;print(json.load(open(sys.argv[1]))["version"])' "$plugin_json")" || return 1
+	mkdir -p "$dir"
+	: > "$dir/installed.txt"
+	: > "$dir/marketplaces.txt"
+	: > "$dir/calls.log"
+	cat > "$dir/copilot" <<FAKE
+#!/usr/bin/env bash
+STATE="$dir/installed.txt"
+MKTS="$dir/marketplaces.txt"
+LOG="$dir/calls.log"
+VER="$ver"
+echo "\$*" >> "\$LOG"
+for a in "\$@"; do [ "\$a" = "--force" ] && { echo "fake copilot: --force is forbidden here" >&2; exit 99; }; done
+case "\$1 \$2 \$3" in
+  "plugin marketplace list")
+    echo "Included with GitHub Copilot:"
+    while IFS=\$'\t' read -r n p; do [ -n "\$n" ] && echo "  • \$n (Local: \$p)"; done < "\$MKTS"
+    exit 0 ;;
+  "plugin marketplace add") printf "%s\t%s\n" "meta-bridge-copilot-local" "\$4" >> "\$MKTS"; exit 0 ;;
+  "plugin marketplace remove") awk -F"\t" -v n="\$4" '\$1 != n' "\$MKTS" > "\$MKTS.tmp"; mv "\$MKTS.tmp" "\$MKTS"; exit 0 ;;
+esac
+case "\$1 \$2" in
+  "plugin list") echo "Installed plugins:"; sed "s/^/  • /;s/\$/ (v\$VER)/" "\$STATE"; exit 0 ;;
+  "plugin uninstall") grep -Fvx "\$3" "\$STATE" > "\$STATE.tmp"; mv "\$STATE.tmp" "\$STATE"; exit 0 ;;
+  "plugin install") echo "\$3" >> "\$STATE"; exit 0 ;;
+esac
+exit 0
+FAKE
+	chmod +x "$dir/copilot"
+}
+
+if [ "$#" -ne 2 ]; then
+	echo "usage: fake-copilot-vendor.sh <dir> <plugin_json>" >&2
+	exit 2
+fi
+make_fake_copilot "$1" "$2"

package/scripts/meta-bridge-hook-log.sh

@@ -4,20 +4,32 @@
 # proves the Claude SessionStart/CwdChanged hook re-armed the mailbox watch. A
 # later `INFO attach record (event=UserPromptSubmit, ...)` is merely degraded
 # backfill and must NOT clear an arm/upsert failure.
-
+#
+# THIS JUDGEMENT IS CLAUDE'S ONLY, and since #82 it has to say so. The Copilot birth
+# unit appends to the SAME log file (one grep for the operator), tagging its lines
+# `LEVEL [copilot]`. Those lines must be invisible here, for a reason stronger than
+# tidiness: a copilot ERROR is often a CORRECT fail-closed refusal (a degraded envelope
+# the unit refused to mint from), and its recovery token can never appear — `armed
+# watch` is the Claude hook rail's token. Copilot's measured extension transport has a
+# different, not-yet-admitted lifecycle and writes no token this doctor owns. Counting them
+# would make the CLAUDE doctor permanently red for a refusal on a different rail, with
+# a prescription pointing at a Claude wake failure that never happened (cross-review,
+# glm, 2026-08-21). Copilot's own recovery rule lives in copilot-bridge-doctor.sh.
 meta_bridge_hook_log_status() {
   local log="$1"
-  if ! grep -q ' ERROR ' "$log" 2>/dev/null; then
+  local own
+  own="$(grep -v ' \[copilot\] ' "$log" 2>/dev/null || true)"
+  if ! printf '%s\n' "$own" | grep -q ' ERROR '; then
     echo "no-error"
     return 0
   fi
 
   local last_err last_recovery
-  last_err="$(grep -n ' ERROR ' "$log" | tail -1 | cut -d: -f1)"
-  last_recovery="$(grep -n ' INFO armed watch ' "$log" | tail -1 | cut -d: -f1)"
+  last_err="$(printf '%s\n' "$own" | grep -n ' ERROR ' | tail -1 | cut -d: -f1)"
+  last_recovery="$(printf '%s\n' "$own" | grep -n ' INFO armed watch ' | tail -1 | cut -d: -f1)"
 
   if [ -z "$last_recovery" ] || [ "$last_err" -gt "$last_recovery" ]; then
-    grep ' ERROR ' "$log" | tail -1
+    printf '%s\n' "$own" | grep ' ERROR ' | tail -1
     return 1
   fi
 

package/scripts/mutants/capability-cache.json

@@ -0,0 +1,64 @@
+{
+	"schemaVersion": 1,
+	"lane": "capability-cache",
+	"mutants": [
+		{
+			"claim": "CAPABILITY-REGISTRY-REREAD-SEES-REPLACEMENT",
+			"title": "memoizing the capability registry into a process-lifetime singleton makes every already-running dispatcher answer out of the registry it booted with — an install that moves a grade or wakeMode is invisible until the operator restarts, and nothing says so",
+			"subject": "pi-extensions/lib/meta-session.ts",
+			"find": [
+				"export function loadMetaCapabilityRegistry(): MetaCapabilityRegistry {",
+				"\treturn parseMetaCapabilityRegistry(fs.readFileSync(metaCapabilitiesFilePath(), \"utf8\"));",
+				"}"
+			],
+			"replace": [
+				"let cachedMetaCapabilities: MetaCapabilityRegistry | null = null;",
+				"export function loadMetaCapabilityRegistry(): MetaCapabilityRegistry {",
+				"\tif (cachedMetaCapabilities === null) {",
+				"\t\tcachedMetaCapabilities = parseMetaCapabilityRegistry(fs.readFileSync(metaCapabilitiesFilePath(), \"utf8\"));",
+				"\t}",
+				"\treturn cachedMetaCapabilities;",
+				"}"
+			],
+			"gate": ["bash", "run.sh", "check-meta-capability-source"],
+			"timeoutSeconds": 300,
+			"signature": "[QK:CAPABILITY-REGISTRY-REREAD-SEES-REPLACEMENT]",
+			"signatureSource": "scripts/check-meta-capability-source.ts"
+		},
+		{
+			"claim": "CAPABILITY-REGISTRY-MISSING-STILL-THROWS",
+			"title": "answering a missing registry with a built-in default turns a broken install into a citizen that silently claims capabilities nobody shipped",
+			"subject": "pi-extensions/lib/meta-session.ts",
+			"find": ["\treturn parseMetaCapabilityRegistry(fs.readFileSync(metaCapabilitiesFilePath(), \"utf8\"));"],
+			"replace": [
+				"\tconst registryPath = metaCapabilitiesFilePath();",
+				"\tif (!fs.existsSync(registryPath)) {",
+				"\t\treturn { schemaVersion: CAPABILITY_SCHEMA_VERSION, backends: {} } as unknown as MetaCapabilityRegistry;",
+				"\t}",
+				"\treturn parseMetaCapabilityRegistry(fs.readFileSync(registryPath, \"utf8\"));"
+			],
+			"gate": ["bash", "run.sh", "check-meta-capability-source"],
+			"timeoutSeconds": 300,
+			"signature": "[QK:CAPABILITY-REGISTRY-MISSING-STILL-THROWS]",
+			"signatureSource": "scripts/check-meta-capability-source.ts"
+		},
+		{
+			"claim": "CAPABILITY-REGISTRY-CORRUPT-STILL-THROWS",
+			"title": "swallowing a parse failure and returning a fallback lets a half-written or hand-edited registry read as a valid one, so the strict parser stops being load-bearing",
+			"subject": "pi-extensions/lib/meta-session.ts",
+			"find": ["\treturn parseMetaCapabilityRegistry(fs.readFileSync(metaCapabilitiesFilePath(), \"utf8\"));"],
+			"replace": [
+				"\tconst rawRegistry = fs.readFileSync(metaCapabilitiesFilePath(), \"utf8\");",
+				"\ttry {",
+				"\t\treturn parseMetaCapabilityRegistry(rawRegistry);",
+				"\t} catch {",
+				"\t\treturn { schemaVersion: CAPABILITY_SCHEMA_VERSION, backends: {} } as unknown as MetaCapabilityRegistry;",
+				"\t}"
+			],
+			"gate": ["bash", "run.sh", "check-meta-capability-source"],
+			"timeoutSeconds": 300,
+			"signature": "[QK:CAPABILITY-REGISTRY-CORRUPT-STILL-THROWS]",
+			"signatureSource": "scripts/check-meta-capability-source.ts"
+		}
+	]
+}