@remnic/core 9.25.2 → 9.25.4

package/dist/access-cli.js

@@ -1,6 +1,6 @@
 import {
   Orchestrator
-} from "./chunk-LFHMUWA2.js";
+} from "./chunk-FDAPXLRC.js";
 import "./chunk-4B77XSG5.js";
 import "./chunk-B7GROTXD.js";
 import "./chunk-DPYYSG6F.js";
@@ -61,9 +61,9 @@ import "./chunk-PHRLJFWZ.js";
 import "./chunk-64NJRYU2.js";
 import "./chunk-K2TDK7GG.js";
 import "./chunk-LTHVM4XN.js";
-import "./chunk-GBAJCDTW.js";
+import "./chunk-BUK2FXOL.js";
 import "./chunk-4RA3C3EV.js";
-import "./chunk-5GSUBCZM.js";
+import "./chunk-TGTTESJS.js";
 import "./chunk-54V4BZWP.js";
 import "./chunk-2CGLBUW3.js";
 import "./chunk-WLZYGLJ4.js";

package/dist/{chunk-GBAJCDTW.js → chunk-BUK2FXOL.js}

@@ -9,7 +9,7 @@ import {
   ProactiveExtractionResultSchema,
   ProactiveQuestionsResultSchema,
   buildProfileConsolidationResultSchema
-} from "./chunk-5GSUBCZM.js";
+} from "./chunk-TGTTESJS.js";
 import {
   normalizeReasoningTrace
 } from "./chunk-54V4BZWP.js";
@@ -43,6 +43,9 @@ import {
 import {
   normalizeProcedureSteps
 } from "./chunk-QDW3E4RD.js";
+import {
+  isMemoryCategory
+} from "./chunk-CGASUJVP.js";
 import {
   FallbackLlmClient,
   fallbackLlmRuntimeContextFromConfig,
@@ -74,6 +77,41 @@ import {
 // src/extraction.ts
 import OpenAI from "openai";
 var PROACTIVE_MIN_CONFIDENCE = 0.8;
+var EXTRACTION_RESPONSE_SHAPE = `{
+  "facts": [{
+    "category": "<category>",
+    "content": "<source-grounded statement>",
+    "confidence": 0.0,
+    "tags": ["<tag>"],
+    "entityRef": "<optional normalized-name>",
+    "promptedByQuestion": "<optional source-grounded question>",
+    "quote": "<optional exact contiguous source span>",
+    "scope": "<optional project-or-global>",
+    "structuredAttributes": {"<key>": "<value>"},
+    "procedureSteps": [{"order": 1, "intent": "<step>"}, {"order": 2, "intent": "<step>"}],
+    "reasoningTrace": {
+      "steps": [{"order": 1, "description": "<step>"}, {"order": 2, "description": "<step>"}],
+      "finalAnswer": "<answer>",
+      "observedOutcome": "<optional outcome>"
+    },
+    "eventTime": "<optional source temporal expression>"
+  }],
+  "entities": [{
+    "name": "<normalized-name>",
+    "type": "<entity-type>",
+    "facts": ["<source-grounded statement>"],
+    "promptedByQuestion": "<optional source-grounded question>",
+    "structuredSections": [{"key": "<section-key>", "title": "<section-title>", "facts": ["<source-grounded statement>"]}]
+  }],
+  "profileUpdates": ["<source-grounded profile update>"],
+  "questions": [{"question": "<source-grounded unresolved question>", "context": "<source-grounded context>", "priority": 0.0}],
+  "identityReflection": "<conversation-grounded agent reflection>",
+  "relationships": [{"source": "<normalized-name>", "target": "<normalized-name>", "label": "<source-grounded relationship>"}]
+}`;
+var EXTRACTION_RESPONSE_PLACEHOLDERS = {};
+for (const placeholder of EXTRACTION_RESPONSE_SHAPE.match(/<[^<>\r\n]+>/g) ?? []) {
+  EXTRACTION_RESPONSE_PLACEHOLDERS[placeholder] = true;
+}
 var CONSOLIDATION_RESPONSE_SCHEMA = `{
   "items": [
     {
@@ -90,6 +128,35 @@ var CONSOLIDATION_RESPONSE_SCHEMA = `{
 function isPlainRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function containsExtractionPlaceholder(value) {
+  if (typeof value === "string") return EXTRACTION_RESPONSE_PLACEHOLDERS[value.trim()] === true;
+  if (Array.isArray(value)) return value.some(containsExtractionPlaceholder);
+  return isPlainRecord(value) && Object.values(value).some(containsExtractionPlaceholder);
+}
+function extractionText(value) {
+  if (typeof value !== "string") return void 0;
+  const text = value.trim();
+  return text.length > 0 && !containsExtractionPlaceholder(text) ? text : void 0;
+}
+function extractionAttributes(value) {
+  if (!isPlainRecord(value)) return void 0;
+  const attributes = {};
+  for (const [key, candidate] of Object.entries(value)) {
+    const normalizedKey = extractionText(key);
+    const normalizedValue = extractionText(candidate);
+    if (normalizedKey !== void 0 && normalizedValue !== void 0) {
+      attributes[normalizedKey] = normalizedValue;
+    }
+  }
+  return Object.keys(attributes).length > 0 ? attributes : void 0;
+}
+function extractionEntityType(value) {
+  const type = extractionText(value);
+  if (type === "person" || type === "project" || type === "tool" || type === "company" || type === "place" || type === "other") {
+    return type;
+  }
+  return void 0;
+}
 function normalizeQuestion(question) {
   const priority = Number.isFinite(question.priority) ? Math.max(0, Math.min(1, question.priority)) : 0.5;
   return {
@@ -209,82 +276,111 @@ var ExtractionEngine = class {
     return !!parsed && typeof parsed === "object" && !Array.isArray(parsed) && ("facts" in parsed || "entities" in parsed || "profileUpdates" in parsed || "questions" in parsed || "relationships" in parsed || "identityReflection" in parsed);
   }
   normalizeExtractionResultPayload(parsed) {
-    const entities = Array.isArray(parsed?.entities) ? parsed.entities.map((e) => this.normalizeEntityUpdate(e)).filter((e) => e.name.length > 0) : [];
-    const facts = Array.isArray(parsed?.facts) ? parsed.facts.map((f) => ({
-      category: typeof f?.category === "string" ? f.category : "fact",
-      content: typeof f?.content === "string" ? f.content : typeof f?.text === "string" ? f.text : "",
-      confidence: typeof f?.confidence === "number" ? f.confidence : 0.7,
-      tags: Array.isArray(f?.tags) ? f.tags.filter((t) => typeof t === "string") : [],
-      entityRef: typeof f?.entityRef === "string" ? f.entityRef : void 0,
-      promptedByQuestion: typeof f?.promptedByQuestion === "string" ? f.promptedByQuestion : void 0,
-      scope: f?.scope === "global" || f?.scope === "project" ? f.scope : void 0,
-      structuredAttributes: f?.structuredAttributes && typeof f.structuredAttributes === "object" && !Array.isArray(f.structuredAttributes) ? Object.fromEntries(
-        Object.entries(f.structuredAttributes).filter(([k, v]) => typeof k === "string" && typeof v === "string")
-      ) : void 0,
-      procedureSteps: Array.isArray(f?.procedureSteps) ? normalizeProcedureSteps(f.procedureSteps) : void 0,
-      reasoningTrace: (() => {
-        const candidate = f?.reasoningTrace && typeof f.reasoningTrace === "object" && !Array.isArray(f.reasoningTrace) ? f.reasoningTrace : f?.reasoning_trace && typeof f.reasoning_trace === "object" && !Array.isArray(f.reasoning_trace) ? f.reasoning_trace : null;
-        return candidate ? normalizeReasoningTrace(candidate) ?? void 0 : void 0;
-      })(),
-      // Issue #1575 PR 2: the LLM provides a verbatim supporting quote
-      // per fact. Optional/nullable per repo gotcha 6 (OpenAI Responses
-      // API emits null for absent optional fields). The post-parse
-      // validator (buildFactProvenance) locates this quote in the
-      // buffered turns and builds verified ProvenanceSource[] entries.
-      quote: typeof f?.quote === "string" && f.quote.trim().length > 0 ? f.quote : void 0,
-      eventTime: typeof f?.eventTime === "string" && f.eventTime.trim().length > 0 ? f.eventTime.trim() : typeof f?.event_time === "string" && f.event_time.trim().length > 0 ? f.event_time.trim() : void 0
-    })).filter((f) => f.content.length > 0) : [];
-    const questions = Array.isArray(parsed?.questions) ? parsed.questions.map((q) => {
-      if (typeof q === "string") return { question: q, context: "", priority: 0.5 };
+    const entities = Array.isArray(parsed?.entities) ? parsed.entities.map((candidate) => this.normalizeEntityUpdate(candidate)).filter((entity) => entity !== void 0 && entity.name.length > 0) : [];
+    const facts = Array.isArray(parsed?.facts) ? parsed.facts.map((candidate) => {
+      const f = isPlainRecord(candidate) ? candidate : {};
+      const category = typeof f.category === "string" ? f.category.trim() : "fact";
+      const reasoningTraceInput = isPlainRecord(f.reasoningTrace) ? f.reasoningTrace : isPlainRecord(f?.reasoning_trace) ? f.reasoning_trace : void 0;
+      if (!isMemoryCategory(category)) return void 0;
+      const procedureSteps = Array.isArray(f.procedureSteps) ? normalizeProcedureSteps(f.procedureSteps) : void 0;
+      const reasoningTrace = reasoningTraceInput ? normalizeReasoningTrace(reasoningTraceInput) ?? void 0 : void 0;
+      if (containsExtractionPlaceholder(procedureSteps) || containsExtractionPlaceholder(reasoningTrace)) {
+        return void 0;
+      }
       return {
-        question: typeof q?.question === "string" ? q.question : typeof q?.text === "string" ? q.text : "",
-        context: typeof q?.context === "string" ? q.context : "",
-        priority: typeof q?.priority === "number" ? q.priority : 0.5
+        category,
+        content: extractionText(f.content) ?? extractionText(f.text) ?? "",
+        confidence: typeof f.confidence === "number" ? f.confidence : 0.7,
+        tags: Array.isArray(f.tags) ? f.tags.flatMap((tag) => {
+          const text = extractionText(tag);
+          return text === void 0 ? [] : [text];
+        }) : [],
+        entityRef: extractionText(f.entityRef),
+        promptedByQuestion: extractionText(f.promptedByQuestion),
+        scope: f.scope === "global" || f.scope === "project" ? f.scope : void 0,
+        structuredAttributes: extractionAttributes(f.structuredAttributes),
+        procedureSteps,
+        reasoningTrace,
+        quote: extractionText(f.quote),
+        eventTime: extractionText(f.eventTime) ?? extractionText(f.event_time)
       };
-    }).filter((q) => q.question.length > 0) : [];
+    }).filter((fact) => fact !== void 0 && fact.content.length > 0) : [];
+    const questions = Array.isArray(parsed?.questions) ? parsed.questions.flatMap((candidate) => {
+      const record = isPlainRecord(candidate) ? candidate : void 0;
+      const question = extractionText(record?.question) ?? extractionText(record?.text) ?? extractionText(candidate);
+      if (question === void 0) return [];
+      return [{
+        question,
+        context: extractionText(record?.context) ?? "",
+        priority: typeof record?.priority === "number" ? record.priority : 0.5
+      }];
+    }) : [];
+    const profileUpdates = Array.isArray(parsed?.profileUpdates) ? parsed.profileUpdates.flatMap((candidate) => {
+      const update = extractionText(candidate);
+      return update === void 0 ? [] : [update];
+    }) : [];
+    const relationships = Array.isArray(parsed?.relationships) ? parsed.relationships.flatMap((candidate) => {
+      const relationship = isPlainRecord(candidate) ? candidate : void 0;
+      const source = extractionText(relationship?.source);
+      const target = extractionText(relationship?.target);
+      const label = extractionText(relationship?.label);
+      if (source === void 0 || target === void 0 || label === void 0) return [];
+      return [{
+        source,
+        target,
+        label,
+        promptedByQuestion: extractionText(relationship?.promptedByQuestion)
+      }];
+    }) : void 0;
     return {
       facts,
       entities,
-      profileUpdates: Array.isArray(parsed?.profileUpdates) ? parsed.profileUpdates.filter((u) => typeof u === "string" && u.trim().length > 0) : [],
+      profileUpdates,
       questions,
-      identityReflection: parsed?.identityReflection ?? void 0,
-      relationships: Array.isArray(parsed?.relationships) ? parsed.relationships.filter(
-        (r) => typeof r?.source === "string" && typeof r?.target === "string" && typeof r?.label === "string"
-      ).map((r) => ({
-        source: r.source,
-        target: r.target,
-        label: r.label,
-        promptedByQuestion: typeof r?.promptedByQuestion === "string" ? r.promptedByQuestion : void 0
-      })) : void 0
+      identityReflection: extractionText(parsed?.identityReflection),
+      relationships
     };
   }
   normalizeEntityUpdate(entity) {
-    const rawUpdates = isPlainRecord(entity?.updates) ? entity.updates : null;
-    const directFacts = Array.isArray(entity?.facts) ? entity.facts.filter((fact) => typeof fact === "string").map((fact) => fact.trim()).filter((fact) => fact.length > 0) : [];
-    const updateFacts = rawUpdates && Array.isArray(rawUpdates.facts) ? rawUpdates.facts.filter((fact) => typeof fact === "string").map((fact) => fact.trim()).filter((fact) => fact.length > 0) : [];
-    const scalarUpdateFacts = rawUpdates ? Object.keys(rawUpdates).sort((a, b) => a.localeCompare(b)).filter((key) => !["facts", "name", "promptedByQuestion", "structuredSections", "type"].includes(key)).flatMap((key) => {
-      const value = rawUpdates[key];
-      if (typeof value === "string" && value.trim().length > 0) {
-        return [`${key}: ${value.trim()}`];
+    const record = isPlainRecord(entity) ? entity : {};
+    const rawUpdates = isPlainRecord(record.updates) ? record.updates : void 0;
+    const normalizedTexts = (value) => Array.isArray(value) ? value.flatMap((candidate) => {
+      const text = extractionText(candidate);
+      return text === void 0 ? [] : [text];
+    }) : [];
+    const directFacts = normalizedTexts(record.facts);
+    const updateFacts = normalizedTexts(rawUpdates?.facts);
+    const scalarUpdateFacts = rawUpdates ? Object.entries(rawUpdates).sort(([left], [right]) => left.localeCompare(right)).flatMap(([key, value]) => {
+      if (["facts", "name", "promptedByQuestion", "structuredSections", "type"].includes(key)) {
+        return [];
       }
+      const normalizedKey = extractionText(key);
+      if (normalizedKey === void 0) return [];
+      const normalizedValue = extractionText(value);
+      if (normalizedValue !== void 0) return [`${normalizedKey}: ${normalizedValue}`];
       if (typeof value === "number" || typeof value === "boolean") {
-        return [`${key}: ${String(value)}`];
+        return [`${normalizedKey}: ${String(value)}`];
       }
       return [];
     }) : [];
-    const structuredSectionsSource = Array.isArray(entity?.structuredSections) ? entity.structuredSections : Array.isArray(rawUpdates?.structuredSections) ? rawUpdates.structuredSections : [];
-    const name = typeof entity?.name === "string" ? entity.name.trim() : typeof entity?.entityId === "string" ? entity.entityId.trim() : typeof rawUpdates?.name === "string" ? rawUpdates.name.trim() : "";
-    const type = typeof entity?.type === "string" && entity.type.trim().length > 0 ? entity.type.trim() : typeof rawUpdates?.type === "string" && rawUpdates.type.trim().length > 0 ? rawUpdates.type.trim() : "other";
+    const structuredSectionsSource = Array.isArray(record.structuredSections) ? record.structuredSections : Array.isArray(rawUpdates?.structuredSections) ? rawUpdates.structuredSections : [];
+    const structuredSections = structuredSectionsSource.flatMap((candidate) => {
+      const section = isPlainRecord(candidate) ? candidate : {};
+      const key = extractionText(section.key);
+      const title = extractionText(section.title);
+      const facts = normalizedTexts(section.facts);
+      if (key === void 0 || title === void 0 || facts.length === 0) return [];
+      return [{ key, title, facts }];
+    });
+    const rawType = record.type ?? rawUpdates?.type;
+    const type = rawType === void 0 ? "other" : extractionEntityType(rawType);
+    if (type === void 0) return void 0;
     return {
-      name,
+      name: extractionText(record.name) ?? extractionText(record.entityId) ?? extractionText(rawUpdates?.name) ?? "",
       type,
       facts: [...directFacts, ...updateFacts, ...scalarUpdateFacts],
-      structuredSections: structuredSectionsSource.length > 0 ? structuredSectionsSource.map((section) => ({
-        key: typeof section?.key === "string" ? section.key.trim() : "",
-        title: typeof section?.title === "string" ? section.title.trim() : "",
-        facts: Array.isArray(section?.facts) ? section.facts.filter((fact) => typeof fact === "string").map((fact) => fact.trim()).filter((fact) => fact.length > 0) : []
-      })).filter((section) => section.key.length > 0 && section.title.length > 0 && section.facts.length > 0) : void 0,
-      promptedByQuestion: typeof entity?.promptedByQuestion === "string" ? entity.promptedByQuestion : typeof rawUpdates?.promptedByQuestion === "string" ? rawUpdates.promptedByQuestion : void 0
+      structuredSections: structuredSections.length > 0 ? structuredSections : void 0,
+      promptedByQuestion: extractionText(record.promptedByQuestion) ?? extractionText(rawUpdates?.promptedByQuestion)
     };
   }
   parseJsonObject(content) {
@@ -372,7 +468,7 @@ var ExtractionEngine = class {
     const profileUpdates = (Array.isArray(result.profileUpdates) ? result.profileUpdates : []).map(
       (update) => typeof update === "string" ? update.trim() : typeof update?.content === "string" ? update.content.trim() : ""
     ).filter((update) => update.length > 0);
-    const entityUpdates = (Array.isArray(result.entityUpdates) ? result.entityUpdates : []).map((entity) => this.normalizeEntityUpdate(entity)).filter((entity) => entity.name.length > 0);
+    const entityUpdates = (Array.isArray(result.entityUpdates) ? result.entityUpdates : []).map((entity) => this.normalizeEntityUpdate(entity)).filter((entity) => entity !== void 0 && entity.name.length > 0);
     return { items, profileUpdates, entityUpdates };
   }
   async applyProactiveQuestionPass(conversation, base) {
@@ -951,22 +1047,8 @@ var ExtractionEngine = class {
           log.debug(
             `extracted ${result.facts.length} facts, ${result.entities.length} entities, ${(result.questions ?? []).length} questions via fallback (${detailed.modelUsed})`
           );
-          const normalizedFacts = result.facts.map((f) => {
-            if (!f) return f;
-            const eventTime = typeof f.eventTime === "string" && f.eventTime.trim().length > 0 ? f.eventTime.trim() : typeof f.event_time === "string" && f.event_time.trim().length > 0 ? f.event_time.trim() : void 0;
-            if (!f.reasoningTrace && eventTime === void 0) return f;
-            return {
-              ...f,
-              ...f.reasoningTrace ? { reasoningTrace: normalizeReasoningTrace(f.reasoningTrace) ?? void 0 } : {},
-              ...eventTime !== void 0 ? { eventTime } : {}
-            };
-          });
-          const sanitized = this.sanitizeExtractionResult({
-            ...result,
-            facts: normalizedFacts,
-            questions: result.questions ?? [],
-            identityReflection: result.identityReflection ?? void 0
-          }, messageTimestamp);
+          const normalized = this.normalizeExtractionResultPayload(result);
+          const sanitized = this.sanitizeExtractionResult(normalized, messageTimestamp);
           const finalResult = await this.applyProactiveQuestionPass(conversation, sanitized);
           return this.attachProvenanceToResult(finalResult, boundedTurns);
         }
@@ -1039,90 +1121,36 @@ var ExtractionEngine = class {
     const truncatedConversation = conversation.length > maxConversationChars ? conversation.slice(0, maxConversationChars) + "\n\n[truncated]" : conversation;
     const localPrompt = `You are a memory extraction system. Extract durable, reusable memories from this conversation.
 
-Memory categories \u2014 use the MOST SPECIFIC category that fits:
-- fact: Objective information about the world
-- preference: User likes, dislikes, or stylistic choices
-- correction: User correcting a mistake (highest priority)
-- entity: People, projects, tools, companies (use canonical hyphenated names like "my-project")
-- decision: Choices made with rationale
-- relationship: How entities relate (e.g., "Alice manages Bob")
-- principle: Durable rules or operating beliefs (e.g., "never use X API")
-- commitment: Promises, obligations, deadlines
-- moment: Emotionally significant events
-- skill: Demonstrated capabilities
-- rule: Explicit operational rules or constraints
-- procedure: Repeatable workflows \u2014 use when the user describes a multi-step play (\u22652 ordered steps). Put the human-readable trigger/context in "content" (e.g. "When you deploy\u2026") and list steps in "procedureSteps" as [{"order":1,"intent":"\u2026"}, \u2026] mirroring the gateway extraction schema.
-- reasoning_trace: Stored solution chains \u2014 use when the user narrates HOW they solved a specific problem step-by-step ("here's how I figured out\u2026", "the debugging went like this\u2026"). Put a short title in "content" (e.g. "How I debugged the staging latency spike") and the chain in "reasoningTrace": {"steps":[{"order":1,"description":"\u2026"}, \u2026], "finalAnswer":"\u2026", "observedOutcome":"\u2026" (optional)}. Require \u22652 ordered steps and a finalAnswer. Do NOT use for ordinary decisions (prefer "decision") or reusable workflows (prefer "procedure").
-
-IMPORTANT: Do NOT label everything as "fact". Use "decision" for architectural choices, "commitment" for deadlines/promises, "principle" for reusable rules, "correction" for when the user rejects a suggestion, etc.
-
-=== DO NOT EXTRACT (negative examples) ===
-These are operational noise - skip them:
-- "The user has a cron job that runs every 30 minutes" (scheduled task descriptions)
-- "The user encountered error XYZ at 3:45 PM" (temporary error states)
-- "The file is located at /path/to/project/file" (transient file paths)
-- "The system is using 4GB of memory" (current resource usage)
-- "The user ran the 'git status' command" (individual command executions)
-- "The conversation took place on Tuesday" (session metadata)
-- "The agent read the file at /path/to/file.txt" (agent's own actions)
-- "The user's OpenClaw automation posts to #channel on failures" (automation behavior descriptions)
-- "The user stores state in /path/to/state.json" (implementation details)
-- "The X-watch automation has been stalled for 58 hours" (system status updates)
-- "The user processed 5 batch files and extracted insights" (processing summaries)
-- "The user has a cron job that runs a Checkpoint Loop every 2 hours" (automation schedules)
-- "The user runs a Morning Surprise cron job daily at 7:30 AM" (automation schedules)
-- "The user runs an X Bookmarks \u2192 Insights pipeline hourly at :13" (automation schedules)
-- "The user's system mines X/Twitter mentions for ideas every 10a/2p/6p" (automation schedules)
-- "The user runs a Health Insights cron job weekday mornings" (automation schedules)
-- "The system monitors the showcase page every 12 hours" (system monitoring configurations)
-
-=== DO EXTRACT (positive examples) ===
-These are durable insights - capture them:
-- "The user prefers dark mode interfaces and finds light mode uncomfortable" (preference)
-- "The user works primarily with TypeScript and avoids Python for frontend code" (long-term fact)
-- "The user's side project 'alpha-trader' uses a custom algorithm for arbitrage" (entity + detail)
-- "The user corrected that PostgreSQL 15 is required, not version 14" (correction)
-- "The user never commits code without running tests first" (principle)
-- "The user has a meeting with the design team every Friday at 2pm" (commitment)
-
-=== Rules ===
-- Extract only NEW information worth remembering across sessions
-- Skip transient details (file paths, current errors, temporary states, agent actions)
-- Confidence: Explicit (0.95-1.0), Implied (0.70-0.94), Inferred (0.40-0.69), Speculative (0.00-0.39)${this.config.provenance?.enabled ? `
-- Source quotes: For each fact, include a "quote" field with the EXACT verbatim words from the conversation that support the fact (copy a contiguous span from a single turn, not a paraphrase). Cap at ~300 chars.` : ""}
-- Corrections get highest confidence (0.95+)
-- Each fact should be standalone and self-contained
-- Lines labelled [context user] or [context assistant] are reference context only. Use them to resolve pronouns and adjacent question/answer pairs, but do not extract a memory stated only in context lines unless a normal [user] or [assistant] line confirms or completes it.
-- CRITICAL: Use canonical hyphenated entity names (e.g., "jane-doe" not "janedoe")
-- CRITICAL: NEVER extract the same fact twice - check for duplicates before adding to facts array
-- CRITICAL: NEVER extract cron job schedules, automation configurations, or system monitoring details (these are operational noise)
-- If uncertain about relevance, prefer NOT extracting${lifecycleCaps.extractionScopeClassification ? `
-- For each fact, set "scope" to "global" (cross-project knowledge: framework bugs, library behavior, user preferences, tool configs, general patterns) or "project" (codebase-specific: file paths, env configs, deployment details, project workarounds). When in doubt, prefer "project".` : ""}
-
-=== Structured Attributes ===
-When a fact contains measurable, categorical, or precisely valued data, add a "structuredAttributes" object with key-value string pairs. This captures exact values for precise retrieval later.
-Examples of when to add structuredAttributes:
-- Product details: {"price": "29.99", "brand": "Sony", "color": "black", "rating": "4.5"}
-- Person details: {"age": "32", "occupation": "engineer", "city": "Austin"}
-- Events with dates: {"date": "2024-03-15", "location": "San Francisco"}
-- Decisions: {"chosen": "PostgreSQL", "rejected": "MongoDB", "reason": "ACID compliance"}
-- Quantities/measurements: {"budget": "50000", "team_size": "5", "deadline": "2024-06-01"}
-Only add structuredAttributes when there are concrete values. Skip for abstract or narrative facts.
-${this.eventTimePromptInstruction()}
-Also generate:
-1. 1-3 genuine questions you're curious about from this conversation
-2. Profile updates about user patterns/behaviors (if any)
-3. Relationships between entities (max 5). Use normalized names like "person-jane-doe", "company-acme-corp".
-4. For entity facts that fit a durable named heading, include entity.structuredSections with {key, title, facts}.
+Use the most specific category:
+- fact: objective information
+- preference: a durable preference or style
+- correction: a correction of a prior mistake
+- entity: a durable person, project, tool, company, or place
+- decision: a choice with rationale
+- relationship: a durable link between two entities
+- principle: a reusable rule or operating belief
+${resolveRecallAuxiliaryCapabilities(this.config).causalRuleExtraction ? "- rule: an explicit causal rule or constraint\n" : ""}- commitment: a promise, obligation, or deadline
+- moment: a significant milestone
+- skill: a demonstrated capability
+- procedure: an explicit reusable workflow with ordered procedureSteps
+- reasoning_trace: Stored solution chains \u2014 an explicitly narrated solution path with reasoningTrace. Use {"category": "reasoning_trace", "reasoningTrace": {"steps": [...], "finalAnswer": "..."}} only when the conversation provides the chain.
 
-Output JSON:
-{
-  "facts": [{"category": "decision", "content": "Chose PostgreSQL over MongoDB for the user service", "importance": 8, "confidence": 0.9, "scope": "project", "structuredAttributes": {"chosen": "PostgreSQL", "rejected": "MongoDB"}}, {"category": "procedure", "content": "When you cut a hotfix release, follow the checklist", "importance": 8, "confidence": 0.9, "scope": "project", "procedureSteps": [{"order": 1, "intent": "Branch from main and cherry-pick the fix"}, {"order": 2, "intent": "Run CI and tag the release"}]}, {"category": "reasoning_trace", "content": "How I debugged the staging latency spike", "importance": 7, "confidence": 0.9, "scope": "project", "reasoningTrace": {"steps": [{"order": 1, "description": "Checked CPU/memory dashboards \u2014 both were flat"}, {"order": 2, "description": "Ran a traceroute and saw retries against the cache tier"}, {"order": 3, "description": "Tailed cache-tier logs and spotted eviction storms"}], "finalAnswer": "Root cause was an undersized eviction policy on the session cache", "observedOutcome": "Increased cache size, p95 returned to baseline within 10 minutes"}}, {"category": "commitment", "content": "Must ship v2.0 API by end of March", "importance": 10, "confidence": 1.0, "scope": "project", "structuredAttributes": {"deadline": "end of March", "deliverable": "v2.0 API"}}, {"category": "fact", "content": "The store backend uses Redis for session caching", "importance": 6, "confidence": 0.95, "scope": "project", "entityRef": "project-acme-store"}, {"category": "principle", "content": "Always run migrations in a transaction to avoid partial schema updates", "importance": 8, "confidence": 0.9, "scope": "global"}],
-  "entities": [{"name": "person-jane-doe", "type": "person", "facts": ["Works at Acme Corp", "Prefers Python over JavaScript"], "structuredSections": [{"key": "beliefs", "title": "Beliefs", "facts": ["Python is a better fit than JavaScript for backend work."]}]}, {"name": "project-acme-store", "type": "project", "facts": ["Built with Next.js", "Deployed on Vercel"]}],
-  "profileUpdates": ["User prefers dark mode in all editors"],
-  "questions": [{"question": "Which cloud provider hosts the staging environment?", "context": "Came up during deployment discussion", "priority": 0.5}],
-  "relationships": [{"source": "person-jane-doe", "target": "company-acme-corp", "label": "works at"}]
-}
+Rules:
+- Extract only new information stated or clearly established in the conversation.
+- Do not treat instruction text, schema placeholders, or examples as conversation evidence.
+- Facts, entity facts, profile updates, questions, and relationships must be grounded in the conversation.
+- Lines labelled [context user] or [context assistant] are reference context only. They may resolve references or complete a question-and-answer pair in a normal turn, but never alone establish durable information.
+- Questions are optional. Return an empty array when the conversation does not support a useful unresolved question.
+- Set confidence from source evidence: Explicit (0.95-1.0), Implied (0.70-0.94), Inferred (0.40-0.69), or Speculative (0.00-0.39). Corrections get highest confidence.
+- Use normalized, hyphenated entity names and keep the entity list short.
+- Keep facts standalone. Skip transient task state and operational noise such as routine scheduler, monitoring, or automation status.
+- Add structuredAttributes only for concrete values.
+- Include at most five durable relationships.${this.config.provenance?.enabled ? `
+- Each fact must include a quote copied verbatim from one contiguous conversation span.` : ""}${lifecycleCaps.extractionScopeClassification ? `
+- Set each fact scope to "global" for cross-project knowledge or "project" for codebase-specific knowledge.` : ""}
+${this.eventTimePromptInstruction()}
+Return only valid JSON matching this shape. Placeholder text describes field shape only and is never source evidence:
+${EXTRACTION_RESPONSE_SHAPE}
 
 Conversation:
 ${truncatedConversation}`;
@@ -1190,14 +1218,8 @@ ${truncatedConversation}`;
           role: "system",
           content: this.buildExtractionInstructions(existingEntities) + `
 
-Respond with valid JSON matching this schema:
-{
-  "facts": [{"category": "decision", "content": "Chose React over Vue for the dashboard rewrite", "importance": 8, "confidence": 0.9, "tags": ["frontend"], "scope": "project", "structuredAttributes": {"chosen": "React", "rejected": "Vue"}}, {"category": "fact", "content": "The API gateway uses rate limiting at 1000 req/min", "importance": 6, "confidence": 0.95, "tags": ["infra"], "scope": "project", "entityRef": "project-dashboard", "structuredAttributes": {"rate_limit": "1000 req/min"}}, {"category": "reasoning_trace", "content": "How I chose the dashboard rewrite framework", "confidence": 0.9, "tags": ["frontend"], "scope": "project", "reasoningTrace": {"steps": [{"order": 1, "description": "Listed constraints: SSR needed, team mostly JS"}, {"order": 2, "description": "Ran a spike in Vue 3 \u2014 worked, but ecosystem felt thin for our needs"}, {"order": 3, "description": "Ran the same spike in React \u2014 integrated faster with Next.js"}], "finalAnswer": "Picked React with Next.js for SSR + ecosystem fit"}}],
-  "entities": [{"name": "person-sarah-chen", "type": "person", "facts": ["Leads the backend team", "Joined from Google in 2024"], "structuredSections": [{"key": "beliefs", "title": "Beliefs", "facts": ["Small teams should own whole systems."]}]}, {"name": "project-dashboard", "type": "project", "facts": ["React-based admin panel", "Deployed on AWS ECS"]}],
-  "profileUpdates": ["User prefers TypeScript over plain JavaScript"],
-  "questions": [{"question": "What database does the analytics service use?", "context": "Came up during discussion of migration plan", "priority": 0.5}],
-  "relationships": [{"source": "person-sarah-chen", "target": "project-dashboard", "label": "leads development of"}]
-}`
+Return only valid JSON matching this shape. Placeholder text describes field shape only and is never source evidence:
+${EXTRACTION_RESPONSE_SHAPE}`
         },
         { role: "user", content: conversation }
       ],
@@ -1226,37 +1248,14 @@ Respond with valid JSON matching this schema:
    * Local LLMs sometimes hit token limits mid-JSON. This tries to salvage valid facts.
    */
   extractPartialFacts(jsonStr) {
-    const allowedCategories = /* @__PURE__ */ new Set([
-      "fact",
-      "preference",
-      "correction",
-      "entity",
-      "decision",
-      "relationship",
-      "principle",
-      "commitment",
-      "moment",
-      "skill",
-      "rule",
-      "procedure",
-      "reasoning_trace"
-    ]);
-    const allowedEntityTypes = /* @__PURE__ */ new Set([
-      "person",
-      "project",
-      "tool",
-      "company",
-      "place",
-      "other"
-    ]);
     const facts = [];
     const entities = [];
     try {
       const factRegex = /\{\s*"category"\s*:\s*"([^"]+)"\s*,\s*"content"\s*:\s*"([^"]+)"\s*,\s*"confidence"\s*:\s*([0-9.]+)/g;
       let match;
       while ((match = factRegex.exec(jsonStr)) !== null) {
-        const rawCat = match[1];
-        const category = allowedCategories.has(rawCat) ? rawCat : "fact";
+        const category = match[1]?.trim() ?? "";
+        if (!isMemoryCategory(category)) continue;
         facts.push({
           category,
           content: match[2].replace(/\\n/g, "\n").replace(/\\"/g, '"'),
@@ -1266,8 +1265,8 @@ Respond with valid JSON matching this schema:
       }
       const entityRegex = /\{\s*"name"\s*:\s*"([^"]+)"\s*,\s*"type"\s*:\s*"([^"]+)"/g;
       while ((match = entityRegex.exec(jsonStr)) !== null) {
-        const rawType = match[2];
-        const type = allowedEntityTypes.has(rawType) ? rawType : "other";
+        const type = extractionEntityType(match[2]);
+        if (type === void 0) continue;
         entities.push({
           name: match[1],
           type,
@@ -1276,7 +1275,7 @@ Respond with valid JSON matching this schema:
       }
     } catch {
     }
-    return { facts, entities, profileUpdates: [], questions: [] };
+    return this.normalizeExtractionResultPayload({ facts, entities, profileUpdates: [], questions: [] });
   }
   /**
    * Bi-temporal event-time extraction instruction (#1578 PR2). Emitted on
@@ -1289,15 +1288,7 @@ Respond with valid JSON matching this schema:
   eventTimePromptInstruction() {
     if (!this.config.temporalBiTemporal) return "";
     return `
-=== Event Time (bi-temporal) ===
-When a fact has an explicit temporal anchor \u2014 a date, month, season, or relative time expression stating WHEN the fact became (or stopped being) true \u2014 capture it verbatim in an "eventTime" field on that fact. Examples:
-- "We moved offices in March" \u2192 "eventTime": "last March"
-- "The API has been rate-limited since 2024" \u2192 "eventTime": "since 2024"
-- "I switched to PostgreSQL on 2025-01-15" \u2192 "eventTime": "2025-01-15"
-- "We used MongoDB until June 2025" \u2192 "eventTime": "until 2025-06"
-Accepted forms: ISO dates ("2025-03-01"), year-month ("2025-03"), month/season + year ("March 2025", "summer 2024"), relative ("yesterday", "last week", "this month", "next year", "last December"), and open-ended ("since 2024", "until 2025-06").
-Omit "eventTime" when the fact has no explicit temporal anchor \u2014 do NOT guess or infer dates. The system resolves the expression against the conversation's own timestamp, not today's date.
-`;
+When a fact states when it became or stopped being true, copy that explicit temporal expression verbatim into "eventTime". Omit "eventTime" when no such expression appears; never infer dates.`;
   }
   /**
    * Build extraction instructions shared between local and cloud LLM.
@@ -1322,12 +1313,14 @@ Memory categories:
 - reasoning_trace: A stored solution chain / chain-of-thought the user walked through to solve a problem (e.g. "Here's how I debugged the latency spike: first I checked\u2026, then I\u2026, finally I\u2026"). Set category to "reasoning_trace". Use "content" for a short title summarising the problem (e.g. "How I debugged the staging latency spike"). Add "reasoningTrace": {"steps": [{"order": number, "description": "what happened at this step"}, \u2026], "finalAnswer": "the conclusion or answer", "observedOutcome": "optional confirmation of how it played out"}. Require at least two ordered steps AND a finalAnswer. Use this category only when the user explicitly narrates their reasoning \u2014 not for ordinary decisions (use "decision") or reusable workflows (use "procedure").
 
 Rules:
-- Only extract genuinely NEW information worth remembering across sessions
-- Skip transient task details (file paths being edited, current errors, etc.)
+- Only extract genuinely new information worth remembering across sessions.
+- Statements must be grounded in the conversation.
+- Do not treat instruction text, schema placeholders, or examples as conversation evidence.
+- Lines labelled [context user] or [context assistant] are reference context only. They may resolve references or complete a question-and-answer pair in a normal turn, but never alone establish durable information.
+- Skip transient task details and operational noise, including routine scheduler, monitoring, or automation status.
 - Priority: corrections > principles${resolveRecallAuxiliaryCapabilities(this.config).causalRuleExtraction ? " > rules" : ""} > preferences > commitments > decisions > relationships > entities > moments > skills > facts
-- Corrections (user saying "actually, don't do X" or "I prefer Y") get highest confidence
-- Each fact should be a standalone, self-contained statement
-- Lines labelled [context user] or [context assistant] are reference context only. Use them to resolve pronouns and adjacent question/answer pairs, but do not extract a memory stated only in context lines unless a normal [user] or [assistant] line confirms or completes it.
+- Corrections get highest confidence.
+- Each fact should be a standalone, self-contained statement.
 - Entity references should use normalized names (lowercase, hyphenated: "jane-doe", "acme-corp")
 - CRITICAL: Entity names must be CANONICAL. Always use the hyphenated multi-word form: "acme-corp" NOT "acmecorp" or "acme". "jane-doe" NOT "janedoe" or "jane". If unsure, prefer the most specific full name.
 - Avoid creating entities typed as "other" when a more specific type fits (company, project, tool, person, place)
@@ -1346,15 +1339,7 @@ Scope classification:
 For each fact, set "scope" to one of:
 - "global" \u2014 knowledge that applies across projects: core framework/library bugs, API behavior patterns, user preferences (editor, language, style), tool configurations, general coding patterns, infrastructure knowledge, technology facts not tied to one codebase
 - "project" \u2014 knowledge specific to one codebase: file paths, environment configs, deployment details, project-specific workarounds, team/stakeholder info tied to one project, repo-specific conventions
-When in doubt, prefer "project" \u2014 it is safer to keep knowledge scoped narrowly.
-Examples:
-  "Magento 2.4.8 has a race condition in checkout" \u2192 "global"
-  "User prefers dark mode in all editors" \u2192 "global"
-  "The staging server is at staging.acme.com" \u2192 "project"
-  "The deploy script lives at scripts/deploy.sh" \u2192 "project"
-  "PostgreSQL 15 requires the uuid-ossp extension for gen_random_uuid()" \u2192 "global"
-  "The acme-store repo uses a custom Webpack config for SSR" \u2192 "project"` : ""}
-
+When in doubt, prefer "project" \u2014 it is safer to keep knowledge scoped narrowly.` : ""}
 Entity creation rules (STRICT):
 - Only create entities for DURABLE things: real people, companies, products, tools, ongoing projects
 - NEVER create entities for transient items: individual PRs, branches, Jira tickets, meetings, agent task IDs, log files, database tables, cron job runs, sessions
@@ -1375,14 +1360,9 @@ Also extract relationships between entities mentioned in the conversation.
 - Only include clear, durable relationships (e.g., "works at", "created", "manages", "uses")
 - Use normalized entity names (e.g., "person-jane-doe", "company-acme-corp")
 
-Also generate 1-3 genuine questions you're curious about based on this conversation. These should be things you'd actually want answers to in future sessions \u2014 not prompts, but real curiosity.
+Questions are optional. Include only source-grounded unresolved questions that would be useful in future sessions; otherwise return an empty array.
 
-Finally, write a brief identity reflection about the AGENT who had this conversation (not about you, the extraction system). Based on what the agent said and did in the conversation:
-- What communication patterns did the agent show? (e.g., proactive vs reactive, verbose vs concise)
-- Did the agent handle the user's needs well or miss something?
-- What behavioral tendencies are visible? (e.g., cautious, creative, thorough, impatient)
-- What could the agent improve next time?
-Do NOT write about the extraction process itself. Do NOT say things like "I extracted durable facts" \u2014 that's about YOUR job, not the agent's behavior.`;
+Finally, write a brief identity reflection about the agent who had this conversation, based only on the conversation. Do not write about the extraction process.`;
   }
   async consolidate(newMemories, existingMemories, currentProfile) {
     const newList = newMemories.map(
@@ -2453,4 +2433,4 @@ export {
   shouldEnableLocalExtractionThinking,
   ExtractionEngine
 };
-//# sourceMappingURL=chunk-GBAJCDTW.js.map
+//# sourceMappingURL=chunk-BUK2FXOL.js.map