heyspex 0.2.0 → 0.2.1

package/scripts/claude-hooks/_intent-classifier-semantic.mjs

@@ -105,6 +105,11 @@ export const KNOWN_BEHAVIORS = Object.freeze([
     description:
       'The user wants to DEFER, POSTPONE, or SCHEDULE a follow-up to a later time — "come back to this later", "remind me in a week", "park/table this until X is done", "schedule this for next week", "not now — later, after the migration". About WHEN to revisit something, not a request to do it now.',
   },
+  {
+    key: 'handoff_intent',
+    description:
+      'The user asks for a hand-off prompt, doc, notes or resume context for the NEXT agent or session ("give me a handoff prompt for the next agent", "hand this off", "what should the next session know"). About producing the hand-off artifact, NOT about loading one (a lane code like GQ5R or `hs handoff load`) and not ordinary work.',
+  },
 ]);
 
 function num(raw, fallback) {

package/scripts/claude-hooks/_run.mjs

@@ -21,10 +21,13 @@
 // stops firing — so an unresolvable mode reads as ON, and a genuinely broken
 // hook path reports on stderr and exits 0.
 
+import crypto from 'node:crypto';
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 
+const STATE_DIR = '.' + 'heyspex';
 const HOOK_DIR = path.dirname(fileURLToPath(import.meta.url));
 const REPO_ROOT = path.resolve(HOOK_DIR, '..', '..');
 
@@ -57,21 +60,8 @@ function resolveHook(name) {
   return abs;
 }
 
-// --- the off-switch -------------------------------------------------------
-// Inlined rather than imported from scripts/heyspex-mode.mjs: this runs on
-// every tool call in every session, and a resolve+parse of another module is
-// real latency for a question answered by one small file read. The two must
-// agree — see the resolution order documented in heyspex-mode.mjs.
-function heyspexIsOff() {
-  try {
-    const raw = String(process.env.HEYSPEX_MODE ?? '').trim().toLowerCase();
-    if (raw) return ['off', '0', 'false', 'disabled', 'disable', 'no'].includes(raw);
-    const state = JSON.parse(fs.readFileSync(path.join(REPO_ROOT, '.heyspex', 'mode.json'), 'utf8'));
-    return state?.mode === 'off';
-  } catch {
-    return false; // fail-open: HeySpex is on unless something says otherwise
-  }
-}
+// --- the off-switch: see modeOffFromProject() below (project-scoped; must agree with heyspex-mode.mjs resolution order:
+// HEYSPEX_MODE env first, then <project>/.heyspex/mode.json).
 
 // --- hooks the off-switch may NOT silence ---------------------------------
 // The productivity hooks (reminders, injections, checkpoints) exist to help,
@@ -101,20 +91,323 @@ function isAlwaysOn(name) {
   return ALWAYS_ON.has(base);
 }
 
-if (!isAlwaysOn(target) && heyspexIsOff()) process.exit(0);
+// ── project roots the mode file may live in ─────────────────────────────────
+// `hs mode off` writes <project>/.heyspex/mode.json. In a customer repo whose hooks come from the plugin /
+// node_modules, REPO_ROOT is the package, not the project, so the dev's switch was ignored. Look in the PROJECT
+// first: CLAUDE_PROJECT_DIR, then the hook payload's cwd, then walk up from process.cwd(); REPO_ROOT stays the
+// last resort. HEYSPEX_MODE (env) keeps precedence over every file.
+function projectRoots(payload) {
+  const roots = [];
+  const add = (r) => {
+    if (typeof r === 'string' && r.trim() && !roots.includes(r.trim())) roots.push(r.trim());
+  };
+  add(process.env.CLAUDE_PROJECT_DIR);
+  add(payload?.cwd);
+  try {
+    let d = process.cwd();
+    for (;;) {
+      if (fs.existsSync(path.join(d, '.heyspex', 'mode.json'))) {
+        add(d);
+        break;
+      }
+      const up = path.dirname(d);
+      if (up === d) break;
+      d = up;
+    }
+  } catch { /* ignore */ }
+  add(REPO_ROOT);
+  return roots;
+}
 
-const hookPath = resolveHook(target);
-if (!hookPath || !fs.existsSync(hookPath)) {
-  process.stderr.write(`[heyspex] _run.mjs: hook not found: ${target}\n`);
+function modeOffFromProject(payload) {
+  try {
+    const raw = String(process.env.HEYSPEX_MODE ?? '').trim().toLowerCase();
+    if (raw) return ['off', '0', 'false', 'disabled', 'disable', 'no'].includes(raw);
+    for (const root of projectRoots(payload)) {
+      const file = path.join(root, '.heyspex', 'mode.json');
+      if (!fs.existsSync(file)) continue;
+      // ANY root saying off wins: the dev's `hs mode off` lives in the project, an older switch in the platform root.
+      if (JSON.parse(fs.readFileSync(file, 'utf8'))?.mode === 'off') return true;
+    }
+  } catch { /* fail-open: on */ }
+  return false;
+}
+
+// ── fail-open, outermost ([[HS-20SW-DRSM-DIAG-heyspex-capture-on-idea-and-workflow]]) ─────────────
+// GitHub Copilot turns ANY non-zero hook exit into a deny (and 2 is always a deny with the reason lost), so a
+// crash anywhere - resolution, import, a hook's own async throw - must exit 0. Exit 2 survives only where a hook
+// truly decided "deny" (Claude Code: stderr reason; Copilot: translated to the JSON deny below).
+process.on('uncaughtException', (err) => {
+  try { process.stderr.write(`[heyspex] hook ${target} crashed (failing open): ${err?.message ?? err}\n`); } catch { /* ignore */ }
+  process.exit(0);
+});
+process.on('unhandledRejection', (err) => {
+  try { process.stderr.write(`[heyspex] hook ${target} rejected (failing open): ${err?.message ?? err}\n`); } catch { /* ignore */ }
   process.exit(0);
+});
+process.on('exit', (code) => {
+  if (code !== 0 && code !== 2) process.exitCode = 0;
+});
+
+function readAll(stream, ms) {
+  return new Promise((resolve) => {
+    let buf = '';
+    const t = setTimeout(() => resolve(buf), ms);
+    t.unref?.();
+    stream.setEncoding('utf8');
+    stream.on('data', (c) => { buf += c; });
+    stream.on('end', () => { clearTimeout(t); resolve(buf); });
+    stream.on('error', () => resolve(buf));
+  });
 }
 
-// Make the hook believe it was invoked directly.
-process.argv = [process.argv[0], hookPath, ...rest];
+// ── Copilot helpers (all best-effort; every failure means "run the hook normally") ─────────────────────────────
+function readJson(file) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; }
+}
+
+// The command text after the shim: `node -e "<bootstrap>" hook [args]` or `node ".../run-hook.mjs" hook [args]`.
+function rowTokens(command) {
+  const c = String(command ?? '');
+  const m = c.match(/^node -e "[^"]*"\s+([\s\S]*)$/) || c.match(/\.mjs"?\s+([\s\S]*)$/);
+  return m ? m[1].trim().split(/\s+/) : [];
+}
+
+/**
+ * The matcher(s) registered for this hook + event, read from the project's Claude settings file and the plugin's
+ * hooks.json. A hook may sit under several matchers; ALL are returned (an unset matcher is ''). null = the hook
+ * is in no row we can read, so no filtering.
+ */
+function matchersForHook(eventName, payload) {
+  const files = [];
+  for (const r of projectRoots(payload)) files.push(path.join(r, '.claude', 'settings.json'));
+  for (const r of [process.env.CLAUDE_PLUGIN_ROOT, process.env.COPILOT_PLUGIN_ROOT, process.env.PLUGIN_ROOT]) {
+    if (r && r.trim()) files.push(path.join(r.trim(), 'hooks', 'hooks.json'));
+  }
+  files.push(path.join(REPO_ROOT, 'plugins', 'heyspex', 'hooks', 'hooks.json'));
+  const want = [target, ...rest].join(' ');
+  const matchers = [];
+  let found = false;
+  for (const file of [...new Set(files)]) {
+    const groups = readJson(file)?.hooks?.[eventName];
+    if (!Array.isArray(groups)) continue;
+    for (const g of groups) {
+      for (const h of g?.hooks ?? []) {
+        const t = rowTokens(h?.command);
+        if (t.length && t.join(' ') === want) { found = true; matchers.push(typeof g.matcher === 'string' ? g.matcher : ''); }
+      }
+    }
+  }
+  return found ? matchers : null;
+}
+
+const DEDUPE_WINDOW_MS = 2000;
+
+/**
+ * Double-firing guard. The first run of a key atomically creates a stamp (flag 'wx'); a second run inside 2 s is
+ * a duplicate. The first run stores its final stdout in the stamp so a duplicate replays a DENY instead of
+ * silently allowing. Keyed by (session, event, hook+args, tool, timestamp | input hash, project).
+ */
+function claimDedupe(payload, eventName) {
+  const none = { duplicate: false };
+  try {
+    if (String(process.env.HEYSPEX_COPILOT_DEDUPE_OFF ?? '').trim() === '1') return none;
+    const session = payload.session_id ?? payload.sessionId;
+    if (typeof session !== 'string' || !session) return none;
+    const ident = payload.timestamp !== undefined
+      ? String(payload.timestamp)
+      : crypto.createHash('sha1').update(JSON.stringify([payload.tool_input ?? null, payload.prompt ?? null])).digest('hex');
+    const key = crypto.createHash('sha1')
+      .update(JSON.stringify([session, eventName, target, rest, payload.tool_name ?? '', ident, payload.cwd ?? '']))
+      .digest('hex');
+    const dir = process.env.HEYSPEX_COPILOT_DEDUPE_DIR?.trim() || path.join(os.tmpdir(), 'heyspex-copilot-dedupe');
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, `${key}.json`);
+    const now = Date.now();
+    try {
+      fs.writeFileSync(file, JSON.stringify({ t: now, out: '' }), { flag: 'wx' });
+    } catch (e) {
+      if (e?.code !== 'EEXIST') return none;
+      const prev = readJson(file);
+      if (prev && typeof prev.t === 'number' && now - prev.t >= 0 && now - prev.t < DEDUPE_WINDOW_MS) {
+        return { duplicate: true, replay: typeof prev.out === 'string' ? prev.out : '' };
+      }
+      fs.writeFileSync(file, JSON.stringify({ t: now, out: '' })); // stale stamp: this run owns it
+    }
+    try { // opportunistic cleanup of old stamps
+      for (const f of fs.readdirSync(dir)) {
+        const fp = path.join(dir, f);
+        if (now - fs.statSync(fp).mtimeMs > 60000) fs.rmSync(fp, { force: true });
+      }
+    } catch { /* ignore */ }
+    return { duplicate: false, store: (final) => { if (final) fs.writeFileSync(file, JSON.stringify({ t: now, out: final })); } };
+  } catch {
+    return none;
+  }
+}
+
+/** True exactly once per (project, session): creates <project>/<state dir>/copilot-style-<session>.stamp. */
+function claimSessionStyleStamp(payload) {
+  try {
+    const session = String(payload.session_id ?? payload.sessionId ?? '').replace(/[^A-Za-z0-9._-]/g, '_').slice(0, 80);
+    if (!session) return false;
+    const root = projectRoots(payload).find((r) => { try { return fs.statSync(r).isDirectory(); } catch { return false; } });
+    if (!root) return false;
+    const dir = path.join(root, STATE_DIR);
+    fs.mkdirSync(dir, { recursive: true });
+    try { fs.writeFileSync(path.join(dir, `copilot-style-${session}.stamp`), new Date().toISOString(), { flag: 'wx' }); } catch { return false; }
+    try { // drop stamps older than a week
+      for (const f of fs.readdirSync(dir)) {
+        if (f.startsWith('copilot-style-') && f.endsWith('.stamp') && Date.now() - fs.statSync(path.join(dir, f)).mtimeMs > 7 * 86400000) fs.rmSync(path.join(dir, f), { force: true });
+      }
+    } catch { /* ignore */ }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function main() {
+  // stdin is read ONCE here (harness detection and the mode file's project root both need the payload) and
+  // handed on to the hook as a fresh stream, so every hook still reads process.stdin exactly as before.
+  let text = '';
+  try {
+    if (!process.stdin.isTTY) text = await readAll(process.stdin, 4000);
+  } catch { /* ignore */ }
+  let payload = null;
+  try { payload = text.trim() ? JSON.parse(text) : null; } catch { payload = null; }
+
+  if (!isAlwaysOn(target) && modeOffFromProject(payload)) process.exit(0);
+
+  // ── harness detection + the Copilot dialect ──────────────────────────────
+  let harness = 'unknown';
+  let copilot = null;
+  try {
+    const { detectHarness } = await import(pathToFileURL(path.join(REPO_ROOT, 'spexharness', 'src', 'adapters', 'detect-harness.mjs')).href);
+    harness = detectHarness(payload, process.env);
+  } catch { /* no adapter in this install: behave exactly as Claude Code */ }
+
+  if (harness === 'copilot') {
+    try {
+      copilot = await import(pathToFileURL(path.join(REPO_ROOT, 'spexharness', 'src', 'adapters', 'copilot.mjs')).href);
+    } catch {
+      // Copilot denies on exit 2 and on any crash, and without the adapter we cannot speak its dialect: fail OPEN.
+      process.stderr.write(`[heyspex] hook ${target}: Copilot adapter unavailable (failing open)\n`);
+      process.exit(0);
+    }
+  }
+  if (copilot) await copilotBranch(copilot);
+
+  // ── the Copilot branch ([[HS-20SW-DRSM-DIAG-heyspex-capture-on-idea-and-workflow]]) ──────────────────────
+  // Everything below runs ONLY when the harness is GitHub Copilot. Guarantees for Copilot, whatever fails:
+  //   * the process exits 0 (Copilot turns ANY non-zero exit into a deny, and 2 loses the reason);
+  //   * stdout is empty (allow) or ONE valid JSON object (a gate's own decision) - never partial / malformed text;
+  //   * a crash, a throwing hook, an unhandled rejection or a bad import is an ALLOW (the _run.mjs handlers above
+  //     exit 0; the exit hook below translates the buffered output).
+  // Behaviors, in order:
+  //   1. opt-out: HEYSPEX_COPILOT_HOOKS_OFF=1 / config agent_behaviors.harness_hooks.copilot.enabled: false
+  //      silences every hook except the ALWAYS_ON security gates.
+  //   2. normalize the payload (camelCase or PascalCase, MCP tool-name spellings -> mcp__heyspex__*).
+  //   3. script-side tool filter: the VS Code Local harness ignores matchers and fires every hook on every tool,
+  //      so the matcher of the registered row (.claude/settings.json or the plugin hooks.json) is re-applied here.
+  //   4. double-firing guard: Copilot CLI loads hooks from the plugin AND .claude/settings.json; a duplicate
+  //      (same session, event, hook, tool, timestamp) inside 2 s exits 0 (replaying a stored decision, if any).
+  //   5. prompt-time context: Copilot DROPS UserPromptSubmit output, so a context-only result prints nothing
+  //      there. SessionStart accepts additionalContext, so ONCE PER SESSION (stamp file under the project's
+  //      state dir) the SessionStart run also emits inject-communication-style's static text as additionalContext.
+  async function copilotBranch(copilot) {
+    if (!isAlwaysOn(target)) {
+      let off = String(process.env.HEYSPEX_COPILOT_HOOKS_OFF ?? '').trim() === '1';
+      if (!off) {
+        try {
+          const { isConfigKeyEnabled } = await import(pathToFileURL(path.join(HOOK_DIR, '_guardrail-loader.mjs')).href);
+          off = !isConfigKeyEnabled('agent_behaviors.harness_hooks.copilot.enabled');
+        } catch { /* config unreadable: stay on */ }
+      }
+      if (off) process.exit(0);
+    }
+    payload = copilot.normalizeCopilotPayload(payload);
+    text = JSON.stringify(payload);
+    const eventName = typeof payload.hook_event_name === 'string' ? payload.hook_event_name : '';
+
+    // (3) script-side tool filter
+    let skip = false;
+    try {
+      if (eventName && typeof payload.tool_name === 'string') {
+        const matchers = matchersForHook(eventName, payload);
+        skip = !!matchers && !copilot.toolMatchesAnyMatcher(matchers, copilot.toolNameCandidates(payload));
+      }
+    } catch { /* lookup failure: run the hook */ }
+    if (skip) process.exit(0);
+
+    // (4) double-firing guard
+    const dedupe = claimDedupe(payload, eventName);
+    if (dedupe.duplicate) {
+      if (dedupe.replay) { try { fs.writeSync(1, dedupe.replay); } catch { /* ignore */ } }
+      process.exit(0);
+    }
+
+    // (5) once-per-session static advisory at SessionStart
+    let extraContext = '';
+    if (eventName === 'SessionStart' && claimSessionStyleStamp(payload)) {
+      try {
+        const mod = await import(pathToFileURL(path.join(HOOK_DIR, 'inject-communication-style.mjs')).href);
+        extraContext = typeof mod.copilotSessionStartText === 'function' ? await mod.copilotSessionStartText() : '';
+      } catch { /* advisory only */ }
+    }
+
+    // Copilot reads ONE top-level {permissionDecision, permissionDecisionReason}; buffer stdout/stderr and
+    // translate at exit: Claude-dialect JSON -> top-level, and a legacy `exit 2 + stderr` deny -> JSON deny, exit 0.
+    let out = '';
+    let err = '';
+    const realStderr = process.stderr.write.bind(process.stderr);
+    process.stdout.write = (chunk, enc, cb) => { out += typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8'); if (typeof enc === 'function') enc(); else if (typeof cb === 'function') cb(); return true; };
+    process.stderr.write = (chunk, enc, cb) => { err += typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8'); if (typeof enc === 'function') enc(); else if (typeof cb === 'function') cb(); return true; };
+    process.on('exit', (code) => {
+      process.exitCode = 0; // Copilot: never non-zero, whatever happened
+      let final = '';
+      try {
+        final = out ? copilot.finalizeCopilotStdout(out, eventName) : '';
+        if (code === 2 && !final) final = copilot.denyFromLegacyExit(err);
+        else if (err && code !== 2) realStderr(err);
+        if (extraContext) final = copilot.mergeAdditionalContext(final, extraContext);
+      } catch { final = ''; }
+      try { dedupe.store?.(final); } catch { /* best effort */ }
+      try { if (final) fs.writeSync(1, final); } catch { /* never let the translation break the hook */ }
+    });
+  }
+
+  // hand the (already read) payload on as a fresh stdin
+  if (!process.stdin.isTTY) {
+    try {
+      const { Readable } = await import('node:stream');
+      const fresh = new Readable({ read() {} });
+      if (text) fresh.push(Buffer.from(text, 'utf8'));
+      fresh.push(null);
+      Object.defineProperty(process, 'stdin', { value: fresh, configurable: true });
+    } catch { /* hooks will see an empty stdin and fail open themselves */ }
+  }
+
+  const hookPath = resolveHook(target);
+  if (!hookPath || !fs.existsSync(hookPath)) {
+    process.stderr.write(`[heyspex] _run.mjs: hook not found: ${target}\n`);
+    process.exit(0);
+  }
+
+  // Make the hook believe it was invoked directly.
+  process.argv = [process.argv[0], hookPath, ...rest];
+
+  try {
+    await import(pathToFileURL(hookPath).href);
+  } catch (err) {
+    process.stderr.write(`[heyspex] hook ${target} failed: ${err?.message ?? err}\n`);
+    process.exit(0);
+  }
+}
 
 try {
-  await import(pathToFileURL(hookPath).href);
+  await main();
 } catch (err) {
-  process.stderr.write(`[heyspex] hook ${target} failed: ${err?.message ?? err}\n`);
+  process.stderr.write(`[heyspex] _run.mjs failed (failing open): ${err?.message ?? err}\n`);
   process.exit(0);
 }

package/scripts/claude-hooks/capture-execution-gate.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+// Claude Code PreToolUse hook -> blocking gate: no research gather / paid-model synthesis /
+// routing-edit sub-agent while THIS session's on-deck capture is unexpanded or ungrounded.
+// [[HS-KNJ8-BQZC-DIAG-an-agent-session-executed-past-capture]]
+//
+// Decision logic + state contract live in scripts/lib/capture-execution-guard.mjs (pure, unit
+// tested). This file is only the stdin/stdout wrapper. Registered in .claude/settings.json on
+// matcher "Bash|PowerShell|Agent|Task" via _run.mjs. Never gates read-only tools, capture writes,
+// /hs-ground, git, or test runs (see the guard's READ_ONLY_HEAD / OFFLINE_FLAG_RE).
+//
+// Kill switches: env HEYSPEX_CAPTURE_EXECUTION_GATE_OFF=1, or config
+// agent_behaviors.capture_execution_gate.enabled: false. FAIL OPEN on every internal error and
+// whenever capture state is unknowable (no session id / no fresh this-session state file).
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { decideCaptureExecution, GATE_CONFIG_KEY } from '../lib/capture-execution-guard.mjs';
+import { isConfigKeyEnabled } from './_guardrail-loader.mjs';
+
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+
+async function readStdin() {
+  if (process.stdin.isTTY) return '';
+  return new Promise((resolve) => {
+    let buf = '';
+    const timer = setTimeout(() => resolve(buf), 200);
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (c) => (buf += c));
+    process.stdin.on('end', () => { clearTimeout(timer); resolve(buf); });
+    process.stdin.on('error', () => { clearTimeout(timer); resolve(buf); });
+  });
+}
+
+try {
+  const raw = await readStdin();
+  const payload = raw ? JSON.parse(raw) : null;
+  if (payload && (payload.hook_event_name === undefined || payload.hook_event_name === 'PreToolUse')) {
+    const root = process.env.CLAUDE_PROJECT_DIR || payload.cwd || REPO_ROOT;
+    const verdict = decideCaptureExecution(
+      { toolName: payload.tool_name, toolInput: payload.tool_input ?? {}, sessionId: payload.session_id },
+      { root, configEnabled: isConfigKeyEnabled(GATE_CONFIG_KEY) },
+    );
+    if (verdict.decision === 'deny') {
+      process.stdout.write(JSON.stringify({
+        hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: verdict.reason },
+      }));
+    }
+  }
+} catch {
+  // fail open
+}

package/scripts/claude-hooks/claim-liveness-shared.mjs

@@ -12,6 +12,7 @@ import { resolveConsoleUrl as resolveConsoleUrlShared } from '../lib/console-url
 // Bearer for the cloud-gated heartbeat PATCH — same reader every other consumer uses, never
 // re-implemented and never printed.
 import { readCredentialsMcpToken } from '../lib/dev-mode.mjs';
+import { hookVaultHeaders } from '../lib/hook-vault-header.mjs';
 // Read-only reuse of the resource governor's OWN liveness rule + config resolver — never a
 // second, hand-invented rule at this layer. See the "Lease liveness" section below.
 import { describeLivenessRule, resolveGovernorConfig } from '../../dev-factory/lib/fleet-queue-file.mjs';
@@ -340,6 +341,7 @@ export function patchHeartbeat(consoleUrl, sessionId, body, token) {
           'content-length': Buffer.byteLength(payload),
           connection: 'close',
           ...(token ? { authorization: `Bearer ${token}` } : {}),
+          ...hookVaultHeaders(),
         },
         timeout: REQUEST_TIMEOUT_MS,
       },

package/scripts/claude-hooks/diagnose-capture-reminder.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+// GENERATED by scripts/generate-hook-shells.mjs (HS-IQBF) — do not hand-edit.
+// This file only wires Claude Code's hook stdin/stdout contract to the
+// spexharness engine port of this gate. To change what this gate DECIDES,
+// edit spexharness/src/gates/diagnose-capture-reminder.mjs. To change the SHAPE of this shell,
+// edit the generator, then rerun: node scripts/generate-hook-shells.mjs
+
+import { runGateAsHook } from '../../spexharness/src/adapters/claude-code.mjs';
+import gate from '../../spexharness/src/gates/diagnose-capture-reminder.mjs';
+
+await runGateAsHook(gate);

package/scripts/claude-hooks/directive-obligation-gate.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+// GENERATED by scripts/generate-hook-shells.mjs (HS-IQBF) — do not hand-edit.
+// This file only wires Claude Code's hook stdin/stdout contract to the
+// spexharness engine port of this gate. To change what this gate DECIDES,
+// edit spexharness/src/gates/directive-obligation-gate.mjs. To change the SHAPE of this shell,
+// edit the generator, then rerun: node scripts/generate-hook-shells.mjs
+
+import { runGateAsHook } from '../../spexharness/src/adapters/claude-code.mjs';
+import { hookGate as gate } from '../../spexharness/src/gates/directive-obligation-gate.mjs';
+
+await runGateAsHook(gate);

package/scripts/claude-hooks/inject-communication-style.mjs

@@ -51,6 +51,26 @@ export function shouldInject() {
   return false;
 }
 
+/**
+ * The static communication-style prose, for the ONE surface that can still carry it: GitHub Copilot's
+ * `sessionStart` additionalContext (Copilot drops UserPromptSubmit output, and per-prompt injection stays
+ * retired on Claude Code). Called ONLY by scripts/claude-hooks/_run.mjs's Copilot branch, once per session.
+ * Honors the historical kill switch and the `agent_behaviors.communication_style.enabled` config key; returns
+ * '' on any failure (never throws).
+ * @returns {Promise<string>}
+ */
+export async function copilotSessionStartText() {
+  try {
+    if (process.env.HEYSPEX_COMMUNICATION_STYLE_OFF === '1') return '';
+    const { loadGuardrails, rulesForSurface, isRuleEnabled } = await import('./_guardrail-loader.mjs');
+    const rule = rulesForSurface(loadGuardrails(), 'userpromptsubmit', 'prime').find((r) => r && r.rule === 'communication-style-prime');
+    if (!rule || !isRuleEnabled(rule)) return '';
+    return typeof rule.inject === 'string' ? rule.inject.trim() : '';
+  } catch {
+    return '';
+  }
+}
+
 /**
  * The hook body. Reads nothing and writes nothing — retirement means there is no longer
  * anything for it to read the payload FOR. Exported so a test can call it directly and