@remnic/core 10.0.12 → 10.0.14

package/src/extraction-quote-grounding.ts

@@ -0,0 +1,232 @@
+/**
+ * Quote-anchored source grounding.
+ *
+ * An extracted fact carries the exact words that support it in `quote`. A quote
+ * that is a verbatim substring of the source (whitespace-normalized) is real
+ * evidence: the claim only has to be supported by the text around that span,
+ * not by word overlap against the whole conversation. Items without such a
+ * quote never get an anchor here and stay on the whole-source rules.
+ */
+
+import type { ExtractionResult } from "./types.js";
+import {
+  GROUNDING_MIN_SHARED_TOKENS,
+  areGroundingTokensCompatible,
+  entityNameStart,
+  hasDenialReporting,
+  hasNonAssertiveReporting,
+  isGroundedEntityName,
+  normalizedEntityIdentifierTokens,
+  sourceSentences,
+  tokenize,
+} from "./extraction-source-grounding-helpers.js";
+
+/** Shortest normalized quote that counts as evidence; "the" or "I" prove nothing. */
+export const QUOTE_ANCHOR_MIN_CHARS = 12;
+/** Characters of context kept on each side of the quote inside its turn. */
+export const QUOTE_ANCHOR_CONTEXT_CHARS = 400;
+/** Share of a claim's content words that must occur in the quote's window. */
+export const QUOTE_ANCHOR_MIN_WINDOW_COVERAGE = 0.35;
+/** Share of a claim's content words that must occur anywhere in the source; the rest is invented. */
+export const QUOTE_ANCHOR_MIN_SOURCE_COVERAGE = 0.75;
+const QUOTE_ANCHOR_MAX_OCCURRENCES = 8;
+const TURN_SEPARATOR = "\n\n";
+const NEGATOR_PATTERN = /\b(?:not|no|never|cannot|without|neither|nor)\b|n't\b/iu;
+const EXCLUSION_PATTERN =
+  /\b(?:exclu\w*|avoid\w*|omit\w*|skip\w*|ignor\w*|forbid\w*|prohibit\w*|disallow\w*|prevent\w*|reject\w*|refus\w*|insufficient|instead|rather|unless|except)\b/iu;
+
+/** A verbatim quote and the text around it inside its turn. */
+export interface QuoteAnchor {
+  /** Whitespace-normalized quote, exactly as it appears in the source. */
+  quote: string;
+  /** `quote` with its turn-local context; `;` inside the quote is rewritten to `,`. */
+  window: string;
+}
+
+export type TokenPool = (token: string) => boolean;
+
+type Entity = ExtractionResult["entities"][number];
+type Relationship = NonNullable<ExtractionResult["relationships"]>[number];
+
+function normalizeWhitespaceWithMap(source: string): { text: string; originalIndex: number[] } {
+  const chars: string[] = [];
+  const originalIndex: number[] = [];
+  let inSpace = false;
+  for (let index = 0; index < source.length; index += 1) {
+    const char = source[index]!;
+    if (/\s/u.test(char)) {
+      if (inSpace) continue;
+      inSpace = true;
+      chars.push(" ");
+    } else {
+      inSpace = false;
+      chars.push(char);
+    }
+    originalIndex.push(index);
+  }
+  return { text: chars.join(""), originalIndex };
+}
+
+function findQuoteAnchors(quote: string, source: string): QuoteAnchor[] {
+  const needle = quote.replace(/\s+/gu, " ").trim();
+  if (needle.length < QUOTE_ANCHOR_MIN_CHARS) return [];
+  const normalized = normalizeWhitespaceWithMap(source);
+  const anchors: QuoteAnchor[] = [];
+  let from = 0;
+  while (anchors.length < QUOTE_ANCHOR_MAX_OCCURRENCES) {
+    const at = normalized.text.indexOf(needle, from);
+    if (at < 0) break;
+    from = at + 1;
+    const start = normalized.originalIndex[at]!;
+    const end = normalized.originalIndex[at + needle.length - 1]! + 1;
+    if (source.slice(start, end).includes(TURN_SEPARATOR)) continue;
+
+    let before = source.slice(Math.max(0, start - QUOTE_ANCHOR_CONTEXT_CHARS), start);
+    const turnStart = before.lastIndexOf(TURN_SEPARATOR);
+    if (turnStart >= 0) before = before.slice(turnStart + TURN_SEPARATOR.length);
+    else if (start > QUOTE_ANCHOR_CONTEXT_CHARS) before = before.replace(/^\S+/u, "");
+
+    let after = source.slice(end, end + QUOTE_ANCHOR_CONTEXT_CHARS);
+    const turnEnd = after.indexOf(TURN_SEPARATOR);
+    if (turnEnd >= 0) after = after.slice(0, turnEnd);
+    else if (source.length - end > QUOTE_ANCHOR_CONTEXT_CHARS) after = after.replace(/\S+$/u, "");
+
+    anchors.push({ quote: needle, window: `${before}${needle.replace(/;/gu, ",")}${after}` });
+  }
+  return anchors;
+}
+
+/**
+ * Returns one anchor per place `quote` occurs verbatim in `source`, or [] when
+ * the quote is absent, too short, or not an exact substring. A quote that
+ * spans a turn separator is not one turn's words and yields no anchor; windows
+ * never extend past their turn.
+ *
+ * The quote is one evidence unit: a `;` inside it is rewritten to `,` in the
+ * window so sentence splitting cannot cut it, or a claim that merges two of
+ * its clauses could never be grounded in a single sentence.
+ *
+ * `source` may have been rewritten before grounding (temporal anchoring,
+ * pronoun resolution) while the model quoted the original words. When the raw
+ * quote is not found, `transformQuote` applies the same rewrite to the quote.
+ */
+export function quoteAnchors(
+  quote: string | undefined,
+  source: string,
+  transformQuote?: (quote: string) => string,
+): QuoteAnchor[] {
+  if (typeof quote !== "string") return [];
+  const exact = findQuoteAnchors(quote, source);
+  if (exact.length > 0 || transformQuote === undefined) return exact;
+  return findQuoteAnchors(transformQuote(quote), source);
+}
+
+export function tokenPool(tokens: ReadonlySet<string>): TokenPool {
+  const list = [...tokens];
+  return (token) => tokens.has(token) || list.some((poolToken) => areGroundingTokensCompatible(token, poolToken));
+}
+
+function hasNegation(text: string): boolean {
+  return NEGATOR_PATTERN.test(text.replace(/[\u2018\u2019]/gu, "'")) || hasDenialReporting(text);
+}
+
+/**
+ * True when the claim asserts what a quote clause denies or does not assert:
+ * "did not approve the budget" or "denied approving it" restated as "approved
+ * the budget", "suspects Bob stole funds" or "Is Alice the CEO?" restated as a
+ * plain statement. A claim that keeps a negator, exclusion word, or reporting
+ * marker ("do not X" reworded as "X is excluded") is not a misstatement.
+ */
+function misstatesQuote(content: string, quote: string): boolean {
+  const keepsNegation = hasNegation(content) || EXCLUSION_PATTERN.test(content);
+  const keepsReporting = hasNonAssertiveReporting(content) || content.trim().endsWith("?");
+  const contentHas = tokenPool(tokenize(content));
+  return (quote.match(/[^;.!?\n]+[;.!?]*/gu) ?? []).some((clause) => {
+    const negated = hasNegation(clause) && !keepsNegation;
+    const unasserted = (clause.trim().endsWith("?") || hasNonAssertiveReporting(clause)) && !keepsReporting;
+    if (!negated && !unasserted) return false;
+    const clauseTokens = [...tokenize(clause)];
+    const shared = clauseTokens.filter(contentHas).length;
+    return shared >= GROUNDING_MIN_SHARED_TOKENS && shared / clauseTokens.length >= 0.5;
+  });
+}
+
+/**
+ * A claim is supported by a verbatim quote when it shares at least
+ * GROUNDING_MIN_SHARED_TOKENS content words with the quote, a good part of its
+ * words sit in the text around the quote, nearly all of them occur in the
+ * source at all, and it does not invert a negated clause of the quote. Reworded
+ * and lightly elaborated claims pass; claims that bring words the conversation
+ * never used, or that have nothing to do with the quote, do not.
+ */
+export function isQuoteAnchoredClaim(content: string, anchor: QuoteAnchor, sourceHas: TokenPool): boolean {
+  const contentTokens = [...tokenize(content)];
+  if (contentTokens.length === 0) return false;
+  const quoteHas = tokenPool(tokenize(anchor.quote));
+  if (contentTokens.filter(quoteHas).length < GROUNDING_MIN_SHARED_TOKENS) return false;
+  const windowHas = tokenPool(tokenize(anchor.window));
+  if (contentTokens.filter(windowHas).length / contentTokens.length < QUOTE_ANCHOR_MIN_WINDOW_COVERAGE) {
+    return false;
+  }
+  return contentTokens.filter(sourceHas).length / contentTokens.length >= QUOTE_ANCHOR_MIN_SOURCE_COVERAGE
+    && !misstatesQuote(content, anchor.quote);
+}
+
+/** Keeps the entity facts (flat and sectioned) `isSupported` accepts; undefined when none remain. */
+export function filterEntityFacts(entity: Entity, isSupported: (fact: string) => boolean): Entity | undefined {
+  const facts = entity.facts.filter(isSupported);
+  const structuredSections = entity.structuredSections?.flatMap((section) => {
+    const groundedFacts = section.facts.filter(isSupported);
+    return groundedFacts.length > 0 ? [{ ...section, facts: groundedFacts }] : [];
+  });
+  if (facts.length === 0 && (structuredSections === undefined || structuredSections.length === 0)) {
+    return undefined;
+  }
+  const { structuredSections: _structuredSections, ...entityWithoutSections } = entity;
+  return {
+    ...entityWithoutSections,
+    facts,
+    ...(structuredSections && structuredSections.length > 0 ? { structuredSections } : {}),
+  };
+}
+
+/**
+ * Entities carry no quote of their own; the anchors of facts that kept support
+ * them. Returns a fact predicate, or undefined when no anchor window names the entity.
+ */
+export function quoteAnchoredEntitySupport(
+  entity: Entity,
+  anchors: readonly QuoteAnchor[],
+  sourceHas: TokenPool,
+): ((fact: string) => boolean) | undefined {
+  const nameAnchors = anchors.filter((anchor) => isGroundedEntityName(entity.name, anchor.window));
+  if (nameAnchors.length === 0) return undefined;
+  return (fact) => nameAnchors.some((anchor) => isQuoteAnchoredClaim(fact, anchor, sourceHas));
+}
+
+/**
+ * The label words and both names must sit in one anchor-window sentence, source
+ * before target, so an invented label or a reversed edge never passes.
+ */
+export function isQuoteAnchoredRelationship(
+  relationship: Relationship,
+  anchors: readonly QuoteAnchor[],
+  sourceHas: TokenPool,
+): boolean {
+  const labelTokens = [...tokenize(relationship.label)];
+  if (labelTokens.length === 0) return false;
+  const relationText = [
+    normalizedEntityIdentifierTokens(relationship.source).join(" "),
+    relationship.label,
+    normalizedEntityIdentifierTokens(relationship.target).join(" "),
+  ].join(" ");
+  return anchors.some((anchor) => {
+    const windowHas = tokenPool(tokenize(anchor.window));
+    return labelTokens.every(windowHas)
+      && sourceSentences(anchor.window).some((sentence) => {
+        const sourceStart = entityNameStart(relationship.source, sentence);
+        return sourceStart >= 0 && entityNameStart(relationship.target, sentence) > sourceStart;
+      })
+      && isQuoteAnchoredClaim(relationText, anchor, sourceHas);
+  });
+}

package/src/extraction-source-grounding-helpers.ts

@@ -901,3 +901,38 @@ export function hasContradictoryPolarity(candidate: string, source: string): boo
   }
   return false;
 }
+
+export function normalizedEntityIdentifierTokens(name: string): string[] {
+  const identifier = normalizeForExactMatch(name).replace(/[-_]+/gu, " ");
+  const tokens = groundingLexemes(identifier)
+    .filter(({ token }) => GROUNDING_STOPWORDS[token] !== true)
+    .map(({ token }) => stemToken(token, true));
+  return tokens.length > 1 && GROUNDING_ENTITY_TYPE_PREFIXES.has(tokens[0] ?? "")
+    ? tokens.slice(1)
+    : tokens;
+}
+
+/** Index of the entity name's tokens inside the sentence's token sequence, or -1. */
+export function entityNameStart(name: string, sentence: string): number {
+  const nameTokens = normalizedEntityIdentifierTokens(name);
+  if (nameTokens.length === 0) return -1;
+  const sentenceTokens = groundingLexemes(sentence)
+    .filter(({ token }) => GROUNDING_STOPWORDS[token] !== true)
+    .map(({ token, preserveTerminalS }) => stemToken(token, preserveTerminalS));
+  return sentenceTokens.findIndex((_, start) =>
+    nameTokens.every((token, offset) => sentenceTokens[start + offset] === token));
+}
+
+export function isGroundedEntityName(name: string, source: string): boolean {
+  return sourceSentences(source).some((sentence) => entityNameStart(name, sentence) >= 0);
+}
+
+/** True when the text reports a claim without asserting it ("suspects", "alleged", "said"). */
+export function hasNonAssertiveReporting(text: string): boolean {
+  return groundingLexemes(text).some(({ token }) => isNonAssertiveReportingVerb(token));
+}
+
+/** True when the text reports a denial ("denied", "refuses"). */
+export function hasDenialReporting(text: string): boolean {
+  return groundingLexemes(text).some(({ token }) => isDenialReportingVerb(token));
+}

package/src/extraction-source-grounding-rules.ts

@@ -1,9 +1,18 @@
 import type { ExtractionResult } from "./types.js";
 import { anchorTemporalExpressions } from "./delinearize.js";
+import {
+  filterEntityFacts,
+  isQuoteAnchoredClaim,
+  isQuoteAnchoredRelationship,
+  quoteAnchoredEntitySupport,
+  quoteAnchors,
+  tokenPool,
+  type QuoteAnchor,
+  type TokenPool,
+} from "./extraction-quote-grounding.js";
 import {
   GROUNDING_AUXILIARY_TOKENS,
   GROUNDING_COPULAR_FORMS,
-  GROUNDING_ENTITY_TYPE_PREFIXES,
   GROUNDING_MIN_COVERAGE,
   GROUNDING_MIN_SHARED_TOKENS,
   GROUNDING_STOPWORDS,
@@ -14,8 +23,10 @@ import {
   groundingTokenSequence,
   hasContradictoryPolarity,
   hasExplicitRoleSubjectToken,
+  isGroundedEntityName,
   isInterrogativeSourceSentence,
   normalizeForExactMatch,
+  normalizedEntityIdentifierTokens,
   normalizedGroundingAlignmentTokenSequence,
   normalizedGroundingTokenSequence,
   sourceSentences,
@@ -30,6 +41,8 @@ export interface ExtractionSourceGroundingOptions {
   sourceGrounding: boolean;
   anchorTemporalExpressions: boolean;
   spanMode?: "off" | "shadow" | "on";
+  /** Rewrite applied to the source before this stage, so a verbatim quote can still be located in it. */
+  quoteTransform?: (quote: string) => string;
 }
 
 export function applyExtractionSourceGrounding(
@@ -62,6 +75,9 @@ export function applyExtractionSourceGrounding(
     anchoredRoleSources,
     options.anchorTemporalExpressions ? anchorSource : undefined,
     options.spanMode ?? "off",
+    options.anchorTemporalExpressions
+      ? (quote) => anchorSource(options.quoteTransform?.(quote) ?? quote)
+      : undefined,
   );
 }
 
@@ -352,25 +368,6 @@ function isSourceGrounded(
   return isSourceGroundedClause(candidate, sourceText, includeInterrogativeSource);
 }
 
-function normalizedEntityIdentifierTokens(name: string): string[] {
-  const identifier = normalizeForExactMatch(name).replace(/[-_]+/gu, " ");
-  const tokens = groundingLexemes(identifier)
-    .filter(({ token }) => GROUNDING_STOPWORDS[token] !== true)
-    .map(({ token }) => stemToken(token, true));
-  return tokens.length > 1 && GROUNDING_ENTITY_TYPE_PREFIXES.has(tokens[0] ?? "")
-    ? tokens.slice(1)
-    : tokens;
-}
-
-function isGroundedEntityName(name: string, source: string): boolean {
-  const nameTokens = normalizedEntityIdentifierTokens(name);
-  return nameTokens.length > 0 && sourceSentences(source).some((sentence) => {
-    const sentenceTokens = groundingLexemes(sentence)
-      .filter(({ token }) => GROUNDING_STOPWORDS[token] !== true)
-      .map(({ token, preserveTerminalS }) => stemToken(token, preserveTerminalS));
-    return containsContiguousGroundingTokens(nameTokens, sentenceTokens);
-  });
-}
 function buildEntitySupportSource(name: string, source: string): string {
   const nameTokens = normalizedEntityIdentifierTokens(name);
   if (nameTokens.length === 0) return "";
@@ -596,6 +593,22 @@ function isGroundedCandidate(
     );
 }
 
+function groundWithinQuoteAnchors(
+  content: string,
+  anchors: readonly QuoteAnchor[],
+  sourceHas: TokenPool,
+): GroundingContext | undefined {
+  const anchor = anchors.find((candidate) => isQuoteAnchoredClaim(content, candidate, sourceHas));
+  if (anchor === undefined) return undefined;
+  return {
+    source: anchor.window,
+    assertionSource: undefined,
+    allowRoleNormalization: GROUNDING_ROLE_SUBJECT_TOKENS.has(
+      (groundingTokenSequence(content)[0] ?? "").replace(/^[\u0000\u0001]/u, ""),
+    ),
+  };
+}
+
 function buildFactSupportSource(
   source: string,
   supportingSentences: ReadonlyArray<string>,
@@ -656,6 +669,8 @@ function filterGroundedFact(
   roleAssertionSources: ExtractionGroundingRoleSources | undefined,
   eventTimeNormalizer: ((eventTime: string) => string) | undefined,
   spanMode: "off" | "shadow" | "on" = "off",
+  anchors: readonly QuoteAnchor[],
+  sourceHas: TokenPool,
 ): ExtractionResult["facts"][number] | undefined {
   // Span-materialized content (issue #2333) is "frame: verbatim slice". The
   // frame is generated deixis, so full-content gating would drop a verbatim
@@ -677,6 +692,7 @@ function filterGroundedFact(
   );
   let gateContent = fact.content;
   let factContext = contentContext;
+  let quoteAnchored = false;
   if (
     !isGroundedCandidate(
       fact.content,
@@ -686,25 +702,35 @@ function filterGroundedFact(
       contentContext.allowRoleNormalization,
     )
   ) {
-    if (embeddedQuote === undefined) return undefined;
-    gateContent = embeddedQuote;
-    factContext = selectGroundingContext(
-      gateContent,
-      resolveGroundingContext(gateContent, source, assertionSource, roleAssertionSources),
-    );
-    if (!isGroundedCandidate(
-      gateContent,
-      factContext.source,
-      factContext.assertionSource,
-      false,
-      factContext.allowRoleNormalization,
-    )) return undefined;
+    const quoteContext = spanMode === "on"
+      ? undefined
+      : groundWithinQuoteAnchors(fact.content, anchors, sourceHas);
+    if (quoteContext !== undefined) {
+      factContext = quoteContext;
+      quoteAnchored = true;
+    } else {
+      if (embeddedQuote === undefined) return undefined;
+      gateContent = embeddedQuote;
+      factContext = selectGroundingContext(
+        gateContent,
+        resolveGroundingContext(gateContent, source, assertionSource, roleAssertionSources),
+      );
+      if (!isGroundedCandidate(
+        gateContent,
+        factContext.source,
+        factContext.assertionSource,
+        false,
+        factContext.allowRoleNormalization,
+      )) return undefined;
+    }
   }
   const factEventTime = fact.eventTime;
   const groundedFactEventTime = factEventTime === undefined
     ? undefined
     : eventTimeNormalizer?.(factEventTime) ?? factEventTime;
-  const factSupportingSentences = sourceSentences(factContext.assertionSource ?? factContext.source).filter(
+  // A quote-anchored claim is reworded from the quote and its turn, so no single
+  // sentence grounds it; the anchor window is the support for its sub-fields.
+  const factSupportingSentences = quoteAnchored ? [] : sourceSentences(factContext.assertionSource ?? factContext.source).filter(
     (sentence) =>
     isGroundedCandidate(
       gateContent,
@@ -730,10 +756,12 @@ function filterGroundedFact(
     ? factContext.assertionSource
     : undefined;
 
-  const factSupportSource = buildFactSupportSource(
-    factContext.assertionSource ?? factContext.source,
-    factSupportingSentences,
-  );
+  const factSupportSource = quoteAnchored
+    ? factContext.source
+    : buildFactSupportSource(
+      factContext.assertionSource ?? factContext.source,
+      factSupportingSentences,
+    );
   const groundedAttributes = fact.structuredAttributes
     ? Object.fromEntries(
       Object.entries(fact.structuredAttributes)
@@ -843,33 +871,17 @@ function filterGroundedEntity(
   entity: ExtractionResult["entities"][number],
   source: string,
   assertionSource: string | undefined,
+  anchorSupport?: (fact: string) => boolean,
 ): ExtractionResult["entities"][number] | undefined {
-  if (!isGroundedEntityName(entity.name, source)) return undefined;
-  const entitySource = buildEntitySupportSource(entity.name, source);
-  const entityAssertionSource = assertionSource === undefined
+  const nameGrounded = isGroundedEntityName(entity.name, source);
+  if (!nameGrounded && anchorSupport === undefined) return undefined;
+  const entitySource = nameGrounded ? buildEntitySupportSource(entity.name, source) : "";
+  const entityAssertionSource = !nameGrounded || assertionSource === undefined
     ? undefined
     : buildEntitySupportSource(entity.name, assertionSource);
-  const facts = entity.facts.filter((fact) =>
-    isGroundedCandidate(fact, entitySource, entityAssertionSource),
-  );
-  const structuredSections = entity.structuredSections
-    ?.flatMap((section) => {
-      const groundedFacts = section.facts.filter((fact) =>
-        isGroundedCandidate(fact, entitySource, entityAssertionSource),
-      );
-      return groundedFacts.length > 0
-        ? [{ ...section, facts: groundedFacts }]
-        : [];
-    });
-  if (facts.length === 0 && (structuredSections === undefined || structuredSections.length === 0)) {
-    return undefined;
-  }
-  const { structuredSections: _structuredSections, ...entityWithoutSections } = entity;
-  return {
-    ...entityWithoutSections,
-    facts,
-    ...(structuredSections && structuredSections.length > 0 ? { structuredSections } : {}),
-  };
+  return filterEntityFacts(entity, (fact) =>
+    (nameGrounded && isGroundedCandidate(fact, entitySource, entityAssertionSource))
+    || anchorSupport?.(fact) === true);
 }
 
 function normalizedEntitySourceText(name: string): string {
@@ -1104,6 +1116,7 @@ export function filterExtractionResultBySource(
   roleAssertionSources?: ExtractionGroundingRoleSources,
   eventTimeNormalizer?: (eventTime: string) => string,
   spanMode: "off" | "shadow" | "on" = "off",
+  quoteTransform?: (quote: string) => string,
 ): ExtractionResult {
   if (source.trim().length === 0) {
     return {
@@ -1117,7 +1130,13 @@ export function filterExtractionResultBySource(
     };
   }
 
+  const quoteSource = assertionSource ?? source;
+  const keptAnchors: QuoteAnchor[] = [];
+  const sourceHas = tokenPool(
+    result.facts.some((fact) => typeof fact.quote === "string") ? tokenize(quoteSource) : new Set(),
+  );
   const facts = result.facts.flatMap((fact) => {
+    const anchors = quoteAnchors(fact.quote, quoteSource, quoteTransform);
     const grounded = filterGroundedFact(
       fact,
       source,
@@ -1125,14 +1144,19 @@ export function filterExtractionResultBySource(
       roleAssertionSources,
       eventTimeNormalizer,
       spanMode,
+      anchors,
+      sourceHas,
     );
-    return grounded === undefined ? [] : [grounded];
+    if (grounded === undefined) return [];
+    keptAnchors.push(...anchors);
+    return [grounded];
   });
   const profileUpdates = result.profileUpdates.filter((update) =>
     isRoleGroundedCandidate(update, source, assertionSource, roleAssertionSources),
   );
   const entities = result.entities.flatMap((entity) => {
-    const grounded = filterGroundedEntity(entity, source, assertionSource);
+    const anchorSupport = quoteAnchoredEntitySupport(entity, keptAnchors, sourceHas);
+    const grounded = filterGroundedEntity(entity, source, assertionSource, anchorSupport);
     return grounded === undefined ? [] : [grounded];
   });
   const questions = result.questions.flatMap((question) => {
@@ -1140,7 +1164,8 @@ export function filterExtractionResultBySource(
     return grounded === undefined ? [] : [grounded];
   });
   const relationships = result.relationships?.filter((relationship) =>
-    isGroundedRelationship(relationship, source, assertionSource),
+    isGroundedRelationship(relationship, source, assertionSource)
+    || isQuoteAnchoredRelationship(relationship, keptAnchors, sourceHas),
   );
   const identityReflection = result.identityReflection
     && isRoleGroundedCandidate(

package/src/extraction-source-grounding.ts

@@ -36,7 +36,7 @@ export function applyExtractionSourceGrounding(
     sourceForGrounding(assertionSourceText) ?? assertionSourceText,
     groundedRoleSources,
     messageTimestamp,
-    options,
+    { ...options, quoteTransform: (quote) => sourceForGrounding(quote) ?? quote },
   );
 }
 
@@ -100,6 +100,15 @@ export function filterExtractionResultBySource(
   roleAssertionSources?: ExtractionGroundingRoleSources,
   eventTimeNormalizer?: (eventTime: string) => string,
   spanMode: "off" | "shadow" | "on" = "off",
+  quoteTransform?: (quote: string) => string,
 ): ExtractionResult {
-  return filterGroundingRules(result, source, assertionSource, roleAssertionSources, eventTimeNormalizer, spanMode);
+  return filterGroundingRules(
+    result,
+    source,
+    assertionSource,
+    roleAssertionSources,
+    eventTimeNormalizer,
+    spanMode,
+    quoteTransform,
+  );
 }

package/src/index.ts

@@ -1401,7 +1401,7 @@ export type {
   CalendarSource,
   RecallDisclosure,
 } from "./types.js";
-export { CONVERGE_CONFLICT_POLICIES, DEFAULT_CONVERGE_CONFLICT_POLICY, DEFAULT_CONVERGE_PEER_REQUEST_TIMEOUT_MS, MAX_CONVERGE_PEER_REQUEST_TIMEOUT_MS, envConvergePeerRequestTimeoutMs, normalizeConvergePeerRequestTimeoutMs, parseConvergeConfig } from "./converge-config.js";
+export { CONVERGE_CONFLICT_POLICIES, DEFAULT_CONVERGE_CONFLICT_POLICY, DEFAULT_CONVERGE_PEER_REQUEST_TIMEOUT_MS, MAX_CONVERGE_PEER_REQUEST_TIMEOUT_MS, envConvergePeerRequestTimeoutMs, normalizeConvergePeerRequestTimeoutMs, parseConvergeConfig, resolveConvergeCaptureWriteLockBackoff } from "./converge-config.js";
 export {
   DEFAULT_RECALL_DISCLOSURE,
   RECALL_DISCLOSURE_LEVELS,

package/src/orchestration/maintenance.ts

@@ -63,6 +63,7 @@ import {
   type LifecyclePendingIo,
 } from "../storage/memory-lifecycle-ledger-access.js";
 import { STATE_FILE_MAX_DECRYPT_BYTES } from "../storage/secure-line-reader.js";
+import { createCompoundingWeeklyCron, type CompoundingWeeklySchedulerHandle } from "../compounding/weekly-scheduler.js";
 import { startLocationAutoSync, type LocationAutoSyncHandle } from "../location/scheduler.js";
 import { ActivitySyncRegistrar } from "../activity/sync-registration.js";
 import type { ActivitySyncRunSummary } from "../activity/runner.js";
@@ -158,6 +159,7 @@ export class MaintenanceScheduler {
   // ── Location day-sync scheduler (issue #2047) — master default-off; the
   // timer + lifecycle contract lives in location/scheduler.ts.
   private locationAutoSync: LocationAutoSyncHandle | null = null;
+  private compoundingWeekly: CompoundingWeeklySchedulerHandle | null = null;
 
 
   constructor(private readonly deps: MaintenanceSchedulerDeps) {
@@ -248,6 +250,8 @@ export class MaintenanceScheduler {
     }
   }
 
+  armCompoundingWeeklyCron(): boolean { if (this.disposed) return false; this.compoundingWeekly ??= createCompoundingWeeklyCron(this.deps); return this.compoundingWeekly !== null; }
+
   async autoRegisterDaySummaryCron(): Promise<void> {
     const home = resolveHomeDir();
     const jobsPath = path.join(home, ".openclaw", "cron", "jobs.json");
@@ -1176,14 +1180,14 @@ export class MaintenanceScheduler {
     // await it last so the rest of teardown runs while the aborted tick unwinds.
     const activityDrain = this.activityRegistrar.dispose();
     const locationDrain = this.locationAutoSync?.stop() ?? Promise.resolve();
-    this.locationAutoSync = null;
+    this.locationAutoSync = null; const weeklyDrain = this.compoundingWeekly?.stop() ?? Promise.resolve(); this.compoundingWeekly = null;
     if (this.qmdMaintenanceTimer) {
       clearTimeout(this.qmdMaintenanceTimer);
       this.qmdMaintenanceTimer = null;
     }
     this.qmdMaintenancePending = false;
     await activityDrain;
-    await locationDrain;
+    await locationDrain; await weeklyDrain;
     // Belt-and-suspenders: clear anything a late tick armed before the latch.
     if (this.qmdMaintenanceTimer) {
       clearTimeout(this.qmdMaintenanceTimer);

package/src/providers/codex-subscription.test.ts

@@ -6,6 +6,7 @@ import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import {
   callCodexCliFallback,
   isCodexCliFallbackRunnerRegistered,
+  type CodexCliFallbackRunner,
   setCodexCliFallbackRunnerForProcess,
 } from "../cli-fallback.js";
 import {
@@ -681,6 +682,17 @@ async function flushLoop(turns = 2): Promise<void> {
   }
 }
 
+/** A runner's child untracks on the child's async exit event, which can
+ * land after the runner promise already settled. Poll for the count to
+ * clear instead of asserting it immediately (CI load made that flaky). */
+async function waitForCodexChildUntrack(runner: CodexCliFallbackRunner, timeoutMs = 2_000): Promise<void> {
+  const waitUntil = Date.now() + timeoutMs;
+  while (__codexSubscriptionTestHooks.activeCodexChildCount(runner) !== 0 && Date.now() < waitUntil) {
+    await flushLoop();
+  }
+  assert.equal(__codexSubscriptionTestHooks.activeCodexChildCount(runner), 0);
+}
+
 test("shared login check: each caller times out on its own budget, without cancelling others", async () => {
   __codexSubscriptionTestHooks.resetLoginStatusCache();
   let clock = 0;
@@ -1104,7 +1116,7 @@ test(
         }
       );
       // The detached child group must be untracked after settle — no leak.
-      assert.equal(__codexSubscriptionTestHooks.activeCodexChildCount(runner), 0);
+      await waitForCodexChildUntrack(runner);
     } finally {
       await rm(dir, { force: true, recursive: true }).catch(() => {});
     }
@@ -1220,7 +1232,7 @@ test(
       assert.equal(process.listenerCount("exit"), before.exit);
       terminateActiveCodexSubscriptionChildren("SIGKILL", runner);
       await pendingDone;
-      assert.equal(__codexSubscriptionTestHooks.activeCodexChildCount(runner), 0);
+      await waitForCodexChildUntrack(runner);
       assert.equal(process.listenerCount("SIGINT"), before.sigint);
       assert.equal(process.listenerCount("SIGTERM"), before.sigterm);
     } finally {
@@ -1283,7 +1295,7 @@ test(
       assert.equal(__codexSubscriptionTestHooks.activeCodexChildCount(second), 1);
       terminateActiveCodexSubscriptionChildren("SIGKILL", first);
       await firstPending;
-      assert.equal(__codexSubscriptionTestHooks.activeCodexChildCount(first), 0);
+      await waitForCodexChildUntrack(first);
       assert.equal(__codexSubscriptionTestHooks.activeCodexChildCount(second), 1);
     } finally {
       terminateActiveCodexSubscriptionChildren("SIGKILL", first);