phronesis 1.0.0 → 1.1.0

package/templates/launcher/phronesis

@@ -0,0 +1,95 @@
+#!/bin/sh
+# Phronesis static managed launcher (change 0065 D1). This file never changes when the
+# backend changes; launcher.env is the commit point. Parsing is data-only: never source/eval.
+
+launcher_fail() {
+  printf '%s\n' "phronesis launcher: $1; reinstall command-line tools." >&2
+  exit 1
+}
+
+decode_value() {
+  __raw=$1
+  case "$__raw" in
+    \"*\")
+      __raw=${__raw#\"}
+      __raw=${__raw%\"}
+      __out=
+      __escaped=0
+      while [ -n "$__raw" ]; do
+        __rest=${__raw#?}
+        __char=${__raw%"$__rest"}
+        __raw=$__rest
+        if [ "$__escaped" = 1 ]; then
+          case "$__char" in
+            [\\]|'"'|'$'|'`') __out=$__out$__char ;;
+            *) launcher_fail "invalid launcher.env escape" ;;
+          esac
+          __escaped=0
+        else
+          case "$__char" in
+            [\\]) __escaped=1 ;;
+            '$'|'`') launcher_fail "unsafe launcher.env value" ;;
+            *) __out=$__out$__char ;;
+          esac
+        fi
+      done
+      [ "$__escaped" = 0 ] || launcher_fail "invalid launcher.env escape"
+      DECODED=$__out
+      ;;
+    \'*\')
+      __raw=${__raw#\'}
+      __raw=${__raw%\'}
+      case "$__raw" in *\'*) launcher_fail "invalid launcher.env quoted value" ;; esac
+      DECODED=$__raw
+      ;;
+    *[\ \	\;\&\|\<\>\$\`\"\']*) launcher_fail "launcher.env value must quote shell metacharacters" ;;
+    *) DECODED=$__raw ;;
+  esac
+}
+
+manifest="$HOME/.phronesis/bin/launcher.env"
+[ ! -L "$manifest" ] || launcher_fail "launcher.env is a symlink"
+[ -f "$manifest" ] || launcher_fail "launcher.env is missing"
+
+PHR_BACKEND=
+PHR_VERSION=
+PHR_TARGET=
+PHR_RUNTIME=
+PHR_GENERATION=
+seen_backend=0
+seen_version=0
+seen_target=0
+seen_runtime=0
+seen_generation=0
+
+while IFS= read -r line || [ -n "$line" ]; do
+  case "$line" in ''|'#'*) continue ;; esac
+  case "$line" in *=*) ;; *) launcher_fail "launcher.env contains an invalid line" ;; esac
+  key=${line%%=*}
+  raw=${line#*=}
+  decode_value "$raw"
+  case "$key" in
+    PHR_BACKEND) [ "$seen_backend" = 0 ] || launcher_fail "launcher.env repeats PHR_BACKEND"; PHR_BACKEND=$DECODED; seen_backend=1 ;;
+    PHR_VERSION) [ "$seen_version" = 0 ] || launcher_fail "launcher.env repeats PHR_VERSION"; PHR_VERSION=$DECODED; seen_version=1 ;;
+    PHR_TARGET) [ "$seen_target" = 0 ] || launcher_fail "launcher.env repeats PHR_TARGET"; PHR_TARGET=$DECODED; seen_target=1 ;;
+    PHR_RUNTIME) [ "$seen_runtime" = 0 ] || launcher_fail "launcher.env repeats PHR_RUNTIME"; PHR_RUNTIME=$DECODED; seen_runtime=1 ;;
+    PHR_GENERATION) [ "$seen_generation" = 0 ] || launcher_fail "launcher.env repeats PHR_GENERATION"; PHR_GENERATION=$DECODED; seen_generation=1 ;;
+    *) launcher_fail "launcher.env contains unknown field $key" ;;
+  esac
+done < "$manifest"
+
+case "$PHR_BACKEND" in app|self-copy) ;; *) launcher_fail "launcher.env has invalid PHR_BACKEND" ;; esac
+case "$PHR_VERSION" in ''|*[!A-Za-z0-9._+-]*) launcher_fail "launcher.env has invalid PHR_VERSION" ;; esac
+case "$PHR_GENERATION" in ''|*[!A-Za-z0-9._+-]*) launcher_fail "launcher.env has invalid PHR_GENERATION" ;; esac
+case "$PHR_GENERATION" in *[!.]*) ;; *) launcher_fail "launcher.env has invalid PHR_GENERATION" ;; esac
+case "$PHR_TARGET" in /*) ;; *) launcher_fail "launcher.env has invalid PHR_TARGET" ;; esac
+case "$PHR_RUNTIME" in /*) ;; *) launcher_fail "launcher.env has invalid PHR_RUNTIME" ;; esac
+[ ! -L "$PHR_TARGET" ] || launcher_fail "recorded target is a symlink"
+[ -f "$PHR_TARGET" ] || launcher_fail "recorded target is missing"
+[ -f "$PHR_RUNTIME" ] && [ -x "$PHR_RUNTIME" ] || launcher_fail "recorded runtime is missing or not executable"
+
+if [ "$PHR_BACKEND" = app ]; then
+  ELECTRON_RUN_AS_NODE=1
+  export ELECTRON_RUN_AS_NODE
+fi
+exec "$PHR_RUNTIME" "$PHR_TARGET" "$@"

package/templates/phronesis-hooks/compile-active-context.sh

@@ -1,38 +1,12 @@
-#!/usr/bin/env bash
-# Phronesis post-compile hook (core-0017 H5): refresh a domain's active-context projection
-# (domains/{domain}/ACTIVE_CONTEXT.md) after a compile commits canonical state. Subscribes
-# to action_type.committed filtered to payload.action_type == compile; the V1 in-pipeline
-# executor fires it synchronously at the commit point (compile accept fires it too, since
-# acceptance emits the same committed event). The committed event arrives as JSON on stdin.
-#
-# It is a MUTATION hook (it writes the tracked projection) — a failure is audited but never
-# blocks the commit. Generated state is never a free-form action write (core-0016 review
-# finding #2), so the refresh runs through the deterministic generator, not a hand-edit.
-#
-# Runtime-free degrade (change 0013): with no phronesis on PATH this exits 0 silently — a
-# compile without the runtime simply leaves the projection for the next runtime pass; the
-# validate-time staleness check is the backstop that flags it stale meanwhile.
-set -uo pipefail
-
-command -v phronesis >/dev/null 2>&1 || exit 0
-
-input="$(cat || true)"
-# The committed payload.path is domains/{domain}/compiled/{type-dir}/{name}.md; the domain
-# is its second segment. node is present wherever phronesis is (the CLI runs on it), so
-# parse the JSON properly instead of regexing it.
-domain="$(printf '%s' "$input" | node -e '
-let d = "";
-process.stdin.on("data", (c) => (d += c)).on("end", () => {
-  try {
-    const ev = JSON.parse(d);
-    const p = String((ev && ev.payload && ev.payload.path) || "");
-    const parts = p.split("/");
-    process.stdout.write(parts[0] === "domains" && parts[1] ? parts[1] : "");
-  } catch {}
-});' 2>/dev/null)"
-[ -n "$domain" ] || exit 0
-
-# cwd is the install root (the executor sets it); --dir makes discovery explicit.
-phronesis active-context refresh --domain "$domain" --dir "$PWD" >/dev/null || true
-
-exit 0
+#!/bin/sh
+# Managed-first binding (change 0065 D2): stdin is inherited by the one resolved CLI.
+PHRONESIS_BIN="$HOME/.phronesis/bin/phronesis"
+PHRONESIS_MANAGED_BIN="$PHRONESIS_BIN"
+if [ -f "$PHRONESIS_BIN" ] && [ -x "$PHRONESIS_BIN" ] && [ ! -L "$PHRONESIS_BIN" ]; then
+  :
+else
+  PHRONESIS_BIN="$(command -v phronesis 2>/dev/null || true)"
+  [ -n "$PHRONESIS_BIN" ] || exit 0
+  [ "$PHRONESIS_BIN" != "$PHRONESIS_MANAGED_BIN" ] || exit 0
+fi
+exec "$PHRONESIS_BIN" hook compile-active-context --surface "${PHRONESIS_SURFACE:-claude-code}"

package/templates/phronesis-hooks/recall-guard.sh

@@ -1,103 +1,12 @@
-#!/usr/bin/env bash
-# Phronesis prompt-submit recall guard (Tier 1 — core-0019 / T5.2a). Surface-aware
-# (change 0028 / core-0034): runs under Claude Code's UserPromptSubmit and Codex's (the
-# .codex/ launcher sets PHRONESIS_SURFACE=codex + PHRONESIS_DIR). Both surfaces share the
-# additionalContext output shape (spike 2026-06-21), so only the install-root resolution
-# and the --surface attribution differ — the emitted JSON is identical.
-#
-# Reads the surface's UserPromptSubmit JSON on stdin, extracts session_id + prompt (+ cwd
-# when present), pipes ONLY the prompt body to `phronesis guard` over stdin, then
-# translates the surface-agnostic {fired, packet} result to the add-only additionalContext
-# shape.
-# Runtime-free degrade: no `phronesis` on PATH means exit 0 with no output.
-set -uo pipefail
-
-command -v phronesis >/dev/null 2>&1 || exit 0
-
-# Install-root resolution without assuming a surface env var (change 0028 / core-0034 P5):
-# an explicit PHRONESIS_DIR (set by the Codex launcher) or CLAUDE_PROJECT_DIR (Claude Code)
-# when it actually holds the install; else walk up from cwd to the nearest .phronesis/
-# (Codex has no $CLAUDE_PROJECT_DIR; a non-git install behaves identically — it keys on
-# .phronesis/, not .git/); else the prior ${CLAUDE_PROJECT_DIR:-$PWD} default. For the
-# shipped Claude posture (opened at the install root, CLAUDE_PROJECT_DIR = that root) the
-# CLAUDE_PROJECT_DIR branch returns exactly the old ${CLAUDE_PROJECT_DIR:-$PWD} value; the
-# behavior changes only when CLAUDE_PROJECT_DIR is set without a .phronesis/ (an install
-# nested under a larger project), where the walk-up now finds the real install instead of
-# silently passing a non-install --dir (a strict improvement; resolver tests pin it).
-resolve_install_dir() {
-  if [ -n "${PHRONESIS_DIR:-}" ] && [ -d "${PHRONESIS_DIR}/.phronesis" ]; then printf '%s' "$PHRONESIS_DIR"; return; fi
-  if [ -n "${CLAUDE_PROJECT_DIR:-}" ] && [ -d "${CLAUDE_PROJECT_DIR}/.phronesis" ]; then printf '%s' "$CLAUDE_PROJECT_DIR"; return; fi
-  local d="$PWD"
-  while [ "$d" != "/" ] && [ ! -d "$d/.phronesis" ]; do d="$(dirname "$d")"; done
-  if [ -d "$d/.phronesis" ]; then printf '%s' "$d"; return; fi
-  printf '%s' "${CLAUDE_PROJECT_DIR:-$PWD}"
-}
-
-PHRONESIS_RESOLVED_DIR="$(resolve_install_dir)"
-# Restrict the surface to a safe token (it rides --surface and, in session-start, a JSON
-# payload); the launcher only ever sets the literal "codex".
-surface="$(printf '%s' "${PHRONESIS_SURFACE:-claude-code}" | tr -cd 'a-z0-9-')"
-[ -n "$surface" ] || surface="claude-code"
-
-input="$(cat || true)"
-printf '%s' "$input" | PHRONESIS_RESOLVED_DIR="$PHRONESIS_RESOLVED_DIR" PHRONESIS_SURFACE="$surface" node -e '
-const { spawnSync } = require("node:child_process");
-const fs = require("node:fs");
-const path = require("node:path");
-
-function domainFromCwd(root, cwd) {
-  if (!root || !cwd) return "";
-  // Normalize BOTH to physical paths before comparing. The install root arrives as a
-  // LOGICAL path (the Codex launcher resolves it with `cd … && pwd`; CLAUDE_PROJECT_DIR is
-  // likewise logical), while a surface may report a REALPATH cwd — and Node`s process.cwd()
-  // is always physical. A logical-vs-physical split (macOS /tmp→/private/tmp, a synced or
-  // aliased workspace) makes path.relative yield `../…`, silently dropping --domain — which
-  // flips the guard to all-domain scope on a multi-domain install (core-0034 review #1).
-  let r = root;
-  let c = cwd;
-  try { r = fs.realpathSync(root); } catch {}
-  try { c = fs.realpathSync(cwd); } catch {}
-  const rel = path.relative(r, c);
-  const parts = rel.split(path.sep);
-  return parts[0] === "domains" && parts[1] ? parts[1] : "";
-}
-
-try {
-  const input = fs.readFileSync(0, "utf8");
-  const payload = JSON.parse(input);
-  const sessionId = typeof payload.session_id === "string" ? payload.session_id : "";
-  const prompt = typeof payload.prompt === "string" ? payload.prompt : "";
-  if (!sessionId || !prompt) process.exit(0);
-
-  const dir = process.env.PHRONESIS_RESOLVED_DIR || process.env.CLAUDE_PROJECT_DIR || process.cwd();
-  const surface = process.env.PHRONESIS_SURFACE || "claude-code";
-  const actor = process.env.PHRONESIS_ACTOR || "agent";
-  const args = [
-    "guard",
-    "--dir", dir,
-    "--session", sessionId,
-    "--surface", surface,
-    "--actor", actor,
-    "--json",
-  ];
-  const domain = domainFromCwd(dir, typeof payload.cwd === "string" ? payload.cwd : process.cwd());
-  if (domain) args.push("--domain", domain);
-
-  const result = spawnSync("phronesis", args, { input: prompt, encoding: "utf8" });
-  if (result.status !== 0) process.exit(0);
-  const parsed = JSON.parse(result.stdout);
-  if (!parsed || parsed.fired !== true || typeof parsed.packet !== "string" || parsed.packet.trim() === "") {
-    process.exit(0);
-  }
-  process.stdout.write(JSON.stringify({
-    hookSpecificOutput: {
-      hookEventName: "UserPromptSubmit",
-      additionalContext: parsed.packet,
-    },
-  }));
-} catch {
-  process.exit(0);
-}
-' 2>/dev/null
-
-exit 0
+#!/bin/sh
+# Managed-first binding (change 0065 D2): stdin is inherited by the one resolved CLI.
+PHRONESIS_BIN="$HOME/.phronesis/bin/phronesis"
+PHRONESIS_MANAGED_BIN="$PHRONESIS_BIN"
+if [ -f "$PHRONESIS_BIN" ] && [ -x "$PHRONESIS_BIN" ] && [ ! -L "$PHRONESIS_BIN" ]; then
+  :
+else
+  PHRONESIS_BIN="$(command -v phronesis 2>/dev/null || true)"
+  [ -n "$PHRONESIS_BIN" ] || exit 0
+  [ "$PHRONESIS_BIN" != "$PHRONESIS_MANAGED_BIN" ] || exit 0
+fi
+exec "$PHRONESIS_BIN" hook recall-guard --surface "${PHRONESIS_SURFACE:-claude-code}"

package/templates/phronesis-hooks/session-start.sh

@@ -1,90 +1,12 @@
-#!/usr/bin/env bash
-# Phronesis session-start hook (Tier 1 — specs/hooks.md; change 0010 D4a). Surface-aware
-# (change 0028 / core-0034): runs under Claude Code's SessionStart and Codex's (the
-# .codex/ launcher sets PHRONESIS_SURFACE=codex + PHRONESIS_DIR).
-#
-# Three jobs, all deterministic:
-#   1. clear any stale skill lifecycle active record for this session (crash/resume
-#      safety net; the next turn's act calls must not inherit an old invocation_id);
-#   2. emit `session.start` into the typed event stream;
-#   3. run the due-check — `phronesis hooks due-check` computes due review_dates,
-#      emits one `outcome.due` per due decision (the V1 authoritative emitter), and
-#      prints the due list. Claude Code injects this stdout into the session context raw;
-#      Codex injects it via hookSpecificOutput.additionalContext (the only output branch).
-#
-# Runtime-free degrade (change 0013): with no phronesis on PATH this exits 0 silently —
-# an honest gap, never an error. That is the ONLY silent path: a present-but-broken
-# runtime (invalid registry, corrupted config) keeps its stderr, because a due-check
-# that fails invisibly at every session start is the exact silent no-fire this hook
-# exists to prevent. `|| true` only keeps a hook error from breaking the session.
-set -uo pipefail
-
-command -v phronesis >/dev/null 2>&1 || exit 0
-
-input="$(cat || true)"
-# Claude Code / Codex hook input is JSON on stdin; node is present wherever phronesis is
-# (the CLI runs on it), so parse properly instead of regexing JSON.
-session_id="$(printf '%s' "$input" | node -e '
-let d = "";
-process.stdin.on("data", (c) => (d += c)).on("end", () => {
-  try { process.stdout.write(String(JSON.parse(d).session_id || "")); } catch {}
-});' 2>/dev/null)"
-# No parseable session id → nothing to attribute events to: exit quietly (same posture
-# as the sweep script) rather than inventing a synthetic session that unrelated
-# sessions would pile onto.
-[ -n "$session_id" ] || exit 0
-
-# Install-root resolution without assuming a surface env var (change 0028 / core-0034 P5):
-# an explicit PHRONESIS_DIR (set by the Codex launcher) or CLAUDE_PROJECT_DIR (Claude Code)
-# when it actually holds the install; else walk up from cwd to the nearest .phronesis/
-# (Codex has no $CLAUDE_PROJECT_DIR; a non-git install behaves identically — it keys on
-# .phronesis/, not .git/); else the prior ${CLAUDE_PROJECT_DIR:-$PWD} default. For the
-# shipped Claude posture — opened at the install root, CLAUDE_PROJECT_DIR = that root — the
-# CLAUDE_PROJECT_DIR branch returns exactly what the old ${CLAUDE_PROJECT_DIR:-$PWD} did. The
-# behavior changes ONLY when CLAUDE_PROJECT_DIR is set but does NOT contain .phronesis (a
-# Claude session opened inside a larger project that nests the install): the old code passed
-# that non-install dir straight to --dir (a silent downstream no-op), the new code walks up
-# from cwd to find the real install — a strict improvement, exercised by the resolver tests.
-resolve_install_dir() {
-  if [ -n "${PHRONESIS_DIR:-}" ] && [ -d "${PHRONESIS_DIR}/.phronesis" ]; then printf '%s' "$PHRONESIS_DIR"; return; fi
-  if [ -n "${CLAUDE_PROJECT_DIR:-}" ] && [ -d "${CLAUDE_PROJECT_DIR}/.phronesis" ]; then printf '%s' "$CLAUDE_PROJECT_DIR"; return; fi
-  local d="$PWD"
-  while [ "$d" != "/" ] && [ ! -d "$d/.phronesis" ]; do d="$(dirname "$d")"; done
-  if [ -d "$d/.phronesis" ]; then printf '%s' "$d"; return; fi
-  printf '%s' "${CLAUDE_PROJECT_DIR:-$PWD}"
-}
-
-dir="$(resolve_install_dir)"
-# The surface name is interpolated into a JSON payload and passed as --surface; restrict it
-# to a safe token so a hostile PHRONESIS_SURFACE cannot break out of the JSON string or the
-# flag (defense in depth — the launcher only ever sets the literal "codex").
-surface="$(printf '%s' "${PHRONESIS_SURFACE:-claude-code}" | tr -cd 'a-z0-9-')"
-[ -n "$surface" ] || surface="claude-code"
-
-phronesis hooks skill-sweep-stale --session "$session_id" --dir "$dir" >/dev/null || true
-
-phronesis event emit session.start --session "$session_id" --surface "$surface" \
-  --dir "$dir" --payload "{\"surface\":\"$surface\"}" >/dev/null || true
-
-if [ "$surface" = "codex" ]; then
-  # Codex SessionStart injects via hookSpecificOutput.additionalContext (Claude Code takes
-  # the raw stdout). Same due-check brain (it still emits outcome.due as a side effect),
-  # surface-specific wrapper only. due-check prints the due list when there are reviews and
-  # "No decisions due for review." otherwise — so the wrap normally fires every session
-  # (matching the Claude path, which injects that same line raw); the `-n` guard only
-  # suppresses the envelope in the degenerate case where due-check produced nothing at all.
-  due_out="$(phronesis hooks due-check --session "$session_id" --surface "$surface" --dir "$dir" || true)"
-  if [ -n "$due_out" ]; then
-    printf '%s' "$due_out" | node -e '
-let d = "";
-process.stdin.on("data", (c) => (d += c)).on("end", () => {
-  process.stdout.write(JSON.stringify({
-    hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: d },
-  }));
-});' 2>/dev/null
-  fi
+#!/bin/sh
+# Managed-first binding (change 0065 D2): stdin is inherited by the one resolved CLI.
+PHRONESIS_BIN="$HOME/.phronesis/bin/phronesis"
+PHRONESIS_MANAGED_BIN="$PHRONESIS_BIN"
+if [ -f "$PHRONESIS_BIN" ] && [ -x "$PHRONESIS_BIN" ] && [ ! -L "$PHRONESIS_BIN" ]; then
+  :
 else
-  phronesis hooks due-check --session "$session_id" --surface "$surface" --dir "$dir" || true
+  PHRONESIS_BIN="$(command -v phronesis 2>/dev/null || true)"
+  [ -n "$PHRONESIS_BIN" ] || exit 0
+  [ "$PHRONESIS_BIN" != "$PHRONESIS_MANAGED_BIN" ] || exit 0
 fi
-
-exit 0
+exec "$PHRONESIS_BIN" hook session-start --surface "${PHRONESIS_SURFACE:-claude-code}"

package/templates/phronesis-hooks/session-sweep.sh

@@ -1,140 +1,17 @@
-#!/usr/bin/env bash
-# Phronesis session-boundary sweep (Tier 1 — specs/hooks.md §"Emission discipline";
-# change 0010 D4b). Surface-aware (change 0028 / core-0034): runs under Claude Code's
-# Stop/SubagentStop/PreCompact and Codex's (the .codex/ launchers set
-# PHRONESIS_SURFACE=codex + PHRONESIS_DIR and bake the variant flag in). The misfire class
-# this closes: "did you store all that?" → "oh, sorry, I was in the flow."
-#
-# A shell script cannot judge "what should have been stored" — the model can. So the
-# deterministic half lives here: as a Stop hook, this blocks the session's end ONCE
-# until the capture sweep has run, then verifies the marker and lets go. The block-continue
-# output ({"decision":"block","reason":...}) and the stop_hook_active loop guard are
-# identical across Claude Code and Codex (spike 2026-06-21), so the Stop path needs no
-# surface branch. The sweep marker is a `session.end` event with a `sweep` payload;
-# `candidates: 0` is the honest negative (existing vocabulary — no invented event type).
-#
-# As a PreCompact hook (--advisory) it cannot block; it prints a best-effort reminder
-# before context is lost — raw on Claude Code, wrapped as Codex {"systemMessage":...}. The
-# Stop hook stays the deterministic backstop. As a SubagentStop hook (--lifecycle-only), it
-# skips the capture sweep and only closes the active skill lifecycle record for that
-# subagent boundary.
-#
-# Runtime-free degrade (change 0013): with no phronesis on PATH this exits 0 silently —
-# an honest gap, never an error.
-set -uo pipefail
-
-command -v phronesis >/dev/null 2>&1 || exit 0
-
-advisory=0
-lifecycle_only=0
-for arg in "$@"; do
-  case "$arg" in
-    --advisory) advisory=1 ;;
-    --lifecycle-only) lifecycle_only=1 ;;
-  esac
-done
-
-input="$(cat || true)"
-# Emit stop_hook_active (a bare boolean) FIRST and the session_id as the REST of the line,
-# so `read -r flag id` keeps a session_id that contains whitespace intact in $session_id —
-# a space-split id would otherwise spill into stop_hook_active and silently defeat the
-# loop guard (core-0034 review #5). Real ids have no spaces; this is fail-safe hardening.
-read -r stop_hook_active session_id <<EOF2
-$(printf '%s' "$input" | node -e '
-let d = "";
-process.stdin.on("data", (c) => (d += c)).on("end", () => {
-  try {
-    const j = JSON.parse(d);
-    process.stdout.write(`${j.stop_hook_active === true} ${j.session_id || "-"}`);
-  } catch { process.stdout.write("false -"); }
-});' 2>/dev/null)
-EOF2
-[ -n "${session_id:-}" ] && [ "$session_id" != "-" ] || exit 0
-
-# Install-root resolution without assuming a surface env var (change 0028 / core-0034 P5):
-# an explicit PHRONESIS_DIR (set by the Codex launcher) or CLAUDE_PROJECT_DIR (Claude Code)
-# when it actually holds the install; else walk up from cwd to the nearest .phronesis/
-# (Codex has no $CLAUDE_PROJECT_DIR; a non-git install behaves identically — it keys on
-# .phronesis/, not .git/); else the prior ${CLAUDE_PROJECT_DIR:-$PWD} default. For the
-# shipped Claude posture (opened at the install root, CLAUDE_PROJECT_DIR = that root) the
-# CLAUDE_PROJECT_DIR branch returns exactly the old ${CLAUDE_PROJECT_DIR:-$PWD} value — a
-# cwd-discovered sweep-status outside the install would fail, and a failed status read as
-# "pending" would BLOCK a session that already swept (Codex round, reproduced). The behavior
-# changes only when CLAUDE_PROJECT_DIR lacks a .phronesis/ (install nested under a larger
-# project): the walk-up now finds the real install instead of passing a non-install --dir.
-resolve_install_dir() {
-  if [ -n "${PHRONESIS_DIR:-}" ] && [ -d "${PHRONESIS_DIR}/.phronesis" ]; then printf '%s' "$PHRONESIS_DIR"; return; fi
-  if [ -n "${CLAUDE_PROJECT_DIR:-}" ] && [ -d "${CLAUDE_PROJECT_DIR}/.phronesis" ]; then printf '%s' "$CLAUDE_PROJECT_DIR"; return; fi
-  local d="$PWD"
-  while [ "$d" != "/" ] && [ ! -d "$d/.phronesis" ]; do d="$(dirname "$d")"; done
-  if [ -d "$d/.phronesis" ]; then printf '%s' "$d"; return; fi
-  printf '%s' "${CLAUDE_PROJECT_DIR:-$PWD}"
-}
-
-dir="$(resolve_install_dir)"
-# Restrict the surface to a safe token (it gates the advisory branch); the launcher only
-# ever sets the literal "codex".
-surface="$(printf '%s' "${PHRONESIS_SURFACE:-claude-code}" | tr -cd 'a-z0-9-')"
-[ -n "$surface" ] || surface="claude-code"
-
-complete_lifecycle() {
-  [ "$advisory" = "1" ] && return 0
-  boundary_event="Stop"
-  [ "$lifecycle_only" = "1" ] && boundary_event="SubagentStop"
-  # stdout is NOT discarded: skill-complete prints a {"systemMessage":...} advisory when a
-  # substantive (heavy) skill completed with zero mesh enrichments (core-0027 J1). As a
-  # Stop-hook stdout JSON it surfaces to the operator, non-blocking; it prints nothing
-  # otherwise, so a swept session's Stop output stays empty. On Codex no invocation_id is
-  # minted (skill-lifecycle is Level-2 partial, change 0028), so there is no active record
-  # to complete — a clean no-op, no fabricated skill.completed (emission honesty, 0021).
-  # Every complete_lifecycle caller exits 0 immediately after, so this is the only thing
-  # on stdout in those branches.
-  phronesis hooks skill-complete --session "$session_id" --dir "$dir" \
-    --boundary-event "$boundary_event" --payload "$input" || true
-}
-
-if [ "$lifecycle_only" = "1" ]; then
-  complete_lifecycle
-  exit 0
+#!/bin/sh
+# Managed-first binding (change 0065 D2): stdin is inherited by the one resolved CLI.
+PHRONESIS_BIN="$HOME/.phronesis/bin/phronesis"
+PHRONESIS_MANAGED_BIN="$PHRONESIS_BIN"
+if [ -f "$PHRONESIS_BIN" ] && [ -x "$PHRONESIS_BIN" ] && [ ! -L "$PHRONESIS_BIN" ]; then
+  :
+else
+  PHRONESIS_BIN="$(command -v phronesis 2>/dev/null || true)"
+  [ -n "$PHRONESIS_BIN" ] || exit 0
+  [ "$PHRONESIS_BIN" != "$PHRONESIS_MANAGED_BIN" ] || exit 0
 fi
-
-if phronesis hooks sweep-status --session "$session_id" --dir "$dir" 2>/dev/null | grep -qx 'swept'; then
-  complete_lifecycle
-  exit 0
-fi
-
-if [ "$advisory" = "1" ]; then
-  reminder="Phronesis sweep reminder: context is about to compact. Review the conversation for unstored decisions, people, and commitments — emit *.candidate events / run the action types, then mark the sweep: phronesis event emit session.end --session $session_id --dir $dir --payload '{\"sweep\":{\"candidates\":N}}' (candidates 0 = honest negative)."
-  if [ "$surface" = "codex" ]; then
-    # PreCompact cannot block; Codex surfaces a non-blocking systemMessage (Claude takes raw).
-    printf '%s' "$reminder" | node -e '
-let d = "";
-process.stdin.on("data", (c) => (d += c)).on("end", () => {
-  process.stdout.write(JSON.stringify({ systemMessage: d }));
-});' 2>/dev/null
-  else
-    echo "$reminder"
-  fi
-  exit 0
-fi
-
-# Never loop: if the stop hook is already re-driving the agent and the marker still
-# has not landed, let the session end — a missing sweep is an honest gap, not a trap.
-# Codex sets stop_hook_active on its Stop event exactly as Claude Code does (spike).
-if [ "$stop_hook_active" = "true" ]; then
-  complete_lifecycle
-  exit 0
-fi
-
-node -e '
-const [session, dir] = process.argv.slice(1);
-console.log(
-  JSON.stringify({
-    decision: "block",
-    reason:
-      `Phronesis capture sweep (session ${session}): before ending, review this conversation for anything that should have been stored — decisions made, people/context learned, commitments given. ` +
-      `Emit a typed candidate for each (phronesis event emit decision.candidate|person.candidate|commitment.candidate --session ${session} --dir ${dir} --payload ...) and/or run the matching action types (phronesis act ... --dir ${dir}). ` +
-      `Then mark the sweep — honestly, 0 candidates is a valid answer: phronesis event emit session.end --session ${session} --dir ${dir} --payload '"'"'{"sweep":{"candidates":N}}'"'"'. After the marker is emitted, stop again.`,
-  }),
-);' "$session_id" "$dir"
-exit 0
+event="session-sweep"
+case "${1:-}" in
+  --advisory) event="session-sweep-precompact" ;;
+  --lifecycle-only) event="session-sweep-subagent" ;;
+esac
+exec "$PHRONESIS_BIN" hook "$event" --surface "${PHRONESIS_SURFACE:-claude-code}"

package/templates/phronesis-hooks/skill-lifecycle.sh

@@ -1,37 +1,12 @@
-#!/usr/bin/env bash
-# Phronesis skill lifecycle hook (Tier 1, Claude Code — specs/event-log.md
-# per-invocation attribution; change 0021; core-0032).
-#
-# start:   consumes PreToolUse(Skill) or UserPromptExpansion hook JSON, mints the
-#          adapter-owned invocation_id, writes .phronesis/invocations/, emits
-#          skill.invoked, and completes any prior sequential invocation first.
-# abandon: consumes StopFailure hook JSON and clears the active record without
-#          fabricating a normal skill.completed event.
-#
-# Runtime-free degrade (change 0013): with no phronesis on PATH this exits 0
-# silently — an honest gap, never an error.
-set -uo pipefail
-
-command -v phronesis >/dev/null 2>&1 || exit 0
-
-mode="${1:-}"
-case "$mode" in
-  start|abandon) ;;
-  *) exit 0 ;;
-esac
-
-input="$(cat || true)"
-dir="${CLAUDE_PROJECT_DIR:-$PWD}"
-
-case "$mode" in
-  start)
-    phronesis hooks skill-start --dir "$dir" --payload "$input" >/dev/null || true
-    ;;
-  abandon)
-    # StopFailure ignores hook output/exit status; keep failures non-blocking but
-    # let stderr surface when the runtime exists and is broken.
-    phronesis hooks skill-abandon --dir "$dir" --payload "$input" >/dev/null || true
-    ;;
-esac
-
-exit 0
+#!/bin/sh
+# Managed-first binding (change 0065 D2): stdin is inherited by the one resolved CLI.
+PHRONESIS_BIN="$HOME/.phronesis/bin/phronesis"
+PHRONESIS_MANAGED_BIN="$PHRONESIS_BIN"
+if [ -f "$PHRONESIS_BIN" ] && [ -x "$PHRONESIS_BIN" ] && [ ! -L "$PHRONESIS_BIN" ]; then
+  :
+else
+  PHRONESIS_BIN="$(command -v phronesis 2>/dev/null || true)"
+  [ -n "$PHRONESIS_BIN" ] || exit 0
+  [ "$PHRONESIS_BIN" != "$PHRONESIS_MANAGED_BIN" ] || exit 0
+fi
+exec "$PHRONESIS_BIN" hook skill-lifecycle --surface "${PHRONESIS_SURFACE:-claude-code}" --mode "${1:-}"

package/templates/skills/lint/SKILL.md

@@ -92,10 +92,15 @@ Mechanical surfaces and finding kinds:
 5. `seed_adoption` surface -> `unadopted_seed`, `duplicate_seed_adoption`
 6. `relationship_value_consistency` surface -> `relationship_value_drift`
 
+The `orphan` surface flags an in-scope object only when it has no typed edge in *either*
+direction to another in-scope object; links to raw sources and self-links never count as
+connectivity (a person wired only to `raw/` is a true orphan, a decision that links out to
+a project is not).
+
 Important `--all-domains` limitation from the deterministic core: bare domain-object
 targets resolve within the source domain, even during an all-domain pass. A full target
-such as `domains/{other}/compiled/projects/{name}.md` counts as a cross-domain inbound
-edge; a bare `projects/{name}` link from another domain does not.
+such as `domains/{other}/compiled/projects/{name}.md` counts as a cross-domain edge (in
+either direction); a bare `projects/{name}` link from another domain does not.
 
 > **Checkpoint 1 - Deterministic floor captured.** Before reading prose for judgment,
 > confirm the `phronesis lint --json` output is in hand, list each mechanical surface as