phronesis 1.0.0

package/src/skills.js

@@ -0,0 +1,355 @@
+// `phronesis skills status` (core-0015 / T3.1) — the diagnosis surface for the
+// install's skill registry, the registry-status parity surface one layer up: which
+// skills are registered, each one's resolved contract (version, weight, tier,
+// prompt_pin, triggers, reads, via_action_types, degrade target), and — on an invalid
+// layer — the SAME load errors the loader refuses with, exit non-zero. The skills
+// layer is a separate failure domain from the action layer (no skill execution exists
+// 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 { existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { pathToFileURL } from 'node:url';
+import fse from 'fs-extra';
+import {
+  loadSkills,
+  resolveActionTypes,
+  resolveInstall,
+  skillFilePath,
+} from '@phronesis/core';
+import { DEFAULT_K, bumpSkill, resolveRepoRoot } from './skills-bump.js';
+
+// skills/ dirs that carry a SKILL.md but no registry entry — informational, never an
+// error (an unregistered skill is inert, the action-type-removal posture: absence
+// refuses to load, and that is a tightening).
+async function unregisteredSkillDirs(root, loaded) {
+  let entries;
+  try {
+    entries = await readdir(join(root, 'skills'), { withFileTypes: true });
+  } catch {
+    // ENOENT (no skills/ dir yet) is the by-design empty case; anything else
+    // (EACCES…) only suppresses this informational listing — the load-bearing
+    // checks above never depend on it. Do not widen this catch into the loader.
+    return [];
+  }
+  const out = [];
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    if (Object.hasOwn(loaded, e.name)) continue;
+    if (await fse.pathExists(join(root, skillFilePath(e.name)))) out.push(e.name);
+  }
+  return out;
+}
+
+// PURE skill-registry resolution (core-0038 D2/D3): resolve the install, read the registry,
+// resolve action types, load the registered skills — returning a STRUCTURED verdict with NO
+// console output and NO process.exitCode side-effect. `runSkillsStatus` (the CLI wrapper) and
+// `phronesis doctor` both consume this, so the diagnosis can never disagree between the two
+// surfaces (the "two consumers → one matcher" rule). `kind` lets the wrapper reproduce its exact
+// per-failure-mode message; `status` + `errors` + `skills`/`unregistered` are what doctor needs.
+export async function skillsStatusReport({ dir } = {}) {
+  const installed = resolveInstall({ dir });
+  if (installed.error) {
+    return { status: 'fail', kind: 'no-install', root: null, errors: [installed.error], skills: {}, unregistered: [], schema_version: null };
+  }
+  const root = installed.root;
+  let registry;
+  try {
+    registry = await fse.readJson(join(root, '.phronesis', 'registry.json'));
+  } catch (err) {
+    return {
+      status: 'fail', kind: 'registry-unreadable', root,
+      errors: [`could not read the install registry (.phronesis/registry.json): ${err.message}`],
+      skills: {}, unregistered: [], schema_version: null,
+    };
+  }
+  // via_action_types resolves against the EFFECTIVE action-type table — same resolver the action
+  // core consumes (the act/status parity lesson). An invalid action layer means there is no
+  // registered set to resolve against: fail closed, naming why.
+  const action = resolveActionTypes(registry);
+  if (action.errors.length) {
+    return { status: 'fail', kind: 'action-registry-invalid', root, errors: action.errors, skills: {}, unregistered: [], schema_version: registry.schema_version };
+  }
+  const { errors, skills } = await loadSkills({
+    installRoot: root,
+    registry,
+    registeredActionTypes: Object.keys(action.effective),
+  });
+  if (errors.length) {
+    return { status: 'fail', kind: 'skills-invalid', root, errors, skills: {}, unregistered: [], schema_version: registry.schema_version };
+  }
+  // Membership universe = the LOADED map (on success its keys are exactly the validated section's),
+  // never a re-read of registry.skills — one validated source.
+  const unregistered = await unregisteredSkillDirs(root, skills);
+  return { status: 'ok', kind: 'ok', root, errors: [], skills, unregistered, schema_version: registry.schema_version };
+}
+
+export async function runSkillsStatus({ dir, json = false } = {}) {
+  const report = await skillsStatusReport({ dir });
+  if (report.status === 'fail') {
+    if (report.kind === 'no-install' || report.kind === 'registry-unreadable') {
+      console.error(report.errors[0]);
+    } else if (report.kind === 'action-registry-invalid') {
+      console.error(
+        'invalid .phronesis/registry.json (action-type registry) — skills cannot resolve via_action_types until it is fixed (see: phronesis registry status):',
+      );
+      for (const e of report.errors) console.error(`  ✗ ${e}`);
+    } else {
+      console.error(
+        'invalid skill registry — the skills layer is disabled until every registered skill is valid (removing a skills entry unregisters that skill):',
+      );
+      for (const e of report.errors) console.error(`  ✗ ${e}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const { root, skills, unregistered, schema_version } = report;
+
+  if (json) {
+    console.log(JSON.stringify({ root, schema_version, skills, unregistered }, null, 2));
+    return;
+  }
+
+  console.log(`Phronesis skill registry — ${root}`);
+  const names = Object.keys(skills);
+  if (!names.length) {
+    console.log(
+      'skills: none registered (.phronesis/registry.json skills section is empty; add skills.{name} entries to register skill dirs)',
+    );
+  }
+  for (const name of names) {
+    const s = skills[name];
+    console.log(`\n${name} @ ${s.version}`);
+    console.log(`  file:       ${s.path}`);
+    console.log(`  weight:     ${s.weight} · tier: ${s.requires_model_tier} · prompt_pin: ${s.prompt_pin.raw}`);
+    const triggers = [
+      s.invocation.explicit.length ? `explicit(${s.invocation.explicit.length})` : null,
+      s.invocation.suggested.length ? `suggested(${s.invocation.suggested.length})` : null,
+      s.invocation.woven ? 'woven' : null,
+    ].filter(Boolean);
+    console.log(`  invocation: ${triggers.join(', ') || 'none declared'}`);
+    console.log(`  reads:      ${s.reads.length} declaration(s)`);
+    console.log(
+      `  writes:     via ${s.writes.via_action_types.length ? s.writes.via_action_types.join(', ') : '(read-only)'}${s.writes.paths.length ? ` · direct: ${s.writes.paths.join(', ')}` : ''}`,
+    );
+    if (s.sub_agents.length) console.log(`  sub_agents: ${s.sub_agents.join(', ')}`);
+    console.log(`  degrades:   ${s.degrade_target}`);
+  }
+  if (unregistered.length) {
+    console.log(
+      `\nunregistered — skills/ dirs with a SKILL.md but no registry entry; these do not load (add a skills.{name} entry to register): ${unregistered.join(', ')}`,
+    );
+  }
+}
+
+// --- `phronesis skills bump` (core-0031 / T7.4 + T7.2 coverage floor) -----------------
+// The deployment-unit gate. This module wires the REAL deps (the candidate-execution
+// substrate, the install corpus, the registry, the judge pin) and hands them to the pure
+// orchestrator in skills-bump.js. The substrate is dynamic-imported FROM THE RESOLVED REPO
+// ROOT — bump is a dev/release op on git-tracked source (B6), so the substrate it runs is
+// 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');
+}
+
+// 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).
+export async function loadCorpusFromInstall({ skill, goldensDir }) {
+  const dir = goldensDir
+    || (process.env.PHRONESIS_INSTALL
+      ? join(process.env.PHRONESIS_INSTALL, 'corpus', 'skill-goldens', skill)
+      : null);
+  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();
+  const goldens = [];
+  const idParts = [];
+  for (const f of files) {
+    const p = join(dir, f);
+    const raw = await readFile(p, 'utf8');
+    let d;
+    // FAIL CLOSED on a malformed golden — a release gate must never SILENTLY shrink its
+    // corpus by skipping a bad file (a dropped hard case is the most dangerous loss). A
+    // file named golden-*.json is asserted to be a golden; if it isn't a well-formed one,
+    // the operator fixes or removes it before the gate can run.
+    try {
+      d = JSON.parse(raw);
+    } catch (err) {
+      throw new Error(
+        `corpus golden ${f} is not valid JSON (${err.message}) — fix or remove ${p}; ` +
+        'the bump gate fails closed rather than silently drop a golden.',
+      );
+    }
+    if (!('input' in d && 'expected' in d && 'model_default' in d)) {
+      throw new Error(
+        `corpus golden ${f} is missing a required field (needs input, expected, model_default) — ` +
+        `fix or remove ${p}; the bump gate fails closed rather than silently skip a golden.`,
+      );
+    }
+    const id = d.id || f.replace(/\.json$/, '');
+    goldens.push({ ...d, id, path: p });
+    idParts.push(`${id}:${sha256(raw)}`);
+  }
+  let manifest = '';
+  for (const mp of [join(dir, 'MANIFEST.md'), join(dir, '..', 'MANIFEST.md')]) {
+    if (existsSync(mp)) {
+      manifest = await readFile(mp, 'utf8');
+      break;
+    }
+  }
+  const identity = `${idParts.sort().join('\n')}\n--manifest--\n${sha256(manifest)}`;
+  let signed = false;
+  const signingPath = join(dir, 'signing.json');
+  if (existsSync(signingPath)) {
+    try {
+      signed = JSON.parse(await readFile(signingPath, 'utf8')).signed === true;
+    } catch {
+      signed = false;
+    }
+  } else if (existsSync(join(dir, 'SIGNED'))) {
+    signed = true;
+  }
+  return { goldens, signed, identity, source: dir };
+}
+
+export async function runSkillsBump({
+  skill,
+  to,
+  repo,
+  k = DEFAULT_K,
+  acceptRegression = false,
+  rebaseline = false,
+  shapeChange = false,
+  qualityFloor,
+  coverageFloor,
+  rationale,
+  acceptedBy = 'operator',
+  judgeModel = 'sonnet',
+  goldensDir,
+  domain,
+  json = false,
+} = {}) {
+  const resolved = resolveRepoRoot({ repo });
+  if (resolved.error) {
+    console.error(resolved.error);
+    process.exitCode = 1;
+    return;
+  }
+  const root = resolved.root;
+
+  // Dynamic-import the substrate from the resolved repo root (B1/B6).
+  const substratePath = join(root, 'harness', 'evals', 'skill-goldens', 'run_candidates.mjs');
+  if (!existsSync(substratePath)) {
+    console.error(
+      `candidate-execution substrate not found at ${substratePath} — skills bump rides core-0028; ` +
+        'run from a repo that carries it.',
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const substrate = await import(pathToFileURL(substratePath).href);
+
+  // The eval-identity registry component MUST be the action-type contract the SUBSTRATE
+  // actually runs against — the substrate resolves core from the repo root (B6), which can
+  // differ from this CLI's bundled @phronesis/core. Hashing the CLI's defaultActionTypesSection()
+  // would let registry/schema drift in the repo's core look "stable" and pass an invalid
+  // comparison. So we read the contract from the substrate's own exported accessor.
+  if (typeof substrate.actionTypeContract !== 'function') {
+    console.error(
+      'the candidate-execution substrate does not export actionTypeContract() — it predates the ' +
+        'eval-identity registry fix (core-0031). Update the substrate (core-0028) before bumping.',
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  const judgePyPath = join(root, 'harness', 'evals', 'judge', 'judge.py');
+  const judgePin = `${judgeModel}|${existsSync(judgePyPath) ? sha256(await readFile(judgePyPath, 'utf8')) : 'absent'}`;
+
+  const deps = {
+    runCandidates: substrate.runCandidates,
+    parseSkillSource: substrate.parseSkillSource,
+    runnerProtocolVersion: substrate.RUNNER_PROTOCOL_VERSION,
+    registrySection: JSON.stringify(substrate.actionTypeContract()),
+    judgePin,
+    judgeModel,
+    judge: 'judge.py',
+    loadCorpus: ({ skill: s }) => loadCorpusFromInstall({ skill: s, goldensDir }),
+    now: new Date(),
+  };
+
+  let result;
+  try {
+    result = await bumpSkill(
+      {
+        skill,
+        toPin: to,
+        repoRoot: root,
+        k,
+        rebaseline,
+        acceptRegression,
+        shapeChange,
+        qualityFloor,
+        coverageFloor,
+        rationale,
+        acceptedBy,
+        activeDomain: domain,
+      },
+      deps,
+    );
+  } catch (err) {
+    // A malformed SKILL.md (no version/prompt_pin), an inconsistent rubric, a corrupt
+    // PINS.md block, or a judge.py crash throws — surface it as a clean failure, not a raw
+    // unhandled-rejection stack trace. Every throw site runs before the PINS write, so no
+    // partial record is left behind.
+    console.error(`✗ skills bump failed: ${err.message}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    printBumpResult(result);
+  }
+  if (result.status !== 'ok') process.exitCode = 1;
+}
+
+function printBumpResult(result) {
+  const axes = result.aggregate
+    ? `quality floors {${Object.entries(result.aggregate.quality.criteria)
+        .map(([c, v]) => `${c}:${v.min}`)
+        .join(', ')}} · coverage floor ${result.aggregate.coverage.hit_rate_min} (fabrications ${result.aggregate.coverage.fabrications})`
+    : '';
+  if (result.status === 'ok') {
+    console.log(`✓ ${result.message}`);
+    if (axes) console.log(`  ${axes}`);
+    console.log(`  gate: ${result.gate_status}${result.corpus_signed ? '' : ' (corpus unsigned)'}${result.coverage_asserted === false ? ' · coverage not exercised' : ''}`);
+    return;
+  }
+  if (result.status === 'refused') {
+    console.error(`⚠ refused — ${result.reason}`);
+    console.error(`  ${result.message}`);
+    return;
+  }
+  if (result.status === 'invalid') {
+    console.error(`✗ ${result.error}`);
+    return;
+  }
+  if (result.status === 'error') {
+    console.error(`✗ error — ${result.reason}`);
+    console.error(`  ${result.message}`);
+    return;
+  }
+  console.error(`✗ blocked — ${result.reason}`);
+  console.error(`  ${result.message}`);
+  if (axes) console.error(`  ${axes}`);
+}

package/src/subscription.js

@@ -0,0 +1,5 @@
+// Subscription matching moved to @phronesis/core in core-0013, when the in-pipeline
+// hook executor became its second consumer — one shared matcher (rules.md two-matchers
+// drift), reachable from the only legal import direction (apps→packages). This shim
+// keeps the CLI surface's import site stable.
+export { validateSubscription, matchesSubscription } from '@phronesis/core';

package/src/validate.js

@@ -0,0 +1,152 @@
+import { resolve, join } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import fse from 'fs-extra';
+import chalk from 'chalk';
+import {
+  checkObjectContent,
+  contextFor,
+  checkArtifactContent,
+  listArtifactFiles,
+  listObjectFiles,
+  checkActiveContextStaleness,
+  validateScheduleRegistry,
+  pruneOrphanScheduleState,
+} from '@phronesis/core';
+import { checkSkillDiscoveryStaleness } from './skill-discovery.js';
+
+// Validate every typed object in domains/*/compiled/ and codex/ against the locked
+// ontology contract (specs/ontology.md, change 0009). Returns { ok, checked, fileErrors }.
+// The per-object check (frontmatter contract + link existence) lives in @phronesis/core's
+// checkObjectContent — the SAME check the action spine's staged writer enforces
+// (core-0008), so an action can never commit what validate would reject. This module is
+// the reporting surface: discovery, iteration, and the per-file error report.
+export async function validateInstallation({ dir } = {}) {
+  const installRoot = resolve(process.cwd(), dir || '.');
+
+  const hasDomains = await fse.pathExists(join(installRoot, 'domains'));
+  const hasCodex = await fse.pathExists(join(installRoot, 'codex'));
+  if (!hasDomains && !hasCodex) {
+    console.error(`Nothing to validate: ${installRoot} has no domains/ or codex/ (not a Phronesis installation).`);
+    process.exitCode = 1;
+    return { ok: false, checked: 0, fileErrors: [] };
+  }
+
+  const files = await listObjectFiles(installRoot);
+
+  const fileErrors = [];
+  let checked = 0;
+
+  for (const rel of files) {
+    if (!contextFor(rel)) continue; // not a typed object (e.g. codex/INDEX.md)
+    checked += 1;
+
+    let errors;
+    try {
+      const content = await readFile(join(installRoot, rel), 'utf8');
+      errors = await checkObjectContent({ installRoot, relPath: rel, content });
+    } catch (err) {
+      errors = [`could not read object: ${err.message}`];
+    }
+
+    if (errors.length) fileErrors.push({ file: rel, errors });
+  }
+
+  // Durable artifacts are intentionally not typed ontology objects, so they get
+  // their own narrow structural pass rather than being smuggled through contextFor.
+  // Keeping it in `phronesis validate` means an exported workspace has one familiar
+  // integrity command even though PRDs remain non-canonical.
+  const artifactFiles = await listArtifactFiles(installRoot);
+  for (const rel of artifactFiles) {
+    checked += 1;
+    let errors;
+    try {
+      const content = await readFile(join(installRoot, rel), 'utf8');
+      errors = await checkArtifactContent({ installRoot, relPath: rel, content });
+    } catch (err) {
+      errors = [`could not read artifact: ${err.message}`];
+    }
+    if (errors.length) fileErrors.push({ file: rel, errors });
+  }
+
+  // Cross-file generated-state hygiene (core-0017 H5): a domain's active-context
+  // projection must not be staler than the compiled objects it summarizes. This is a
+  // CROSS-file check (not per-object checkObjectContent, which sees one file), and it runs
+  // at validate time — not as a post-commit gate hook, which fires after the write lands
+  // and could not "fail validation until refreshed."
+  const staleFindings = await checkActiveContextStaleness({ installRoot });
+  const skillFindings = await checkSkillDiscoveryStaleness({ installRoot });
+
+  // Schedule registry (core-0051 / change 0042): a HARD contract check (shape / unknown field /
+  // bad cadence / duplicate id / connector_pull target), plus the D1b warn-and-prune of orphan
+  // runtime-state entries (a `last_completed` for an id no longer declared). The prune is a
+  // safe GC of gitignored derived state — informational, never a failure. Runs BEFORE the hard
+  // check reads nothing it depends on; both are independent.
+  const scheduleResult = await validateScheduleRegistry({ installRoot });
+  const scheduleErrors = scheduleResult.errors;
+  // Prune orphan runtime-state ONLY when declarations are valid — never against an unreliable
+  // declared set (Codex round-2 F2; pruneOrphanScheduleState is also self-guarded). The prune is
+  // a NICETY: a write failure (EACCES on a read-only state dir) must WARN, never crash validation
+  // — the core call is guarded and this try/catch is belt-and-suspenders (PR #138 review).
+  let pruned = [];
+  let pruneError = null;
+  if (scheduleErrors.length === 0) {
+    try {
+      const r = await pruneOrphanScheduleState({ installRoot });
+      pruned = r.pruned;
+      pruneError = r.error || null;
+    } catch (err) {
+      pruneError = `could not prune orphan schedule state: ${err.message}`;
+    }
+  }
+
+  const ok =
+    fileErrors.length === 0 &&
+    staleFindings.length === 0 &&
+    skillFindings.length === 0 &&
+    scheduleErrors.length === 0;
+  if (pruned.length) {
+    console.error(
+      chalk.yellow(`! pruned ${pruned.length} orphan schedule-state entr(ies) (no matching declaration): ${pruned.join(', ')}`),
+    );
+  }
+  if (pruneError) {
+    // A prune write failure is a WARNING, not a validation failure — `ok` is unaffected.
+    console.error(chalk.yellow(`! ${pruneError} — validation is unaffected; re-run once .phronesis/state/ is writable to clean them`));
+  }
+  report(ok, checked, fileErrors, staleFindings, skillFindings, scheduleErrors);
+  process.exitCode = ok ? 0 : 1;
+  return { ok, checked, fileErrors, staleFindings, skillFindings, scheduleErrors, prunedScheduleState: pruned, scheduleStatePruneError: pruneError };
+}
+
+function report(ok, checked, fileErrors, staleFindings = [], skillFindings = [], scheduleErrors = []) {
+  if (ok) {
+    console.log(chalk.dim(`validate: ${checked} object(s) checked.`));
+    console.log(`${chalk.green('✓')} valid — every object satisfies the ontology contract.`);
+    return;
+  }
+  for (const { file, errors } of fileErrors) {
+    console.error(chalk.bold(file));
+    for (const e of errors) console.error(`  ${chalk.red('✗')} ${e}`);
+  }
+  for (const f of staleFindings) {
+    console.error(chalk.bold(`domains/${f.domain}/ACTIVE_CONTEXT.md`));
+    console.error(
+      `  ${chalk.red('✗')} stale: ${f.key} is updated ${f.objectDate} but the projection records ${f.projectionDate} — run \`phronesis active-context refresh --domain ${f.domain}\``,
+    );
+  }
+  for (const f of skillFindings) {
+    console.error(chalk.bold(f.domain ? `domains/${f.domain}/AGENTS.md` : 'AGENTS.md skill discovery'));
+    console.error(`  ${chalk.red('✗')} ${f.message}`);
+  }
+  if (scheduleErrors.length) {
+    console.error(chalk.bold('.phronesis/schedule.json'));
+    for (const e of scheduleErrors) console.error(`  ${chalk.red('✗')} ${e}`);
+  }
+  const issues = fileErrors.reduce((n, f) => n + f.errors.length, 0);
+  const parts = [];
+  if (fileErrors.length) parts.push(`${issues} issue(s) across ${fileErrors.length} object(s)`);
+  if (staleFindings.length) parts.push(`${staleFindings.length} stale projection entr(ies)`);
+  if (skillFindings.length) parts.push(`${skillFindings.length} stale skill-discovery entr(ies)`);
+  if (scheduleErrors.length) parts.push(`${scheduleErrors.length} schedule-registry issue(s)`);
+  console.error(`${chalk.red('✗')} ${parts.join(' + ')} (${checked} object(s) checked).`);
+}

package/templates/claude/settings.json

@@ -0,0 +1,86 @@
+{
+  "$comment": "Phronesis hooks (Tier 1, Claude Code — specs/hooks.md; changes 0010 + 0005 + 0021). UserPromptSubmit: run the pre-answer recall guard and add context only. PreToolUse(Skill) + UserPromptExpansion: mint adapter-owned skill invocation ids and emit skill.invoked. SessionStart: clear stale invocation state, emit session.start, and surface due decision reviews. Stop/SubagentStop: emit skill.completed at the real boundary after the sweep is not blocking. StopFailure: clear errored-turn invocation state without synthetic completion. PreCompact: best-effort sweep reminder before context is lost. Scripts degrade to a clean no-op when no phronesis runtime is on PATH.",
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR/.phronesis/hooks/recall-guard.sh\""
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Skill",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR/.phronesis/hooks/skill-lifecycle.sh\" start"
+          }
+        ]
+      }
+    ],
+    "UserPromptExpansion": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR/.phronesis/hooks/skill-lifecycle.sh\" start"
+          }
+        ]
+      }
+    ],
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR/.phronesis/hooks/session-start.sh\""
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR/.phronesis/hooks/session-sweep.sh\""
+          }
+        ]
+      }
+    ],
+    "SubagentStop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR/.phronesis/hooks/session-sweep.sh\" --lifecycle-only"
+          }
+        ]
+      }
+    ],
+    "StopFailure": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR/.phronesis/hooks/skill-lifecycle.sh\" abandon"
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR/.phronesis/hooks/session-sweep.sh\" --advisory"
+          }
+        ]
+      }
+    ]
+  }
+}