phronesis 1.0.0 → 1.1.0

package/src/adapter.js

@@ -8,11 +8,26 @@
 // canonical state and emits no events.
 
 import { join } from 'node:path';
-import { readFileSync, statSync, existsSync, mkdtempSync, writeFileSync, chmodSync, rmSync, realpathSync } from 'node:fs';
+import { readFileSync, lstatSync, existsSync, mkdtempSync, mkdirSync, writeFileSync, chmodSync, rmSync, realpathSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { spawnSync } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
-import { resolveInstall, RE_SLUG } from '@phronesis/core';
+import { fileURLToPath } from 'node:url';
+import {
+  resolveInstall,
+  RE_SLUG,
+  runAction,
+  runContextRelevanceGuard,
+  runDueCheck,
+  appendEvent,
+  readEvents,
+  beginSkillInvocation,
+  completeActiveSkillInvocation,
+  abandonActiveSkillInvocation,
+  readActiveInvocation,
+  sweepStatus,
+  readAuditLog,
+} from '@phronesis/core';
 import { CODEX_ADAPTER_HOOKS, CODEX_SURFACE_RESOLVER } from './layout.js';
 import { validateCodexHooksSchema } from './codex-hooks-schema.js';
 
@@ -22,6 +37,7 @@ import { validateCodexHooksSchema } from './codex-hooks-schema.js';
 const HOOKS = CODEX_ADAPTER_HOOKS;
 
 const DESKTOP_CHECKLIST = 'docs/surface-setup.md';
+const CODEX_HOOK_TEMPLATE_DIR = fileURLToPath(new URL('../templates/codex-surface/hooks/', import.meta.url));
 
 // Read the install's domains from the registry (the adapter test runs against the
 // domain workspace open target — domains/{slug}/.codex/). Falls back to 'pm'.
@@ -43,19 +59,27 @@ function installDomains(root) {
 
 function isExecutable(p) {
   try {
-    const st = statSync(p);
+    const st = lstatSync(p);
     // A runnable launcher/script must be a REGULAR file with an exec bit — a directory carries the
-    // exec bit too (0755) and would otherwise read as a runnable script (core-0038 Codex round-3 F1).
+    // exec bit too (0755), and a symlink must not be followed during structural inspection.
     return st.isFile() && Boolean(st.mode & 0o111);
   } catch {
     return false;
   }
 }
 
+function matchesCanonicalHookBytes(installedPath, templateName) {
+  try {
+    return readFileSync(installedPath).equals(readFileSync(join(CODEX_HOOK_TEMPLATE_DIR, templateName)));
+  } catch {
+    return false;
+  }
+}
+
 // Structural: the emitted domains/{slug}/.codex/ wiring matches the CODEX_ADAPTER_HOOKS
 // contract — hooks.json present + parseable, each event wired to its bare relative
-// launcher path, each launcher present + executable + handing off to its shared script,
-// each shared script present. Returns { checks: [...], compliant: bool }.
+// launcher path, and each launcher present + executable + bound to the contracted
+// `phronesis hook <event> --surface codex` interface. Returns { checks, compliant }.
 function checkEmission(root, slug) {
   const checks = [];
   const add = (ok, label, detail = '') => checks.push({ ok, label, detail });
@@ -85,7 +109,14 @@ function checkEmission(root, slug) {
   // The shared resolver the launchers source — infrastructure, not an event hook, but
   // every launcher fails to source it if it is absent, so it must ship + be present.
   const resolverPath = join(codexDir, 'hooks', CODEX_SURFACE_RESOLVER);
-  add(existsSync(resolverPath), `resolver ${CODEX_SURFACE_RESOLVER} present`, existsSync(resolverPath) ? '' : 'missing — launchers cannot resolve the install root');
+  const resolverOk = isExecutable(resolverPath);
+  add(resolverOk, `resolver ${CODEX_SURFACE_RESOLVER} present + regular executable`, resolverOk ? '' : 'missing, symlinked, not regular, or not +x — launchers cannot resolve the managed CLI/install root');
+  const resolverCanonical = resolverOk && matchesCanonicalHookBytes(resolverPath, CODEX_SURFACE_RESOLVER);
+  add(
+    resolverCanonical,
+    `resolver ${CODEX_SURFACE_RESOLVER} matches canonical shipped bytes`,
+    resolverCanonical ? '' : 'hand-modified resolver; run `phronesis adapter test codex` for behavioral proof',
+  );
 
   const hooks = (config && config.hooks) || {};
   // Exact-set match against the contract: an event wired in hooks.json but absent from
@@ -123,34 +154,24 @@ function checkEmission(root, slug) {
     add(wired, `${h.event} → ${expected} (exactly one entry + command)`, wiredDetail);
 
     const launcherPath = join(codexDir, 'hooks', h.launcher);
-    const launcherOk = existsSync(launcherPath) && isExecutable(launcherPath);
-    add(launcherOk, `launcher ${h.launcher} present + executable`, launcherOk ? '' : 'missing or not +x');
-
-    const scriptPath = join(root, '.phronesis', 'hooks', h.script);
-    const scriptOk = existsSync(scriptPath) && isExecutable(scriptPath);
-    add(scriptOk, `shared script .phronesis/hooks/${h.script} present + executable`, scriptOk ? '' : 'missing or not +x');
+    const launcherOk = isExecutable(launcherPath);
+    add(launcherOk, `launcher ${h.launcher} present + regular executable`, launcherOk ? '' : 'missing, symlinked, not regular, or not +x');
+    const launcherBound = launcherOk && matchesCanonicalHookBytes(launcherPath, h.launcher);
+    add(
+      launcherBound,
+      `launcher ${h.launcher} binds hook ${h.hookEvent} --surface codex`,
+      launcherBound ? '' : 'hand-modified launcher; run `phronesis adapter test codex` for behavioral proof',
+    );
   }
 
   return { checks, compliant: checks.every((c) => c.ok) };
 }
 
-// Behavioral: run the reinforcement launchers (Stop, UserPromptSubmit, SessionStart) through
-// scripted events and assert each not only REACHES the right `phronesis` subcommand but produces
-// the operator-facing OUTPUT — for recall + due-check, the Codex hookSpecificOutput.additionalContext
-// envelope that actually injects the packet. Reaching `guard`/`due-check` but emitting nothing is
-// NOT recall injection (core-0034 review, round 4). The shim never execs the real CLI: it logs argv
-// AND returns CANNED guard JSON / due-check text — so the shared scripts run their envelope
-// formatting while this self-check stays non-mutating by construction (the REAL guard emits
-// recall.candidate/injected and due-check emits outcome.due/session.start, none of which may touch
-// the operator's install; the shim writes nothing and spawns nothing). A launcher OR its shared
-// .phronesis/hooks/ script replaced by a bare `exit 0` (present + executable, so the structural
-// emission check still passes), or one that calls the subcommand but drops its output, never
-// produces the envelope — so the probe fails (the "Level-1 compliant while recall is dead" gap).
-// Asserts: (a) Stop emits {"decision":"block"} (its own `node -e`, surfaces behind the shim) and
-// reaches `hooks sweep-status`; (b) UserPromptSubmit reaches `guard --surface codex` AND wraps the
-// guard packet into a UserPromptSubmit additionalContext envelope; (c) SessionStart wraps the
-// due-check text into a SessionStart additionalContext envelope; (d) the install root resolves from
-// a SUBDIR of the open target (its block reason carries `--dir <root>`, resolved in-shell).
+// Behavioral: run the reinforcement launchers against a NON-EXECING shim for the new single CLI
+// hook interface. The shim logs argv and returns nonce-bearing surface output, so the probe proves
+// each launcher reaches the exact event, preserves stdout, and resolves the install root without
+// ever running the real (state-mutating) guard/due-check/session-start logic on the operator install.
+// The CLI hook interface itself is exercised end-to-end by validate-hooks and hook.test.js.
 function checkBehavior(root, slug) {
   const checks = [];
   const add = (ok, label, detail = '') => checks.push({ ok, label, detail });
@@ -161,40 +182,42 @@ function checkBehavior(root, slug) {
     return { checks, compliant: false };
   }
 
-  // Sentinels the shim feeds back as the guard packet / due-check text; the probes assert these
-  // survive into the emitted additionalContext envelope (proves the shared script wrapped them).
-  // PER-RUN NONCE, not a fixed literal: a constant sentinel could be satisfied by a shared script
-  // that hardcodes the envelope without wrapping anything (a vacuous pass — review round 4); a
-  // value the shared script cannot know forces it to actually carry THIS run's result through.
+  // Sentinels the shim feeds back as hook-interface output; the probes assert these survive through
+  // each thin launcher. PER-RUN NONCE, not a fixed literal: a constant sentinel could be satisfied
+  // by a launcher that hardcodes the envelope (a vacuous pass — review round 4); a value the
+  // launcher cannot know forces it to carry THIS run's result through.
   const nonce = randomBytes(8).toString('hex');
   const RECALL_SENTINEL = `ADAPTER_PROBE_RECALL_${nonce}`;
   const DUE_SENTINEL = `ADAPTER_PROBE_DUE_${nonce}`;
+  const PRECOMPACT_SENTINEL = `ADAPTER_PROBE_PRECOMPACT_${nonce}`;
 
   let shimDir;
   try {
     shimDir = mkdtempSync(join(tmpdir(), 'phronesis-adapter-'));
     const argvLog = join(shimDir, 'argv.log');
     const shim = join(shimDir, 'phronesis');
-    // Logs argv, returns CANNED output for the two subcommands whose result the shared scripts
-    // wrap into an envelope (`guard` → a fired recall result; `hooks due-check` → due text), and
-    // exits 0 for everything else (sweep-status, skill-sweep-stale, event emit, …) — so the Stop
-    // sweep reads "unswept" and NOTHING is execed or written (non-mutating). `$1`/`$2`/`$*` are
-    // literal shell, not JS interpolation (no `${`).
+    const shimHome = join(shimDir, 'home');
+    mkdirSync(shimHome);
+    // Canned hook-interface output. The per-run nonce proves stdout came from THIS invocation,
+    // not a launcher-forged fixed envelope. PHRONESIS_DIR is set by _resolve.sh.
     writeFileSync(
       shim,
       [
-        '#!/usr/bin/env bash',
+        '#!/bin/sh',
         `printf '%s\\n' "$*" >> ${JSON.stringify(argvLog)}`,
-        'case "$1" in',
-        `  guard) printf '%s' '{"fired":true,"packet":"${RECALL_SENTINEL}"}' ;;`,
-        `  hooks) case "$2" in due-check) printf '%s' '${DUE_SENTINEL}' ;; esac ;;`,
+        'case "$1:$2" in',
+        `  hook:recall-guard) printf '%s' '{"hookSpecificOutput":{"hookEventName":"UserPromptSubmit","additionalContext":"${RECALL_SENTINEL}"}}' ;;`,
+        `  hook:session-start) printf '%s' '{"hookSpecificOutput":{"hookEventName":"SessionStart","additionalContext":"${DUE_SENTINEL}"}}' ;;`,
+        `  hook:session-sweep) printf '{"decision":"block","reason":"--dir %s"}' "$PHRONESIS_DIR" ;;`,
+        `  hook:session-sweep-precompact) printf '%s' '{"systemMessage":"${PRECOMPACT_SENTINEL}"}' ;;`,
+        '  hook:session-sweep-subagent) : ;;',
         'esac',
         'exit 0',
         '',
       ].join('\n'),
     );
     chmodSync(shim, 0o755);
-    const env = { ...process.env, PATH: `${shimDir}:${process.env.PATH || ''}` };
+    const env = { ...process.env, HOME: shimHome, PATH: `${shimDir}:${process.env.PATH || ''}` };
     const target = join(root, 'domains', slug);
     const readLog = () => {
       try {
@@ -203,9 +226,9 @@ function checkBehavior(root, slug) {
         return '';
       }
     };
-    const runLauncher = (name, cwd, input) => spawnSync('bash', [join(codexHooks, name)], { cwd, env, input, encoding: 'utf8' });
+    const runLauncher = (name, cwd, input) => spawnSync('sh', [join(codexHooks, name)], { cwd, env, input, encoding: 'utf8' });
     // True iff stdout is exactly a Codex hookSpecificOutput envelope for `hookEventName` whose
-    // additionalContext carries `sentinel` (i.e. the shared script wrapped the canned result).
+    // additionalContext carries `sentinel` (i.e. the launcher preserved this invocation's output).
     const envelopeInjects = (stdout, hookEventName, sentinel) => {
       try {
         const j = JSON.parse(String(stdout || '').trim());
@@ -220,8 +243,8 @@ function checkBehavior(root, slug) {
     const atTarget = runLauncher('session-sweep.sh', target, stopFixture);
     const blocks = atTarget.status === 0 && /"decision":"block"/.test(atTarget.stdout || '');
     add(blocks, 'Stop emits {"decision":"block"} (Codex capture-sweep shape)', blocks ? '' : (atTarget.stderr || atTarget.stdout || '').trim());
-    const sweepReached = /(^|\n)hooks sweep-status\b/.test(readLog());
-    add(sweepReached, 'Stop sweep reaches `phronesis hooks sweep-status`', sweepReached ? '' : 'the shared session-sweep.sh never invoked sweep-status (stubbed/broken script?)');
+    const sweepReached = /(^|\n)hook session-sweep --surface codex\b/.test(readLog());
+    add(sweepReached, 'Stop reaches `phronesis hook session-sweep --surface codex`', sweepReached ? '' : 'the launcher never invoked the contracted Stop event');
 
     // (b) UserPromptSubmit recall: reaches `guard --surface codex` (surface attribution) AND wraps
     // the guard packet into the additionalContext envelope (the actual injection — reaching guard
@@ -229,10 +252,10 @@ function checkBehavior(root, slug) {
     const recallLauncher = join(codexHooks, 'recall-guard.sh');
     if (existsSync(recallLauncher)) {
       const recall = runLauncher('recall-guard.sh', target, '{"session_id":"adapter_probe","prompt":"Should I wait before deciding?"}');
-      const guardReached = /(^|\n)guard .*--surface codex\b/.test(readLog());
-      add(guardReached, 'UserPromptSubmit recall reaches `phronesis guard --surface codex`', guardReached ? '' : 'the shared recall-guard.sh never invoked guard (stubbed/broken script?)');
+      const guardReached = /(^|\n)hook recall-guard --surface codex\b/.test(readLog());
+      add(guardReached, 'UserPromptSubmit reaches `phronesis hook recall-guard --surface codex`', guardReached ? '' : 'the launcher never invoked the contracted recall event');
       const recallInjected = envelopeInjects(recall.stdout, 'UserPromptSubmit', RECALL_SENTINEL);
-      add(recallInjected, 'UserPromptSubmit recall injects the packet as hookSpecificOutput.additionalContext', recallInjected ? '' : 'recall-guard.sh reached guard but emitted no Codex additionalContext envelope — the operator gets no injection');
+      add(recallInjected, 'UserPromptSubmit preserves hookSpecificOutput.additionalContext stdout', recallInjected ? '' : 'launcher reached the hook interface but dropped/forged its stdout');
     } else {
       add(false, 'UserPromptSubmit recall launcher runnable', 'recall-guard.sh launcher missing');
     }
@@ -243,13 +266,51 @@ function checkBehavior(root, slug) {
     const startLauncher = join(codexHooks, 'session-start.sh');
     if (existsSync(startLauncher)) {
       const start = runLauncher('session-start.sh', target, '{"session_id":"adapter_probe","source":"startup"}');
+      const startReached = /(^|\n)hook session-start --surface codex\b/.test(readLog());
+      add(startReached, 'SessionStart reaches `phronesis hook session-start --surface codex`', startReached ? '' : 'the launcher never invoked the contracted session-start event');
       const dueInjected = envelopeInjects(start.stdout, 'SessionStart', DUE_SENTINEL);
-      add(dueInjected, 'SessionStart due-check injects via hookSpecificOutput.additionalContext', dueInjected ? '' : 'session-start.sh reached due-check but did not wrap it in the Codex SessionStart additionalContext envelope');
+      add(dueInjected, 'SessionStart preserves hookSpecificOutput.additionalContext stdout', dueInjected ? '' : 'launcher reached the hook interface but dropped/forged its stdout');
     } else {
       add(false, 'SessionStart launcher runnable', 'session-start.sh launcher missing');
     }
 
-    // (d) install-root resolution from a subdir of the open target (nearest-.phronesis walk-up).
+    // (d) The two remaining lifecycle boundaries are distinct contracted launchers. Drive both
+    // through the same argv-log shim; PreCompact also has a surface envelope to preserve.
+    const precompactLauncher = join(codexHooks, 'session-sweep-precompact.sh');
+    if (existsSync(precompactLauncher)) {
+      const precompact = runLauncher(
+        'session-sweep-precompact.sh',
+        target,
+        '{"session_id":"adapter_probe_precompact","stop_hook_active":false}',
+      );
+      const precompactReached = /(^|\n)hook session-sweep-precompact --surface codex\b/.test(readLog());
+      add(precompactReached, 'PreCompact reaches `phronesis hook session-sweep-precompact --surface codex`', precompactReached ? '' : 'the launcher never invoked the contracted PreCompact event');
+      let precompactEnvelope = false;
+      try {
+        precompactEnvelope = JSON.parse(String(precompact.stdout || '').trim())?.systemMessage === PRECOMPACT_SENTINEL;
+      } catch {
+        precompactEnvelope = false;
+      }
+      add(precompactEnvelope, 'PreCompact preserves the unswept systemMessage envelope', precompactEnvelope ? '' : 'launcher reached the hook interface but dropped/forged its systemMessage stdout');
+    } else {
+      add(false, 'PreCompact launcher runnable', 'session-sweep-precompact.sh launcher missing');
+    }
+
+    const subagentLauncher = join(codexHooks, 'session-sweep-subagent.sh');
+    if (existsSync(subagentLauncher)) {
+      const subagent = runLauncher(
+        'session-sweep-subagent.sh',
+        target,
+        '{"session_id":"adapter_probe_subagent","stop_hook_active":false}',
+      );
+      const subagentReached = subagent.status === 0
+        && /(^|\n)hook session-sweep-subagent --surface codex\b/.test(readLog());
+      add(subagentReached, 'SubagentStop reaches `phronesis hook session-sweep-subagent --surface codex`', subagentReached ? '' : (subagent.stderr || 'the launcher never invoked the contracted SubagentStop event').trim());
+    } else {
+      add(false, 'SubagentStop launcher runnable', 'session-sweep-subagent.sh launcher missing');
+    }
+
+    // (e) install-root resolution from a subdir of the open target (nearest-.phronesis walk-up).
     // The launcher runs from the kernel-realpath'd cwd, so it emits the realpath of the install
     // root; compare realpaths so a symlinked prefix (macOS /var → /private/var) is not a false
     // failure. The block reason's `--dir` is resolved in-shell, independent of the shim.
@@ -274,7 +335,7 @@ function checkBehavior(root, slug) {
 }
 
 // structuralOnly (core-0038 F1): run ONLY the read-only emission check (parses hooks.json, checks
-// launcher/script presence + executability — pure file reads, NO spawning). `checkBehavior` EXECUTES
+// launcher/resolver presence + executability — pure file reads, NO spawning). `checkBehavior` EXECUTES
 // the install's hook scripts via spawnSync; that is fine for `adapter test codex` (a deliberate
 // operator self-check) but NOT for `phronesis doctor`, whose read-only promise must hold even on a
 // MODIFIED install — a tampered hook could write to the install before satisfying the probe. So
@@ -282,9 +343,11 @@ function checkBehavior(root, slug) {
 function buildReport(root, domains, { structuralOnly = false } = {}) {
   const perDomain = domains.map((slug) => {
     const emission = checkEmission(root, slug);
-    // Only probe behavior when the wiring is structurally present (else the probe just
-    // re-reports the same missing files as opaque spawn failures) AND behavior was requested.
-    const behavior = !structuralOnly && emission.compliant ? checkBehavior(root, slug) : { checks: [], compliant: emission.compliant, skipped: structuralOnly || undefined };
+    // `adapter test` is the deliberate behavioral proof even for hand-modified bytes; doctor
+    // passes structuralOnly and therefore never executes an install-owned candidate.
+    const behavior = structuralOnly
+      ? { checks: [], compliant: emission.compliant, skipped: true }
+      : checkBehavior(root, slug);
     return { domain: slug, emission, behavior };
   });
 
@@ -333,7 +396,8 @@ function printHuman(report) {
   );
   console.log('');
   console.log('  Trust: open Codex AT the domain workspace dir above (Codex does not parent-walk to find .codex/).');
-  console.log('  Enable the project hooks: CLI `/hooks`, or the app Settings → Coding → Hooks. Editing the config re-hashes → re-trust.');
+  console.log('  Enable the project hooks: CLI `/hooks`, or the app Settings → Coding → Hooks.');
+  console.log('  Trust note (verified on Codex v0.145.0-alpha.18): registration trust keys on hooks.json, not script bytes; a changed config should show the review banner.');
 }
 
 // PURE Codex-adapter report (core-0038 D2/D3): resolve the install + build the structural +
@@ -357,14 +421,255 @@ export function codexAdapterReport({ dir, domain, structuralOnly = false } = {})
   return { root, report: buildReport(root, domains, { structuralOnly }) };
 }
 
+// --- Desktop adapter (change 0055 / CR4) ------------------------------------------------
+//
+// Unlike Codex (shell-wired `.codex/hooks.json`), the Craft Phronesis Desktop app is a
+// FIRST-PARTY, in-process surface: its reinforcement + lifecycle loop is direct calls to
+// `@phronesis/core` (runContextRelevanceGuard, runDueCheck, the skill-lifecycle producer, the
+// session-boundary sweep — change 0056 makes the producer emit `surface: 'desktop'`). So the
+// compliance CONTRACT the desktop stands on IS auto-assertable from the CLI: this probe drives the
+// exact core call-sequence the desktop engine makes against a THROWAWAY synthetic install and
+// verifies the emitted event stream. It builds its OWN temp install (it emits events, so it must
+// never touch operator data — the codex probe stays non-mutating with a PATH shim; the desktop probe
+// stays non-mutating by owning a disposable install) and removes it in `finally`. What it does NOT
+// assert is the LIVE app UI (that the running Electron app actually calls these primitives in its
+// loop and renders the felt-presence surfaces) — that is the desktop's own headless engine e2e
+// (`validate-desktop`, Node 22) plus a warm-run dogfood. The split is stated in the report.
+
+const DESKTOP_SURFACE = 'desktop';
+const DESKTOP_ACTOR = 'agent';
+
+function seedProbeInstall(root) {
+  mkdirSync(join(root, '.phronesis'), { recursive: true });
+  mkdirSync(join(root, 'domains', 'pm', 'compiled', 'decisions'), { recursive: true });
+  writeFileSync(
+    join(root, '.phronesis', 'registry.json'),
+    `${JSON.stringify(
+      { schema_version: 1, created_by: 'adapter-desktop-probe', domains: ['pm'], skills: { 'prd-draft': { version: '0.2.0' } } },
+      null,
+      2,
+    )}\n`,
+  );
+  // Owned-context object for the seeded-injection fixture.
+  writeFileSync(
+    join(root, 'domains', 'pm', 'compiled', 'decisions', '2026-01-10-acme-pricing-tiers.md'),
+    '---\ntype: decision\nname: 2026-01-10-acme-pricing-tiers\ntitle: Acme pricing tiers\ndomain: pm\nexposure: private\ncreated: 2026-01-10\n---\n\nWe set the Acme pricing tiers at three levels.\n',
+  );
+  // Overdue decision (review_date long past, no recorded outcome) for the due-check fixture.
+  writeFileSync(
+    join(root, 'domains', 'pm', 'compiled', 'decisions', '2020-01-01-legacy-review.md'),
+    '---\ntype: decision\nname: 2020-01-01-legacy-review\ntitle: Legacy review obligation\ndomain: pm\nexposure: private\ncreated: 2020-01-01\nreview_date: 2020-06-01\n---\n\nA decision whose review is long overdue.\n',
+  );
+}
+
+// Run the four contract properties (plan §7.3) against a throwaway synthetic install. Returns
+// { checks: [{ok,label,detail}], compliant }. Async — it awaits the core primitives.
+async function runDesktopProbe() {
+  const base = mkdtempSync(join(tmpdir(), 'phronesis-desktop-adapter-'));
+  const checks = [];
+  const add = (ok, label, detail = '') => checks.push({ ok, label, detail });
+  try {
+    const root = join(base, 'install');
+    seedProbeInstall(root);
+    const S = DESKTOP_SURFACE;
+    const A = DESKTOP_ACTOR;
+    const session = 'sess_desktop_probe';
+    const guard = (prompt) =>
+      runContextRelevanceGuard({ installRoot: root, cwd: root, prompt, session, surface: S, actor: A });
+
+    // Fixture 1 — seeded-state injection: owned-context prompt fires + retrieves the seeded object.
+    try {
+      const g = await guard('what should I do about my Acme pricing tiers decision?');
+      const ok = g.fired === true && g.empty_result === false && g.result_count > 0;
+      add(ok, 'guard fixture 1: owned-context prompt injects recall (fired, non-empty)', ok ? '' : `fired=${g.fired} empty=${g.empty_result} count=${g.result_count}`);
+    } catch (e) {
+      add(false, 'guard fixture 1: owned-context prompt injects recall (fired, non-empty)', e.message);
+    }
+
+    // Fixture 2 — no-cue: the guard does not fire and emits nothing.
+    try {
+      const g = await guard('explain how a binary search works in general');
+      add(g.fired === false, 'guard fixture 2: no-cue prompt does not fire (no recall events)', g.fired === false ? '' : `guard fired on a no-cue prompt (fired=${g.fired})`);
+    } catch (e) {
+      add(false, 'guard fixture 2: no-cue prompt does not fire (no recall events)', e.message);
+    }
+
+    // Fixture 3 — honest negative: fires, but no matching state → empty_result.
+    try {
+      const g = await guard('what should I do about my zzqx qwrtplk rollout?');
+      const ok = g.fired === true && g.empty_result === true && g.result_count === 0;
+      add(ok, 'guard fixture 3: owned-context prompt with no matching state yields an honest negative', ok ? '' : `fired=${g.fired} empty=${g.empty_result} count=${g.result_count}`);
+    } catch (e) {
+      add(false, 'guard fixture 3: owned-context prompt with no matching state yields an honest negative', e.message);
+    }
+
+    // Event-stream corroboration: exactly two recall pairs (fixtures 1 + 3 — fixture 2 emitted none),
+    // one non-empty + one empty, all stamped surface:desktop / actor:agent.
+    try {
+      const injected = (await readEvents({ installRoot: root, type: 'recall.injected' })).filter((e) => e.session_id === session);
+      const cand = (await readEvents({ installRoot: root, type: 'recall.candidate' })).filter((e) => e.session_id === session);
+      const allDesktop = [...injected, ...cand].every((e) => e.surface === S && e.actor === A);
+      const empties = injected.filter((e) => e.payload.empty_result === true).length;
+      const nonEmpties = injected.filter((e) => e.payload.empty_result === false).length;
+      const ok = injected.length === 2 && cand.length === 2 && empties === 1 && nonEmpties === 1 && allDesktop;
+      add(ok, 'recall events: two candidate/injected pairs (surface:desktop), one empty + one non-empty; none from the no-cue prompt', ok ? '' : `candidate=${cand.length} injected=${injected.length} empty=${empties} nonEmpty=${nonEmpties} allDesktop=${allDesktop}`);
+    } catch (e) {
+      add(false, 'recall events: two candidate/injected pairs (surface:desktop), one empty + one non-empty; none from the no-cue prompt', e.message);
+    }
+
+    // Due-check surfacing: an overdue decision → outcome.due (surface:desktop).
+    try {
+      const res = await runDueCheck({ installRoot: root, session, surface: S, actor: A });
+      const dueEvents = (await readEvents({ installRoot: root, type: 'outcome.due' })).filter((e) => e.session_id === session);
+      const ok = res.due.length >= 1 && dueEvents.length >= 1 && dueEvents.every((e) => e.surface === S);
+      add(ok, 'due-check surfaces an overdue decision (outcome.due, surface:desktop)', ok ? '' : `due=${res.due.length} events=${dueEvents.length}`);
+    } catch (e) {
+      add(false, 'due-check surfaces an overdue decision (outcome.due, surface:desktop)', e.message);
+    }
+
+    // Sweep block-once: a planted decision.candidate is banked; the turn's sweep-close emits exactly
+    // ONE session.end sweep marker; a second close is a no-op (never loops).
+    try {
+      const sweepSession = 'sess_desktop_sweep';
+      await appendEvent({ installRoot: root, type: 'decision.candidate', session_id: sweepSession, actor: A, surface: S, payload: { proposed_decision: 'Adopt the planted tiering decision', confidence: 0.8 } });
+      const close = async () => {
+        const status = await sweepStatus({ installRoot: root, session: sweepSession });
+        if (status.swept) return { emitted: false };
+        const candidates = (await readEvents({ installRoot: root }))
+          .filter((e) => e.session_id === sweepSession && ['decision.candidate', 'person.candidate', 'commitment.candidate'].includes(e.type)).length;
+        await appendEvent({ installRoot: root, type: 'session.end', session_id: sweepSession, actor: A, surface: S, payload: { sweep: { candidates } } });
+        return { emitted: true, candidates };
+      };
+      const first = await close();
+      const second = await close(); // block-once: already swept → no second marker
+      const markers = (await readEvents({ installRoot: root, type: 'session.end' }))
+        .filter((e) => e.session_id === sweepSession && e.payload && e.payload.sweep && Number.isInteger(e.payload.sweep.candidates));
+      const st = await sweepStatus({ installRoot: root, session: sweepSession });
+      const ok = first.emitted === true && second.emitted === false && markers.length === 1 && st.swept === true && st.candidates === 1;
+      add(ok, 'sweep block-once: a banked candidate yields exactly one session.end sweep marker per turn (never loops)', ok ? '' : `first=${first.emitted} second=${second.emitted} markers=${markers.length} candidates=${st.candidates}`);
+    } catch (e) {
+      add(false, 'sweep block-once: a banked candidate yields exactly one session.end sweep marker per turn (never loops)', e.message);
+    }
+
+    // Level-2 SUCCESS path (Codex R2 F3): begin a registered skill → commit an action carrying its
+    // invocation_id → complete. Assert EXACTLY ONE skill.completed with the matching invocation_id and
+    // surface:desktop (so the "skill.invoked/completed are real" Level-2 claim is not under-tested).
+    try {
+      const okSession = 'sess_desktop_skill_ok';
+      const begun = await beginSkillInvocation({ installRoot: root, skill: { name: 'prd-draft' }, session: okSession, surface: S });
+      const invId = begun.record && begun.record.invocation_id;
+      await runAction({
+        type: 'log_decision',
+        payload: { title: 'Skill-run decision', created: '2026-01-05' },
+        ctx: { dir: root, session: okSession, surface: S, actor: A, invocation_id: invId },
+      });
+      const done = await completeActiveSkillInvocation({ installRoot: root, session: okSession, surface: S });
+      const completedEvents = (await readEvents({ installRoot: root, type: 'skill.completed' }))
+        .filter((e) => e.session_id === okSession && e.payload && e.payload.invocation_id === invId);
+      const ok =
+        begun.started === true &&
+        done.completed === true &&
+        completedEvents.length === 1 &&
+        completedEvents[0].surface === S &&
+        completedEvents[0].payload.action_types_committed >= 1;
+      add(ok, 'Level-2 success path: begin → act → complete emits exactly one skill.completed (surface:desktop, real invocation_id)', ok ? '' : `started=${begun.started} completed=${done.completed} completedEvents=${completedEvents.length}`);
+    } catch (e) {
+      add(false, 'Level-2 success path: begin → act → complete emits exactly one skill.completed (surface:desktop, real invocation_id)', e.message);
+    }
+
+    // No fabricated events on the error path (StopFailure-equivalent): abandon clears the record and
+    // leaves an honest gap — skill.invoked stands, NO synthetic skill.completed, an abandon audit written.
+    try {
+      const errSession = 'sess_desktop_error';
+      const begun = await beginSkillInvocation({ installRoot: root, skill: { name: 'prd-draft' }, session: errSession, surface: S });
+      const abandoned = await abandonActiveSkillInvocation({ installRoot: root, session: errSession, surface: S, reason: 'turn-error' });
+      const invoked = (await readEvents({ installRoot: root, type: 'skill.invoked' })).filter((e) => e.session_id === errSession);
+      const completed = (await readEvents({ installRoot: root, type: 'skill.completed' })).filter((e) => e.session_id === errSession);
+      const active = await readActiveInvocation({ installRoot: root, session: errSession });
+      const audit = (await readAuditLog(root)).filter((e) => e.outcome === 'skill-lifecycle-abandoned' && e.session_id === errSession);
+      const ok = begun.started === true && abandoned.abandoned === true && invoked.length === 1 && invoked[0].surface === S && completed.length === 0 && active === null && audit.length === 1;
+      add(ok, 'error path: abandon leaves an honest gap — skill.invoked stands, no fabricated skill.completed', ok ? '' : `begun=${begun.started} invoked=${invoked.length} completed=${completed.length} active=${active ? 'present' : 'null'} audit=${audit.length}`);
+    } catch (e) {
+      add(false, 'error path: abandon leaves an honest gap — skill.invoked stands, no fabricated skill.completed', e.message);
+    }
+
+    return { checks, compliant: checks.every((c) => c.ok) };
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+// PURE desktop-adapter report — async (awaits the core call-sequence). Ignores `dir`: the desktop is
+// in-process with no per-install wiring to check, and the probe must emit into a throwaway install,
+// never the operator's. Returns { report }.
+export async function desktopAdapterReport() {
+  const probe = await runDesktopProbe();
+  return {
+    report: {
+      surface: 'desktop',
+      install: '(throwaway synthetic install — desktop is in-process; no per-install wiring)',
+      level_1: {
+        name: 'reinforcement',
+        status: probe.compliant ? 'compliant' : 'non-compliant',
+        wires: ['recall-guard', 'due-check', 'capture-sweep'],
+      },
+      level_2: {
+        name: 'skill-lifecycle',
+        status: probe.compliant ? 'compliant' : 'non-compliant',
+        reason:
+          'First-party in-process minter (change 0056): skill.invoked/completed with real invocation_ids and surface:desktop; the error path abandons without a fabricated skill.completed.',
+      },
+      note: 'Auto-asserts the reinforcement + lifecycle CONTRACT via core. The live app UI half is operator-verified (the desktop headless engine e2e + a warm-run dogfood).',
+      checks: probe.checks,
+      compliant: probe.compliant,
+    },
+  };
+}
+
+function printHumanDesktop(report) {
+  const mark = (ok) => (ok ? '✓' : '✗');
+  console.log(`phronesis adapter test desktop — ${report.install}`);
+  console.log('');
+  for (const c of report.checks) {
+    console.log(`  ${mark(c.ok)} ${c.label}${c.detail ? ` — ${c.detail}` : ''}`);
+  }
+  console.log('');
+  console.log(`  Level 1 (reinforcement):   ${report.level_1.status.toUpperCase()} — wires ${report.level_1.wires.join(', ')}`);
+  console.log(`  Level 2 (skill-lifecycle): ${report.level_2.status.toUpperCase()} — ${report.level_2.reason}`);
+  console.log('');
+  console.log(`  ${report.note}`);
+  console.log('');
+  console.log(
+    report.compliant
+      ? '  Craft Phronesis Desktop is contract-compliant: the in-process reinforcement + lifecycle loop fires correctly.'
+      : '  Desktop adapter contract check FAILED — see the failed checks above.',
+  );
+}
+
 export async function runAdapterTest({ surface, dir, domain, json = false } = {}) {
   if (!surface) {
-    console.error('adapter test: a <surface> is required (V1: codex).');
+    console.error('adapter test: a <surface> is required (V1: codex, desktop).');
     process.exitCode = 1;
     return null;
   }
+  if (surface === 'desktop') {
+    // The desktop probe runs against a THROWAWAY synthetic install (it is in-process, with no
+    // per-install wiring) — so --dir/--domain do not apply. Disclose rather than silently ignore
+    // (Fable finding 9). Not printed under --json (keep the report the sole stdout payload).
+    if ((dir || domain) && !json) {
+      console.error('note: adapter test desktop runs against a throwaway synthetic install (the desktop is in-process); --dir/--domain do not apply and are ignored.');
+    }
+    const { report } = await desktopAdapterReport();
+    if (json) {
+      console.log(JSON.stringify(report, null, 2));
+    } else {
+      printHumanDesktop(report);
+    }
+    process.exitCode = report.compliant ? 0 : 1;
+    return report;
+  }
   if (surface !== 'codex') {
-    console.error(`adapter test: unsupported surface "${surface}". V1 ships the Codex adapter test (claude-code is the primary, always-on surface).`);
+    console.error(`adapter test: unsupported surface "${surface}". V1 ships the Codex and Craft Phronesis Desktop adapter tests (claude-code is the primary, always-on surface).`);
     process.exitCode = 1;
     return null;
   }