phronesis 1.0.0 → 1.1.0

package/src/skills.js

@@ -7,8 +7,8 @@
 // in the act pipeline), but it RESOLVES against it: via_action_types must name
 // registered action types, so an invalid action layer blocks skill resolution too.
 
-import { join } from 'node:path';
-import { readdir, readFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { lstat, readdir, readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { createHash } from 'node:crypto';
 import { pathToFileURL } from 'node:url';
@@ -152,15 +152,18 @@ export async function runSkillsStatus({ dir, json = false } = {}) {
 // that repo's, and a packaged CLI without harness/ still loads (the import is lazy).
 
 function sha256(value) {
-  return createHash('sha256').update(String(value), 'utf8').digest('hex');
+  const hash = createHash('sha256');
+  hash.update(Buffer.isBuffer(value) ? value : String(value), Buffer.isBuffer(value) ? undefined : 'utf8');
+  return hash.digest('hex');
 }
 
 // Resolve the skill's golden corpus the same way run_skill_goldens.py does:
 // --goldens-dir → $PHRONESIS_INSTALL/corpus/skill-goldens/<skill> (goldens are real
 // operator material; they live in the install, never the repo — change 0023). Builds the
-// name-free corpus identity (sorted id:hash + manifest hash) and reads signedness from an
-// explicit marker only (signing authority is T7.0/T7.6; absent ⇒ provisional, never a
-// false green).
+// name-free corpus identity (sorted id:hash + eval-sidecar hash + manifest hash) and reads
+// signedness from either a directory marker or every admitted golden's operator-signature
+// fields. The sidecar carries agent-owned eval mechanics so adding coverage/applicability
+// does not mutate the bytes the operator already signed.
 export async function loadCorpusFromInstall({ skill, goldensDir }) {
   const dir = goldensDir
     || (process.env.PHRONESIS_INSTALL
@@ -169,9 +172,16 @@ export async function loadCorpusFromInstall({ skill, goldensDir }) {
   if (!dir || !existsSync(dir)) {
     return { goldens: [], signed: false, identity: '', source: dir || '(no $PHRONESIS_INSTALL set)' };
   }
-  const files = (await readdir(dir)).filter((f) => /^golden-.*\.json$/.test(f)).sort();
+  // Only primary golden records enter the corpus. Named sidecars such as
+  // golden-001.eval.json / .approvals.json are mechanics, not extra goldens.
+  const files = (await readdir(dir)).filter((f) => /^golden-[a-z0-9-]+\.json$/i.test(f)).sort();
   const goldens = [];
   const idParts = [];
+  const evalSidecarKeys = new Set([
+    'coverage_expectations',
+    'rubric_criteria_exercised',
+    'scenario_preamble',
+  ]);
   for (const f of files) {
     const p = join(dir, f);
     const raw = await readFile(p, 'utf8');
@@ -195,8 +205,40 @@ export async function loadCorpusFromInstall({ skill, goldensDir }) {
       );
     }
     const id = d.id || f.replace(/\.json$/, '');
-    goldens.push({ ...d, id, path: p });
-    idParts.push(`${id}:${sha256(raw)}`);
+    const evalPath = p.replace(/\.json$/, '.eval.json');
+    let evalSidecar = {};
+    let evalRaw = '';
+    if (existsSync(evalPath)) {
+      evalRaw = await readFile(evalPath, 'utf8');
+      try {
+        evalSidecar = JSON.parse(evalRaw);
+      } catch (err) {
+        throw new Error(
+          `corpus eval sidecar ${basename(evalPath)} is not valid JSON (${err.message}) — ` +
+          'fix it; the bump gate fails closed rather than run under partial mechanics.',
+        );
+      }
+      if (!evalSidecar || typeof evalSidecar !== 'object' || Array.isArray(evalSidecar)) {
+        throw new Error(`corpus eval sidecar ${basename(evalPath)} must be a JSON object`);
+      }
+      const unknown = Object.keys(evalSidecar).filter((key) => !evalSidecarKeys.has(key));
+      if (unknown.length) {
+        throw new Error(
+          `corpus eval sidecar ${basename(evalPath)} has unknown key(s): ${unknown.join(', ')}`,
+        );
+      }
+      if (
+        'scenario_preamble' in evalSidecar
+        && (typeof evalSidecar.scenario_preamble !== 'string' || evalSidecar.scenario_preamble.trim() === '')
+      ) {
+        throw new Error(
+          `corpus eval sidecar ${basename(evalPath)} scenario_preamble must be a non-empty string`,
+        );
+      }
+    }
+    goldens.push({ ...d, ...evalSidecar, id, path: p });
+    const mechanics = await hashGoldenMechanics(p, evalRaw);
+    idParts.push(`${id}:${sha256(raw)}:mechanics:${mechanics}`);
   }
   let manifest = '';
   for (const mp of [join(dir, 'MANIFEST.md'), join(dir, '..', 'MANIFEST.md')]) {
@@ -206,7 +248,9 @@ export async function loadCorpusFromInstall({ skill, goldensDir }) {
     }
   }
   const identity = `${idParts.sort().join('\n')}\n--manifest--\n${sha256(manifest)}`;
-  let signed = false;
+  const individuallySigned =
+    goldens.length > 0 && goldens.every((golden) => golden.signed === true && golden.status === 'operator-signed');
+  let signed = individuallySigned;
   const signingPath = join(dir, 'signing.json');
   if (existsSync(signingPath)) {
     try {
@@ -220,6 +264,53 @@ export async function loadCorpusFromInstall({ skill, goldensDir }) {
   return { goldens, signed, identity, source: dir };
 }
 
+async function hashGoldenMechanics(goldenPath, evalRaw) {
+  const base = goldenPath.replace(/\.json$/i, '');
+  const entries = [`eval.json:${sha256(evalRaw)}`];
+  for (const [label, path] of [
+    ['approvals.json', `${base}.approvals.json`],
+    ['workspace', `${base}.workspace`],
+    ['retrieval', `${base}.retrieval`],
+  ]) {
+    entries.push(`${label}:${await hashMechanicsPath(path, label)}`);
+  }
+  return sha256(entries.join('\n'));
+}
+
+async function hashMechanicsPath(path, label) {
+  if (!existsSync(path)) return 'absent';
+  const stat = await lstat(path);
+  if (stat.isSymbolicLink()) {
+    throw new Error(`corpus mechanics ${label} must not contain symlinks: ${path}`);
+  }
+  if (stat.isFile()) return `file:${sha256(await readFile(path))}`;
+  if (!stat.isDirectory()) {
+    throw new Error(`corpus mechanics ${label} must be a file or directory: ${path}`);
+  }
+  const out = [];
+  async function walk(dir, rel = '') {
+    const children = await readdir(dir, { withFileTypes: true });
+    for (const child of children.sort((a, b) => a.name.localeCompare(b.name))) {
+      const childRel = rel ? `${rel}/${child.name}` : child.name;
+      const childPath = join(dir, child.name);
+      const childStat = await lstat(childPath);
+      if (childStat.isSymbolicLink()) {
+        throw new Error(`corpus mechanics ${label} must not contain symlinks: ${childPath}`);
+      }
+      if (childStat.isDirectory()) {
+        out.push(`dir:${childRel}`);
+        await walk(childPath, childRel);
+      } else if (childStat.isFile()) {
+        out.push(`file:${childRel}:${sha256(await readFile(childPath))}`);
+      } else {
+        throw new Error(`corpus mechanics ${label} contains an unsupported entry: ${childPath}`);
+      }
+    }
+  }
+  await walk(path);
+  return `dir:${sha256(out.join('\n'))}`;
+}
+
 export async function runSkillsBump({
   skill,
   to,
@@ -227,6 +318,7 @@ export async function runSkillsBump({
   k = DEFAULT_K,
   acceptRegression = false,
   rebaseline = false,
+  verifyCurrent = false,
   shapeChange = false,
   qualityFloor,
   coverageFloor,
@@ -295,6 +387,7 @@ export async function runSkillsBump({
         repoRoot: root,
         k,
         rebaseline,
+        verifyCurrent,
         acceptRegression,
         shapeChange,
         qualityFloor,

package/templates/codex/INDEX.md

@@ -7,8 +7,9 @@ Format: `- [Title](path) — one-line hook`.
 ## seed/ — immutable seeded principles
 
 _Shipped, external starter principles — not your earned codex. Quarantined out of retrieval_
-_until you adopt one via `promote_to_codex`, passing the seed as a `--json` payload:_
-_`--json '{"from_seed":"<collection>/<slug>","rationale":"…"}'` (`act` takes only `--json`)._
+_until you adopt one, with the full command:_
+_`phronesis act promote_to_codex --json '{"from_seed":"<collection>/<slug>","rationale":"..."}'`_
+_(`act` takes semantic inputs only inside `--json`)._
 _Each carries a `## Interview Prompt` — a question to ask about your own world._
 
 ### pm/ — product-management frameworks
@@ -62,6 +63,7 @@ _Each carries a `## Interview Prompt` — a question to ask about your own world
 - [The Eval Is the Spec](seed/ai-practice/the-eval-is-the-spec.md) — For a probabilistic product, the specification is the eval set. You define behavior by examples and graders, not prose — because…
 - [The Gold Dust Is What Leaves No Trace](seed/ai-practice/the-gold-dust-leaves-no-trace.md) — The codifiable playbook is already being extracted from recorded traces; the gold dust is the situated judgment read live off an…
 - [The Model Is Not the Moat](seed/ai-practice/the-model-is-not-the-moat.md) — The model is not the moat; the system around it is. When raw capability commoditizes, defensibility lives in proprietary data,…
+- [The Workspace Is Part of the Thinking](seed/ai-practice/the-workspace-is-part-of-the-thinking.md) — A store that is always there, easy to reach, and full of what you ratified is not a record of your thinking. It is part of it.
 - [When Generation Is Cheap, Judgment Is the Work](seed/ai-practice/when-generation-is-cheap-judgment-is-the-work.md) — When generation becomes cheap, the bottleneck moves from making to judging. The scarce skill is knowing which output is actually…
 
 ## personal/ — operator-earned and adopted

package/templates/codex/seed/ai-practice/the-workspace-is-part-of-the-thinking.md

@@ -0,0 +1,96 @@
+---
+type: codex-principle-seed
+name: the-workspace-is-part-of-the-thinking
+title: "The Workspace Is Part of the Thinking"
+created: 2026-07-12
+exposure: shareable
+stance: adopted
+provenance:
+  authored_by: seed
+---
+
+> **A store that is always there, easy to reach, and full of what you yourself
+> ratified is not a record of your thinking. It is part of it. Build to that
+> standard, and spend the effort where the tradition put it: not on capturing
+> more, on compounding what was caught.**
+
+In 1998 two philosophers asked where the mind stops and the rest of the world
+begins. Their answer was not at the skull. Their test case was a man who
+compensates for failing memory with a notebook. He writes down what he learns
+and looks it up when he needs it, and the notebook is so reliably present that
+he believed what was in it before he opened it. Their claim is that when
+something outside the mind does the work memory would do, it becomes part of the
+thinking, not merely an aid to it. The claim is contested philosophy, not
+settled science, and what has survived more than a quarter-century of
+professional criticism is its tempered form: the store does not mimic the
+brain, it complements it, and the pair outthinks the brain alone. Treat it here
+as a design standard. The workspace is not documentation of the thinking. Done
+right, it is some of the thinking.
+
+The philosophers put four conditions around "done right," and they read like a
+practical test. The store is a constant in your life: where the work happens, not
+a destination you remember to visit. Its contents are directly available: a
+store you must dig through fails the condition. What it returns, you trust on
+retrieval. And you trust it because you put it there: everything in it was
+ratified by you at some point in the past. The authors called the fourth
+condition arguable and the first three crucial. For a workspace that asks for
+automatic trust, however, the fourth is what earns the third. Automatic trust is
+reckless for content you did not author, which is how navigation apps route
+trusting drivers into water. It is appropriate for a store of your own past
+judgments, because you know where they came from: you. That is why the compile
+loop ends with your approval, and why anything that came from somewhere else
+stays marked as such. Writing in 1998, the authors scored the technologies of
+their day against the conditions: the Internet failed, and "information in
+certain files on my computer may qualify." Files you own, on a disk you control,
+were the closest thing to qualifying from the start.
+
+The builders got there first, independently, which is worth more than any
+citation chain. Bush designed the memex in 1945 and said the essential feature
+was not the storing: "the process of tying two items together is the important
+thing." Luhmann filed roughly ninety thousand cards, published hundreds of
+works, and called the content of the notes secondary to the network of links;
+his box, he said, was a mere container until years of connective work made it a
+partner. His test for partnership is the sharpest available: the partners must
+be able to surprise each other. A workspace that only echoes back what you filed
+is a container. One whose connections return something you did not plan is
+thinking with you.
+
+That leaves one practical priority, and the market has it backwards. Capture is
+the cheap half of the loop, and making it cheaper spends effort on the part that
+was never hard; the graveyard of abandoned note systems is capture-heavy and
+synthesis-poor. Retrieval is not judgment. Bringing a note back is not the same
+act as knowing which note matters here. So aim the effort at the expensive half.
+Compile what was caught. Link it to what it contradicts and what it confirms.
+Ratify what earned it. The workspace becomes part of the thinking at the point
+where its structure starts doing work the bare notes cannot.
+
+The boundary stays honest. The workspace extends your thinking; it does not
+extend your consciousness, and it does not supply your aims. It holds your cases
+and the record you have made from them. The aim lives in the codex, and the call
+stays yours; the companion principle "Phronesis: Judgment in the Particular"
+names that half. One corollary follows and it is why ownership is a moral stance
+here, not a feature: if the store is genuinely part of your thinking, then losing
+it to a vendor, a format, or a revoked login is closer to an injury than to an
+inconvenience. Nothing that is part of a mind should have a landlord.
+
+*Diagnostic: before adding a store or a surface to the trusted path, score it
+against the four conditions. Constantly there? Directly available? Do you trust
+what it gives back? Do you trust it because you approved what went in? A resource
+that fails the conditions is a tool you consult, and consulting tools is fine.
+Only what passes is part of the thinking, and only what is part of the thinking
+deserves automatic trust.*
+
+*Source: Clark and Chalmers, "The Extended Mind" (Analysis, 1998) for the parity
+argument and the four conditions; Record and Miller (2018) for the trust
+inversion on unauthored content; Bush, "As We May Think" (1945) and Luhmann,
+"Communicating with Slip Boxes" (1981) for the tradition's own verdict that
+capture is secondary to connection; the retention literature on abandoned
+capture-first systems. The parity thesis is used here as a design standard:
+contested philosophy that has survived its critics, not settled science.*
+
+## Interview Prompt
+
+Name the one external place you already trust without double-checking: a
+notebook, a file, a list you never second-guess. What earned it that trust? Hold
+onto the answer. Whatever that standard is, it is the standard this workspace has
+to meet before it deserves the same.

package/templates/codex-surface/README.md

@@ -6,10 +6,10 @@ against `specs/hooks.md` "Surface adapters".
 
 ## Purpose
 
-Codex native lifecycle hooks run the same Phronesis reinforcement scripts as
+Codex native lifecycle hooks run the same Phronesis reinforcement logic as
 Claude Code. The JSON config points each Codex event at a small launcher in
-`./hooks/`; each launcher resolves the installation root and hands off to the
-shared script under `<install>/.phronesis/hooks/`.
+`./hooks/`; each launcher resolves the installation root and calls the matching
+event on the CLI's single `hook` interface.
 
 Keep `hooks.json` schema-pure. Codex parses hook config strictly: unknown JSON
 fields are fatal at every level, and there is no JSON comment mechanism.
@@ -19,9 +19,8 @@ Documentation belongs in this README or in script comments, never in
 ## Root Resolution
 
 Codex has no `$CLAUDE_PROJECT_DIR` equivalent and runs hooks at the session
-working directory. Each launcher marks `PHRONESIS_SURFACE=codex`, resolves the
-installation root with `hooks/_resolve.sh`, then execs the matching shared
-script in `<install>/.phronesis/hooks/`.
+working directory. Each launcher resolves the installation root with
+`hooks/_resolve.sh`, then execs `phronesis hook <event> --surface codex`.
 
 The resolver anchors on the launcher location first, then falls back to walking
 up to the nearest `.phronesis/` marker. That keeps the launcher tied to its own
@@ -53,13 +52,13 @@ does not force a re-trust.
 
 ## Wiring
 
-| Codex event | Launcher | Shared script | Output role |
+| Codex event | Launcher | CLI event | Output role |
 |---|---|---|---|
-| `SessionStart` | `.codex/hooks/session-start.sh` | `.phronesis/hooks/session-start.sh` | Due-check `additionalContext` |
-| `UserPromptSubmit` | `.codex/hooks/recall-guard.sh` | `.phronesis/hooks/recall-guard.sh` | Recall guard `additionalContext` |
-| `Stop` | `.codex/hooks/session-sweep.sh` | `.phronesis/hooks/session-sweep.sh` | Capture sweep `decision:block` plus `reason` |
-| `SubagentStop` | `.codex/hooks/session-sweep-subagent.sh` | `.phronesis/hooks/session-sweep.sh` | Subagent sweep variant |
-| `PreCompact` | `.codex/hooks/session-sweep-precompact.sh` | `.phronesis/hooks/session-sweep.sh` | Compaction reminder |
+| `SessionStart` | `.codex/hooks/session-start.sh` | `session-start` | Due-check `additionalContext` |
+| `UserPromptSubmit` | `.codex/hooks/recall-guard.sh` | `recall-guard` | Recall guard `additionalContext` |
+| `Stop` | `.codex/hooks/session-sweep.sh` | `session-sweep` | Capture sweep `decision:block` plus `reason` |
+| `SubagentStop` | `.codex/hooks/session-sweep-subagent.sh` | `session-sweep-subagent` | Subagent sweep variant |
+| `PreCompact` | `.codex/hooks/session-sweep-precompact.sh` | `session-sweep-precompact` | Compaction reminder |
 
 The commands in `hooks.json` are bare relative paths with no arguments. The
 variant is baked into each launcher, so the wiring works whether Codex execs the
@@ -67,7 +66,7 @@ command directly or through a shell.
 
 ## Runtime-Free Degrade
 
-Every launcher exits cleanly with no output when no `phronesis` runtime is on
-`PATH` or when its target shared script is missing. That runtime-free no-op
-posture is part of change 0013: missing runtime means an honest gap, not a
-noisy hook failure.
+Every launcher resolves `~/.phronesis/bin/phronesis` first, then a `phronesis`
+on `PATH`, and exits cleanly with no output when neither exists. That
+runtime-free no-op posture is part of change 0013: missing runtime means an
+honest gap, not a noisy hook failure.

package/templates/codex-surface/hooks/_resolve.sh

@@ -1,28 +1,22 @@
-#!/usr/bin/env bash
-# Phronesis Codex launcher resolver — SOURCED by the .codex/hooks/*.sh launchers (change
-# 0028 / core-0034). Sets PHRONESIS_ROOT to the installation root, or `exit 0` (a clean
-# runtime-free / no-install degrade that the sourcing launcher inherits).
-#
-# Resolution anchors on THIS file's own emitted location — it ships at
-# <root>/domains/{slug}/.codex/hooks/_resolve.sh, a fixed FOUR levels under the install
-# root — so it is independent of the session cwd AND immune to a stray .phronesis/ ancestor
-# (a second checkout, or a domain workspace copied out of its install). A blind
-# walk-up-from-cwd would capture the wrong install in those cases. Only if that fixed anchor
-# does not resolve to an install (e.g. the open target was relocated to a different depth)
-# does it fall back to a nearest-.phronesis walk-up from cwd. The launcher still verifies the
-# target script before exec, so an incomplete install degrades to a clean no-op, never a
-# noisy `env: … No such file` (exit 127).
-command -v phronesis >/dev/null 2>&1 || exit 0
+#!/bin/sh
+# Sourced by each Codex launcher: managed-first CLI binding plus own-location install root.
+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
 
-# Bare ${BASH_SOURCE:-$0}, NOT the array-subscript "[0]" form: that subscript is a bashism that
-# dash (the `sh <path>` interpreter on Linux/CI) rejects with "Bad substitution", and this file
-# is SOURCED by a launcher that may itself be running under dash (core-0034 review #1, round 3).
-# Under bash, bare $BASH_SOURCE is array element 0 = THIS file's path (sourced-frame aware).
-# Under POSIX sh it is unset → $0, which in a sourced frame is the *launcher's* $0 — but the
-# launcher is co-located with this resolver in the same .codex/hooks/ dir, so `dirname` lands on
-# that dir either way, and the four-levels-up anchor below is identical.
+# Bare ${BASH_SOURCE:-$0}, never the dash-invalid array-subscript form.
 __src="${BASH_SOURCE:-$0}"
-__here="$(cd "$(dirname "$__src")" 2>/dev/null && pwd || true)"
+case "$__src" in
+  */*) __dir="${__src%/*}" ;;
+  *) __dir="." ;;
+esac
+__here="$(cd "$__dir" 2>/dev/null && pwd || true)"
 PHRONESIS_ROOT=""
 if [ -n "$__here" ]; then
   __anchor="$(cd "$__here/../../../.." 2>/dev/null && pwd || true)"
@@ -30,7 +24,14 @@ if [ -n "$__here" ]; then
 fi
 if [ -z "$PHRONESIS_ROOT" ]; then
   __d="$PWD"
-  while [ "$__d" != "/" ] && [ ! -d "$__d/.phronesis" ]; do __d="$(dirname "$__d")"; done
+  while [ "$__d" != "/" ] && [ ! -d "$__d/.phronesis" ]; do
+    case "$__d" in
+      */*) __d="${__d%/*}"; [ -n "$__d" ] || __d="/" ;;
+      *) __d="/" ;;
+    esac
+  done
   [ -d "$__d/.phronesis" ] && PHRONESIS_ROOT="$__d"
 fi
 [ -n "$PHRONESIS_ROOT" ] || exit 0
+PHRONESIS_DIR="$PHRONESIS_ROOT"
+export PHRONESIS_BIN PHRONESIS_DIR

package/templates/codex-surface/hooks/recall-guard.sh

@@ -1,30 +1,5 @@
-#!/usr/bin/env bash
-# Phronesis Codex surface launcher → recall-guard (UserPromptSubmit).
-#
-# Resolves the install root via the sibling _resolve.sh (sourced — it anchors on the
-# launcher's own emitted location, so it is cwd-independent and decoy-immune), then hands
-# the event off on stdin to the SHARED, surface-aware recall-guard.sh in
-# <install>/.phronesis/hooks/, marking PHRONESIS_SURFACE=codex. The .codex/hooks.json wires
-# this as a BARE no-arg command path (the variant flag, if any, is baked into the launcher),
-# so the wiring holds whether Codex execs directly or via a shell — one script set, branch
-# on surface (specs/hooks.md §"Surface adapters").
-#
-# Runtime-free / no-install / incomplete-install degrade (change 0013): exit 0, no output —
-# an honest gap, never a noisy error. _resolve.sh exits 0 when phronesis is off PATH or no
-# install resolves; the target-exists check below covers an incomplete install.
-# `set -u` only (no pipefail): no pipelines here, and `set -o pipefail` aborts noisily under
-# a strict POSIX /bin/sh if Codex execs the bare command via `sh <path>` (core-0034 review
-# #2). The exec'd shared script keeps its own bash shebang + pipefail.
-#
-# The source line below uses bare ${BASH_SOURCE:-$0} — NOT the array-subscript "[0]" form: that
-# subscript is a bashism that dash (the `sh <path>` interpreter on Linux/CI) rejects with "Bad
-# substitution" and exits 2 — BEFORE any degrade path — which would defeat the very POSIX-safety
-# the pipefail choice above buys (core-0034 review #1, round 3). Bare $BASH_SOURCE reads array
-# element 0 under bash and is an unset (→ $0) plain var under POSIX sh; both name THIS launcher,
-# and the launcher is co-located with _resolve.sh, so `dirname` lands on the hooks dir either way.
-set -u
-
-. "$(cd "$(dirname "${BASH_SOURCE:-$0}")" 2>/dev/null && pwd || echo /nonexistent)/_resolve.sh" 2>/dev/null || exit 0
-target="$PHRONESIS_ROOT/.phronesis/hooks/recall-guard.sh"
-[ -x "$target" ] || exit 0
-exec env PHRONESIS_SURFACE=codex PHRONESIS_DIR="$PHRONESIS_ROOT" "$target" "$@"
+#!/bin/sh
+__src="${BASH_SOURCE:-$0}"
+case "$__src" in */*) __dir="${__src%/*}" ;; *) __dir="." ;; esac
+. "$(cd "$__dir" 2>/dev/null && pwd || echo /nonexistent)/_resolve.sh" 2>/dev/null || exit 0
+exec "$PHRONESIS_BIN" hook recall-guard --surface codex

package/templates/codex-surface/hooks/session-start.sh

@@ -1,18 +1,5 @@
-#!/usr/bin/env bash
-# Phronesis Codex surface launcher → session-start due-check (SessionStart).
-#
-# Resolves the install root via the sibling _resolve.sh (sourced) and hands off to the
-# SHARED session-start.sh, which under PHRONESIS_SURFACE=codex wraps the due-check printout
-# in Codex's hookSpecificOutput.additionalContext shape. See recall-guard.sh for the
-# launcher rationale; see _resolve.sh for the cwd-independent, decoy-immune root resolution.
-#
-# Runtime-free / no-install / incomplete-install degrade (change 0013): exit 0, no output.
-# `set -u` only (no pipefail), and bare ${BASH_SOURCE:-$0} not the "[0]"-subscript form — both
-# keep this POSIX /bin/sh-safe (dash rejects the array subscript with "Bad substitution"); see
-# recall-guard.sh (core-0034 #2 / #1-round-3).
-set -u
-
-. "$(cd "$(dirname "${BASH_SOURCE:-$0}")" 2>/dev/null && pwd || echo /nonexistent)/_resolve.sh" 2>/dev/null || exit 0
-target="$PHRONESIS_ROOT/.phronesis/hooks/session-start.sh"
-[ -x "$target" ] || exit 0
-exec env PHRONESIS_SURFACE=codex PHRONESIS_DIR="$PHRONESIS_ROOT" "$target" "$@"
+#!/bin/sh
+__src="${BASH_SOURCE:-$0}"
+case "$__src" in */*) __dir="${__src%/*}" ;; *) __dir="." ;; esac
+. "$(cd "$__dir" 2>/dev/null && pwd || echo /nonexistent)/_resolve.sh" 2>/dev/null || exit 0
+exec "$PHRONESIS_BIN" hook session-start --surface codex

package/templates/codex-surface/hooks/session-sweep-precompact.sh

@@ -1,20 +1,5 @@
-#!/usr/bin/env bash
-# Phronesis Codex surface launcher → pre-compaction capture reminder (PreCompact).
-#
-# The --advisory variant of the shared session-sweep.sh: it cannot block, so it surfaces a
-# best-effort "review the conversation for unstored context before it compacts" reminder.
-# Under PHRONESIS_SURFACE=codex the shared script emits the reminder as Codex's
-# {"systemMessage":...} (Claude Code takes the raw line). The variant flag is baked in here,
-# not passed through hooks.json, so the command path stays bare. See recall-guard.sh /
-# _resolve.sh for the launcher mechanics.
-#
-# Runtime-free / no-install / incomplete-install degrade (change 0013): exit 0, no output.
-# `set -u` only (no pipefail), and bare ${BASH_SOURCE:-$0} not the "[0]"-subscript form — both
-# keep this POSIX /bin/sh-safe (dash rejects the array subscript with "Bad substitution"); see
-# recall-guard.sh (core-0034 #2 / #1-round-3).
-set -u
-
-. "$(cd "$(dirname "${BASH_SOURCE:-$0}")" 2>/dev/null && pwd || echo /nonexistent)/_resolve.sh" 2>/dev/null || exit 0
-target="$PHRONESIS_ROOT/.phronesis/hooks/session-sweep.sh"
-[ -x "$target" ] || exit 0
-exec env PHRONESIS_SURFACE=codex PHRONESIS_DIR="$PHRONESIS_ROOT" "$target" --advisory "$@"
+#!/bin/sh
+__src="${BASH_SOURCE:-$0}"
+case "$__src" in */*) __dir="${__src%/*}" ;; *) __dir="." ;; esac
+. "$(cd "$__dir" 2>/dev/null && pwd || echo /nonexistent)/_resolve.sh" 2>/dev/null || exit 0
+exec "$PHRONESIS_BIN" hook session-sweep-precompact --surface codex

package/templates/codex-surface/hooks/session-sweep-subagent.sh

@@ -1,23 +1,5 @@
-#!/usr/bin/env bash
-# Phronesis Codex surface launcher → subagent-boundary sweep (SubagentStop).
-#
-# The --lifecycle-only variant of the shared session-sweep.sh: it skips the capture sweep
-# and only closes an open skill-lifecycle record for the subagent boundary. On Codex this is
-# presently inert — Codex mints no invocation_id (no UserPromptExpansion / matchable Skill
-# PreToolUse, so skill-lifecycle telemetry is Level-2 PARTIAL, change 0028 /
-# event-log.md §"Compliance levels") — so there is nothing to close. It is wired with the
-# SAME script Claude Code uses (not a Codex-specific path) so the boundary is handled
-# correctly if Codex later surfaces the lifecycle; it fabricates nothing meanwhile (emission
-# honesty, change 0021). The variant flag is baked in here, not passed through hooks.json, so
-# the command path stays bare. See recall-guard.sh / _resolve.sh for the launcher mechanics.
-#
-# Runtime-free / no-install / incomplete-install degrade (change 0013): exit 0, no output.
-# `set -u` only (no pipefail), and bare ${BASH_SOURCE:-$0} not the "[0]"-subscript form — both
-# keep this POSIX /bin/sh-safe (dash rejects the array subscript with "Bad substitution"); see
-# recall-guard.sh (core-0034 #2 / #1-round-3).
-set -u
-
-. "$(cd "$(dirname "${BASH_SOURCE:-$0}")" 2>/dev/null && pwd || echo /nonexistent)/_resolve.sh" 2>/dev/null || exit 0
-target="$PHRONESIS_ROOT/.phronesis/hooks/session-sweep.sh"
-[ -x "$target" ] || exit 0
-exec env PHRONESIS_SURFACE=codex PHRONESIS_DIR="$PHRONESIS_ROOT" "$target" --lifecycle-only "$@"
+#!/bin/sh
+__src="${BASH_SOURCE:-$0}"
+case "$__src" in */*) __dir="${__src%/*}" ;; *) __dir="." ;; esac
+. "$(cd "$__dir" 2>/dev/null && pwd || echo /nonexistent)/_resolve.sh" 2>/dev/null || exit 0
+exec "$PHRONESIS_BIN" hook session-sweep-subagent --surface codex

package/templates/codex-surface/hooks/session-sweep.sh

@@ -1,19 +1,5 @@
-#!/usr/bin/env bash
-# Phronesis Codex surface launcher → capture sweep (Stop).
-#
-# Resolves the install root via the sibling _resolve.sh (sourced) and hands the Stop event
-# off on stdin to the SHARED session-sweep.sh. 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 shared script needs no Stop-path
-# branch. See recall-guard.sh for the launcher rationale; _resolve.sh for root resolution.
-#
-# Runtime-free / no-install / incomplete-install degrade (change 0013): exit 0, no output.
-# `set -u` only (no pipefail), and bare ${BASH_SOURCE:-$0} not the "[0]"-subscript form — both
-# keep this POSIX /bin/sh-safe (dash rejects the array subscript with "Bad substitution"); see
-# recall-guard.sh (core-0034 #2 / #1-round-3).
-set -u
-
-. "$(cd "$(dirname "${BASH_SOURCE:-$0}")" 2>/dev/null && pwd || echo /nonexistent)/_resolve.sh" 2>/dev/null || exit 0
-target="$PHRONESIS_ROOT/.phronesis/hooks/session-sweep.sh"
-[ -x "$target" ] || exit 0
-exec env PHRONESIS_SURFACE=codex PHRONESIS_DIR="$PHRONESIS_ROOT" "$target" "$@"
+#!/bin/sh
+__src="${BASH_SOURCE:-$0}"
+case "$__src" in */*) __dir="${__src%/*}" ;; *) __dir="." ;; esac
+. "$(cd "$__dir" 2>/dev/null && pwd || echo /nonexistent)/_resolve.sh" 2>/dev/null || exit 0
+exec "$PHRONESIS_BIN" hook session-sweep --surface codex