@jungjaehoon/mama-core 1.3.3 → 1.4.1

package/dist/memory/bootstrap-builder.d.ts

@@ -0,0 +1,10 @@
+import type { MemoryAgentBootstrap, MemoryScopeRef } from './types.js';
+interface BuildMemoryAgentBootstrapParams {
+    scopes: MemoryScopeRef[];
+    channelKey?: string;
+    currentGoal?: string;
+    mainAgentState?: MemoryAgentBootstrap['main_agent_state'];
+}
+export declare function buildMemoryAgentBootstrap(params: BuildMemoryAgentBootstrapParams): Promise<MemoryAgentBootstrap>;
+export {};
+//# sourceMappingURL=bootstrap-builder.d.ts.map

package/dist/memory/bootstrap-builder.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMemoryAgentBootstrap = buildMemoryAgentBootstrap;
+const event_store_js_1 = require("./event-store.js");
+const finding_store_js_1 = require("./finding-store.js");
+const profile_builder_js_1 = require("./profile-builder.js");
+const truth_store_js_1 = require("./truth-store.js");
+const channel_summary_store_js_1 = require("./channel-summary-store.js");
+async function buildMemoryAgentBootstrap(params) {
+    const [truthRows, findings, recentEvents, channelSummary] = await Promise.all([
+        (0, truth_store_js_1.queryRelevantTruth)({
+            query: '',
+            scopes: params.scopes,
+            includeHistory: true,
+        }),
+        (0, finding_store_js_1.listOpenAuditFindings)(),
+        (0, event_store_js_1.listRecentMemoryEvents)(10),
+        params.channelKey ? (0, channel_summary_store_js_1.getChannelSummary)(params.channelKey) : Promise.resolve(null),
+    ]);
+    const scopedTruth = truthRows.filter((row) => row.scope_refs.some((scopeRef) => params.scopes.some((scope) => scope.kind === scopeRef.kind && scope.id === scopeRef.id)));
+    const profile = (0, profile_builder_js_1.classifyProfileEntries)(scopedTruth.map((row) => ({
+        id: row.memory_id,
+        topic: row.topic,
+        kind: 'decision',
+        summary: row.effective_summary,
+        details: row.effective_details,
+        confidence: row.trust_score,
+        status: row.truth_status === 'quarantined' ? 'stale' : row.truth_status,
+        scopes: row.scope_refs,
+        source: {
+            package: 'mama-core',
+            source_type: 'truth_projection',
+        },
+        created_at: 0,
+        updated_at: 0,
+    })));
+    return {
+        current_goal: params.currentGoal,
+        scope_context: params.scopes,
+        channel_summary_markdown: channelSummary?.summary_markdown,
+        truth_snapshot: scopedTruth.map((row) => ({
+            id: row.memory_id,
+            topic: row.topic,
+            summary: row.effective_summary,
+            trust_score: row.trust_score,
+        })),
+        open_audit_findings: findings.map((finding) => ({
+            id: finding.finding_id,
+            kind: finding.kind,
+            severity: finding.severity,
+            summary: finding.summary,
+        })),
+        recent_memory_events: recentEvents.map((event) => ({
+            id: event.event_id,
+            type: event.event_type,
+            topic: event.topic,
+            created_at: event.created_at,
+        })),
+        profile_snapshot: {
+            static: profile.static.map((entry) => ({ id: entry.id, summary: entry.summary })),
+            dynamic: profile.dynamic.map((entry) => ({ id: entry.id, summary: entry.summary })),
+        },
+        main_agent_state: params.mainAgentState,
+    };
+}
+//# sourceMappingURL=bootstrap-builder.js.map

package/dist/memory/channel-summary-state-store.d.ts

@@ -0,0 +1,19 @@
+import type { ChannelSummaryStateRecord, MemoryAuditAck, MemoryScopeRef } from './types.js';
+export declare function getChannelSummaryState(channelKey: string): Promise<ChannelSummaryStateRecord | null>;
+export declare function recordChannelAudit(input: {
+    channelKey: string;
+    turnId: string;
+    topic: string;
+    scopeRefs: MemoryScopeRef[];
+    ack: MemoryAuditAck;
+    savedMemories?: Array<{
+        id: string;
+        topic: string;
+        summary: string;
+    }>;
+}): Promise<{
+    eventIds: string[];
+    findingIds: string[];
+    state: ChannelSummaryStateRecord;
+}>;
+//# sourceMappingURL=channel-summary-state-store.d.ts.map

package/dist/memory/channel-summary-state-store.js

@@ -0,0 +1,223 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChannelSummaryState = getChannelSummaryState;
+exports.recordChannelAudit = recordChannelAudit;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const db_manager_js_1 = require("../db-manager.js");
+const channel_summary_store_js_1 = require("./channel-summary-store.js");
+const event_store_js_1 = require("./event-store.js");
+const finding_store_js_1 = require("./finding-store.js");
+const MAX_ACTIVE_DECISIONS = 6;
+const MAX_RECENT_MILESTONES = 8;
+const MAX_RECENT_AUDIT_OUTCOMES = 6;
+function truncate(text, maxLength) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    return `${text.slice(0, maxLength - 1)}…`;
+}
+function createStateHash(state) {
+    return node_crypto_1.default.createHash('sha1').update(JSON.stringify(state)).digest('hex');
+}
+function deserializeState(row) {
+    const parsed = JSON.parse(String(row.state_json));
+    return {
+        channel_key: String(row.channel_key),
+        active_topic: parsed.active_topic,
+        active_decisions: parsed.active_decisions ?? [],
+        recent_milestones: parsed.recent_milestones ?? [],
+        recent_audit_outcomes: parsed.recent_audit_outcomes ?? [],
+        state_hash: String(row.state_hash),
+        updated_at: Number(row.updated_at),
+    };
+}
+function createEmptyState(channelKey) {
+    const now = Date.now();
+    const base = {
+        active_topic: undefined,
+        active_decisions: [],
+        recent_milestones: [],
+        recent_audit_outcomes: [],
+    };
+    return {
+        channel_key: channelKey,
+        ...base,
+        state_hash: createStateHash(base),
+        updated_at: now,
+    };
+}
+function createLegacySeedState(channelKey, legacySummary) {
+    const base = {
+        active_topic: undefined,
+        active_decisions: [],
+        recent_milestones: [
+            {
+                topic: 'legacy_summary',
+                action: 'no_op',
+                summary: legacySummary.summary_markdown.replace(/\s+/g, ' ').trim(),
+                timestamp: legacySummary.updated_at,
+            },
+        ],
+        recent_audit_outcomes: [],
+    };
+    return {
+        channel_key: channelKey,
+        ...base,
+        state_hash: createStateHash(base),
+        updated_at: legacySummary.updated_at,
+    };
+}
+function renderChannelSummaryMarkdown(state) {
+    const lines = ['## Channel Summary'];
+    if (state.active_topic) {
+        lines.push(`- Current topic: ${state.active_topic}`);
+    }
+    if (state.active_decisions.length > 0) {
+        lines.push('', '## Active Decisions');
+        for (const decision of state.active_decisions) {
+            lines.push(`- ${decision.topic}: ${truncate(decision.summary, 160)}`);
+        }
+    }
+    if (state.recent_milestones.length > 0) {
+        lines.push('', '## Recent Milestones');
+        for (const milestone of state.recent_milestones) {
+            lines.push(`- ${milestone.topic} (${milestone.action}): ${truncate(milestone.summary, 140)}`);
+        }
+    }
+    if (state.recent_audit_outcomes.length > 0) {
+        lines.push('', '## Audit Signals');
+        for (const outcome of state.recent_audit_outcomes) {
+            const note = outcome.reason ? ` — ${truncate(outcome.reason, 120)}` : '';
+            lines.push(`- ${outcome.topic}: ${outcome.status}${note}`);
+        }
+    }
+    return lines.join('\n');
+}
+function reduceState(previous, input) {
+    const next = {
+        ...previous,
+        active_decisions: previous.active_decisions.slice(),
+        recent_milestones: previous.recent_milestones.slice(),
+        recent_audit_outcomes: previous.recent_audit_outcomes.slice(),
+        updated_at: input.timestamp,
+    };
+    next.recent_audit_outcomes.unshift({
+        topic: input.topic,
+        status: input.ack.status,
+        reason: input.ack.reason,
+        timestamp: input.timestamp,
+    });
+    next.recent_audit_outcomes = next.recent_audit_outcomes.slice(0, MAX_RECENT_AUDIT_OUTCOMES);
+    if (input.ack.status === 'applied' && input.savedMemories && input.savedMemories.length > 0) {
+        next.active_topic = input.savedMemories[0]?.topic ?? input.topic;
+        for (const memory of input.savedMemories) {
+            next.active_decisions = next.active_decisions.filter((entry) => entry.memory_id !== memory.id && entry.topic !== memory.topic);
+            next.active_decisions.unshift({
+                memory_id: memory.id,
+                topic: memory.topic,
+                summary: memory.summary,
+                updated_at: input.timestamp,
+            });
+            next.recent_milestones.unshift({
+                topic: memory.topic,
+                action: input.ack.action,
+                summary: memory.summary,
+                timestamp: input.timestamp,
+                memory_id: memory.id,
+            });
+        }
+        next.active_decisions = next.active_decisions.slice(0, MAX_ACTIVE_DECISIONS);
+        next.recent_milestones = next.recent_milestones.slice(0, MAX_RECENT_MILESTONES);
+    }
+    const stateHash = createStateHash({
+        active_topic: next.active_topic,
+        active_decisions: next.active_decisions,
+        recent_milestones: next.recent_milestones,
+        recent_audit_outcomes: next.recent_audit_outcomes,
+    });
+    return {
+        ...next,
+        state_hash: stateHash,
+    };
+}
+async function getChannelSummaryState(channelKey) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const row = adapter
+        .prepare(`
+        SELECT channel_key, state_json, state_hash, updated_at
+        FROM channel_summary_state
+        WHERE channel_key = ?
+      `)
+        .get(channelKey);
+    return row ? deserializeState(row) : null;
+}
+async function recordChannelAudit(input) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const timestamp = Date.now();
+    const legacySummary = await (0, channel_summary_store_js_1.getChannelSummary)(input.channelKey);
+    const previous = (await getChannelSummaryState(input.channelKey)) ??
+        (legacySummary
+            ? createLegacySeedState(input.channelKey, legacySummary)
+            : createEmptyState(input.channelKey));
+    const eventIds = [];
+    const findingIds = [];
+    const eventType = input.ack.status === 'failed'
+        ? 'audit_failed'
+        : input.ack.action === 'no_op'
+            ? 'no_op'
+            : input.ack.action;
+    eventIds.push(await (0, event_store_js_1.appendMemoryEvent)({
+        event_type: eventType,
+        actor: 'memory_agent',
+        source_turn_id: input.turnId,
+        memory_id: input.savedMemories?.[0]?.id,
+        topic: input.topic,
+        scope_refs: input.scopeRefs,
+        reason: input.ack.reason,
+        created_at: timestamp,
+    }));
+    if (input.ack.status === 'failed') {
+        findingIds.push(await (0, finding_store_js_1.createAuditFinding)({
+            kind: 'unsupported_claim',
+            severity: 'high',
+            summary: input.ack.reason ?? `memory audit failed for ${input.topic}`,
+            evidence_refs: eventIds,
+            affected_memory_ids: input.savedMemories?.map((memory) => memory.id) ?? [],
+            recommended_action: 'consult_memory',
+        }));
+    }
+    const state = reduceState(previous, {
+        topic: input.topic,
+        ack: input.ack,
+        savedMemories: input.savedMemories,
+        timestamp,
+    });
+    adapter
+        .prepare(`
+        INSERT OR REPLACE INTO channel_summary_state (
+          channel_key,
+          state_json,
+          state_hash,
+          updated_at
+        )
+        VALUES (?, ?, ?, ?)
+      `)
+        .run(input.channelKey, JSON.stringify({
+        active_topic: state.active_topic,
+        active_decisions: state.active_decisions,
+        recent_milestones: state.recent_milestones,
+        recent_audit_outcomes: state.recent_audit_outcomes,
+    }), state.state_hash, timestamp);
+    await (0, channel_summary_store_js_1.upsertChannelSummary)({
+        channelKey: input.channelKey,
+        summaryMarkdown: renderChannelSummaryMarkdown(state),
+        deltaHash: state.state_hash,
+    });
+    return { eventIds, findingIds, state };
+}
+//# sourceMappingURL=channel-summary-state-store.js.map

package/dist/memory/channel-summary-store.d.ts

@@ -0,0 +1,8 @@
+import type { ChannelSummaryRecord } from './types.js';
+export declare function upsertChannelSummary(input: {
+    channelKey: string;
+    summaryMarkdown: string;
+    deltaHash?: string;
+}): Promise<void>;
+export declare function getChannelSummary(channelKey: string): Promise<ChannelSummaryRecord | null>;
+//# sourceMappingURL=channel-summary-store.d.ts.map

package/dist/memory/channel-summary-store.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertChannelSummary = upsertChannelSummary;
+exports.getChannelSummary = getChannelSummary;
+const db_manager_js_1 = require("../db-manager.js");
+function toChannelSummary(row) {
+    return {
+        channel_key: String(row.channel_key),
+        summary_markdown: String(row.summary_markdown),
+        delta_hash: typeof row.delta_hash === 'string' ? row.delta_hash : undefined,
+        updated_at: Number(row.updated_at),
+    };
+}
+async function upsertChannelSummary(input) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    adapter
+        .prepare(`
+        INSERT OR REPLACE INTO channel_summaries (
+          channel_key,
+          summary_markdown,
+          delta_hash,
+          updated_at
+        )
+        VALUES (?, ?, ?, ?)
+      `)
+        .run(input.channelKey, input.summaryMarkdown, input.deltaHash ?? null, Date.now());
+}
+async function getChannelSummary(channelKey) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const row = adapter
+        .prepare(`
+        SELECT channel_key, summary_markdown, delta_hash, updated_at
+        FROM channel_summaries
+        WHERE channel_key = ?
+      `)
+        .get(channelKey);
+    return row ? toChannelSummary(row) : null;
+}
+//# sourceMappingURL=channel-summary-store.js.map

package/dist/memory/event-store.d.ts

@@ -0,0 +1,5 @@
+import type { MemoryEventRecord } from './types.js';
+export declare function appendMemoryEvent(input: Omit<MemoryEventRecord, 'event_id'>): Promise<string>;
+export declare function listMemoryEventsForTopic(topic: string): Promise<MemoryEventRecord[]>;
+export declare function listRecentMemoryEvents(limit?: number): Promise<MemoryEventRecord[]>;
+//# sourceMappingURL=event-store.d.ts.map

package/dist/memory/event-store.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendMemoryEvent = appendMemoryEvent;
+exports.listMemoryEventsForTopic = listMemoryEventsForTopic;
+exports.listRecentMemoryEvents = listRecentMemoryEvents;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const db_manager_js_1 = require("../db-manager.js");
+function deserializeEvent(row) {
+    return {
+        event_id: String(row.event_id),
+        event_type: row.event_type,
+        actor: row.actor,
+        source_turn_id: typeof row.source_turn_id === 'string' && row.source_turn_id.length > 0
+            ? row.source_turn_id
+            : undefined,
+        memory_id: typeof row.memory_id === 'string' && row.memory_id.length > 0 ? row.memory_id : undefined,
+        topic: typeof row.topic === 'string' && row.topic.length > 0 ? row.topic : undefined,
+        scope_refs: JSON.parse(String(row.scope_refs)),
+        evidence_refs: typeof row.evidence_refs === 'string'
+            ? JSON.parse(row.evidence_refs)
+            : undefined,
+        reason: typeof row.reason === 'string' ? row.reason : undefined,
+        created_at: Number(row.created_at),
+    };
+}
+async function appendMemoryEvent(input) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const eventId = `evt_${node_crypto_1.default.randomUUID().replace(/-/g, '')}`;
+    adapter
+        .prepare(`
+        INSERT INTO memory_events (
+          event_id, event_type, actor, source_turn_id, memory_id, topic,
+          scope_refs, evidence_refs, reason, created_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `)
+        .run(eventId, input.event_type, input.actor, input.source_turn_id ?? null, input.memory_id ?? null, input.topic ?? null, JSON.stringify(input.scope_refs), input.evidence_refs ? JSON.stringify(input.evidence_refs) : null, input.reason ?? null, input.created_at);
+    return eventId;
+}
+async function listMemoryEventsForTopic(topic) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const rows = adapter
+        .prepare(`
+        SELECT event_id, event_type, actor, source_turn_id, memory_id, topic,
+               scope_refs, evidence_refs, reason, created_at
+        FROM memory_events
+        WHERE topic = ?
+        ORDER BY created_at DESC
+      `)
+        .all(topic);
+    return rows.map(deserializeEvent);
+}
+async function listRecentMemoryEvents(limit = 10) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const rows = adapter
+        .prepare(`
+        SELECT event_id, event_type, actor, source_turn_id, memory_id, topic,
+               scope_refs, evidence_refs, reason, created_at
+        FROM memory_events
+        ORDER BY created_at DESC
+        LIMIT ?
+      `)
+        .all(limit);
+    return rows.map(deserializeEvent);
+}
+//# sourceMappingURL=event-store.js.map

package/dist/memory/evolution-engine.d.ts

@@ -0,0 +1,22 @@
+import type { MemoryEdge, MemoryRecord } from './types.js';
+interface EvolutionInput {
+    incoming: Pick<MemoryRecord, 'topic' | 'summary' | 'kind'>;
+    existing: Array<Pick<MemoryRecord, 'id' | 'topic' | 'summary' | 'kind'> & {
+        _semanticMatch?: boolean;
+    }>;
+}
+export interface EvolutionResult {
+    edges: MemoryEdge[];
+}
+/**
+ * Resolve how an incoming memory relates to existing memories.
+ *
+ * Supersede rules (conservative — avoid information loss):
+ *   1. Raw → Extracted: structured fact replaces raw conversation (same topic, raw kind)
+ *   2. Same fact update: same topic + high summary overlap (≥0.6) between two extracted facts
+ *
+ * Everything else → builds_on (preserves independent facts under same topic)
+ */
+export declare function resolveMemoryEvolution(input: EvolutionInput): EvolutionResult;
+export {};
+//# sourceMappingURL=evolution-engine.d.ts.map

package/dist/memory/evolution-engine.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveMemoryEvolution = resolveMemoryEvolution;
+const STOP_WORDS = new Set([
+    'the',
+    'is',
+    'a',
+    'an',
+    'to',
+    'in',
+    'on',
+    'of',
+    'for',
+    'and',
+    'or',
+    'but',
+    'it',
+    'we',
+    'i',
+    'this',
+    'that',
+    'with',
+    'as',
+    'at',
+    'by',
+    'from',
+    'be',
+    'are',
+    'was',
+    'were',
+    'been',
+    'has',
+    'have',
+    'had',
+    'do',
+    'does',
+    'did',
+    'will',
+    'would',
+    'can',
+    'could',
+    'should',
+    'not',
+    'no',
+    'so',
+    'if',
+    'up',
+    'out',
+    'all',
+    'its',
+    'user',
+    'assistant',
+]);
+const MIN_TOKEN_LENGTH = 3;
+function summaryOverlapRatio(left, right) {
+    const tokenize = (s) => new Set(s
+        .toLowerCase()
+        .split(/[^a-z0-9_]+/)
+        .filter((t) => t.length >= MIN_TOKEN_LENGTH && !STOP_WORDS.has(t)));
+    const leftTokens = tokenize(left);
+    const rightTokens = tokenize(right);
+    if (leftTokens.size === 0 && rightTokens.size === 0) {
+        return left.toLowerCase().trim() === right.toLowerCase().trim() ? 1 : 0;
+    }
+    const smaller = leftTokens.size <= rightTokens.size ? leftTokens : rightTokens;
+    const larger = leftTokens.size > rightTokens.size ? leftTokens : rightTokens;
+    let shared = 0;
+    for (const t of smaller) {
+        if (larger.has(t))
+            shared++;
+    }
+    return shared / Math.max(smaller.size, 1);
+}
+/**
+ * Resolve how an incoming memory relates to existing memories.
+ *
+ * Supersede rules (conservative — avoid information loss):
+ *   1. Raw → Extracted: structured fact replaces raw conversation (same topic, raw kind)
+ *   2. Same fact update: same topic + high summary overlap (≥0.6) between two extracted facts
+ *
+ * Everything else → builds_on (preserves independent facts under same topic)
+ */
+function resolveMemoryEvolution(input) {
+    const edges = [];
+    for (const existing of input.existing) {
+        if (existing.topic === input.incoming.topic) {
+            // Rule 1: Raw → Extracted supersede (ingestConversation saves raw first, then extracted)
+            // Raw records have kind='fact' but summary starts with conversation text (role prefixes)
+            const existingIsRaw = existing.kind === 'fact' && /^(user:|assistant:)/i.test(existing.summary.trim());
+            if (existingIsRaw) {
+                edges.push({
+                    from_id: 'incoming',
+                    to_id: existing.id,
+                    type: 'supersedes',
+                    reason: 'Structured extraction replaces raw conversation',
+                });
+                continue;
+            }
+            // Rule 2: Same fact update — supersede if summaries share meaningful overlap.
+            // Threshold 0.3 balances: "Use SQLite" → "Switch to PostgreSQL" (same topic, genuine update)
+            // vs "User's cat Luna" / "User's wedding plan" (same topic, independent facts).
+            const overlap = summaryOverlapRatio(existing.summary, input.incoming.summary);
+            if (overlap >= 0.3) {
+                edges.push({
+                    from_id: 'incoming',
+                    to_id: existing.id,
+                    type: 'supersedes',
+                    reason: `Updated fact (${(overlap * 100).toFixed(0)}% overlap)`,
+                });
+                continue;
+            }
+            // Different content under same topic → independent facts, link as builds_on
+            edges.push({
+                from_id: 'incoming',
+                to_id: existing.id,
+                type: 'builds_on',
+                reason: `Related but distinct (${(overlap * 100).toFixed(0)}% overlap)`,
+            });
+            continue;
+        }
+        // Semantic candidates (vector similarity >= 0.82) → builds_on
+        if (existing._semanticMatch) {
+            edges.push({
+                from_id: 'incoming',
+                to_id: existing.id,
+                type: 'builds_on',
+                reason: 'Semantically similar memory detected via vector search',
+            });
+        }
+    }
+    return { edges };
+}
+//# sourceMappingURL=evolution-engine.js.map

package/dist/memory/extraction-prompt.d.ts

@@ -0,0 +1,4 @@
+import { type ConversationMessage, type ExtractedMemoryUnit } from './types.js';
+export declare function buildExtractionPrompt(messages: ConversationMessage[], existingTopics?: string[]): string;
+export declare function parseExtractionResponse(response: string): ExtractedMemoryUnit[];
+//# sourceMappingURL=extraction-prompt.d.ts.map