greprag 5.21.0 → 5.22.0

package/dist/commands/init.js

@@ -1,9 +1,9 @@
 "use strict";
-/** greprag init — configure Claude Code for GrepRAG memory.
+/** greprag init — configure agent clients for GrepRAG memory.
  *
  * 1. Obtain API key (provided or provisioned)
  * 2. Validate key against health endpoint
- * 3. Update ~/.claude/settings.json with env vars + hooks */
+ * 3. Update the target platform's native hooks/plugin/config */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -39,6 +39,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runInit = runInit;
+exports.applyCodexHooks = applyCodexHooks;
 exports.applySettings = applySettings;
 exports.patchClaudeMdContent = patchClaudeMdContent;
 const fs = __importStar(require("fs"));
@@ -47,7 +48,112 @@ const os = __importStar(require("os"));
 const readline = __importStar(require("readline"));
 const child_process_1 = require("child_process");
 const project_anchor_1 = require("../project-anchor");
+const codex_1 = require("./codex");
 const API_URL = 'https://api.greprag.com';
+function hasEnvPrefix(prefix) {
+    return Object.keys(process.env).some(k => k.startsWith(prefix));
+}
+function findUp(start, fileName) {
+    let dir = path.resolve(start);
+    while (true) {
+        const candidate = path.join(dir, fileName);
+        if (fs.existsSync(candidate))
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+function detectAgentTargets(cwd = process.cwd()) {
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    const detections = [];
+    const claudeEvidence = [];
+    if (process.env.CLAUDE_CODE_SESSION_ID)
+        claudeEvidence.push('CLAUDE_CODE_SESSION_ID is set');
+    if (process.env.CLAUDE_PROJECT_DIR)
+        claudeEvidence.push('CLAUDE_PROJECT_DIR is set');
+    if (home && fs.existsSync(path.join(home, '.claude')))
+        claudeEvidence.push('~/.claude exists');
+    if (claudeEvidence.length > 0)
+        detections.push({ target: 'claude', evidence: claudeEvidence });
+    const codexEvidence = [];
+    if (hasEnvPrefix('CODEX_'))
+        codexEvidence.push('CODEX_* environment is set');
+    if (home && fs.existsSync(path.join(home, '.codex')))
+        codexEvidence.push('~/.codex exists');
+    const agentsPath = findUp(cwd, 'AGENTS.md');
+    if (agentsPath)
+        codexEvidence.push(`AGENTS.md found at ${agentsPath}`);
+    if (codexEvidence.length > 0)
+        detections.push({ target: 'codex', evidence: codexEvidence });
+    const opencodeEvidence = [];
+    if (hasEnvPrefix('OPENCODE'))
+        opencodeEvidence.push('OPENCODE* environment is set');
+    if (home && fs.existsSync(path.join(home, '.config', 'opencode')))
+        opencodeEvidence.push('~/.config/opencode exists');
+    if (opencodeEvidence.length > 0)
+        detections.push({ target: 'opencode', evidence: opencodeEvidence });
+    return detections;
+}
+function describeTarget(target) {
+    if (target === 'claude')
+        return 'Claude Code';
+    if (target === 'codex')
+        return 'Codex';
+    return 'OpenCode';
+}
+function explicitInitHint() {
+    return [
+        'Run one of:',
+        '  greprag init --codex',
+        '  greprag init --claude',
+        '  greprag init --opencode',
+    ].join('\n');
+}
+async function chooseInitTarget() {
+    const detections = detectAgentTargets();
+    if (!process.stdin.isTTY) {
+        if (detections.length === 1)
+            return detections[0].target;
+        console.error('  Error: greprag init could not safely choose an agent target in non-interactive mode.');
+        if (detections.length > 1) {
+            console.error('  Detected more than one possible agent:');
+            for (const d of detections) {
+                console.error(`    - ${describeTarget(d.target)}: ${d.evidence.join('; ')}`);
+            }
+        }
+        console.error(explicitInitHint());
+        process.exit(1);
+    }
+    if (detections.length === 1) {
+        const detected = detections[0];
+        console.log(`\n  Detected ${describeTarget(detected.target)} (${detected.evidence.join('; ')}).`);
+        const answer = (await prompt(`  Configure GrepRAG for ${describeTarget(detected.target)}? (Y/n): `)).trim().toLowerCase();
+        if (!answer || answer === 'y' || answer === 'yes')
+            return detected.target;
+    }
+    else if (detections.length > 1) {
+        console.log('\n  Multiple agent environments look available:');
+        for (const d of detections) {
+            console.log(`    - ${describeTarget(d.target)}: ${d.evidence.join('; ')}`);
+        }
+    }
+    console.log('\n  Which agent are you setting up GrepRAG for?');
+    console.log('    1. Codex');
+    console.log('    2. Claude Code');
+    console.log('    3. OpenCode');
+    const answer = (await prompt('  Choose 1, 2, or 3: ')).trim().toLowerCase();
+    if (answer === '1' || answer === 'codex')
+        return 'codex';
+    if (answer === '2' || answer === 'claude' || answer === 'claude code')
+        return 'claude';
+    if (answer === '3' || answer === 'opencode' || answer === 'open code')
+        return 'opencode';
+    console.error('  Error: no agent target selected.');
+    console.error(explicitInitHint());
+    process.exit(1);
+}
 async function runInit(opts) {
     // --all: run the FULL standard init for cwd first (API key, hooks, anchor,
     // global anchor, skill, chip-spawn doc, CLAUDE.md patch), THEN bulk-register
@@ -56,24 +162,37 @@ async function runInit(opts) {
     // Reuse the existing GREPRAG_API_KEY from settings if one is already there,
     // so re-runs don't churn the tenant's key via the provision path.
     if (opts.all) {
-        let apiKey = opts.apiKey;
-        if (!apiKey) {
-            apiKey = readSettings(getSettingsPath()).env?.GREPRAG_API_KEY;
-        }
+        let apiKey = opts.apiKey || readSharedApiKey();
         await runInit({ ...opts, all: false, apiKey });
         return runInitAll(opts.root);
     }
-    // --global: create ~/.claude/project.json only — no API key, no hooks.
+    // --global: create ~/.greprag/project.json only — no API key, no hooks.
     if (opts.global) {
         return runGlobalInit(opts.name);
     }
+    const explicitTargets = [opts.claude, opts.codex, opts.opencode].filter(Boolean).length;
+    if (explicitTargets > 1) {
+        console.error('  Error: choose only one target: --claude, --codex, or --opencode.');
+        process.exit(1);
+    }
     // --opencode: configure for OpenCode instead of Claude Code.
     if (opts.opencode) {
         return runOpenCodeInit(opts);
     }
+    // --codex: configure Codex lifecycle hooks.
+    if (opts.codex) {
+        return runCodexInit(opts);
+    }
+    if (!opts.claude) {
+        const target = await chooseInitTarget();
+        if (target === 'codex')
+            return runCodexInit(opts);
+        if (target === 'opencode')
+            return runOpenCodeInit(opts);
+    }
     console.log('\n  greprag init — Setting up agent memory for Claude Code\n');
     // Step 1: Get API key
-    let apiKey = opts.apiKey;
+    let apiKey = opts.apiKey || readSharedApiKey();
     if (!apiKey) {
         let tenantId = opts.tenantId;
         if (!tenantId) {
@@ -101,21 +220,7 @@ async function runInit(opts) {
         process.exit(1);
     }
     console.log('  Key validated against api.greprag.com');
-    // Cache identity (numeric handle + aliases) so `greprag status` can return
-    // a usable routing address offline. adr: adr/numeric-handles.md
-    try {
-        const { fetchIdentity, writeCache } = await Promise.resolve().then(() => __importStar(require('./identity')));
-        const home = process.env.HOME || process.env.USERPROFILE || '';
-        const cachePath = `${home}/.greprag/identity.json`;
-        const ident = await fetchIdentity('https://api.greprag.com', apiKey);
-        writeCache(cachePath, ident);
-        if (ident.handle)
-            console.log(`  Identity:        ${ident.handle}`);
-    }
-    catch (e) {
-        // Non-fatal — `greprag identity show` can repopulate later.
-        console.log(`  Identity cache deferred (${e.message})`);
-    }
+    await cacheIdentity(apiKey);
     // Step 3: Update settings.json
     console.log('  Configuring Claude Code settings...');
     const settingsPath = getSettingsPath();
@@ -133,7 +238,7 @@ async function runInit(opts) {
         changes.push(`Project anchor: ${anchor.projectName} (${anchor.projectId.slice(0, 8)}) — derived from git history`);
     }
     else {
-        changes.push(`Project anchor: ${anchor.projectName} (${anchor.projectId.slice(0, 8)}) — stored in .claude/project.json`);
+        changes.push(`Project anchor: ${anchor.projectName} (${anchor.projectId.slice(0, 8)}) — stored in .greprag/project.json`);
         // Only patch gitignore when the file is load-bearing for identity.
         const gitignoreResult = ensureAnchorTrackable(process.cwd());
         if (gitignoreResult)
@@ -155,25 +260,19 @@ async function runInit(opts) {
     // with capabilities the operator may not want. Postinstall mirrors this
     // policy (sync greprag/ always, refresh-only for opted-in advisors).
     // adr: adr/skill-bundle-shape.md
-    const skillRoot = path.join(__dirname, '../../skill');
-    const skillsTargetRoot = path.join(os.homedir(), '.claude', 'skills');
-    const CORE_SKILL = 'greprag';
+    const skillRoot = getSkillRoot();
     const optionalSkills = [];
     if (fs.existsSync(skillRoot)) {
+        const installed = installCoreSkill('claude');
+        if (installed)
+            changes.push(`Skill: installed → ${installed}`);
         for (const entry of fs.readdirSync(skillRoot, { withFileTypes: true })) {
             if (!entry.isDirectory())
                 continue;
             if (entry.name === 'templates')
                 continue;
-            if (entry.name === CORE_SKILL) {
-                const srcDir = path.join(skillRoot, entry.name);
-                const destDir = path.join(skillsTargetRoot, entry.name);
-                copySkillDir(srcDir, destDir);
-                changes.push(`Skill: installed → ${destDir}`);
-            }
-            else {
+            if (entry.name !== 'greprag')
                 optionalSkills.push(entry.name);
-            }
         }
     }
     // Step 6b: Install the chip-spawn doc to ~/.claude/docs/chip-spawn.md. The
@@ -219,14 +318,14 @@ async function runInit(opts) {
  *  global plugins directory.
  *
  *  Does NOT create a separate `.opencode/project.json` — the opencode plugin's
- *  `readAnchor` checks `.claude/project.json` first, so a single anchor in
- *  `.claude/` is shared between both clients and memory accumulates under one
- *  project_id. A user who initialized opencode first and Claude Code second
- *  on the same repo gets the same project_id from both inits (idempotent). */
+ *  `readAnchor` checks `.greprag/project.json` first, so a single shared
+ *  anchor is used by all clients and memory accumulates under one project_id.
+ *  A user who initialized opencode first and Claude Code second on the same
+ *  repo gets the same project_id from both inits (idempotent). */
 async function runOpenCodeInit(opts) {
     console.log('\n  greprag init — Setting up agent memory for OpenCode\n');
     // Step 1: Get API key (same provision path as Claude Code init)
-    let apiKey = opts.apiKey;
+    let apiKey = opts.apiKey || readSharedApiKey();
     if (!apiKey) {
         let tenantId = opts.tenantId;
         if (!tenantId) {
@@ -254,14 +353,15 @@ async function runOpenCodeInit(opts) {
         process.exit(1);
     }
     console.log('  Key validated against api.greprag.com');
-    // Step 3: Ensure env vars are set in ~/.claude/settings.json
-    // (shared env between Claude Code and OpenCode — the plugin reads this
-    // file via loadClaudeEnv on boot to get GREPRAG_API_KEY + MEMORY_HOOK_ENABLED)
+    await cacheIdentity(apiKey);
+    writeGrepragEnv(apiKey);
+    // Step 3: Ensure env vars are also set in ~/.claude/settings.json for
+    // backwards compatibility with older OpenCode plugin installs.
     const settingsPath = getSettingsPath();
     const settings = readSettings(settingsPath);
     if (!settings.env)
         settings.env = {};
-    const envChanges = [];
+    const envChanges = ['Wrote ~/.greprag/.env'];
     if (!settings.env.GREPRAG_API_KEY) {
         settings.env.GREPRAG_API_KEY = apiKey;
         envChanges.push('Set GREPRAG_API_KEY');
@@ -274,7 +374,7 @@ async function runOpenCodeInit(opts) {
         writeSettings(settingsPath, settings);
     }
     // Step 4: Resolve the canonical project anchor via the same cascade Claude
-    // Code uses. Idempotent — if `.claude/project.json` already exists, this
+    // Code uses. Idempotent — if `.greprag/project.json` already exists, this
     // returns the existing anchor unchanged. In a git repo with commits, the
     // identity is derived from the root commit SHA and the file holds only
     // settings (no project_id). The opencode plugin's readAnchor reads this
@@ -334,11 +434,114 @@ async function runOpenCodeInit(opts) {
     console.log(`    - Project anchor: ${anchor.anchorPath} (source: ${anchor.source})`);
     if (pluginInstalled)
         console.log(`    - Plugin: ${pluginDest}`);
+    console.log(`    - Shared env: ${getGrepragEnvPath()}`);
     console.log('  OpenCode will load the plugin automatically on next session start.');
     console.log('  The /greprag skill is also available for on-demand briefings.\n');
 }
+/** greprag init --codex
+ *  Configures GrepRAG for Codex lifecycle hooks. Codex does not read
+ *  ~/.claude/settings.json env, so this path writes ~/.greprag/.env and a
+ *  user-level ~/.codex/hooks.json. The hooks still call the same greprag-hook
+ *  binary; codex-* subcommands only adapt Codex's prompt/Stop payload shape. */
+async function runCodexInit(opts) {
+    console.log('\n  greprag init — Setting up agent memory for Codex\n');
+    let apiKey = opts.apiKey || readSharedApiKey();
+    if (!apiKey) {
+        let tenantId = opts.tenantId;
+        if (!tenantId) {
+            tenantId = await prompt('  Enter a tenant ID (alphanumeric + hyphens, 3-32 chars): ');
+        }
+        tenantId = tenantId.trim().toLowerCase();
+        if (!tenantId) {
+            console.error('  Error: tenant ID is required');
+            process.exit(1);
+        }
+        console.log(`  Provisioning API key for tenant "${tenantId}"...`);
+        const result = await provision(tenantId);
+        if (!result.ok) {
+            console.error(`  Error: ${result.error}`);
+            process.exit(1);
+        }
+        apiKey = result.apiKey;
+        console.log(`  API key created: ${apiKey.slice(0, 17)}...`);
+    }
+    console.log('  Validating API key...');
+    const valid = await validateKey(apiKey);
+    if (!valid) {
+        console.error('  Error: API key validation failed.');
+        process.exit(1);
+    }
+    console.log('  Key validated against api.greprag.com');
+    const changes = [];
+    writeGrepragEnv(apiKey);
+    changes.push('Wrote ~/.greprag/.env for Codex hooks');
+    await cacheIdentity(apiKey);
+    const anchor = (0, project_anchor_1.ensureAnchor)(process.cwd());
+    if (anchor.source === 'git') {
+        changes.push(`Project anchor: ${anchor.projectName} (${anchor.projectId.slice(0, 8)}) — derived from git history`);
+    }
+    else {
+        changes.push(`Project anchor: ${anchor.projectName} (${anchor.projectId.slice(0, 8)}) — stored in .greprag/project.json`);
+        const gitignoreResult = ensureAnchorTrackable(process.cwd());
+        if (gitignoreResult)
+            changes.push(gitignoreResult);
+    }
+    const globalAnchor = (0, project_anchor_1.ensureGlobalAnchor)();
+    changes.push(`Global anchor: ${globalAnchor.projectName} (${globalAnchor.projectId.slice(0, 8)})`);
+    writeProjectPath(anchor.projectName, process.cwd());
+    changes.push(`Registered repo path for ${anchor.projectName} → ~/.greprag/projects.json`);
+    const codexSkill = installCoreSkill('codex');
+    if (codexSkill)
+        changes.push(`Skill: installed → ${codexSkill}`);
+    try {
+        const res = await fetch(`${API_URL}/v1/inbox/projects/register`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ project_id: anchor.projectId, project_name: anchor.projectName }),
+        });
+        const reg = await res.json();
+        changes.push(reg.ok ? 'Project registered for inbox addressing' : `Inbox registration: ${reg.error || 'failed'}`);
+    }
+    catch {
+        changes.push('Inbox registration skipped (network)');
+    }
+    const hooksPath = getCodexHooksPath();
+    const hooks = readCodexHooks(hooksPath);
+    const hookChanges = applyCodexHooks(hooks);
+    writeCodexHooks(hooksPath, hooks);
+    changes.push(...hookChanges);
+    const startup = (0, codex_1.codexStartupInfo)();
+    if (startup.installed) {
+        changes.push(`Codex live inbox startup watcher already installed (${startup.path})`);
+    }
+    else if (process.stdin.isTTY) {
+        const answer = (await prompt('  Install Codex live inbox watcher at login? (Y/n): ')).trim().toLowerCase();
+        if (!answer || answer === 'y' || answer === 'yes') {
+            (0, codex_1.installCodexStartup)();
+            changes.push(`Codex live inbox startup watcher installed (${startup.path})`);
+        }
+        else {
+            changes.push('Codex live inbox startup watcher skipped (run `greprag codex startup install` later)');
+        }
+    }
+    else {
+        changes.push('Codex live inbox startup watcher not installed (run `greprag codex startup install`)');
+    }
+    console.log('\n  Setup complete!\n');
+    for (const change of changes) {
+        console.log(`    - ${change}`);
+    }
+    console.log(`\n  Codex hooks file: ${hooksPath}`);
+    console.log(`  Project anchor: ${anchor.anchorPath}`);
+    console.log('  In Codex, run /hooks and trust the GrepRAG hook definitions.');
+    console.log('  For live inbox push, run: greprag codex startup install');
+    console.log('  Memory hooks will activate on your next Codex session.\n');
+}
 /** greprag init --global
- *  Creates ~/.claude/project.json with a stable UUID.
+ *  Creates ~/.greprag/project.json with a stable UUID.
  *  Designed for Cowork / any agent session whose cwd has no repo-level anchor.
  *  Idempotent — safe to run again; returns the existing anchor if already present. */
 async function runGlobalInit(name) {
@@ -356,7 +559,7 @@ async function runGlobalInit(name) {
 }
 /** greprag init --all
  *  Bulk-register every git repo at depth 1 under a scan root (default: parent
- *  of cwd). Per-repo work: ensureAnchor (writes .claude/project.json or relies
+ *  of cwd). Per-repo work: ensureAnchor (writes .greprag/project.json or relies
  *  on the git-derived cascade), writeProjectPath (~/.greprag/projects.json),
  *  inbox registration (so `send --to <name>@.../<project-name>` resolves), and
  *  gitignore patch when the anchor file is load-bearing for identity.
@@ -367,11 +570,9 @@ async function runGlobalInit(name) {
 async function runInitAll(rootPath) {
     console.log('\n  greprag init --all — Register every git repo for inbox addressing\n');
     // 1. Existing API key required.
-    const settingsPath = getSettingsPath();
-    const settings = readSettings(settingsPath);
-    const apiKey = settings.env?.GREPRAG_API_KEY;
+    const apiKey = readSharedApiKey();
     if (!apiKey) {
-        console.error('  Error: no GREPRAG_API_KEY in ~/.claude/settings.json.');
+        console.error('  Error: no GREPRAG_API_KEY in ~/.greprag/.env or ~/.claude/settings.json.');
         console.error('  Run `greprag init` once to set up the key + hooks, then re-run init --all.');
         process.exit(1);
     }
@@ -587,6 +788,10 @@ function getSettingsPath() {
     const home = process.env.HOME || process.env.USERPROFILE || '';
     return path.join(home, '.claude', 'settings.json');
 }
+function getGrepragEnvPath() {
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    return path.join(home, '.greprag', '.env');
+}
 function readSettings(settingsPath) {
     try {
         const raw = fs.readFileSync(settingsPath, 'utf-8');
@@ -603,6 +808,221 @@ function writeSettings(settingsPath, settings) {
     }
     fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
 }
+function writeGrepragEnv(apiKey) {
+    const file = getGrepragEnvPath();
+    const dir = path.dirname(file);
+    let existing = {};
+    try {
+        const raw = fs.readFileSync(file, 'utf-8');
+        for (const line of raw.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const idx = trimmed.indexOf('=');
+            if (idx < 1)
+                continue;
+            existing[trimmed.slice(0, idx)] = trimmed.slice(idx + 1);
+        }
+    }
+    catch { /* missing — write fresh */ }
+    existing.GREPRAG_API_KEY = apiKey;
+    existing.MEMORY_HOOK_ENABLED = 'true';
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    const body = Object.entries(existing)
+        .map(([k, v]) => `${k}=${v}`)
+        .join('\n') + '\n';
+    fs.writeFileSync(file, body);
+}
+function readEnvFile(file) {
+    const out = {};
+    try {
+        const raw = fs.readFileSync(file, 'utf-8');
+        for (const line of raw.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const idx = trimmed.indexOf('=');
+            if (idx < 1)
+                continue;
+            let value = trimmed.slice(idx + 1).trim();
+            if ((value.startsWith('"') && value.endsWith('"')) ||
+                (value.startsWith("'") && value.endsWith("'"))) {
+                value = value.slice(1, -1);
+            }
+            out[trimmed.slice(0, idx).trim()] = value;
+        }
+    }
+    catch { /* missing env file */ }
+    return out;
+}
+function readSharedApiKey() {
+    return process.env.GREPRAG_API_KEY
+        || readEnvFile(getGrepragEnvPath()).GREPRAG_API_KEY
+        || readSettings(getSettingsPath()).env?.GREPRAG_API_KEY;
+}
+async function cacheIdentity(apiKey) {
+    try {
+        const { fetchIdentity, writeCache } = await Promise.resolve().then(() => __importStar(require('./identity')));
+        const home = process.env.HOME || process.env.USERPROFILE || '';
+        const cachePath = path.join(home, '.greprag', 'identity.json');
+        const ident = await fetchIdentity('https://api.greprag.com', apiKey);
+        writeCache(cachePath, ident);
+        if (ident.handle)
+            console.log(`  Identity:        ${ident.handle}`);
+    }
+    catch (e) {
+        console.log(`  Identity cache deferred (${e.message})`);
+    }
+}
+function getSkillRoot() {
+    return path.join(__dirname, '../../skill');
+}
+function skillTargetRoot(target) {
+    const dir = target === 'codex' ? '.codex' : '.claude';
+    return path.join(os.homedir(), dir, 'skills');
+}
+function installCoreSkill(target) {
+    const srcDir = path.join(getSkillRoot(), 'greprag');
+    if (!fs.existsSync(srcDir))
+        return null;
+    const destDir = path.join(skillTargetRoot(target), 'greprag');
+    copySkillDir(srcDir, destDir);
+    return destDir;
+}
+function getCodexHooksPath() {
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    return path.join(home, '.codex', 'hooks.json');
+}
+function readCodexHooks(hooksPath) {
+    try {
+        const raw = fs.readFileSync(hooksPath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+function writeCodexHooks(hooksPath, hooks) {
+    const dir = path.dirname(hooksPath);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(hooksPath, JSON.stringify(hooks, null, 2) + '\n');
+}
+function applyCodexHooks(config) {
+    const changes = [];
+    if (!config.hooks)
+        config.hooks = {};
+    const recapHook = {
+        matcher: 'startup|resume|clear|compact',
+        hooks: [{
+                type: 'command',
+                command: 'greprag-hook recap',
+                timeout: 3,
+                statusMessage: 'Loading GrepRAG memory',
+            }],
+    };
+    if (!hasGrepragHookWithMatcher(config.hooks.SessionStart, 'recap', recapHook.matcher)) {
+        if (!config.hooks.SessionStart)
+            config.hooks.SessionStart = [];
+        config.hooks.SessionStart.push(recapHook);
+        changes.push('Added Codex SessionStart hook (memory recap)');
+    }
+    else {
+        changes.push('Codex SessionStart recap hook already configured (skipped)');
+    }
+    const sessionHook = {
+        matcher: 'startup|resume|clear|compact',
+        hooks: [{
+                type: 'command',
+                command: 'greprag-hook session-id',
+                timeout: 3,
+                statusMessage: 'Loading GrepRAG session id',
+            }],
+    };
+    if (!hasGrepragHookWithMatcher(config.hooks.SessionStart, 'session-id', sessionHook.matcher)) {
+        if (!config.hooks.SessionStart)
+            config.hooks.SessionStart = [];
+        config.hooks.SessionStart.push(sessionHook);
+        changes.push('Added Codex SessionStart hook (session-id awareness)');
+    }
+    else {
+        changes.push('Codex SessionStart session-id hook already configured (skipped)');
+    }
+    const notifyHook = {
+        matcher: '',
+        hooks: [{
+                type: 'command',
+                command: 'greprag-hook codex-notify',
+                timeout: 3,
+                statusMessage: 'Checking GrepRAG inbox',
+            }],
+    };
+    if (!hasGrepragHook(config.hooks.UserPromptSubmit, 'codex-notify')) {
+        if (!config.hooks.UserPromptSubmit)
+            config.hooks.UserPromptSubmit = [];
+        config.hooks.UserPromptSubmit.push(notifyHook);
+        changes.push('Added Codex UserPromptSubmit hook (prompt cache + inbox steering)');
+    }
+    else {
+        changes.push('Codex UserPromptSubmit hook already configured (skipped)');
+    }
+    const inboxHook = {
+        matcher: '',
+        hooks: [{
+                type: 'command',
+                command: 'greprag-hook codex-inbox',
+                timeout: 3,
+                statusMessage: 'Checking GrepRAG inbox',
+            }],
+    };
+    if (!hasGrepragHook(config.hooks.PostToolUse, 'codex-inbox')) {
+        if (!config.hooks.PostToolUse)
+            config.hooks.PostToolUse = [];
+        config.hooks.PostToolUse.push(inboxHook);
+        changes.push('Added Codex PostToolUse hook (inbox steering)');
+    }
+    else {
+        changes.push('Codex PostToolUse inbox hook already configured (skipped)');
+    }
+    const storeHook = {
+        matcher: '',
+        hooks: [{
+                type: 'command',
+                command: 'greprag-hook codex-store',
+                timeout: 10,
+                statusMessage: 'Storing GrepRAG turn',
+            }],
+    };
+    if (!hasGrepragHook(config.hooks.Stop, 'codex-store')) {
+        if (!config.hooks.Stop)
+            config.hooks.Stop = [];
+        config.hooks.Stop.push(storeHook);
+        changes.push('Added Codex Stop hook (memory store)');
+    }
+    else {
+        changes.push('Codex Stop hook already configured (skipped)');
+    }
+    const postCompactHook = {
+        matcher: 'manual|auto',
+        hooks: [{
+                type: 'command',
+                command: 'greprag-hook session-id',
+                timeout: 3,
+                statusMessage: 'Restoring GrepRAG session id',
+            }],
+    };
+    if (!hasGrepragHookWithMatcher(config.hooks.PostCompact, 'session-id', postCompactHook.matcher)) {
+        if (!config.hooks.PostCompact)
+            config.hooks.PostCompact = [];
+        config.hooks.PostCompact.push(postCompactHook);
+        changes.push('Added Codex PostCompact hook (session-id awareness)');
+    }
+    else {
+        changes.push('Codex PostCompact session-id hook already configured (skipped)');
+    }
+    return changes;
+}
 function applySettings(settings, apiKey) {
     const changes = [];
     // Env vars
@@ -812,14 +1232,14 @@ function patchGlobalClaudeMd() {
     return true;
 }
 // -- Anchor trackability ----------------------------------------------------
-/** When a repo gitignores `.claude/`, the anchor file we just wrote won't
+/** When a repo gitignores `.greprag/`, the anchor file we just wrote won't
  *  survive a fresh clone or worktree switch — the deterministic-hash fallback
  *  will silently take over, splitting the project_id and breaking inbox
  *  addressing. Detect that case at init time and patch the gitignore so the
  *  anchor is durably tracked.
  *
- *  Common patterns we handle: `.claude/`, `.claude`, `/.claude/`, `/.claude`.
- *  Each is rewritten to its `*`-contents form so a `!.claude/project.json`
+ *  Common patterns we handle: `.greprag/`, `.greprag`, `/.greprag/`, `/.greprag`.
+ *  Each is rewritten to its `*`-contents form so a `!.greprag/project.json`
  *  re-include works (git won't descend into an excluded directory, so the
  *  trailing-slash directory pattern must become a contents-only pattern).
  *
@@ -838,7 +1258,7 @@ function ensureAnchorTrackable(projectRoot) {
     // 1 when not ignored. Either non-zero exit means "no work to do."
     let checkOutput;
     try {
-        checkOutput = (0, child_process_1.execSync)('git check-ignore -v .claude/project.json', {
+        checkOutput = (0, child_process_1.execSync)('git check-ignore -v .greprag/project.json', {
             cwd: projectRoot,
             encoding: 'utf-8',
             stdio: ['pipe', 'pipe', 'pipe'],
@@ -862,7 +1282,7 @@ function ensureAnchorTrackable(projectRoot) {
         return null;
     const trimmed = pattern.trim();
     const dirPatterns = new Set([
-        '.claude/', '.claude', '/.claude/', '/.claude',
+        '.greprag/', '.greprag', '/.greprag/', '/.greprag',
     ]);
     if (dirPatterns.has(trimmed)) {
         // Preserve leading slash if present in the original pattern.
@@ -871,13 +1291,13 @@ function ensureAnchorTrackable(projectRoot) {
         // Replace the single directory-ignore line with the contents-ignore form
         // plus the re-include for project.json. Git evaluates patterns in order
         // and re-includes override later, so the order matters: `*` first, then `!`.
-        lines.splice(lineNum - 1, 1, `${prefix}.claude/*`, `!${prefix}.claude/project.json`);
+        lines.splice(lineNum - 1, 1, `${prefix}.greprag/*`, `!${prefix}.greprag/project.json`);
         fs.writeFileSync(gitignorePath, lines.join('\n'));
-        return `Patched ${gitignoreRel}: \`${trimmed}\` → \`${prefix}.claude/*\` + \`!${prefix}.claude/project.json\` (anchor now trackable)`;
+        return `Patched ${gitignoreRel}: \`${trimmed}\` -> \`${prefix}.greprag/*\` + \`!${prefix}.greprag/project.json\` (anchor now trackable)`;
     }
     // Unrecognized pattern — don't risk breaking the user's other intent. Tell
     // them what to do manually.
-    return `WARNING: .claude/project.json is ignored by \`${pattern}\` in ${gitignoreRel}. The anchor won't survive a fresh clone. Add \`!.claude/project.json\` after that line manually, or run \`git add -f .claude/project.json\` to force-track it once.`;
+    return `WARNING: .greprag/project.json is ignored by \`${pattern}\` in ${gitignoreRel}. The anchor won't survive a fresh clone. Add \`!.greprag/project.json\` after that line manually, or run \`git add -f .greprag/project.json\` to force-track it once.`;
 }
 // -- Input ------------------------------------------------------------------
 /** Recursively copy a skill directory from the package bundle into