iranti 0.3.11 → 0.3.13

package/README.md

@@ -1,19 +1,21 @@
 # Iranti
 
 [![License: AGPL-3.0](https://img.shields.io/badge/License-AGPL--3.0-blue.svg)](https://www.gnu.org/licenses/agpl-3.0.en.html)
+[![MCP Server](https://img.shields.io/badge/MCP-server-purple.svg)](https://modelcontextprotocol.io)
+[![npm](https://img.shields.io/badge/npm-iranti-red.svg)](https://www.npmjs.com/package/iranti)
 [![Python](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
 [![TypeScript](https://img.shields.io/badge/typescript-5.0+-blue.svg)](https://www.typescriptlang.org/)
 [![CrewAI Compatible](https://img.shields.io/badge/CrewAI-compatible-green.svg)](https://www.crewai.com/)
 
-**Memory infrastructure for multi-agent AI systems.**
+**Memory infrastructure for multi-agent AI systems — with a built-in MCP server.**
 
 Iranti gives agents persistent, identity-based memory. Facts written by one agent are retrievable by any other agent through exact entity+key lookup. Iranti also supports hybrid search (lexical + vector) when exact keys are unknown. Memory persists across sessions and survives context window limits.
 
-**Repo version:** `0.3.4`  
+**Repo version:** `0.3.11`
 Published packages:
-- npm `iranti@0.3.4`
-- npm `@iranti/sdk@0.3.4`
-- PyPI `iranti==0.3.4`
+- npm `iranti@0.3.11`
+- npm `@iranti/sdk@0.3.11`
+- PyPI `iranti==0.3.11`
 
 ---
 
@@ -23,6 +25,32 @@ Iranti is a knowledge base for multi-agent systems. The primary read path is ide
 
 ---
 
+## MCP Server
+
+Iranti ships a stdio MCP server compatible with Claude Code, GitHub Copilot, Codex, and any MCP-compliant client:
+
+```bash
+# Fast path for Claude Code
+iranti claude-setup
+
+# Fast path for Codex
+iranti codex-setup
+
+# Fast path for GitHub Copilot
+iranti copilot-setup
+
+# Manual / other MCP clients
+iranti mcp
+```
+
+MCP tools exposed: `iranti_handshake`, `iranti_attend`, `iranti_write`, `iranti_query`, `iranti_search`, `iranti_checkpoint`, `iranti_ingest`, `iranti_relate`, `iranti_related`, `iranti_related_deep`, `iranti_history`, `iranti_who_knows`, `iranti_observe`, and more.
+
+Full setup guides:
+- [Claude Code](docs/guides/claude-code.md)
+- [Codex](docs/guides/codex.md)
+
+---
+
 ## Runtime Roles
 
 - **User**: Person who interacts with an app or chatbot built on Iranti.

package/dist/scripts/claude-code-memory-hook.js

@@ -315,7 +315,9 @@ function emitHookContext(event, additionalContext) {
             additionalContext,
         },
     };
-    process.stdout.write(`${JSON.stringify(payload)}\n`);
+    // Use synchronous write to fd 1 to avoid libuv UV_HANDLE_CLOSING assertion
+    // on Windows when Node exits while an async stdout write is still pending.
+    require('fs').writeSync(1, `${JSON.stringify(payload)}\n`);
 }
 function shouldFetchMemory(prompt) {
     const normalized = prompt.trim();

package/dist/scripts/codex-setup.js

@@ -364,6 +364,147 @@ function writeWorkspaceVsCodeMcpFile(projectEnv, options) {
     }, null, 2)}\n`, 'utf8');
     return { filePath: mcpFile, status: 'updated' };
 }
+/**
+ * Protocol reminder hook script content for Codex UserPromptSubmit.
+ * Same content as the Claude Code version — fires before every user prompt.
+ */
+function buildProtocolReminderHookScript() {
+    return [
+        '#!/usr/bin/env node',
+        "'use strict';",
+        '// Iranti protocol reminder hook — fires on UserPromptSubmit for any Iranti project.',
+        '// Cross-platform: runs on Windows, macOS, Linux via Node.js.',
+        '// Exits cleanly with no output for non-Iranti projects.',
+        "const fs = require('fs');",
+        "const path = require('path');",
+        '',
+        "const envFile = path.join(process.cwd(), '.env.iranti');",
+        'if (!fs.existsSync(envFile)) process.exit(0);',
+        '',
+        'const content = [',
+        "  'IRANTI PROTOCOL (required this turn):',",
+        "  '1. iranti_attend(phase=pre-response) BEFORE replying',",
+        "  '2. iranti_attend BEFORE each Read / Grep / Glob / Bash / WebSearch / WebFetch',",
+        "  '3. iranti_write AFTER each Edit or Write:',",
+        "  '   entity: project/[id]/file/[filename] -- not the broad project entity',",
+        "  '   value must include: absolutePath, lines, before, after, verify, why',",
+        "  '4. iranti_write AFTER each Bash that reveals system state (build, errors, ports, env)',",
+        "  '5. iranti_write AFTER each WebSearch/WebFetch -- write findings AND dead ends / 404s',",
+        "  '6. iranti_attend(phase=post-response) AFTER every response without exception',",
+        "].join('\\n') + '\\n';",
+        "require('fs').writeSync(1, content);",
+        '',
+    ].join('\n');
+}
+/**
+ * Write the protocol-reminder hook script into the project's .codex/ directory
+ * and return a status result matching the workspace file pattern.
+ */
+function writeProtocolReminderHook(projectEnv) {
+    const projectPath = node_path_1.default.dirname(projectEnv);
+    const codexDir = node_path_1.default.join(projectPath, '.codex');
+    const hookFile = node_path_1.default.join(codexDir, 'iranti-protocol-hook.js');
+    const hookContent = buildProtocolReminderHookScript();
+    node_fs_1.default.mkdirSync(codexDir, { recursive: true });
+    if (!node_fs_1.default.existsSync(hookFile)) {
+        node_fs_1.default.writeFileSync(hookFile, hookContent, 'utf8');
+        return { filePath: hookFile, status: 'created' };
+    }
+    const existing = node_fs_1.default.readFileSync(hookFile, 'utf8');
+    if (existing !== hookContent) {
+        node_fs_1.default.writeFileSync(hookFile, hookContent, 'utf8');
+        return { filePath: hookFile, status: 'updated' };
+    }
+    return { filePath: hookFile, status: 'unchanged' };
+}
+/**
+ * Write a .codex/hooks.json referencing the protocol-reminder hook.
+ * This fires on UserPromptSubmit when the codex_hooks feature is enabled.
+ */
+function writeCodexHooksConfig(projectEnv) {
+    const projectPath = node_path_1.default.dirname(projectEnv);
+    const codexDir = node_path_1.default.join(projectPath, '.codex');
+    const hooksConfigFile = node_path_1.default.join(codexDir, 'hooks.json');
+    const hookScriptPath = node_path_1.default.join(codexDir, 'iranti-protocol-hook.js');
+    const hooksConfig = {
+        hooks: {
+            UserPromptSubmit: [
+                {
+                    matcher: '',
+                    hooks: [
+                        {
+                            type: 'command',
+                            command: `node ${hookScriptPath.replace(/\\/g, '/')}`,
+                        },
+                    ],
+                },
+            ],
+        },
+    };
+    node_fs_1.default.mkdirSync(codexDir, { recursive: true });
+    const nextContent = `${JSON.stringify(hooksConfig, null, 2)}\n`;
+    if (!node_fs_1.default.existsSync(hooksConfigFile)) {
+        node_fs_1.default.writeFileSync(hooksConfigFile, nextContent, 'utf8');
+        return { filePath: hooksConfigFile, status: 'created' };
+    }
+    const existing = node_fs_1.default.readFileSync(hooksConfigFile, 'utf8');
+    if (existing === nextContent) {
+        return { filePath: hooksConfigFile, status: 'unchanged' };
+    }
+    // Merge: keep existing hooks, add/replace UserPromptSubmit from iranti.
+    try {
+        const parsed = JSON.parse(existing);
+        const existingHooks = parsed.hooks && typeof parsed.hooks === 'object' && !Array.isArray(parsed.hooks)
+            ? parsed.hooks
+            : {};
+        const merged = {
+            ...parsed,
+            hooks: {
+                ...existingHooks,
+                UserPromptSubmit: hooksConfig.hooks.UserPromptSubmit,
+            },
+        };
+        const mergedContent = `${JSON.stringify(merged, null, 2)}\n`;
+        if (mergedContent === existing) {
+            return { filePath: hooksConfigFile, status: 'unchanged' };
+        }
+        node_fs_1.default.writeFileSync(hooksConfigFile, mergedContent, 'utf8');
+        return { filePath: hooksConfigFile, status: 'updated' };
+    }
+    catch {
+        // Can't parse existing — overwrite
+        node_fs_1.default.writeFileSync(hooksConfigFile, nextContent, 'utf8');
+        return { filePath: hooksConfigFile, status: 'updated' };
+    }
+}
+/**
+ * Check if the codex_hooks feature is enabled globally.
+ */
+function isCodexHooksFeatureEnabled(repoRoot) {
+    try {
+        const output = run('codex', ['features', 'list'], repoRoot);
+        const match = output.match(/codex_hooks\s+\S+\s+(true|false)/);
+        return match?.[1] === 'true';
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Enable the codex_hooks feature flag if not already enabled.
+ */
+function ensureCodexHooksFeature(repoRoot) {
+    if (isCodexHooksFeatureEnabled(repoRoot)) {
+        return true;
+    }
+    try {
+        run('codex', ['features', 'enable', 'codex_hooks'], repoRoot);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function canUseInstalledIranti(repoRoot) {
     try {
         run('iranti', ['mcp', '--help'], repoRoot);
@@ -428,8 +569,12 @@ async function main() {
             vscode: writeWorkspaceVsCodeMcpFile(workspaceProjectEnv, options),
             agents: writeWorkspaceAgentsFile(workspaceProjectEnv),
             irantiMd: writeWorkspaceIrantiMdFile(workspaceProjectEnv),
+            protocolHook: writeProtocolReminderHook(workspaceProjectEnv),
+            hooksConfig: writeCodexHooksConfig(workspaceProjectEnv),
         }
         : null;
+    // Enable the codex_hooks feature flag so the UserPromptSubmit hook fires.
+    const hooksFeatureEnabled = ensureCodexHooksFeature(repoRoot);
     const registered = run('codex', ['mcp', 'get', options.name], repoRoot);
     console.log(registered);
     console.log('');
@@ -468,6 +613,9 @@ async function main() {
             console.log(`Workspace .vscode/mcp.json: ${workspaceFilesResult.vscode.status} (${workspaceFilesResult.vscode.filePath})`);
             console.log(`Workspace AGENTS.md: ${workspaceFilesResult.agents.status} (${workspaceFilesResult.agents.filePath})`);
             console.log(`Workspace IRANTI.md: ${workspaceFilesResult.irantiMd.status} (${workspaceFilesResult.irantiMd.filePath})`);
+            console.log(`Protocol hook: ${workspaceFilesResult.protocolHook.status} (${workspaceFilesResult.protocolHook.filePath})`);
+            console.log(`Hooks config: ${workspaceFilesResult.hooksConfig.status} (${workspaceFilesResult.hooksConfig.filePath})`);
+            console.log(`codex_hooks feature: ${hooksFeatureEnabled ? 'enabled' : 'not enabled (UserPromptSubmit hook requires codex_hooks feature)'}`);
             const closeout = await (0, scaffoldCloseout_1.writeProjectScaffoldCloseout)({
                 tool: 'codex',
                 projectPath: node_path_1.default.dirname(boundProjectEnv),
@@ -477,6 +625,8 @@ async function main() {
                     { path: workspaceFilesResult.vscode.filePath, status: workspaceFilesResult.vscode.status },
                     { path: workspaceFilesResult.agents.filePath, status: workspaceFilesResult.agents.status },
                     { path: workspaceFilesResult.irantiMd.filePath, status: workspaceFilesResult.irantiMd.status },
+                    { path: workspaceFilesResult.protocolHook.filePath, status: workspaceFilesResult.protocolHook.status },
+                    { path: workspaceFilesResult.hooksConfig.filePath, status: workspaceFilesResult.hooksConfig.status },
                 ],
                 agentId: options.agent || 'codex_code',
             });

package/dist/scripts/iranti-cli.js

@@ -2231,6 +2231,218 @@ function makeClaudeHookEntry(event, projectEnvPath) {
         ],
     };
 }
+function makeClaudeWriteGuardHookEntry(hookScriptDir) {
+    return {
+        matcher: 'Edit|Write',
+        hooks: [
+            {
+                type: 'command',
+                command: `node ${quoteClaudeHookArg(path_1.default.join(hookScriptDir, 'iranti-write-guard-hook.js'))}`,
+            },
+        ],
+    };
+}
+function makeClaudeEditTrackerHookEntry(hookScriptDir) {
+    return {
+        matcher: 'Edit|Write',
+        hooks: [
+            {
+                type: 'command',
+                command: `node ${quoteClaudeHookArg(path_1.default.join(hookScriptDir, 'iranti-edit-tracker-hook.js'))}`,
+            },
+        ],
+    };
+}
+/**
+ * Embedded JS content for the write-guard hook (PreToolUse).
+ * Blocks Edit/Write if the agent has pending unwritten edits in .iranti-write-debt.
+ */
+function buildWriteGuardHookScript() {
+    return `#!/usr/bin/env node
+'use strict';
+// Iranti write-guard hook — fires on PreToolUse for Edit/Write.
+// Checks whether the agent has pending unwritten edits by querying the
+// .iranti-write-debt signal file. If the agent edited files without calling
+// iranti_write, this hook DENIES the next edit and injects a reminder.
+//
+// Falls through silently (allows) for non-Iranti projects or if check fails.
+const fs = require('fs');
+const path = require('path');
+
+const envFile = path.join(process.cwd(), '.env.iranti');
+if (!fs.existsSync(envFile)) {
+    process.exit(0);
+}
+
+let input = '';
+try {
+    input = fs.readFileSync(0, 'utf8');
+} catch {
+    process.exit(0);
+}
+
+let hookData;
+try {
+    hookData = JSON.parse(input);
+} catch {
+    process.exit(0);
+}
+
+const toolName = hookData.tool_name || hookData.toolName || '';
+if (toolName !== 'Edit' && toolName !== 'Write') {
+    process.exit(0);
+}
+
+const signalFile = path.join(process.cwd(), '.iranti-write-debt');
+if (!fs.existsSync(signalFile)) {
+    process.exit(0);
+}
+
+let debt;
+try {
+    debt = JSON.parse(fs.readFileSync(signalFile, 'utf8'));
+} catch {
+    process.exit(0);
+}
+
+const pendingEdits = debt.pendingEdits || 0;
+const lastEditAt = debt.lastEditAt || null;
+
+if (pendingEdits < 1) {
+    process.exit(0);
+}
+
+const output = JSON.stringify({
+    hookEventName: 'PreToolUse',
+    permissionDecision: 'deny',
+    permissionDecisionReason: \`Iranti write-guard: \${pendingEdits} file edit(s) since last iranti_write (last edit: \${lastEditAt || 'unknown'}). Call iranti_write for each pending edit before making new changes.\`,
+    additionalContext: [
+        'IRANTI WRITE-GUARD BLOCKED THIS EDIT.',
+        \`You have \${pendingEdits} pending file edit(s) that have not been written to Iranti shared memory.\`,
+        'Before making any more edits, you MUST call iranti_write for each pending edit.',
+        'Include: entity (project/[id]/file/[filename]), absolutePath, lines changed, what changed and why.',
+        'After writing all pending edits, this guard will allow new edits.',
+    ].join('\\n'),
+});
+
+require('fs').writeSync(1, output);
+`;
+}
+/**
+ * Embedded JS content for the edit-tracker hook (PostToolUse).
+ * Increments the .iranti-write-debt counter after each Edit/Write.
+ */
+function buildEditTrackerHookScript() {
+    return `#!/usr/bin/env node
+'use strict';
+// Iranti edit-tracker hook — fires on PostToolUse for Edit/Write.
+// Increments the write-debt counter so the PreToolUse write-guard knows
+// the agent has pending unwritten edits.
+//
+// The write-debt file (.iranti-write-debt) is cleared by the MCP server
+// when iranti_write is called, completing the enforcement loop.
+//
+// Falls through silently for non-Iranti projects.
+const fs = require('fs');
+const path = require('path');
+
+const envFile = path.join(process.cwd(), '.env.iranti');
+if (!fs.existsSync(envFile)) {
+    process.exit(0);
+}
+
+let input = '';
+try {
+    input = fs.readFileSync(0, 'utf8');
+} catch {
+    process.exit(0);
+}
+
+let hookData;
+try {
+    hookData = JSON.parse(input);
+} catch {
+    process.exit(0);
+}
+
+const toolName = hookData.tool_name || hookData.toolName || '';
+if (toolName !== 'Edit' && toolName !== 'Write') {
+    process.exit(0);
+}
+
+const signalFile = path.join(process.cwd(), '.iranti-write-debt');
+let debt = { pendingEdits: 0, edits: [] };
+
+try {
+    if (fs.existsSync(signalFile)) {
+        debt = JSON.parse(fs.readFileSync(signalFile, 'utf8'));
+    }
+} catch {
+    debt = { pendingEdits: 0, edits: [] };
+}
+
+const editedFile = hookData.tool_input?.file_path
+    || hookData.input?.file_path
+    || hookData.tool_input?.filePath
+    || hookData.input?.filePath
+    || 'unknown';
+
+debt.pendingEdits = (debt.pendingEdits || 0) + 1;
+debt.lastEditAt = new Date().toISOString();
+debt.edits = debt.edits || [];
+debt.edits.push({
+    file: editedFile,
+    at: debt.lastEditAt,
+});
+
+if (debt.edits.length > 20) {
+    debt.edits = debt.edits.slice(-20);
+}
+
+try {
+    fs.writeFileSync(signalFile, JSON.stringify(debt, null, 2), 'utf8');
+} catch {
+    // Can't write signal — that's okay, guard just won't fire
+}
+
+const output = JSON.stringify({
+    hookEventName: 'PostToolUse',
+    additionalContext: \`Iranti: file edited (\${path.basename(editedFile)}). \${debt.pendingEdits} pending edit(s) awaiting iranti_write. Write before making more edits.\`,
+});
+
+require('fs').writeSync(1, output);
+`;
+}
+/**
+ * Embedded JS content for the Codex/generic protocol reminder hook (UserPromptSubmit).
+ * Injects a protocol reminder before every user prompt in Codex sessions.
+ */
+function buildProtocolReminderHookScript() {
+    return `#!/usr/bin/env node
+'use strict';
+// Iranti protocol reminder hook — fires on UserPromptSubmit for any Iranti project.
+// Cross-platform: runs on Windows, macOS, Linux via Node.js.
+// Exits cleanly with no output for non-Iranti projects.
+const fs = require('fs');
+const path = require('path');
+
+const envFile = path.join(process.cwd(), '.env.iranti');
+if (!fs.existsSync(envFile)) process.exit(0);
+
+const content = [
+  'IRANTI PROTOCOL (required this turn):',
+  '1. iranti_attend(phase=pre-response) BEFORE replying',
+  '2. iranti_attend BEFORE each Read / Grep / Glob / Bash / WebSearch / WebFetch',
+  '3. iranti_write AFTER each Edit or Write:',
+  '   entity: project/[id]/file/[filename] -- not the broad project entity',
+  '   value must include: absolutePath, lines, before, after, verify, why',
+  '4. iranti_write AFTER each Bash that reveals system state (build, errors, ports, env)',
+  '5. iranti_write AFTER each WebSearch/WebFetch -- write findings AND dead ends / 404s',
+  '6. iranti_attend(phase=post-response) AFTER every response without exception',
+].join('\\n') + '\\n';
+require('fs').writeSync(1, content);
+`;
+}
 const IRANTI_CLAUDE_ALLOWED_TOOLS = [
     'mcp__iranti__iranti_handshake',
     'mcp__iranti__iranti_attend',
@@ -2267,6 +2479,7 @@ function needsClaudeHookSettingsUpgrade(value) {
     if (!hooks) {
         return false;
     }
+    // Legacy hook format detection — upgrade needed if old-style entries exist.
     for (const event of ['SessionStart', 'UserPromptSubmit', 'Stop']) {
         const entries = hooks[event];
         if (!Array.isArray(entries) || entries.length === 0) {
@@ -2276,6 +2489,13 @@ function needsClaudeHookSettingsUpgrade(value) {
             return true;
         }
     }
+    // Write-guard hooks missing — upgrade needed to add PreToolUse/PostToolUse.
+    if (!Array.isArray(hooks.PreToolUse) || hooks.PreToolUse.length === 0) {
+        return true;
+    }
+    if (!Array.isArray(hooks.PostToolUse) || hooks.PostToolUse.length === 0) {
+        return true;
+    }
     return false;
 }
 function mergeClaudePermissionAllowList(existing) {
@@ -2295,7 +2515,7 @@ function mergeClaudePermissionAllowList(existing) {
         allow,
     };
 }
-function makeClaudeHookSettings(projectEnvPath, existing) {
+function makeClaudeHookSettings(projectEnvPath, existing, hookScriptDir) {
     const existingHooks = existing && isClaudeHooksObject(existing.hooks)
         ? existing.hooks
         : {};
@@ -2307,6 +2527,17 @@ function makeClaudeHookSettings(projectEnvPath, existing) {
             .map((value) => String(value))
             .filter((value) => value !== 'iranti')
         : undefined;
+    const hooks = {
+        ...existingHooks,
+        SessionStart: [makeClaudeHookEntry('SessionStart', projectEnvPath)],
+        UserPromptSubmit: [makeClaudeHookEntry('UserPromptSubmit', projectEnvPath)],
+        Stop: [makeClaudeHookEntry('Stop', projectEnvPath)],
+    };
+    // Write-guard hooks: block edits until prior edits are written to Iranti.
+    if (hookScriptDir) {
+        hooks.PreToolUse = [makeClaudeWriteGuardHookEntry(hookScriptDir)];
+        hooks.PostToolUse = [makeClaudeEditTrackerHookEntry(hookScriptDir)];
+    }
     return {
         ...(existing ?? {}),
         enableAllProjectMcpServers: false,
@@ -2318,12 +2549,7 @@ function makeClaudeHookSettings(projectEnvPath, existing) {
         ...(existingEnabledMcpjsonServers
             ? { enabledMcpjsonServers: existingEnabledMcpjsonServers }
             : {}),
-        hooks: {
-            ...existingHooks,
-            SessionStart: [makeClaudeHookEntry('SessionStart', projectEnvPath)],
-            UserPromptSubmit: [makeClaudeHookEntry('UserPromptSubmit', projectEnvPath)],
-            Stop: [makeClaudeHookEntry('Stop', projectEnvPath)],
-        },
+        hooks,
     };
 }
 async function writeClaudeCodeProjectFiles(projectPath, projectEnvPath, force = false) {
@@ -2416,22 +2642,65 @@ async function writeClaudeCodeProjectFiles(projectPath, projectEnvPath, force =
     }
     const claudeDir = path_1.default.join(projectPath, '.claude');
     await ensureDir(claudeDir);
+    // Write hook scripts into .claude/ directory.
+    const writeGuardHookFile = path_1.default.join(claudeDir, 'iranti-write-guard-hook.js');
+    let writeGuardHookStatus = 'unchanged';
+    const writeGuardContent = buildWriteGuardHookScript();
+    if (!fs_1.default.existsSync(writeGuardHookFile)) {
+        await writeText(writeGuardHookFile, writeGuardContent);
+        writeGuardHookStatus = 'created';
+    }
+    else {
+        const existing = fs_1.default.readFileSync(writeGuardHookFile, 'utf8');
+        if (existing !== writeGuardContent) {
+            await writeText(writeGuardHookFile, writeGuardContent);
+            writeGuardHookStatus = 'updated';
+        }
+    }
+    const editTrackerHookFile = path_1.default.join(claudeDir, 'iranti-edit-tracker-hook.js');
+    let editTrackerHookStatus = 'unchanged';
+    const editTrackerContent = buildEditTrackerHookScript();
+    if (!fs_1.default.existsSync(editTrackerHookFile)) {
+        await writeText(editTrackerHookFile, editTrackerContent);
+        editTrackerHookStatus = 'created';
+    }
+    else {
+        const existing = fs_1.default.readFileSync(editTrackerHookFile, 'utf8');
+        if (existing !== editTrackerContent) {
+            await writeText(editTrackerHookFile, editTrackerContent);
+            editTrackerHookStatus = 'updated';
+        }
+    }
+    const protocolReminderHookFile = path_1.default.join(claudeDir, 'iranti-protocol-hook.js');
+    let protocolReminderHookStatus = 'unchanged';
+    const protocolReminderContent = buildProtocolReminderHookScript();
+    if (!fs_1.default.existsSync(protocolReminderHookFile)) {
+        await writeText(protocolReminderHookFile, protocolReminderContent);
+        protocolReminderHookStatus = 'created';
+    }
+    else {
+        const existing = fs_1.default.readFileSync(protocolReminderHookFile, 'utf8');
+        if (existing !== protocolReminderContent) {
+            await writeText(protocolReminderHookFile, protocolReminderContent);
+            protocolReminderHookStatus = 'updated';
+        }
+    }
     const settingsFile = path_1.default.join(claudeDir, 'settings.local.json');
     let settingsStatus = 'unchanged';
     if (!fs_1.default.existsSync(settingsFile)) {
-        await writeText(settingsFile, `${JSON.stringify(makeClaudeHookSettings(projectEnvPath), null, 2)}\n`);
+        await writeText(settingsFile, `${JSON.stringify(makeClaudeHookSettings(projectEnvPath, undefined, claudeDir), null, 2)}\n`);
         settingsStatus = 'created';
     }
     else {
         const existingSettings = readJsonFile(settingsFile);
         if (existingSettings && typeof existingSettings === 'object' && !Array.isArray(existingSettings)) {
             if (force || needsClaudeHookSettingsUpgrade(existingSettings)) {
-                await writeText(settingsFile, `${JSON.stringify(makeClaudeHookSettings(projectEnvPath, existingSettings), null, 2)}\n`);
+                await writeText(settingsFile, `${JSON.stringify(makeClaudeHookSettings(projectEnvPath, existingSettings, claudeDir), null, 2)}\n`);
                 settingsStatus = 'updated';
             }
         }
         else if (force) {
-            await writeText(settingsFile, `${JSON.stringify(makeClaudeHookSettings(projectEnvPath), null, 2)}\n`);
+            await writeText(settingsFile, `${JSON.stringify(makeClaudeHookSettings(projectEnvPath, undefined, claudeDir), null, 2)}\n`);
             settingsStatus = 'updated';
         }
     }
@@ -2478,6 +2747,9 @@ async function writeClaudeCodeProjectFiles(projectPath, projectEnvPath, force =
         files: [
             { path: mcpFile, status: mcpStatus },
             { path: vscodeMcpFile, status: vscodeMcpStatus },
+            { path: writeGuardHookFile, status: writeGuardHookStatus },
+            { path: editTrackerHookFile, status: editTrackerHookStatus },
+            { path: protocolReminderHookFile, status: protocolReminderHookStatus },
             { path: settingsFile, status: settingsStatus },
             { path: claudeMdFile, status: claudeMdStatus },
             { path: irantiMdFile, status: irantiMdStatus },
@@ -2490,6 +2762,9 @@ async function writeClaudeCodeProjectFiles(projectPath, projectEnvPath, force =
         settings: settingsStatus,
         claudeMd: claudeMdStatus,
         irantiMd: irantiMdStatus,
+        writeGuardHook: writeGuardHookStatus,
+        editTrackerHook: editTrackerHookStatus,
+        protocolReminderHook: protocolReminderHookStatus,
         closeout,
     };
 }
@@ -8079,13 +8354,15 @@ async function claudeSetupCommand(args) {
                 createdSettings += 1;
             if (result.settings === 'updated')
                 updatedSettings += 1;
-            if (result.mcp === 'unchanged' && result.vscodeMcp === 'unchanged' && result.settings === 'unchanged' && result.irantiMd === 'unchanged')
+            if (result.mcp === 'unchanged' && result.vscodeMcp === 'unchanged' && result.settings === 'unchanged' && result.irantiMd === 'unchanged' && result.writeGuardHook === 'unchanged' && result.editTrackerHook === 'unchanged')
                 unchanged += 1;
             console.log(`  ${projectPath}`);
-            console.log(`    mcp       ${result.mcp}`);
-            console.log(`    vscode    ${result.vscodeMcp}`);
-            console.log(`    settings  ${result.settings}`);
-            console.log(`    iranti.md ${result.irantiMd}`);
+            console.log(`    mcp          ${result.mcp}`);
+            console.log(`    vscode       ${result.vscodeMcp}`);
+            console.log(`    settings     ${result.settings}`);
+            console.log(`    iranti.md    ${result.irantiMd}`);
+            console.log(`    write-guard  ${result.writeGuardHook}`);
+            console.log(`    edit-tracker ${result.editTrackerHook}`);
         }
         console.log('');
         console.log('Summary:');
@@ -8114,19 +8391,25 @@ async function claudeSetupCommand(args) {
     }
     const result = await writeClaudeCodeProjectFiles(projectPath, projectEnvPath, force);
     console.log(`${okLabel()} Claude Code integration scaffolded`);
-    console.log(`  project   ${projectPath}`);
-    console.log(`  binding   ${projectEnvPath}`);
-    console.log(`  mcp       ${path_1.default.join(projectPath, '.mcp.json')}`);
-    console.log(`  vscode    ${path_1.default.join(projectPath, '.vscode', 'mcp.json')}`);
-    console.log(`  settings  ${path_1.default.join(projectPath, '.claude', 'settings.local.json')}`);
-    console.log(`  claude.md ${path_1.default.join(projectPath, 'CLAUDE.md')}`);
-    console.log(`  iranti.md ${path_1.default.join(projectPath, 'IRANTI.md')}`);
-    console.log(`  mcp status        ${result.mcp}`);
-    console.log(`  vscode status     ${result.vscodeMcp}`);
-    console.log(`  settings status   ${result.settings}`);
-    console.log(`  claude.md status  ${result.claudeMd}`);
-    console.log(`  iranti.md status  ${result.irantiMd}`);
-    console.log(`  memory closeout   ${result.closeout.status} (${result.closeout.detail})`);
+    console.log(`  project      ${projectPath}`);
+    console.log(`  binding      ${projectEnvPath}`);
+    console.log(`  mcp          ${path_1.default.join(projectPath, '.mcp.json')}`);
+    console.log(`  vscode       ${path_1.default.join(projectPath, '.vscode', 'mcp.json')}`);
+    console.log(`  settings     ${path_1.default.join(projectPath, '.claude', 'settings.local.json')}`);
+    console.log(`  claude.md    ${path_1.default.join(projectPath, 'CLAUDE.md')}`);
+    console.log(`  iranti.md    ${path_1.default.join(projectPath, 'IRANTI.md')}`);
+    console.log(`  write-guard  ${path_1.default.join(projectPath, '.claude', 'iranti-write-guard-hook.js')}`);
+    console.log(`  edit-tracker ${path_1.default.join(projectPath, '.claude', 'iranti-edit-tracker-hook.js')}`);
+    console.log(`  protocol     ${path_1.default.join(projectPath, '.claude', 'iranti-protocol-hook.js')}`);
+    console.log(`  mcp status           ${result.mcp}`);
+    console.log(`  vscode status        ${result.vscodeMcp}`);
+    console.log(`  settings status      ${result.settings}`);
+    console.log(`  claude.md status     ${result.claudeMd}`);
+    console.log(`  iranti.md status     ${result.irantiMd}`);
+    console.log(`  write-guard status   ${result.writeGuardHook}`);
+    console.log(`  edit-tracker status  ${result.editTrackerHook}`);
+    console.log(`  protocol status      ${result.protocolReminderHook}`);
+    console.log(`  memory closeout      ${result.closeout.status} (${result.closeout.detail})`);
     console.log(`${infoLabel()} Next: open Claude Code in this project and verify Iranti tools are available.`);
 }
 async function chatCommand(args) {