robrain 2.3.7 → 2.3.8

package/dist/lib/release-guard.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=release-guard.test.d.ts.map

package/dist/lib/release-guard.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"release-guard.test.d.ts","sourceRoot":"","sources":["../../src/lib/release-guard.test.ts"],"names":[],"mappings":""}

package/dist/lib/release-guard.test.js

@@ -0,0 +1,60 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { evaluateReleaseGuard, manifestStatusToPublished, originHasReleaseTag } from './release-guard.js';
+describe('originHasReleaseTag', () => {
+    const lsRemote = [
+        'aaa111\trefs/tags/v2.3.4',
+        'bbb222\trefs/tags/v2.3.5',
+        'ccc333\trefs/tags/v2.3.5^{}',
+        '',
+    ].join('\n');
+    it('finds a lightweight tag ref', () => {
+        assert.equal(originHasReleaseTag(lsRemote, '2.3.4'), true);
+    });
+    it('finds an annotated tag via its peeled ref', () => {
+        assert.equal(originHasReleaseTag('ccc333\trefs/tags/v2.3.5^{}\n', '2.3.5'), true);
+    });
+    it('does not match prefixes of longer versions', () => {
+        assert.equal(originHasReleaseTag('ddd444\trefs/tags/v2.3.45\n', '2.3.4'), false);
+    });
+    it('returns false when the tag is absent or output is empty', () => {
+        assert.equal(originHasReleaseTag(lsRemote, '2.3.7'), false);
+        assert.equal(originHasReleaseTag('', '2.3.7'), false);
+    });
+});
+describe('manifestStatusToPublished', () => {
+    it('reads 200 as published and 404 as missing', () => {
+        assert.equal(manifestStatusToPublished(200), true);
+        assert.equal(manifestStatusToPublished(404), false);
+    });
+    it('throws on auth errors and outages instead of treating them as a missing image', () => {
+        assert.throws(() => manifestStatusToPublished(401));
+        assert.throws(() => manifestStatusToPublished(429));
+        assert.throws(() => manifestStatusToPublished(502));
+    });
+});
+describe('evaluateReleaseGuard', () => {
+    const base = {
+        version: '2.3.7',
+        imageRepo: 'ghcr.io/adelinamart/robrain-perception',
+    };
+    it('passes when the tag is on origin and the image is on GHCR', () => {
+        const result = evaluateReleaseGuard({ ...base, originHasTag: true, imagePublished: true });
+        assert.equal(result.ok, true);
+        assert.deepEqual(result.problems, []);
+    });
+    it('fails with both problems when tag and image are missing (the 2.3.6/2.3.7 incident)', () => {
+        const result = evaluateReleaseGuard({ ...base, originHasTag: false, imagePublished: false });
+        assert.equal(result.ok, false);
+        assert.equal(result.problems.length, 2);
+        assert.match(result.problems[0], /git push origin v2\.3\.7/);
+        assert.match(result.problems[1], /robrain-perception:2\.3\.7 is not published/);
+    });
+    it('fails on image-only gap when the tag is pushed but the workflow has not finished', () => {
+        const result = evaluateReleaseGuard({ ...base, originHasTag: true, imagePublished: false });
+        assert.equal(result.ok, false);
+        assert.equal(result.problems.length, 1);
+        assert.match(result.problems[0], /publish-perception-image\.yml/);
+    });
+});
+//# sourceMappingURL=release-guard.test.js.map

package/dist/lib/release-guard.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"release-guard.test.js","sourceRoot":"","sources":["../../src/lib/release-guard.test.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "robrain",
-  "version": "2.3.7",
+  "version": "2.3.8",
   "type": "module",
   "description": "RoBrain CLI for installation, setup, and memory workflows",
   "author": "Rory Plans, Inc.",
@@ -41,15 +41,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "pnpm build && node scripts/vendor-sensing-mcp.mjs && node scripts/vendor-hermes-plugin.mjs",
-    "dev": "tsc --watch",
-    "typecheck": "tsc --noEmit",
-    "test": "pnpm build && node --test dist/lib/editor.codex.test.js dist/lib/mcp-bundle.test.js dist/lib/claude-plugin.test.js dist/lib/hermes-plugin.test.js dist/commands/outcomes.test.js dist/commands/export-interchange.test.js dist/commands/up.test.js dist/commands/mcp.test.js",
-    "pack:verify": "node scripts/verify-publish-tarball.mjs",
-    "postinstall": "node scripts/chmod-bin.cjs"
-  },
   "dependencies": {
     "dotenv": "^16.4.5",
     "chalk": "^5.3.0",
@@ -61,5 +52,13 @@
     "typescript": "^5.4.0",
     "@types/node": "^20.0.0",
     "@types/prompts": "^2.4.9"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "pnpm build && node --test dist/lib/editor.codex.test.js dist/lib/release-guard.test.js dist/lib/mcp-bundle.test.js dist/lib/claude-plugin.test.js dist/lib/hermes-plugin.test.js dist/lib/codex-hooks.test.js dist/commands/outcomes.test.js dist/commands/export-interchange.test.js dist/commands/up.test.js dist/commands/mcp.test.js",
+    "pack:verify": "node scripts/verify-publish-tarball.mjs",
+    "postinstall": "node scripts/chmod-bin.cjs"
   }
-}
+}

package/scripts/vendor-codex-hooks.mjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+// Assemble the Codex hook scripts into vendor/codex-hooks for the published
+// tarball: the shared scripts come from the Claude plugin (single source),
+// stop.mjs from the Codex plugin. Same pattern as vendor-sensing-mcp.
+import { cpSync, existsSync, mkdirSync, rmSync } from 'fs'
+import { dirname, join } from 'path'
+import { fileURLToPath } from 'url'
+
+const cliRoot = join(dirname(fileURLToPath(import.meta.url)), '..')
+const claudeHooks = join(cliRoot, '..', '..', 'plugins', 'claude-code', 'hooks')
+const codexHooks  = join(cliRoot, '..', '..', 'plugins', 'codex', 'hooks')
+const dest = join(cliRoot, 'vendor', 'codex-hooks')
+
+const wanted = [
+  [claudeHooks, 'lib.mjs'],
+  [claudeHooks, 'session-start.mjs'],
+  [claudeHooks, 'user-prompt-submit.mjs'],
+  [codexHooks, 'stop.mjs'],
+]
+
+for (const [dir, f] of wanted) {
+  if (!existsSync(join(dir, f))) {
+    console.error('vendor-codex-hooks: missing', join(dir, f))
+    process.exit(1)
+  }
+}
+
+rmSync(dest, { recursive: true, force: true })
+mkdirSync(dest, { recursive: true })
+for (const [dir, f] of wanted) cpSync(join(dir, f), join(dest, f))
+console.log(`Vendored codex hooks → packages/cli/vendor/codex-hooks`)

package/scripts/verify-publish-tarball.mjs

@@ -20,6 +20,7 @@ mkdirSync(work, { recursive: true })
 try {
   execFileSync('node', ['scripts/vendor-sensing-mcp.mjs'], { cwd: cliRoot, stdio: 'inherit' })
   execFileSync('node', ['scripts/vendor-hermes-plugin.mjs'], { cwd: cliRoot, stdio: 'inherit' })
+  execFileSync('node', ['scripts/vendor-codex-hooks.mjs'], { cwd: cliRoot, stdio: 'inherit' })
 
   execFileSync('pnpm', ['pack', '--pack-destination', work], { cwd: cliRoot, stdio: 'inherit' })
 
@@ -70,6 +71,14 @@ try {
     fail(`installHermesPlugin() copy incomplete at ${dest}`)
   }
 
+  // Codex hooks: vendored scripts present and installable from the tarball.
+  const codexHooksUrl = pathToFileURL(join(extracted, 'dist', 'lib', 'codex-hooks.js')).href
+  const { installCodexHooks } = await import(codexHooksUrl)
+  const codexHooksDest = installCodexHooks(join(work, 'codex-hooks'))
+  if (!codexHooksDest || !existsSync(join(codexHooksDest, 'stop.mjs'))) {
+    fail('installCodexHooks() could not materialize from the tarball vendor dir')
+  }
+
   // Smoke-test the server entry robrain mcp execs (no CLI deps needed in the tarball).
   const mcpEntry = join(extracted, 'vendor', 'sensing-mcp', 'dist', 'index.js')
   await new Promise((resolve, reject) => {

package/scripts/verify-release-artifacts.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+// Publish gate: refuse to publish a CLI version whose GHCR Perception image
+// does not exist — `robrain up` defaults its Docker tag to the CLI version, so
+// npm-without-image breaks every no-clone install. Runs in prepublishOnly
+// after the build; evaluation logic lives in dist/lib/release-guard.js.
+// Emergency bypass: ROBRAIN_SKIP_RELEASE_GUARD=1 pnpm publish
+import { execFileSync } from 'child_process'
+import { readFileSync } from 'fs'
+import { dirname, join } from 'path'
+import { fileURLToPath, pathToFileURL } from 'url'
+
+const cliRoot = join(dirname(fileURLToPath(import.meta.url)), '..')
+
+if (process.env.ROBRAIN_SKIP_RELEASE_GUARD === '1') {
+  console.warn('release-guard SKIPPED via ROBRAIN_SKIP_RELEASE_GUARD=1 — the GHCR image for this version may not exist.')
+  process.exit(0)
+}
+
+const { evaluateReleaseGuard, manifestStatusToPublished, originHasReleaseTag } =
+  await import(pathToFileURL(join(cliRoot, 'dist', 'lib', 'release-guard.js')).href)
+const { DEFAULT_IMAGE_REPO } = await import(pathToFileURL(join(cliRoot, 'dist', 'commands', 'up.js')).href)
+
+const version = JSON.parse(readFileSync(join(cliRoot, 'package.json'), 'utf8')).version
+
+function fail(problems) {
+  console.error(`\nrelease-guard FAILED for robrain@${version}:\n`)
+  for (const p of problems) console.error(`  ✗ ${p}\n`)
+  console.error('  (Emergency bypass: ROBRAIN_SKIP_RELEASE_GUARD=1)\n')
+  process.exit(1)
+}
+
+let lsRemote
+try {
+  lsRemote = execFileSync('git', ['ls-remote', '--tags', 'origin', `refs/tags/v${version}*`], {
+    cwd: cliRoot,
+    encoding: 'utf8',
+  })
+} catch (err) {
+  fail([`could not query origin tags (git ls-remote failed): ${err.message}`])
+}
+
+// Anonymous pull-scope token, then HEAD the version's manifest — per-tag, so
+// immune to tags/list pagination as releases accumulate.
+const ghcrRepo = DEFAULT_IMAGE_REPO.replace(/^ghcr\.io\//, '')
+let imagePublished
+try {
+  const tokenRes = await fetch(`https://ghcr.io/token?scope=repository:${ghcrRepo}:pull`)
+  const { token } = await tokenRes.json()
+  const manifestRes = await fetch(`https://ghcr.io/v2/${ghcrRepo}/manifests/${version}`, {
+    method: 'HEAD',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      // The multi-arch index plus single-manifest fallbacks; without these
+      // some registries 404 even for tags that exist.
+      Accept: [
+        'application/vnd.oci.image.index.v1+json',
+        'application/vnd.docker.distribution.manifest.list.v2+json',
+        'application/vnd.oci.image.manifest.v1+json',
+        'application/vnd.docker.distribution.manifest.v2+json',
+      ].join(', '),
+    },
+  })
+  imagePublished = manifestStatusToPublished(manifestRes.status)
+} catch (err) {
+  fail([`could not check ${DEFAULT_IMAGE_REPO}:${version} on GHCR: ${err.message}`])
+}
+
+const result = evaluateReleaseGuard({
+  version,
+  imageRepo: DEFAULT_IMAGE_REPO,
+  originHasTag: originHasReleaseTag(lsRemote, version),
+  imagePublished,
+})
+
+if (!result.ok) fail(result.problems)
+
+console.log(`release-guard ok — v${version} tag on origin, ${DEFAULT_IMAGE_REPO}:${version} published`)

package/vendor/codex-hooks/lib.mjs

@@ -0,0 +1,276 @@
+// plugins/claude-code/hooks/lib.mjs
+// ─────────────────────────────────────────────────────────────
+// Shared plumbing for RoBrain Claude Code plugin hooks.
+//
+// Design constraints:
+//  - Zero dependencies, Node >= 18 (built-in fetch). Hooks must start fast.
+//  - Fail-open ALWAYS: a dead Perception, missing config, or timeout must
+//    never block or break the user's Claude Code session. Hooks print nothing
+//    and exit 0 on any failure.
+//  - Thin client: raw turns go to Perception POST /signals with
+//    needs_classification=true — classification/extraction/dedup happen
+//    server-side, so this plugin (and future Codex/Cursor ports) stays dumb.
+// ─────────────────────────────────────────────────────────────
+
+import { createHash } from 'node:crypto'
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+/** Read all of stdin (the hook input JSON). */
+export async function readStdin() {
+  const chunks = []
+  for await (const chunk of process.stdin) chunks.push(chunk)
+  return Buffer.concat(chunks).toString('utf8')
+}
+
+export function parseHookInput(raw) {
+  try {
+    return JSON.parse(raw)
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * Perception connection: env wins, then ~/.robrain/config.json (written by
+ * `robrain up` / `robrain install`), then localhost default.
+ */
+export function loadPerception() {
+  let url = process.env.PERCEPTION_URL?.trim() || ''
+  let key = process.env.PERCEPTION_API_KEY?.trim() || ''
+  if (!url || !key) {
+    try {
+      const cfg = JSON.parse(readFileSync(join(homedir(), '.robrain', 'config.json'), 'utf8'))
+      if (!url && typeof cfg.perceptionUrl === 'string') url = cfg.perceptionUrl.trim()
+      if (!key && typeof cfg.perceptionKey === 'string') key = cfg.perceptionKey.trim()
+    } catch {
+      // no config yet — fall through to defaults
+    }
+  }
+  return { url: url || 'http://localhost:3001', key }
+}
+
+/**
+ * Same derivation as the CLI (packages/cli/src/lib/project.ts): prefer the
+ * project_id init-project wrote into CLAUDE.md / AGENTS.md / the Cursor rule,
+ * else a stable hash of the working directory.
+ */
+export function resolveProjectId(cwd) {
+  for (const rel of ['CLAUDE.md', 'AGENTS.md', join('.cursor', 'rules', 'robrain.mdc')]) {
+    const p = join(cwd, rel)
+    try {
+      if (!existsSync(p)) continue
+      const match = readFileSync(p, 'utf8').match(/project_id="([^"]+)"/)
+      if (match?.[1]) return match[1].trim()
+    } catch {
+      // unreadable file — try the next candidate
+    }
+  }
+  return createHash('sha256').update(cwd).digest('hex').slice(0, 12)
+}
+
+/** fetch with a hard timeout; returns null instead of throwing. */
+export async function perceptionFetch(path, { url, key }, init = {}, timeoutMs = 2500) {
+  try {
+    const res = await fetch(`${url}${path}`, {
+      ...init,
+      headers: {
+        'Content-Type': 'application/json',
+        ...(key ? { Authorization: `Bearer ${key}` } : {}),
+        ...(init.headers ?? {}),
+      },
+      signal: AbortSignal.timeout(timeoutMs),
+    })
+    if (!res.ok) return null
+    return await res.json()
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Extract the trailing turn from a Claude Code transcript (JSONL): the last
+ * user text message and every assistant text block after it, plus file paths
+ * touched by Edit/Write/NotebookEdit tool calls in that span.
+ */
+export function extractLastTurn(transcriptPath) {
+  let lines
+  try {
+    lines = readFileSync(transcriptPath, 'utf8').split('\n').filter(Boolean)
+  } catch {
+    return null
+  }
+
+  let lastUserIdx = -1
+  const entries = []
+  for (const line of lines) {
+    let e
+    try {
+      e = JSON.parse(line)
+    } catch {
+      continue
+    }
+    entries.push(e)
+  }
+
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const e = entries[i]
+    if (e.type === 'user' && !e.isMeta && typeof textOf(e.message?.content) === 'string' && textOf(e.message.content).trim()) {
+      // Skip tool_result-only user entries (tool outputs come back as user role)
+      if (hasOnlyToolResults(e.message?.content)) continue
+      lastUserIdx = i
+      break
+    }
+  }
+  if (lastUserIdx === -1) return null
+
+  const userMessage = textOf(entries[lastUserIdx].message?.content) ?? ''
+  const replyParts = []
+  const filesTouched = new Set()
+
+  for (let i = lastUserIdx + 1; i < entries.length; i++) {
+    const e = entries[i]
+    if (e.type !== 'assistant') continue
+    const content = e.message?.content
+    if (!Array.isArray(content)) continue
+    for (const block of content) {
+      if (block.type === 'text' && block.text?.trim()) replyParts.push(block.text)
+      if (block.type === 'tool_use') {
+        const fp = block.input?.file_path ?? block.input?.notebook_path
+        if (typeof fp === 'string' && fp) filesTouched.add(fp)
+      }
+    }
+  }
+
+  if (!userMessage.trim() || replyParts.length === 0) return null
+
+  // Sequence: number of user-authored messages up to and including this one —
+  // stable across re-reads of the same transcript.
+  let sequence = 0
+  for (let i = 0; i <= lastUserIdx; i++) {
+    const e = entries[i]
+    if (e.type === 'user' && !e.isMeta && !hasOnlyToolResults(e.message?.content) && textOf(e.message?.content)?.trim()) sequence++
+  }
+
+  return {
+    userMessage,
+    claudeReply: replyParts.join('\n\n'),
+    filesTouched: [...filesTouched].slice(0, 50),
+    sequence: Math.max(1, sequence),
+  }
+}
+
+function textOf(content) {
+  if (typeof content === 'string') return content
+  if (Array.isArray(content)) {
+    return content.filter(b => b.type === 'text').map(b => b.text ?? '').join('\n')
+  }
+  return null
+}
+
+function hasOnlyToolResults(content) {
+  return Array.isArray(content) && content.length > 0 && content.every(b => b.type === 'tool_result')
+}
+
+// ── Session-scoped warning state ──────────────────────────────
+// The same veto re-injected on every on-topic prompt is context spend for
+// zero new information — Control must never cost more context than it saves.
+
+const STATE_DIR = join(homedir(), '.robrain', 'state')
+
+function warnedFile(sessionId) {
+  const safe = sessionId.replace(/[^A-Za-z0-9._-]/g, '_').slice(0, 120)
+  return join(STATE_DIR, `cc-warned-${safe}.json`)
+}
+
+/** Decision ids already warned about in this session. */
+export function loadWarnedIds(sessionId) {
+  if (!sessionId) return new Set()
+  try {
+    const ids = JSON.parse(readFileSync(warnedFile(sessionId), 'utf8'))
+    return new Set(Array.isArray(ids) ? ids : [])
+  } catch {
+    return new Set()
+  }
+}
+
+export function recordWarnedIds(sessionId, ids) {
+  if (!sessionId || ids.length === 0) return
+  try {
+    mkdirSync(STATE_DIR, { recursive: true })
+    const merged = [...new Set([...loadWarnedIds(sessionId), ...ids])].slice(-200)
+    writeFileSync(warnedFile(sessionId), JSON.stringify(merged))
+    cleanupStateDir()
+  } catch {
+    // fail-open — a broken state file must never block the session
+  }
+}
+
+/** Best-effort hygiene: drop state files older than 7 days. */
+function cleanupStateDir() {
+  try {
+    const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000
+    for (const f of readdirSync(STATE_DIR)) {
+      const p = join(STATE_DIR, f)
+      try {
+        if (statSync(p).mtimeMs < cutoff) unlinkSync(p)
+      } catch {
+        // race or permissions — skip
+      }
+    }
+  } catch {
+    // dir unreadable — skip
+  }
+}
+
+// ── Per-session prompt stash ──────────────────────────────────
+// Written by the UserPromptSubmit hook, read by stop hooks that cannot rely
+// on a parseable transcript (Codex ships last_assistant_message on Stop stdin
+// but its transcript format is not a contract we own). Pairing the stashed
+// prompt with that message gives deterministic capture with zero transcript
+// assumptions.
+
+function stashFile(sessionId) {
+  const safe = sessionId.replace(/[^A-Za-z0-9._-]/g, '_').slice(0, 120)
+  return join(STATE_DIR, `stash-${safe}.json`)
+}
+
+export function stashPrompt(sessionId, prompt) {
+  if (!sessionId || !prompt) return
+  try {
+    mkdirSync(STATE_DIR, { recursive: true })
+    const prev = loadPromptStash(sessionId)
+    writeFileSync(stashFile(sessionId), JSON.stringify({
+      prompt: prompt.slice(0, 60_000),
+      sequence: (prev?.sequence ?? 0) + 1,
+    }))
+  } catch {
+    // fail-open
+  }
+}
+
+export function loadPromptStash(sessionId) {
+  if (!sessionId) return null
+  try {
+    const s = JSON.parse(readFileSync(stashFile(sessionId), 'utf8'))
+    return typeof s?.prompt === 'string' ? s : null
+  } catch {
+    return null
+  }
+}
+
+/** Emit hook JSON output (context injection) and exit 0. */
+export function emitContext(hookEventName, additionalContext) {
+  if (additionalContext) {
+    process.stdout.write(JSON.stringify({
+      hookSpecificOutput: { hookEventName, additionalContext },
+    }))
+  }
+  process.exit(0)
+}
+
+/** Silent success — hooks must never fail the session. */
+export function exitSilently() {
+  process.exit(0)
+}

package/vendor/codex-hooks/session-start.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+// SessionStart hook — inject the always-on project summary (top decisions with
+// their rejected alternatives) at the start of every Claude Code session.
+// Deterministic replacement for the model remembering to call sensing_start_session.
+
+import {
+  readStdin, parseHookInput, loadPerception, resolveProjectId,
+  perceptionFetch, emitContext, exitSilently,
+} from './lib.mjs'
+
+const input = parseHookInput(await readStdin())
+const cwd = input.cwd ?? process.cwd()
+const perception = loadPerception()
+const projectId = resolveProjectId(cwd)
+
+const summary = await perceptionFetch(`/projects/${projectId}/summary`, perception, {}, 3000)
+const text = summary?.summary ?? summary?.always_on_summary
+if (!text || typeof text !== 'string' || !text.trim()) exitSilently()
+
+emitContext(
+  'SessionStart',
+  [
+    '## RoBrain project memory (always-on summary)',
+    'Prior decisions for this project, including rejected alternatives. Respect the rejections —',
+    'if a task invites a previously rejected approach, surface the rejection instead of re-proposing it.',
+    '',
+    text.trim(),
+  ].join('\n'),
+)

package/vendor/codex-hooks/stop.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+// Codex Stop hook — deterministic turn capture for Codex CLI / IDE.
+//
+// Codex's Stop stdin carries `last_assistant_message` directly, and the
+// UserPromptSubmit hook stashed the user prompt — so capture needs ZERO
+// assumptions about Codex's transcript format (which is not a contract we
+// own). The transcript, when it happens to parse as Claude-style JSONL, only
+// enriches the signal with files touched.
+//
+// Ships the turn to Perception POST /signals with needs_classification=true;
+// extraction, the confidence gate, and near-duplicate dedup run server-side —
+// including dedup against turns captured via the Sensing MCP protocol, so
+// running both double-captures nothing.
+
+import {
+  readStdin, parseHookInput, loadPerception, resolveProjectId,
+  perceptionFetch, extractLastTurn, loadPromptStash, exitSilently,
+} from './lib.mjs'
+
+const input = parseHookInput(await readStdin())
+
+// stop_hook_active guards re-entry when a stop hook itself continues the turn.
+if (input.stop_hook_active) exitSilently()
+
+const sessionId = typeof input.session_id === 'string' ? input.session_id : ''
+const cwd = input.cwd ?? process.cwd()
+if (!sessionId) exitSilently()
+
+// Reply: stdin first; transcript parse as fallback.
+let reply = typeof input.last_assistant_message === 'string' ? input.last_assistant_message : ''
+
+// Prompt: the UserPromptSubmit stash is authoritative; transcript is fallback.
+const stash = loadPromptStash(sessionId)
+let userMessage = stash?.prompt ?? ''
+let sequence = stash?.sequence ?? 1
+let filesTouched = []
+
+if ((!userMessage || !reply) && input.transcript_path) {
+  const turn = extractLastTurn(input.transcript_path)
+  if (turn) {
+    if (!userMessage) { userMessage = turn.userMessage; sequence = turn.sequence }
+    if (!reply) reply = turn.claudeReply
+    filesTouched = turn.filesTouched
+  }
+} else if (input.transcript_path) {
+  // Both present — transcript only enriches with files touched, best-effort.
+  const turn = extractLastTurn(input.transcript_path)
+  if (turn) filesTouched = turn.filesTouched
+}
+
+if (!userMessage.trim() || !reply.trim()) exitSilently()
+
+const perception = loadPerception()
+const projectId = resolveProjectId(cwd)
+
+await perceptionFetch('/signals', perception, {
+  method: 'POST',
+  headers: { 'X-Project-Id': projectId },
+  body: JSON.stringify({
+    signal: {
+      turn: {
+        session_id:    `codex-${sessionId}`.slice(0, 200),
+        sequence,
+        user_message:  userMessage.slice(0, 60_000),
+        claude_reply:  reply.slice(0, 60_000),
+        files_touched: filesTouched,
+        timestamp:     new Date().toISOString(),
+      },
+      decision_type:        'unclassified',
+      confidence:           0,
+      files_affected:       filesTouched,
+      scope:                'team',
+      needs_classification: true,
+    },
+  }),
+}, 8000)
+
+exitSilently()