clementine-agent 1.18.20 → 1.18.21

package/dist/agent/auto-update.js

@@ -5,14 +5,41 @@
  * Source modifications from self-improve are tracked in ~/.clementine/ (not git),
  * so git pull is always clean. After pulling, source mods are reconciled.
  */
-import { execSync } from 'node:child_process';
-import { writeFileSync } from 'node:fs';
+import { execFileSync, execSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import pino from 'pino';
 import { BASE_DIR } from '../config.js';
 import { reconcileSourceMods } from './source-mods.js';
 const logger = pino({ name: 'clementine.auto-update' });
 const SENTINEL_PATH = path.join(BASE_DIR, '.restart-sentinel.json');
+function readDataEnv() {
+    const envPath = path.join(BASE_DIR, '.env');
+    if (!existsSync(envPath))
+        return {};
+    try {
+        return Object.fromEntries(readFileSync(envPath, 'utf-8')
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line && !line.startsWith('#') && line.includes('='))
+            .map((line) => {
+            const idx = line.indexOf('=');
+            return [line.slice(0, idx).trim(), line.slice(idx + 1).trim().replace(/^["']|["']$/g, '')];
+        }));
+    }
+    catch {
+        return {};
+    }
+}
+function flagEnabled(name, envFile) {
+    const raw = process.env[name] ?? envFile[name];
+    return /^(1|true|yes|on)$/i.test(String(raw ?? ''));
+}
+function shouldPrefetchEmbeddings() {
+    const envFile = readDataEnv();
+    return flagEnabled('CLEMENTINE_INSTALL_EMBEDDINGS', envFile)
+        || flagEnabled('CLEMENTINE_PREFETCH_EMBEDDINGS', envFile);
+}
 /**
  * Check if upstream has new commits. Safe to call from cron — no side effects.
  */
@@ -121,6 +148,23 @@ export async function applyUpdate(pkgDir) {
             logger.error({ err }, 'Build failed after update');
             return { success: false, error: `Build failed after update: ${String(err)}` };
         }
+        // 4b. Optional embedding model prefetch. npm postinstall may run before
+        // the freshly pulled TypeScript has been built; this second pass uses the
+        // just-built CLI so repo updates and npm-style updates behave the same.
+        if (shouldPrefetchEmbeddings()) {
+            try {
+                execFileSync(process.execPath, [path.join(pkgDir, 'dist', 'cli', 'index.js'), 'memory', 'model', 'install'], {
+                    cwd: pkgDir,
+                    stdio: 'pipe',
+                    env: { ...process.env, CLEMENTINE_HOME: BASE_DIR },
+                    timeout: 10 * 60_000,
+                });
+                logger.info('Local embedding model prefetch succeeded after update');
+            }
+            catch (err) {
+                logger.warn({ err }, 'Local embedding model prefetch failed after update');
+            }
+        }
         // 5. Reconcile source modifications
         const reconcileResult = reconcileSourceMods(pkgDir);
         logger.info({

package/dist/agent/local-turn.d.ts

@@ -1,4 +1,5 @@
 import type { ClementineJson } from '../config/clementine-json.js';
+import { type ToolsetName } from './toolsets.js';
 export type ProactivityMode = 'quiet' | 'balanced' | 'proactive' | 'operator';
 export type ResponseStyle = 'concise' | 'balanced' | 'detailed';
 export type ProgressVisibility = 'quiet' | 'normal' | 'detailed';
@@ -19,14 +20,29 @@ export type LocalTurnIntent = {
     kind: 'stop';
 } | {
     kind: 'status';
+} | {
+    kind: 'last_action';
+} | {
+    kind: 'compress_context';
+} | {
+    kind: 'debug_status';
+} | {
+    kind: 'toolset';
+    toolset: ToolsetName;
 } | {
     kind: 'preference_update';
     updates: AssistantExperienceUpdate;
     summary: string;
 };
+export type ApprovalReply = true | false | 'always' | null;
 export declare function isStopRequest(text: string): boolean;
 export declare function isStatusRequest(text: string): boolean;
+export declare function isLastActionRequest(text: string): boolean;
+export declare function isCompressContextRequest(text: string): boolean;
+export declare function isDebugStatusRequest(text: string): boolean;
 export declare function isTinyAcknowledgment(text: string): boolean;
+export declare function detectApprovalReply(text: string): ApprovalReply;
+export declare function looksLikeApprovalPrompt(text: string): boolean;
 export declare function detectLocalTurn(text: string): LocalTurnIntent;
 export declare function applyAssistantExperienceUpdate(cfg: ClementineJson, updates: AssistantExperienceUpdate): ClementineJson;
 //# sourceMappingURL=local-turn.d.ts.map

package/dist/agent/local-turn.js

@@ -1,8 +1,10 @@
 import { isStandaloneGreeting } from './turn-policy.js';
+import { normalizeToolsetName } from './toolsets.js';
 function normalize(text) {
     return text
         .trim()
         .toLowerCase()
+        .replace(/[‘’`]/g, "'")
         .replace(/[.!?]+$/g, '')
         .replace(/\s+/g, ' ');
 }
@@ -20,7 +22,31 @@ export function isStatusRequest(text) {
     const n = normalize(text);
     if (wordCount(n) > 8)
         return false;
-    return /^(status|task status|deep status|progress|what'?s happening|what'?s going on|what are you doing|are you working|anything running|what'?s running|background status|check status|where are we)$/.test(n);
+    return /^(status|task status|deep status|progress|what'?s happening|what'?s going on|what are you doing|what are you working on|what are you running|are you working|anything running|what'?s runnin?g?(?: now| right now)?|what is runnin?g?(?: now| right now)?|background status|check status|where are we)$/.test(n);
+}
+export function isLastActionRequest(text) {
+    const n = normalize(text);
+    if (wordCount(n) > 10)
+        return false;
+    return /^(last action|last turn|what happened last turn|what did you do|did you do it|did that actually run|did you actually do it|why didn'?t you do it|why did that not run|what happened)$/.test(n);
+}
+export function isCompressContextRequest(text) {
+    const n = normalize(text);
+    if (wordCount(n) > 8)
+        return false;
+    return /^(compress context|compact context|compress session|compact session|context compact|context compress|save and reset context|reset context but keep memory)$/.test(n);
+}
+export function isDebugStatusRequest(text) {
+    const n = normalize(text);
+    if (wordCount(n) > 6)
+        return false;
+    return /^(debug|debug status|session debug|agent debug|diagnostics|show diagnostics)$/.test(n);
+}
+function parseToolsetRequest(text) {
+    const n = normalize(text);
+    const match = n.match(/^(?:set |switch |use |enable )?(?:toolset|tool set|tools mode|tool mode)(?: to|:)? ([a-z _-]+)$/)
+        ?? n.match(/^toolset ([a-z _-]+)$/);
+    return match ? normalizeToolsetName(match[1]) : null;
 }
 export function isTinyAcknowledgment(text) {
     const n = normalize(text);
@@ -28,6 +54,24 @@ export function isTinyAcknowledgment(text) {
         return false;
     return /^(thanks|thank you|thx|ty|nice|great|perfect|awesome|cool|ok|okay|sounds good|got it|makes sense|love it)$/.test(n);
 }
+export function detectApprovalReply(text) {
+    const n = normalize(text);
+    if (wordCount(n) > 4)
+        return null;
+    if (/^(always)$/.test(n))
+        return 'always';
+    if (/^(no|nope|deny|denied|skip)$/.test(n))
+        return false;
+    if (/^(yes|y|yep|yeah|ok|okay|approve|approved|go|go ahead|do it|send it|perfect|sounds good|looks good|lgtm)$/.test(n)) {
+        return true;
+    }
+    return null;
+}
+export function looksLikeApprovalPrompt(text) {
+    const n = normalize(text);
+    return /\b(good to go|okay to send|ok to send|ready to send|should i send|want me to send|approve|confirm|fire it off)\b/.test(n)
+        || /\b(send|email|message|post|publish|delete|change|update|run|execute)\b[\s\S]{0,120}\?$/i.test(text.trim());
+}
 function parseProactivity(text) {
     if (/\b(operator mode|operator)\b/i.test(text))
         return 'operator';
@@ -71,6 +115,15 @@ export function detectLocalTurn(text) {
         return { kind: 'stop' };
     if (isStatusRequest(text))
         return { kind: 'status' };
+    if (isLastActionRequest(text))
+        return { kind: 'last_action' };
+    if (isCompressContextRequest(text))
+        return { kind: 'compress_context' };
+    if (isDebugStatusRequest(text))
+        return { kind: 'debug_status' };
+    const toolset = parseToolsetRequest(text);
+    if (toolset)
+        return { kind: 'toolset', toolset };
     if (isStandaloneGreeting(text))
         return { kind: 'greeting' };
     if (isTinyAcknowledgment(text))

package/dist/agent/route-classifier.d.ts

@@ -29,6 +29,7 @@ export declare function isDirectImperative(userMessage: string): {
     match: boolean;
     pattern?: string;
 };
+export declare function hasNoDelegationInstruction(userMessage: string): boolean;
 /**
  * Decide whether the user is talking ABOUT an agent rather than to them.
  * The explicit-mention fast path otherwise routes a message like

package/dist/agent/route-classifier.js

@@ -91,6 +91,22 @@ export function isDirectImperative(userMessage) {
     }
     return { match: false };
 }
+export function hasNoDelegationInstruction(userMessage) {
+    return /\b(don't|dont|do not|don't you|please don't|please dont)\s+(delegate|route|send|pass|hand ?off|handoff)\b/i.test(userMessage)
+        || /\b(no|without)\s+(delegating|routing|sending|passing|handing ?off|handoff)\b/i.test(userMessage)
+        || /\bkeep (this|that|it)?\s*(with )?(clementine|you|yourself)\b/i.test(userMessage);
+}
+function isExplicitDelegationToAgent(text, firstName, slug) {
+    const ident = `${firstName}|${slug}`;
+    const re = new RegExp(`\\b(send|route|delegate|pass|hand\\s*off|handoff)\\b[\\s\\w']{0,40}?\\b(to\\s+)?(${ident})\\b`, 'i');
+    return re.test(text);
+}
+function isVocativeAgentAddress(text, firstName, slug) {
+    const ident = `${firstName}|${slug}`;
+    const normalized = text.trim();
+    const openerRe = new RegExp(`^(hey\\s+|hi\\s+|yo\\s+)?(${ident})(\\b|\\s*[,—-])`, 'i');
+    return openerRe.test(normalized);
+}
 /**
  * Decide whether the user is talking ABOUT an agent rather than to them.
  * The explicit-mention fast path otherwise routes a message like
@@ -111,8 +127,8 @@ export function isAskingAboutAgent(text, firstName, slug) {
     const possessiveRe = new RegExp(`\\b(${ident})('s|s')\\b`, 'i');
     if (possessiveRe.test(text))
         return true;
-    const askingRe = new RegExp(`\\b(how|what|where|who|when|why|is|are|was|were|did|does|do|will|can|could|would|should|has|have|had|tell\\s+me|show\\s+me|let\\s+me\\s+know|any\\s+update|update\\s+on|status\\s+of|about)\\b[\\s\\w']{0,40}?\\b(${ident})\\b`, 'i');
-    return askingRe.test(text);
+    const askingRe = new RegExp(`\\b(how|what|where|who|when|why|is|are|was|were|did|does|do|will|can|could|would|should|has|have|had|tell\\s+me|show\\s+me|let\\s+me\\s+know|any\\s+update|update\\s+on|status\\s+of|about|fix|check|review)\\b[\\s\\w']{0,80}?\\b(${ident})\\b`, 'i');
+    return askingRe.test(text) || new RegExp(`\\b(for|about|on)\\s+(${ident})\\b`, 'i').test(text);
 }
 /**
  * Session keys eligible for routing. Any key NOT in this set is
@@ -252,6 +268,13 @@ export async function classifyRoute(userMessage, agents, gateway) {
     const specialists = agents.filter(a => a.slug !== 'clementine');
     if (specialists.length === 0)
         return null;
+    if (hasNoDelegationInstruction(userMessage)) {
+        return {
+            targetAgent: 'clementine',
+            confidence: 0.95,
+            reasoning: 'User explicitly asked not to delegate or route this away from Clementine.',
+        };
+    }
     // Direct-imperative guardrail: user is instructing Clementine to act —
     // do not delegate, even if an agent is named.
     const imperative = isDirectImperative(userMessage);
@@ -272,7 +295,9 @@ export async function classifyRoute(userMessage, agents, gateway) {
         const wordRe = new RegExp(`\\b(${firstName}|${a.slug})\\b`, 'i');
         if (!wordRe.test(trimmed))
             continue;
-        if (isAskingAboutAgent(trimmed, firstName, a.slug)) {
+        const explicitDelegation = isExplicitDelegationToAgent(trimmed, firstName, a.slug);
+        const vocativeAddress = isVocativeAgentAddress(trimmed, firstName, a.slug);
+        if (!explicitDelegation && !vocativeAddress && isAskingAboutAgent(trimmed, firstName, a.slug)) {
             // The user is asking ABOUT the agent ("how is <agent> doing", "<agent>'s
             // tasks", "did <agent> handle that?") rather than addressing them. Fall
             // through to the LLM classifier, which has a system-prompt rule for
@@ -280,6 +305,8 @@ export async function classifyRoute(userMessage, agents, gateway) {
             logger.debug({ slug: a.slug, trigger: 'meta-mention-bypass' }, 'Routing skipped — name appears as topic, not vocative');
             continue;
         }
+        if (!explicitDelegation && !vocativeAddress)
+            continue;
         logger.debug({ slug: a.slug, trigger: 'explicit-mention' }, 'Fast-path routing decision');
         return {
             targetAgent: a.slug,

package/dist/agent/toolsets.d.ts

@@ -0,0 +1,14 @@
+export type ToolsetName = 'auto' | 'safe' | 'diagnostic' | 'communications' | 'memory' | 'full';
+export interface ToolsetPreset {
+    name: ToolsetName;
+    label: string;
+    description: string;
+    directive: string;
+}
+export declare const TOOLSET_PRESETS: readonly ToolsetPreset[];
+export declare function normalizeToolsetName(input: string | undefined | null): ToolsetName | null;
+export declare function getToolsetPreset(name: ToolsetName): ToolsetPreset;
+export declare function formatToolsetChoices(): string;
+export declare function isRestrictedToolset(name: ToolsetName): boolean;
+export declare function toolsetAllowsLocalWrites(name: ToolsetName): boolean;
+//# sourceMappingURL=toolsets.d.ts.map

package/dist/agent/toolsets.js

@@ -0,0 +1,68 @@
+export const TOOLSET_PRESETS = [
+    {
+        name: 'auto',
+        label: 'Auto',
+        description: 'Route to the smallest inferred tool surface for each turn.',
+        directive: '',
+    },
+    {
+        name: 'safe',
+        label: 'Safe',
+        description: 'Memory and read-only local context; no external sends or local writes.',
+        directive: 'Toolset safe: use memory and read-only local context. Do not send messages, email, delete data, deploy, or modify files unless the user switches toolsets.',
+    },
+    {
+        name: 'diagnostic',
+        label: 'Diagnostic',
+        description: 'Bounded logs, local reads, memory, and diagnostics; no external sends.',
+        directive: 'Toolset diagnostic: diagnose with bounded reads and capped command output. Prefer targeted log slices, summaries, and transcript_search. Do not send external messages or make product changes.',
+    },
+    {
+        name: 'communications',
+        label: 'Communications',
+        description: 'Email/message workflows plus memory; avoid code and deployment tools.',
+        directive: 'Toolset communications: focus on email, calendar, messaging, approvals, and memory continuity. Do not edit code, deploy, or run unrelated local commands.',
+    },
+    {
+        name: 'memory',
+        label: 'Memory',
+        description: 'Memory, transcript, and relationship tools only unless explicitly changed.',
+        directive: 'Toolset memory: use memory_read, memory_search, memory_recall, transcript_search, working_memory, and user_model. Avoid external integrations and local shell/file writes.',
+    },
+    {
+        name: 'full',
+        label: 'Full',
+        description: 'Explicit operator mode for broad integrations and admin work.',
+        directive: 'Toolset full: the user explicitly enabled the broad operator surface for this chat. Still keep tool output bounded and ask before destructive or irreversible actions.',
+    },
+];
+const TOOLSET_BY_NAME = new Map(TOOLSET_PRESETS.map((preset) => [preset.name, preset]));
+export function normalizeToolsetName(input) {
+    const value = String(input ?? '').trim().toLowerCase().replace(/[\s_-]+/g, '-');
+    if (!value)
+        return null;
+    if (value === 'diagnostics' || value === 'debug')
+        return 'diagnostic';
+    if (value === 'comm' || value === 'comms' || value === 'communication')
+        return 'communications';
+    if (value === 'mem')
+        return 'memory';
+    if (value === 'all' || value === 'operator')
+        return 'full';
+    return TOOLSET_BY_NAME.has(value) ? value : null;
+}
+export function getToolsetPreset(name) {
+    return TOOLSET_BY_NAME.get(name) ?? TOOLSET_BY_NAME.get('auto');
+}
+export function formatToolsetChoices() {
+    return TOOLSET_PRESETS
+        .map((preset) => `- ${preset.name}: ${preset.description}`)
+        .join('\n');
+}
+export function isRestrictedToolset(name) {
+    return name === 'safe' || name === 'diagnostic' || name === 'memory';
+}
+export function toolsetAllowsLocalWrites(name) {
+    return name === 'auto' || name === 'full';
+}
+//# sourceMappingURL=toolsets.js.map

package/dist/brain/ingestion-pipeline.d.ts

@@ -32,6 +32,13 @@ export interface IngestResult {
     recordsWritten: number;
     recordsSkipped: number;
     recordsFailed: number;
+    recordsUnchanged: number;
+    recallCheckStatus?: 'ok' | 'partial' | 'skipped';
+    recallCheck?: {
+        checked: number;
+        hits: number;
+        missing: string[];
+    };
     errors: Array<{
         externalId?: string;
         error: string;

package/dist/brain/ingestion-pipeline.js

@@ -10,7 +10,7 @@
  *     → tag provenance → ingested_rows (structured overlay)
  *     → graph extractor → ingestion_runs audit
  */
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { VAULT_DIR } from '../config.js';
 import { getStore } from '../tools/shared.js';
@@ -33,6 +33,8 @@ export async function runIngestion(opts) {
     let recordsWritten = 0;
     let recordsSkipped = 0;
     let recordsFailed = 0;
+    let recordsUnchanged = 0;
+    const touchedExternalIds = new Set();
     const report = (stage, message) => {
         opts.onProgress?.({
             runId: runId ?? -1,
@@ -52,6 +54,14 @@ export async function runIngestion(opts) {
             recordsWritten += 1;
             if (sum)
                 writtenSummaries.push(sum);
+            if (sum?.externalId)
+                touchedExternalIds.add(sum.externalId);
+        },
+        onUnchanged: (sum) => {
+            recordsSkipped += 1;
+            recordsUnchanged += 1;
+            if (sum?.externalId)
+                touchedExternalIds.add(sum.externalId);
         },
         onSkip: () => { recordsSkipped += 1; },
         onFail: (err) => { recordsFailed += 1; errors.push(err); },
@@ -145,12 +155,28 @@ export async function runIngestion(opts) {
                 });
             }
         }
+        let recallCheckStatus = 'skipped';
+        let recallCheck;
+        if (!opts.dryRun && touchedExternalIds.size > 0) {
+            const missing = [];
+            for (const externalId of touchedExternalIds) {
+                if (!store.findChunkByExternalId(source.slug, externalId))
+                    missing.push(externalId);
+            }
+            recallCheck = {
+                checked: touchedExternalIds.size,
+                hits: touchedExternalIds.size - missing.length,
+                missing,
+            };
+            recallCheckStatus = missing.length === 0 ? 'ok' : 'partial';
+        }
         // Finalize
         const status = recordsFailed > 0 && recordsWritten === 0 ? 'error' :
             recordsFailed > 0 ? 'partial' : 'ok';
         if (runId !== null) {
             store.updateIngestionRun(runId, {
-                recordsIn, recordsWritten, recordsSkipped, recordsFailed,
+                recordsIn, recordsWritten, recordsSkipped, recordsFailed, recordsUnchanged,
+                recallCheckStatus,
                 errorsJson: errors.length ? JSON.stringify(errors.slice(0, 50)) : null,
                 overviewNotePath,
                 status,
@@ -165,6 +191,9 @@ export async function runIngestion(opts) {
             recordsWritten,
             recordsSkipped,
             recordsFailed,
+            recordsUnchanged,
+            recallCheckStatus,
+            recallCheck,
             errors,
             plannedRecords: opts.dryRun ? plannedRecords : undefined,
             overviewNotePath,
@@ -176,6 +205,7 @@ export async function runIngestion(opts) {
         if (runId !== null) {
             store.updateIngestionRun(runId, {
                 recordsIn, recordsWritten, recordsSkipped, recordsFailed: recordsFailed + 1,
+                recordsUnchanged,
                 errorsJson: JSON.stringify(errors),
                 status: 'error',
                 finished: true,
@@ -189,6 +219,8 @@ export async function runIngestion(opts) {
             recordsWritten,
             recordsSkipped,
             recordsFailed: recordsFailed + 1,
+            recordsUnchanged,
+            recallCheckStatus: 'skipped',
             errors,
             plannedRecords: opts.dryRun ? plannedRecords : undefined,
         };
@@ -207,8 +239,11 @@ async function processStructured(record, mapping, source, opts, store, _report,
             counters.onWrite(summaryBundle);
             return;
         }
-        await writeRecord(ingested, source, store);
-        counters.onWrite(summaryBundle);
+        const outcome = await writeRecord(ingested, source, store);
+        if (outcome === 'unchanged')
+            counters.onUnchanged(summaryBundle);
+        else
+            counters.onWrite(summaryBundle);
     }
     catch (err) {
         counters.onFail({ externalId: record.externalId, error: err instanceof Error ? err.message : String(err) });
@@ -242,8 +277,11 @@ async function processFreeForm(record, source, opts, store, report, planned, _er
             counters.onWrite(summaryBundle);
             return;
         }
-        await writeRecord(ingested, source, store);
-        counters.onWrite(summaryBundle);
+        const outcome = await writeRecord(ingested, source, store);
+        if (outcome === 'unchanged')
+            counters.onUnchanged(summaryBundle);
+        else
+            counters.onWrite(summaryBundle);
     }
     catch (err) {
         counters.onFail({ externalId: record.externalId, error: err instanceof Error ? err.message : String(err) });
@@ -266,37 +304,84 @@ async function writeRecord(record, source, store) {
             record.tags = [...record.tags, `project:${projSlug}`];
         }
     }
-    // 1) Raw payload → artifact store
-    const artifactId = store.storeArtifact({
-        toolName: `ingest:${source.slug}`,
-        summary: record.title || record.externalId,
-        content: record.rawPayload,
-        tags: [source.slug, sourceType, ...record.tags].join(','),
-        sessionKey: null,
-        agentSlug: source.agentSlug ?? null,
-    });
-    record.artifactId = artifactId;
-    // 2) Vault note: write markdown file with frontmatter + body
+    // 1) Vault note content. Build this before artifact writes so exact re-runs
+    // can be classified as unchanged without duplicating audit blobs.
     const abs = path.join(VAULT_DIR, record.targetRelPath);
     const dir = path.dirname(abs);
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
+    if (existsSync(abs) && record.frontmatter && 'ingested_at' in record.frontmatter) {
+        try {
+            const current = readFileSync(abs, 'utf-8');
+            const match = current.match(/^ingested_at:\s*(.+)$/m);
+            if (match?.[1]) {
+                const raw = match[1].trim();
+                try {
+                    record.frontmatter.ingested_at = JSON.parse(raw);
+                }
+                catch {
+                    record.frontmatter.ingested_at = raw.replace(/^['"]|['"]$/g, '');
+                }
+            }
+        }
+        catch {
+            // Fall through with a fresh timestamp if the old note can't be read.
+        }
+    }
     const fm = { title: record.title, ...record.frontmatter };
     const frontmatterBlock = Object.entries(fm)
         .map(([k, v]) => `${k}: ${serializeYaml(v)}`)
         .join('\n');
     const fileContent = `---\n${frontmatterBlock}\n---\n\n# ${record.title}\n\n${record.body}\n`;
+    if (existsSync(abs)) {
+        try {
+            const current = readFileSync(abs, 'utf-8');
+            if (current === fileContent && store.findChunkByExternalId(record.sourceSlug, record.externalId)) {
+                store.recordMemoryEvent?.({
+                    sourceType: 'ingestion',
+                    sourceId: null,
+                    sessionKey: null,
+                    agentSlug: source.agentSlug ?? null,
+                    content: `${record.sourceSlug}:${record.externalId}\nunchanged\n${record.summary}`,
+                    indexed: true,
+                });
+                return 'unchanged';
+            }
+        }
+        catch {
+            // If the existing file can't be read, fall through and rewrite.
+        }
+    }
+    // 2) Raw payload → artifact store
+    const artifactId = store.storeArtifact({
+        toolName: `ingest:${source.slug}`,
+        summary: record.title || record.externalId,
+        content: record.rawPayload,
+        tags: [source.slug, sourceType, ...record.tags].join(','),
+        sessionKey: null,
+        agentSlug: source.agentSlug ?? null,
+    });
+    record.artifactId = artifactId;
+    // 3) Vault note: write markdown file with frontmatter + body
     writeFileSync(abs, fileContent, 'utf-8');
-    // 3) Re-index via existing vault pipeline (chunks, FTS, wikilinks)
+    // 4) Re-index via existing vault pipeline (chunks, FTS, wikilinks)
     store.updateFile(record.targetRelPath, source.agentSlug ?? undefined);
-    // 4) Tag provenance on the chunks we just wrote
+    // 5) Tag provenance on the chunks we just wrote
     store.tagChunksForSource(record.targetRelPath, {
         sourceSlug: record.sourceSlug,
         externalId: record.externalId,
         sourceType,
         lastSyncedAt: nowIso,
     });
-    // 5) Structured overlay for SQL aggregates
+    store.recordMemoryEvent?.({
+        sourceType: 'ingestion',
+        sourceId: artifactId,
+        sessionKey: null,
+        agentSlug: source.agentSlug ?? null,
+        content: `${record.sourceSlug}:${record.externalId}\n${record.title}\n${record.summary}`,
+        indexed: true,
+    });
+    // 6) Structured overlay for SQL aggregates
     if (record.structuredRow) {
         const chunkRef = store.findChunkByExternalId(record.sourceSlug, record.externalId);
         store.insertIngestedRow({
@@ -308,8 +393,9 @@ async function writeRecord(record, source, store) {
             structuredColumns: Object.fromEntries(Object.entries(record.structuredRow).map(([k, v]) => [k, coerceCol(v)])),
         });
     }
-    // 6) Graph (best-effort, no-op if graph unavailable)
+    // 7) Graph (best-effort, no-op if graph unavailable)
     await writeGraphForRecord(record);
+    return 'written';
 }
 async function applyStructuredColumns(mapping) {
     const store = await getStore();