iranti 0.1.0 → 0.1.2

package/.env.example

@@ -11,27 +11,31 @@ LLM_PROVIDER_FALLBACK=openai,groq,mistral,mock
 
 # Gemini (when LLM_PROVIDER=gemini)
 GEMINI_API_KEY=
-GEMINI_MODEL=gemini-2.0-flash-001
+GEMINI_MODEL=gemini-2.5-flash
 
-# Model routing overrides (optional)
-CLASSIFICATION_MODEL=gemini-2.0-flash-001
-RELEVANCE_MODEL=gemini-2.0-flash-001
-CONFLICT_MODEL=gemini-2.5-pro
-SUMMARIZATION_MODEL=gemini-2.0-flash-001
-TASK_INFERENCE_MODEL=gemini-2.0-flash-001
-EXTRACTION_MODEL=gemini-2.0-flash-001
+# Model routing overrides (optional).
+# Leave these blank unless you intentionally pin per-task models
+# for your selected provider.
+CLASSIFICATION_MODEL=
+RELEVANCE_MODEL=
+CONFLICT_MODEL=
+SUMMARIZATION_MODEL=
+TASK_INFERENCE_MODEL=
+EXTRACTION_MODEL=
 
 # Anthropic (when LLM_PROVIDER=claude)
 ANTHROPIC_API_KEY=
+ANTHROPIC_MODEL=claude-sonnet-4
+ANTHROPIC_BASE_URL=
 
 # OpenAI (when LLM_PROVIDER=openai)
 OPENAI_API_KEY=
-OPENAI_MODEL=gpt-4o-mini
+OPENAI_MODEL=gpt-5-mini
 OPENAI_BASE_URL=https://api.openai.com/v1
 
 # Groq (when LLM_PROVIDER=groq)
 GROQ_API_KEY=
-GROQ_MODEL=llama-3.3-70b-versatile
+GROQ_MODEL=meta-llama/llama-4-scout-17b-16e-instruct
 
 # Mistral (when LLM_PROVIDER=mistral)
 MISTRAL_API_KEY=
@@ -59,5 +63,15 @@ IRANTI_ARCHIVIST_DEBOUNCE_MS=60000
 # Periodic maintenance interval; set >0 to enable (e.g. 21600000 = 6h)
 IRANTI_ARCHIVIST_INTERVAL_MS=0
 
+# Hybrid search embedding dimensions (default 256)
+IRANTI_EMBEDDING_DIM=256
+
+# Optional Claude Code / MCP integration defaults
+IRANTI_MCP_DEFAULT_AGENT=claude_code
+IRANTI_MCP_DEFAULT_SOURCE=ClaudeCode
+IRANTI_CLAUDE_AGENT_ID=
+IRANTI_CLAUDE_ENTITY_HINTS=
+IRANTI_CLAUDE_MAX_FACTS=6
+
 # Node environment
 NODE_ENV=development

package/README.md

@@ -7,13 +7,13 @@
 
 **Memory infrastructure for multi-agent AI systems.**
 
-Iranti gives agents persistent, identity-based memory. Facts written by one agent are retrievable by any other agent through exact entity+key lookup, not similarity search. Memory persists across sessions and survives context window limits.
+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.
 
 ---
 
 ## What is Iranti?
 
-Iranti is a knowledge base for multi-agent systems. Unlike vector databases that retrieve by semantic similarity, Iranti retrieves by identity — this specific entity (`project/nexus_prime`), this specific key (`deadline`), with confidence attached. When Agent A writes a fact, Agent B can retrieve it by exact lookup without being told it exists. Facts persist in PostgreSQL and survive context window boundaries through the `observe()` API.
+Iranti is a knowledge base for multi-agent systems. The primary read path is identity retrieval — this specific entity (`project/nexus_prime`), this specific key (`deadline`), with confidence attached. When Agent A writes a fact, Agent B can retrieve it by exact lookup without being told it exists. Facts persist in PostgreSQL and survive context window boundaries through the `observe()` API. For discovery workflows, Iranti supports hybrid search (full-text + vector similarity).
 
 ---
 
@@ -33,14 +33,14 @@ Iranti is a knowledge base for multi-agent systems. Unlike vector databases that
 
 | Feature | Vector DB | Iranti |
 |---|---|---|
-| **Retrieval** | Similarity (nearest neighbor) | Identity (entity+key) |
+| **Retrieval** | Similarity (nearest neighbor) | Identity-first + optional hybrid search |
 | **Storage** | Embeddings in vector space | Structured facts with keys |
 | **Persistence** | Stateless between calls | Persistent across sessions |
 | **Confidence** | No confidence tracking | Per-fact confidence scores |
 | **Conflicts** | No conflict resolution | Automatic resolution + escalation |
 | **Context** | No context awareness | `observe()` injects missing facts |
 
-Vector databases answer "what's similar to X?" Iranti answers "what do we know about X?"
+Vector databases answer "what's similar to X?" Iranti answers "what do we know about X?" and can run hybrid search when exact keys are unknown.
 
 ---
 
@@ -161,6 +161,42 @@ npm run api-key:revoke -- --key-id chatbot_alice
 Use the printed token (`keyId.secret`) as `X-Iranti-Key`.
 Scopes use `resource:action` format (for example `kb:read`, `memory:write`, `metrics:read`, `proxy:chat`).
 
+### Security Baseline
+
+- Use one scoped key per app/service identity.
+- Rotate any key that is exposed in logs, screenshots, or chat.
+- Keep escalation/log paths outside the repo working tree.
+- Use TLS/reverse proxy for non-local deployments.
+
+Security quickstart: [`docs/guides/security-quickstart.md`](docs/guides/security-quickstart.md)
+Claude Code guide: [`docs/guides/claude-code.md`](docs/guides/claude-code.md)
+Codex guide: [`docs/guides/codex.md`](docs/guides/codex.md)
+Release guide: [`docs/guides/releasing.md`](docs/guides/releasing.md)
+
+### Claude Code via MCP
+
+Iranti ships a local stdio MCP server for Claude Code and other MCP clients:
+
+```bash
+iranti mcp
+```
+
+Use it with a project-local `.mcp.json`, and optionally add `iranti claude-hook` for `SessionStart` and `UserPromptSubmit`.
+
+Guide: [`docs/guides/claude-code.md`](docs/guides/claude-code.md)
+
+### Codex via MCP
+
+Codex uses a global MCP registry rather than a project-local `.mcp.json`. Register Iranti once, then launch Codex in this repo so `AGENTS.md` applies:
+
+```bash
+npm run build
+npm run codex:setup
+npm run codex:run
+```
+
+Guide: [`docs/guides/codex.md`](docs/guides/codex.md)
+
 ---
 
 ## Install Strategy (Double Layer)
@@ -195,13 +231,22 @@ Defaults:
 ### 3) Create a named instance
 
 ```bash
-iranti instance create local --port 3001 --db-url "postgresql://postgres:yourpassword@localhost:5432/iranti_local"
+iranti instance create local --port 3001 --db-url "postgresql://postgres:yourpassword@localhost:5432/iranti_local" --provider mock
 iranti instance show local
 ```
 
-Then edit the printed instance `.env` file and set:
-- `DATABASE_URL` (real value)
-- `IRANTI_API_KEY` (real token)
+Finish onboarding or change settings later with:
+
+```bash
+# Provider/db updates
+iranti configure instance local --provider openai --provider-key sk-... --db-url "postgresql://postgres:realpassword@localhost:5432/iranti_local"
+iranti configure instance local --interactive
+
+# Create a registry-backed API key and sync it into the instance env
+iranti auth create-key --instance local --key-id local_admin --owner "Local Admin" --scopes "kb:read,kb:write,memory:read,memory:write,agents:read,agents:write" --write-instance
+```
+
+You can rerun `iranti configure instance ...` later to rotate provider keys or replace the instance API token.
 
 ### 4) Run Iranti from that instance
 
@@ -218,8 +263,33 @@ iranti project init . --instance local --agent-id chatbot_main
 
 This writes `.env.iranti` in the project with the correct `IRANTI_URL`, `IRANTI_API_KEY`, and default agent identity.
 
+Later changes use the same surface:
+
+```bash
+iranti configure project . --instance local --agent-id chatbot_worker
+iranti configure project . --interactive
+iranti auth create-key --instance local --key-id chatbot_worker --owner "Chatbot Worker" --scopes "kb:read,memory:read,memory:write" --project .
+```
+
 For multi-agent systems, bind once per project and set unique agent IDs per worker (for example `planner_agent`, `research_agent`, `critic_agent`).
 
+### Installation Diagnostics
+
+Use the CLI doctor command before first run or before a release check:
+
+```bash
+iranti doctor
+iranti doctor --instance local
+iranti status
+iranti upgrade
+```
+
+This validates the active env file, database URL, API key presence, provider selection, and provider-specific credentials.
+`iranti status` shows the current runtime root, known instances, and local binding files.
+`iranti upgrade` prints the supported upgrade commands for npm and Python installs.
+`iranti configure ...` updates instance/project credentials without manual env editing.
+`iranti auth ...` manages registry-backed API keys and can sync them into instance or project bindings.
+
 ---
 
 ## Core API
@@ -267,6 +337,21 @@ for fact in facts:
     print(f"[{fact['key']}] {fact['summary']} (confidence: {fact['confidence']})")
 ```
 
+### Hybrid Search
+
+```python
+matches = client.search(
+    query="current blocker launch readiness",
+    entity_type="project",
+    limit=5,
+    lexical_weight=0.45,
+    vector_weight=0.55,
+)
+
+for item in matches:
+    print(item["entity"], item["key"], item["score"])
+```
+
 ### Context Persistence (attend)
 
 ```python
@@ -404,7 +489,7 @@ Iranti has four internal components:
 
 | Component | Role |
 |---|---|
-| **Library** | PostgreSQL knowledge base. Active truth (soft-deleted entries marked as archived). Full provenance in Archive table. |
+| **Library** | PostgreSQL knowledge base. Active truth in `knowledge_base` with full provenance in `archive`; archived rows are retained and marked `[ARCHIVED]` in active storage. |
 | **Librarian** | Manages all writes. Detects conflicts, reasons about resolution, escalates when uncertain. |
 | **Attendant** | Per-agent working memory manager. Implements `attend()`, `observe()`, and `handshake()` APIs. |
 | **Archivist** | Periodic cleanup. Archives expired and low-confidence entries. Processes human-resolved conflicts. |
@@ -417,6 +502,7 @@ Express server on port 3001 with endpoints:
 - `POST /kb/ingest` - Ingest raw text, auto-chunk into facts
 - `GET /kb/query/:entityType/:entityId/:key` - Query specific fact
 - `GET /kb/query/:entityType/:entityId` - Query all facts for entity
+- `GET /kb/search` - Hybrid search across facts
 - `POST /memory/attend` - Decide whether to inject memory for this turn
 - `POST /memory/observe` - Context persistence (inject missing facts)
 - `POST /memory/handshake` - Working memory brief for agent session
@@ -430,17 +516,20 @@ All endpoints require `X-Iranti-Key` header for authentication.
 
 ## Schema
 
-Three PostgreSQL tables:
+Six PostgreSQL tables:
 
 ```
-knowledge_base          — active truth (archived entries soft-deleted with confidence=0)
-archive                 — full provenance history, never deleted, includes supersededBy links
-entity_relationships    — directional graph: MEMBER_OF, PART_OF, AUTHORED, etc.
+knowledge_base          - active truth (archived rows retained with confidence=0)
+archive                 - full provenance history, never deleted
+entity_relationships    - directional graph: MEMBER_OF, PART_OF, AUTHORED, etc.
+entities                - canonical entity identity registry
+entity_aliases          - normalized aliases mapped to canonical entities
+write_receipts          - idempotency receipts for requestId replay safety
 ```
 
-Every table has a `properties` JSON column for caller-defined metadata. New entity types, relationship types, and fact keys never require migrations — they are just strings you define.
+New entity types, relationship types, and fact keys do not require migrations; they are caller-defined strings.
 
-**Archive semantics**: When an entry is archived, it remains in knowledge_base with confidence set to 0 and summary marked as `[ARCHIVED]`. A full copy is written to the archive table with supersededBy linking for traceability. Nothing is ever truly deleted.
+**Archive semantics**: When an entry is archived, it remains in knowledge_base with confidence set to 0 and summary marked as `[ARCHIVED]`. A full copy is written to the archive table for traceability. Nothing is ever truly deleted.
 
 ---
 
@@ -514,7 +603,9 @@ docs/
 - **Issues**: [GitHub Issues](https://github.com/nfemmanuel/iranti/issues)
 - **Discussions**: [GitHub Discussions](https://github.com/nfemmanuel/iranti/discussions)
 - **Email**: oluwaniifemi.emmanuel@uni.minerva.edu
+- **Changelog**: [`CHANGELOG.md`](CHANGELOG.md)
 
 ---
 
 **Built with ❤️ for the multi-agent AI community.**
+

package/bin/iranti.js

@@ -21,4 +21,4 @@ try {
   console.error('Iranti CLI is not built. Run "npm run build" first.');
   console.error(message);
   process.exit(1);
-}
+}

package/dist/scripts/api-key-create.js

@@ -42,16 +42,10 @@ async function main() {
     console.log('\nCopy this token now (it will not be shown again):');
     console.log(created.token);
     console.log('\nUse it as: X-Iranti-Key: <token>\n');
-    await (0, client_1.getDb)().$disconnect();
+    process.exit(0);
 }
 main().catch(async (err) => {
     console.error('Failed to create API key:', err instanceof Error ? err.message : String(err));
-    try {
-        await (0, client_1.getDb)().$disconnect();
-    }
-    catch {
-        // ignore
-    }
     process.exit(1);
 });
 //# sourceMappingURL=api-key-create.js.map

package/dist/scripts/api-key-list.js

@@ -27,16 +27,10 @@ async function main() {
             }
         }
     }
-    await (0, client_1.getDb)().$disconnect();
+    process.exit(0);
 }
 main().catch(async (err) => {
     console.error('Failed to list API keys:', err instanceof Error ? err.message : String(err));
-    try {
-        await (0, client_1.getDb)().$disconnect();
-    }
-    catch {
-        // ignore
-    }
     process.exit(1);
 });
 //# sourceMappingURL=api-key-list.js.map

package/dist/scripts/api-key-revoke.js

@@ -27,16 +27,10 @@ async function main() {
         process.exit(1);
     }
     console.log(`Revoked API key: ${keyId}`);
-    await (0, client_1.getDb)().$disconnect();
+    process.exit(0);
 }
 main().catch(async (err) => {
     console.error('Failed to revoke API key:', err instanceof Error ? err.message : String(err));
-    try {
-        await (0, client_1.getDb)().$disconnect();
-    }
-    catch {
-        // ignore
-    }
     process.exit(1);
 });
 //# sourceMappingURL=api-key-revoke.js.map

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

@@ -0,0 +1,328 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config");
+const path_1 = __importDefault(require("path"));
+const sdk_1 = require("../src/sdk");
+const runtimeEnv_1 = require("../src/lib/runtimeEnv");
+const MEMORY_NEED_POSITIVE_PATTERNS = [
+    /\bwhat(?:'s| is| was)?\s+my\b/i,
+    /\bdo you remember\b/i,
+    /\bremind me\b/i,
+    /\bmy\s+(?:favorite|favourite|name|email|phone|address|city|country|movie|snack|color|colour)\b/i,
+    /\bwe decided\b/i,
+    /\bearlier\b/i,
+    /\bprevious(?:ly)?\b/i,
+    /\bagain\b/i,
+];
+const MEMORY_NEED_NEGATIVE_PATTERNS = [
+    /^\s*(hi|hello|hey|yo|sup|good (?:morning|afternoon|evening))\b[!.?\s]*$/i,
+    /^\s*(thanks|thank you|cool|great|nice)\b[!.?\s]*$/i,
+];
+function printHelp() {
+    console.log([
+        'Claude Code -> Iranti hook helper',
+        '',
+        'Usage:',
+        '  ts-node scripts/claude-code-memory-hook.ts --event SessionStart',
+        '  ts-node scripts/claude-code-memory-hook.ts --event UserPromptSubmit',
+        '',
+        'Optional flags:',
+        '  --project-env <path>   Explicit .env.iranti path',
+        '  --instance-env <path>  Explicit instance env path',
+        '  --env-file <path>      Explicit base .env path',
+        '',
+        'Reads Claude Code hook JSON from stdin and returns hookSpecificOutput.additionalContext on stdout.',
+    ].join('\n'));
+}
+function parseArgs(argv) {
+    const out = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const token = argv[i];
+        if (!token.startsWith('--'))
+            continue;
+        const key = token.slice(2);
+        const next = argv[i + 1];
+        if (!next || next.startsWith('--')) {
+            out[key] = 'true';
+            continue;
+        }
+        out[key] = next;
+        i += 1;
+    }
+    return out;
+}
+async function readStdin() {
+    return new Promise((resolve) => {
+        let out = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => { out += chunk; });
+        process.stdin.on('end', () => resolve(out));
+        process.stdin.resume();
+    });
+}
+function parsePayload(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return {};
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return {};
+    }
+}
+function requireConnectionString() {
+    const connectionString = process.env.DATABASE_URL?.trim();
+    if (!connectionString) {
+        throw new Error('DATABASE_URL is required for claude-code-memory-hook.');
+    }
+    return connectionString;
+}
+function slugify(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+}
+function getCwd(payload) {
+    const fromPayload = typeof payload.cwd === 'string' && payload.cwd.trim().length > 0
+        ? payload.cwd.trim()
+        : null;
+    return fromPayload || process.cwd();
+}
+function getDefaultAgentId(payload) {
+    const explicit = process.env.IRANTI_CLAUDE_AGENT_ID?.trim();
+    if (explicit)
+        return explicit;
+    const projectBindingAgent = process.env.IRANTI_AGENT_ID?.trim();
+    if (projectBindingAgent)
+        return projectBindingAgent;
+    const base = path_1.default.basename(getCwd(payload));
+    return `claude_code_${slugify(base || 'project')}`;
+}
+function getEntityHints(payload) {
+    const out = new Set();
+    const cwd = getCwd(payload);
+    const projectHint = `project/${slugify(path_1.default.basename(cwd) || 'project')}`;
+    out.add(projectHint);
+    const memoryEntity = process.env.IRANTI_MEMORY_ENTITY?.trim();
+    if (memoryEntity) {
+        out.add(memoryEntity);
+    }
+    const envHints = (process.env.IRANTI_CLAUDE_ENTITY_HINTS ?? '')
+        .split(',')
+        .map((value) => value.trim())
+        .filter(Boolean);
+    for (const hint of envHints)
+        out.add(hint);
+    return Array.from(out);
+}
+async function ensureHookAgent(iranti, payload) {
+    const agentId = getDefaultAgentId(payload);
+    await iranti.registerAgent({
+        agentId,
+        name: process.env.IRANTI_CLAUDE_AGENT_NAME?.trim() || 'Claude Code Hook',
+        description: process.env.IRANTI_CLAUDE_AGENT_DESCRIPTION?.trim() || 'Claude Code automatic memory hook',
+        capabilities: ['working_memory', 'memory_injection'],
+        model: process.env.ANTHROPIC_MODEL || 'claude-code',
+    });
+    return agentId;
+}
+function getPrompt(payload) {
+    const candidates = [
+        payload.prompt,
+        payload.message,
+        payload.text,
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === 'string' && candidate.trim()) {
+            return candidate.trim();
+        }
+    }
+    return '';
+}
+function getMaxFacts() {
+    const raw = Number(process.env.IRANTI_CLAUDE_MAX_FACTS ?? 6);
+    if (!Number.isFinite(raw) || raw < 1)
+        return 6;
+    return Math.min(12, Math.trunc(raw));
+}
+function formatSessionContext(facts, cwd) {
+    const limited = facts.slice(0, getMaxFacts());
+    const lines = [
+        '[Iranti Session Memory]',
+        `Project: ${path_1.default.basename(cwd)}`,
+    ];
+    if (limited.length > 0) {
+        lines.push('Relevant memory:');
+        for (const fact of limited) {
+            lines.push(`- ${fact.entity}/${fact.key}: ${fact.summary}`);
+        }
+    }
+    return lines.join('\n');
+}
+function formatPromptContext(facts) {
+    if (facts.length === 0)
+        return '';
+    const lines = ['[Iranti Retrieved Memory]'];
+    for (const fact of facts) {
+        lines.push(`- ${fact.entity}/${fact.key}: ${fact.summary}`);
+    }
+    return lines.join('\n');
+}
+function emitHookContext(event, additionalContext) {
+    const payload = {
+        hookSpecificOutput: {
+            hookEventName: event,
+            additionalContext,
+        },
+    };
+    process.stdout.write(`${JSON.stringify(payload)}\n`);
+}
+function shouldFetchMemory(prompt) {
+    const normalized = prompt.trim();
+    if (!normalized)
+        return false;
+    if (MEMORY_NEED_NEGATIVE_PATTERNS.some((pattern) => pattern.test(normalized))) {
+        return false;
+    }
+    if (MEMORY_NEED_POSITIVE_PATTERNS.some((pattern) => pattern.test(normalized))) {
+        return true;
+    }
+    if (/\b(my|our|we)\b/i.test(normalized)) {
+        return true;
+    }
+    return normalized.includes('/');
+}
+function dedupeFacts(facts) {
+    const byKey = new Map();
+    for (const fact of facts) {
+        const identity = `${fact.entity}/${fact.key}`;
+        const existing = byKey.get(identity);
+        if (!existing || fact.confidence > existing.confidence) {
+            byKey.set(identity, fact);
+        }
+    }
+    return Array.from(byKey.values())
+        .sort((a, b) => b.confidence - a.confidence || a.entity.localeCompare(b.entity) || a.key.localeCompare(b.key))
+        .slice(0, getMaxFacts());
+}
+async function loadAttendantStateFacts(iranti, agent) {
+    const state = await iranti.query(`agent/${agent}`, 'attendant_state');
+    if (!state.found || !state.value || typeof state.value !== 'object') {
+        return [];
+    }
+    const workingMemory = Array.isArray(state.value.workingMemory)
+        ? state.value.workingMemory
+        : [];
+    return workingMemory.flatMap((entry) => {
+        const entityKey = typeof entry.entityKey === 'string' ? entry.entityKey.trim() : '';
+        const summary = typeof entry.summary === 'string' ? entry.summary.trim() : '';
+        if (!entityKey || !summary)
+            return [];
+        const segments = entityKey.split('/');
+        if (segments.length < 3)
+            return [];
+        return [{
+                entity: `${segments[0]}/${segments[1]}`,
+                key: segments.slice(2).join('/'),
+                summary,
+                confidence: typeof entry.confidence === 'number' ? entry.confidence : 0,
+                source: typeof entry.source === 'string' ? entry.source : 'attendant',
+            }];
+    });
+}
+async function loadEntityFacts(iranti, entities) {
+    const out = [];
+    for (const entity of entities) {
+        const trimmed = entity.trim();
+        if (!trimmed)
+            continue;
+        const entries = await iranti.queryAll(trimmed).catch(() => []);
+        for (const entry of entries) {
+            out.push({
+                entity: trimmed,
+                key: entry.key,
+                summary: entry.summary,
+                confidence: entry.confidence,
+                source: entry.source,
+            });
+        }
+    }
+    return out;
+}
+async function searchPromptFacts(iranti, prompt, entityHints) {
+    if (!prompt.trim())
+        return [];
+    const results = await iranti.search({
+        query: prompt,
+        limit: getMaxFacts(),
+        minScore: Number(process.env.IRANTI_CLAUDE_MIN_SEARCH_SCORE ?? 0.05),
+    }).catch(() => []);
+    const searched = results.map((result) => ({
+        entity: result.entity,
+        key: result.key,
+        summary: result.summary,
+        confidence: result.confidence,
+        source: result.source,
+    }));
+    if (searched.length > 0) {
+        return searched;
+    }
+    return loadEntityFacts(iranti, entityHints);
+}
+async function main() {
+    if (process.argv.includes('--help') || process.argv.includes('-h')) {
+        printHelp();
+        return;
+    }
+    const args = parseArgs(process.argv.slice(2));
+    const event = args.event;
+    if (event !== 'SessionStart' && event !== 'UserPromptSubmit') {
+        throw new Error('--event must be SessionStart or UserPromptSubmit');
+    }
+    const payload = parsePayload(await readStdin());
+    (0, runtimeEnv_1.loadRuntimeEnv)({
+        payloadCwd: getCwd(payload),
+        projectEnvFile: args['project-env'],
+        instanceEnvFile: args['instance-env'],
+        explicitEnvFile: args['env-file'],
+    });
+    const cwd = getCwd(payload);
+    const iranti = new sdk_1.Iranti({
+        connectionString: requireConnectionString(),
+        llmProvider: process.env.LLM_PROVIDER,
+    });
+    const agent = await ensureHookAgent(iranti, payload);
+    const entityHints = getEntityHints(payload);
+    if (event === 'SessionStart') {
+        const persistedFacts = await loadAttendantStateFacts(iranti, agent);
+        const directFacts = persistedFacts.length > 0
+            ? persistedFacts
+            : await loadEntityFacts(iranti, entityHints);
+        emitHookContext(event, formatSessionContext(dedupeFacts(directFacts), cwd));
+        process.exit(0);
+    }
+    const prompt = getPrompt(payload);
+    if (!prompt) {
+        process.exit(0);
+    }
+    if (!shouldFetchMemory(prompt)) {
+        process.exit(0);
+    }
+    const facts = await searchPromptFacts(iranti, prompt, entityHints);
+    const context = formatPromptContext(dedupeFacts(facts));
+    if (!context) {
+        process.exit(0);
+    }
+    emitHookContext(event, context);
+    process.exit(0);
+}
+main().catch((error) => {
+    console.error('[claude-code-memory-hook] fatal:', error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});
+//# sourceMappingURL=claude-code-memory-hook.js.map