@remnic/core 9.32.0 → 9.34.0

package/dist/{chunk-QDTZ2HF7.js → chunk-DMT2RGAZ.js}

@@ -1,10 +1,10 @@
 import {
   parseXrayFormat
-} from "./chunk-VMZ56EE3.js";
+} from "./chunk-MYXWPG5O.js";
 import {
   RECALL_DISCLOSURE_LEVELS,
   isRecallDisclosure
-} from "./chunk-VVDPPDDF.js";
+} from "./chunk-HXDWZFNP.js";
 
 // src/recall-xray-cli.ts
 function parseXrayDisclosureFlag(value) {
@@ -50,4 +50,4 @@ export {
   parseXrayBudgetFlag,
   parseXrayCliOptions
 };
-//# sourceMappingURL=chunk-QDTZ2HF7.js.map
+//# sourceMappingURL=chunk-DMT2RGAZ.js.map

package/dist/{chunk-QIHIHZYC.js → chunk-DP7ZV2II.js}

@@ -1,6 +1,12 @@
 import {
   looksLikeMechanicalTelemetryTranscript
 } from "./chunk-4RA3C3EV.js";
+import {
+  applyGroundingWithConnector,
+  headerConnector,
+  renderExtractionConversation,
+  resolveSourceConnector
+} from "./chunk-B6XHIBIB.js";
 import {
   ConsolidationResultSchema,
   DaySummaryResultSchema,
@@ -9,7 +15,7 @@ import {
   ProactiveExtractionResultSchema,
   ProactiveQuestionsResultSchema,
   buildProfileConsolidationResultSchema
-} from "./chunk-TGTTESJS.js";
+} from "./chunk-CMQZNEIF.js";
 import {
   normalizeReasoningTrace
 } from "./chunk-54V4BZWP.js";
@@ -23,7 +29,6 @@ import {
   LocalLlmClient
 } from "./chunk-ZCPP5OW6.js";
 import {
-  applyExtractionSourceGrounding,
   attachExtractionProvenance
 } from "./chunk-YIAA2X3D.js";
 import {
@@ -477,7 +482,7 @@ var ExtractionEngine = class {
     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, groundingSource, assertionSource, messageTimestamp, roleAssertionSources, signal) {
+  async applyProactiveQuestionPass(conversation, base, ctx, signal) {
     if (!resolvePipelineProcessingCapabilities(this.config).proactiveExtraction) return base;
     const maxAdditional = Math.max(0, Math.floor(this.config.maxProactiveQuestionsPerExtraction));
     if (!shouldRunProactivePass(this.config, maxAdditional, this.shouldUseLocalLlm, this.localLlm)) return base;
@@ -489,16 +494,11 @@ var ExtractionEngine = class {
         base,
         proactive,
         maxAdditional,
+        ctx.sourceConnector,
         signal
       );
-      const sanitizedAdditions = this.sanitizeExtractionResult(proactiveAdditions, messageTimestamp);
-      const groundedAdditions = this.applySourceGrounding(
-        sanitizedAdditions,
-        groundingSource,
-        assertionSource,
-        roleAssertionSources,
-        messageTimestamp
-      );
+      const sanitizedAdditions = this.sanitizeExtractionResult(proactiveAdditions, ctx.messageTimestamp);
+      const groundedAdditions = applyGroundingWithConnector(this.config, sanitizedAdditions, ctx);
       if (!this.hasExtractionOutputs(groundedAdditions)) return base;
       return this.mergeProactiveExtractionPass(base, groundedAdditions, maxAdditional);
     } catch (err) {
@@ -609,7 +609,7 @@ var ExtractionEngine = class {
     if (!fallbackResult?.questions) return [];
     return fallbackResult.questions.map((q) => normalizeQuestion(q)).filter((q) => q.question.length > 0).filter((q) => !existingQuestionKeys.has(q.question.toLowerCase())).slice(0, maxAdditional);
   }
-  async answerProactiveQuestions(conversation, base, proactiveQuestions, maxAdditional, signal) {
+  async answerProactiveQuestions(conversation, base, proactiveQuestions, maxAdditional, sourceConnector, signal) {
     const factsPreview = base.facts.slice(0, 8).map((f) => `- (${f.category}) ${f.content}`).join("\n");
     const entitiesPreview = base.entities.slice(0, 8).map((entity) => `- (${entity.type}) ${entity.name}: ${entity.facts.join("; ") || "(no facts)"}`).join("\n");
     const proactivePreview = proactiveQuestions.slice(0, maxAdditional).map((question, index) => `${index + 1}. ${question.question}${question.context ? `
@@ -626,6 +626,7 @@ var ExtractionEngine = class {
       // (chatgpt-codex thread on extraction.ts:1607). Returns "" when the
       // bi-temporal gate is off, keeping the prompt unchanged by default.
       this.eventTimePromptInstruction(),
+      headerConnector(sourceConnector) !== void 0 && resolveMemoryLifecycleCapabilities(this.config).extractionScopeClassification ? `Tool, command, or CLI-flag instructions tied to the ${sourceConnector} agent are "project" scope; when you recover one, begin the fact with a leading "In ${sourceConnector}, " clause naming that agent (e.g. "In ${sourceConnector}, use the search tool with a repository path.").` : "",
       "",
       "Base extracted facts (do not repeat):",
       factsPreview || "(none)",
@@ -829,22 +830,9 @@ var ExtractionEngine = class {
     }
     return null;
   }
-  applySourceGrounding(result, sourceText, assertionSourceText = sourceText, roleAssertionSources, messageTimestamp) {
-    const capabilities = resolvePipelineProcessingCapabilities(this.config);
-    return applyExtractionSourceGrounding(
-      result,
-      sourceText,
-      assertionSourceText,
-      roleAssertionSources,
-      messageTimestamp,
-      {
-        sourceGrounding: capabilities.sourceGrounding,
-        anchorTemporalExpressions: capabilities.delinearize
-      }
-    );
-  }
-  finalizeExtractionResult(result, turns) {
-    return attachExtractionProvenance(result, turns, this.config.provenance);
+  finalizeExtractionResult(result, turns, sourceConnector) {
+    const provenanced = attachExtractionProvenance(result, turns, this.config.provenance);
+    return sourceConnector === void 0 ? provenanced : { ...provenanced, sourceConnector };
   }
   async extract(turns, existingEntities, signal) {
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(this.config);
@@ -857,21 +845,20 @@ var ExtractionEngine = class {
       ...turn,
       content: turn.role === "assistant" ? applyWorkExtractionBoundary(turn.content) : turn.content
     })).filter((turn) => turn.content.trim().length > 0);
-    const conversation = boundedTurns.map((t) => {
-      const roleLabel = t.extractionContextOnly === true ? `context ${t.role}` : t.role;
-      return `[${roleLabel}] ${t.content}`;
-    }).join("\n\n");
+    const resolvedConnector = resolveSourceConnector(boundedTurns);
+    const sourceConnector = lifecycleCaps.extractionScopeClassification ? resolvedConnector : void 0;
+    const { conversation, renderedConversation } = renderExtractionConversation(boundedTurns, headerConnector(sourceConnector));
     const groundingSource = boundedTurns.map((turn) => turn.content).join("\n\n");
     const assertionSource = boundedTurns.filter((turn) => turn.extractionContextOnly !== true).map((turn) => turn.content).join("\n\n");
     const roleAssertionSources = {
       profile: boundedTurns.filter((turn) => turn.role === "user" && turn.extractionContextOnly !== true).map((turn) => turn.content).join("\n\n"),
       identity: boundedTurns.filter((turn) => turn.role === "assistant" && turn.extractionContextOnly !== true).map((turn) => turn.content).join("\n\n")
     };
-    if (conversation.trim().length === 0) {
+    if (renderedConversation.trim().length === 0) {
       log.debug("extraction skipped \u2014 conversation only contained non-memory work-layer context");
       return { facts: [], profileUpdates: [], entities: [], questions: [] };
     }
-    if (lifecycleCaps.extractionTelemetryPrefilter && looksLikeMechanicalTelemetryTranscript(conversation)) {
+    if (lifecycleCaps.extractionTelemetryPrefilter && looksLikeMechanicalTelemetryTranscript(renderedConversation)) {
       log.debug("extraction skipped \u2014 mechanical action/state telemetry without durable-memory cues");
       return {
         facts: [],
@@ -882,6 +869,14 @@ var ExtractionEngine = class {
     }
     const lastTurnTs = boundedTurns.length > 0 ? new Date(boundedTurns[boundedTurns.length - 1].timestamp) : void 0;
     const messageTimestamp = lastTurnTs && !isNaN(lastTurnTs.getTime()) ? lastTurnTs : void 0;
+    const groundingContext = {
+      groundingSource,
+      assertionSource,
+      roleAssertionSources,
+      messageTimestamp,
+      sourceConnector,
+      scopeClassificationEnabled: lifecycleCaps.extractionScopeClassification
+    };
     const traceId = crypto.randomUUID();
     const emittedDirectStart = !!(this.shouldUseDirectClient || this.shouldUseLocalLlm);
     if (emittedDirectStart) {
@@ -908,23 +903,9 @@ var ExtractionEngine = class {
             this.emit({ kind: "llm_end", traceId, model: this.config.localLlmModel, operation: "extraction", durationMs });
             log.debug(`extraction: used local LLM \u2014 ${localResult.facts.length} facts, ${localResult.entities.length} entities`);
             const sanitized = this.sanitizeExtractionResult(localResult, messageTimestamp);
-            const grounded = this.applySourceGrounding(
-              sanitized,
-              groundingSource,
-              assertionSource,
-              roleAssertionSources,
-              messageTimestamp
-            );
-            const finalResult = await this.applyProactiveQuestionPass(
-              conversation,
-              grounded,
-              groundingSource,
-              assertionSource,
-              messageTimestamp,
-              roleAssertionSources,
-              signal
-            );
-            return this.finalizeExtractionResult(finalResult, boundedTurns);
+            const grounded = applyGroundingWithConnector(this.config, sanitized, groundingContext);
+            const finalResult = await this.applyProactiveQuestionPass(conversation, grounded, groundingContext, signal);
+            return this.finalizeExtractionResult(finalResult, boundedTurns, resolvedConnector);
           }
           if (!this.config.localLlmFallback) {
             log.warn("extraction: local LLM failed and fallback disabled");
@@ -970,23 +951,9 @@ var ExtractionEngine = class {
             this.emit({ kind: "llm_end", traceId, model: this.config.model, operation: "extraction", durationMs });
             log.debug(`extraction: used direct client (${this.config.model}) \u2014 ${directResult.facts.length} facts, ${directResult.entities.length} entities`);
             const sanitized = this.sanitizeExtractionResult(directResult, messageTimestamp);
-            const grounded = this.applySourceGrounding(
-              sanitized,
-              groundingSource,
-              assertionSource,
-              roleAssertionSources,
-              messageTimestamp
-            );
-            const finalResult = await this.applyProactiveQuestionPass(
-              conversation,
-              grounded,
-              groundingSource,
-              assertionSource,
-              messageTimestamp,
-              roleAssertionSources,
-              signal
-            );
-            return this.finalizeExtractionResult(finalResult, boundedTurns);
+            const grounded = applyGroundingWithConnector(this.config, sanitized, groundingContext);
+            const finalResult = await this.applyProactiveQuestionPass(conversation, grounded, groundingContext, signal);
+            return this.finalizeExtractionResult(finalResult, boundedTurns, resolvedConnector);
           }
           try {
             this.emit({
@@ -1078,23 +1045,9 @@ var ExtractionEngine = class {
           );
           const normalized = this.normalizeExtractionResultPayload(result);
           const sanitized = this.sanitizeExtractionResult(normalized, messageTimestamp);
-          const grounded = this.applySourceGrounding(
-            sanitized,
-            groundingSource,
-            assertionSource,
-            roleAssertionSources,
-            messageTimestamp
-          );
-          const finalResult = await this.applyProactiveQuestionPass(
-            conversation,
-            grounded,
-            groundingSource,
-            assertionSource,
-            messageTimestamp,
-            roleAssertionSources,
-            signal
-          );
-          return this.finalizeExtractionResult(finalResult, boundedTurns);
+          const grounded = applyGroundingWithConnector(this.config, sanitized, groundingContext);
+          const finalResult = await this.applyProactiveQuestionPass(conversation, grounded, groundingContext, signal);
+          return this.finalizeExtractionResult(finalResult, boundedTurns, resolvedConnector);
         }
         this.emit({
           kind: "llm_error",
@@ -1192,7 +1145,7 @@ Rules:
 - 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.` : ""}
+- Set each fact scope to "global" for cross-project knowledge or "project" for codebase-specific knowledge. Tool, command, or CLI-flag instructions tied to one agent are "project" (the same tool name can mean different things across agents); when keeping one, begin the fact with a leading "In <agent>," clause naming that agent.` : ""}
 ${this.eventTimePromptInstruction()}
 Return only valid JSON matching this shape. Placeholder text describes field shape only and is never source evidence:
 ${EXTRACTION_RESPONSE_SHAPE}
@@ -1386,8 +1339,8 @@ Rules:
 
 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
+- "global" \u2014 knowledge that applies across projects: core framework/library bugs, API behavior patterns, user preferences (editor, language, style), 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. Tool, command, or CLI-flag instructions TIED TO ONE AGENT are also "project", because the same tool name means different things in different agent integrations (a "search" tool may search repository code in one agent and the web in another); when keeping such an agent-tied instruction, the fact text MUST name the originating agent as a leading "In <agent>," clause (e.g. "In Pi, use the search tool with a repository path."). A tool/command fact that holds in every agent and every repo is NOT agent-tied \u2014 leave it "global" and do not add a qualifier (e.g. "\`git status --short\` emits compact output"). Examples: "In Pi, the search tool takes a repository path" -> "project"; "\`git status --short\` emits compact output" -> "global".
 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
@@ -2482,4 +2435,4 @@ export {
   shouldEnableLocalExtractionThinking,
   ExtractionEngine
 };
-//# sourceMappingURL=chunk-QIHIHZYC.js.map
+//# sourceMappingURL=chunk-DP7ZV2II.js.map