@remnic/core 9.45.3 → 9.45.5

package/src/orchestration/recall-internal.ts

@@ -39,6 +39,7 @@ import { collectNativeKnowledgeChunks, formatNativeKnowledgeSection, searchNativ
 import { objectiveStateStoreOverrideForNamespace, searchObjectiveStateSnapshots } from "../objective-state.js";
 import { type GraphRecallRankedResult, type GraphRecallShadowComparison, mergeGraphExpandedResults } from "./graph-recall-coordinator.js";
 import { buildProcedureRecallSection } from "../procedural/procedure-recall.js";
+import { canRecallToolScopedMemory } from "../tool-scoped-memory.js";
 import { buildQmdRecallCacheKey, getCachedQmdRecall, setCachedQmdRecall } from "../qmd-recall-cache.js";
 import { MEMORY_ID_PATTERN } from "../recall-handles.js";
 import {
@@ -95,7 +96,13 @@ import {
 } from "../orchestrator.js";
 import { isGenericRecallExcludedPath } from "./generic-recall-paths.js";
 import type { RecallSectionBuckets } from "./recall-section-coordinator.js";
+import {
+  reconcileRecallResultPartition,
+  type RecallResultPartition,
+  type RecallResultPartitionSink,
+} from "./recall-rerank-coordinator.js";
 import type { RecallInternalDeps } from "./recall-internal-deps.js";
+
 export class RecallInternalCoordinator {
   constructor(
     private readonly deps: RecallInternalDeps,
@@ -279,6 +286,7 @@ export class RecallInternalCoordinator {
     // sites) updates the same counter; the X-ray capture block
     // reads this as the cold-fallback pool.
     const xrayColdPoolSink = { size: 0 };
+    let selectedResultPartition: RecallResultPartition | null = null;
     let identityInjectionModeUsed: IdentityInjectionMode | "none" = "none";
     let identityInjectedChars = 0;
     let identityInjectionTruncated = false;
@@ -566,6 +574,7 @@ export class RecallInternalCoordinator {
             query: retrievalQuery,
             tierExplain: null,
             results: [],
+            appliedResultLimit: recallResultLimit,
             filters: [
               {
                 name: "planner-mode",
@@ -1296,7 +1305,11 @@ export class RecallInternalCoordinator {
         source: "fresh",
         success: true,
       });
-      return results;
+      return lifecycleCaps.extractionScopeClassification
+        ? results.filter((artifact) =>
+            canRecallToolScopedMemory(artifact.frontmatter, options.sourceConnector),
+          )
+        : results;
     })();
 
     const objectiveStatePromise = (async (): Promise<string | null> => {
@@ -2794,6 +2807,10 @@ export class RecallInternalCoordinator {
           profileStorage,
           retrievalQuery,
           this.deps.config,
+          {
+            partitionToolScoped: lifecycleCaps.extractionScopeClassification,
+            requestingConnector: options.sourceConnector,
+          },
         );
       } catch (err) {
         log.debug(
@@ -3959,6 +3976,7 @@ export class RecallInternalCoordinator {
           abortSignal: options.abortSignal,
           dropUnresolved: true,
           recallNamespaces,
+          requestingConnector: options.sourceConnector,
         },
       );
 
@@ -3971,7 +3989,7 @@ export class RecallInternalCoordinator {
             recallNamespaces,
             retrievalQuery,
             qmdBoostInput.memoryByPath,
-            { asOfMs },
+            { asOfMs, requestingConnector: options.sourceConnector },
           ),
         qmdBoostInput.results,
       );
@@ -4092,13 +4110,25 @@ export class RecallInternalCoordinator {
       // Diversify via MMR over the full candidate pool *before* truncating to
       // the final recall limit. Running MMR after the slice would be unable
       // to promote diverse candidates sitting just below the cutoff.
-      memoryResults = this.deps.diversifyAndLimitRecallResults(
-        "memories",
-        memoryResults,
-        recallResultLimit,
-        retrievalQuery,
-        caps,
-      );
+      const hotQmdPartition =
+        options.xrayCapture === true
+          ? this.deps.recallRerankCoordinator.diversifyRecallResultsWithHeadroom(
+              "memories",
+              memoryResults,
+              recallResultLimit,
+              retrievalQuery,
+              caps,
+            )
+          : null;
+      memoryResults = hotQmdPartition
+        ? [...hotQmdPartition.appliedResults]
+        : this.deps.diversifyAndLimitRecallResults(
+            "memories",
+            memoryResults,
+            recallResultLimit,
+            retrievalQuery,
+            caps,
+          );
       // E-Mem-inspired memory reconstruction: fill gaps for referenced entities
       if (resolveRecallEnhancementCapabilities(this.deps.config).memoryReconstruction && memoryResults.length > 0) {
         try {
@@ -4150,6 +4180,7 @@ export class RecallInternalCoordinator {
         }
         recallSource = "hot_qmd";
         recalledMemoryCount = memoryResults.length;
+        selectedResultPartition = hotQmdPartition;
         this.deps.publishRecallResults({
           title: "Relevant Memories",
           results: memoryResults,
@@ -4199,7 +4230,7 @@ export class RecallInternalCoordinator {
               recallNamespaces,
               retrievalQuery,
               undefined,
-              { asOfMs },
+              { asOfMs, requestingConnector: options.sourceConnector },
             );
             // MMR runs on the pre-truncation pool so diverse candidates just
             // below the cutoff can be promoted into the injected set.
@@ -4207,16 +4238,29 @@ export class RecallInternalCoordinator {
               xrayBranchPoolSize.hot_embedding,
               boostedScoped.length,
             );
-            return this.deps.diversifyAndLimitRecallResults(
-              "memories",
-              boostedScoped,
-              recallResultLimit,
-              retrievalQuery,
-              caps,
-            );
+            return boostedScoped;
           },
           [] as QmdSearchResult[],
         );
+        const embeddingPartition =
+          options.xrayCapture === true
+            ? this.deps.recallRerankCoordinator.diversifyRecallResultsWithHeadroom(
+                "memories",
+                scoped,
+                recallResultLimit,
+                retrievalQuery,
+                caps,
+              )
+            : null;
+        scoped =
+          embeddingPartition?.appliedResults ??
+          this.deps.diversifyAndLimitRecallResults(
+            "memories",
+            scoped,
+            recallResultLimit,
+            retrievalQuery,
+            caps,
+          );
         // Issue #1577 — apply TrustScore on the embedding-fallback path so the
         // feature gate is consistent across ALL recall paths (rule 41 parity).
         {
@@ -4260,6 +4304,7 @@ export class RecallInternalCoordinator {
           }
           recallSource = "hot_embedding";
           recalledMemoryCount = scoped.length;
+          selectedResultPartition = reconcileRecallResultPartition(embeddingPartition, scoped);
           this.deps.publishRecallResults({
             title: "Relevant Memories",
             results: scoped,
@@ -4278,6 +4323,8 @@ export class RecallInternalCoordinator {
             .filter(Boolean);
           xrayRecalledResults = scoped;
         } else {
+          const coldPartitionSink: RecallResultPartitionSink | undefined =
+            options.xrayCapture === true ? { partition: null } : undefined;
           const longTerm = await this.deps.applyColdFallbackPipeline({
             prompt: retrievalQuery,
             recallNamespaces,
@@ -4291,9 +4338,11 @@ export class RecallInternalCoordinator {
               backendDegradations.push(degradation);
             },
             xrayPoolSizeSink: xrayColdPoolSink,
+            resultPartitionSink: coldPartitionSink,
             trustByPathSink,
             deadlineAtMs: enrichmentAssemblyDeadlineAtMs,
             asOfMs,
+            requestingConnector: options.sourceConnector,
             ...(options.includeLowConfidence === true ? { includeLowConfidence: true } : {}),
           });
           // Issue #1577 — read the cold pipeline's trust map back so cold
@@ -4309,6 +4358,7 @@ export class RecallInternalCoordinator {
             }
             recallSource = "cold_fallback";
             recalledMemoryCount = longTerm.length;
+            selectedResultPartition = coldPartitionSink?.partition ?? null;
             this.deps.publishRecallResults({
               title: "Long-Term Memories (Fallback)",
               results: longTerm,
@@ -4394,7 +4444,7 @@ export class RecallInternalCoordinator {
               recallNamespaces,
               retrievalQuery,
               undefined,
-              { asOfMs },
+              { asOfMs, requestingConnector: options.sourceConnector },
             );
             // MMR runs on the pre-truncation pool so diverse candidates just
             // below the cutoff can be promoted into the injected set.
@@ -4402,16 +4452,29 @@ export class RecallInternalCoordinator {
               xrayBranchPoolSize.hot_embedding,
               boostedScoped.length,
             );
-            return this.deps.diversifyAndLimitRecallResults(
-              "memories",
-              boostedScoped,
-              recallResultLimit,
-              retrievalQuery,
-              caps,
-            );
+            return boostedScoped;
           },
           [] as QmdSearchResult[],
         );
+        const embeddingPartition =
+          options.xrayCapture === true
+            ? this.deps.recallRerankCoordinator.diversifyRecallResultsWithHeadroom(
+                "memories",
+                scoped,
+                recallResultLimit,
+                retrievalQuery,
+                caps,
+              )
+            : null;
+        scoped =
+          embeddingPartition?.appliedResults ??
+          this.deps.diversifyAndLimitRecallResults(
+            "memories",
+            scoped,
+            recallResultLimit,
+            retrievalQuery,
+            caps,
+          );
         // Issue #1577 — apply TrustScore on the embedding-fallback path so the
         // feature gate is consistent across ALL recall paths (rule 41 parity).
         {
@@ -4452,6 +4515,7 @@ export class RecallInternalCoordinator {
         }
         recallSource = "hot_embedding";
         recalledMemoryCount = scoped.length;
+        selectedResultPartition = reconcileRecallResultPartition(embeddingPartition, scoped);
         this.deps.publishRecallResults({
           title: "Relevant Memories",
           results: scoped,
@@ -4538,6 +4602,8 @@ export class RecallInternalCoordinator {
             queryAwarePrefilter.candidatePaths &&
             queryAwareScopedMemories.length === 0
           ) {
+            const coldPartitionSink: RecallResultPartitionSink | undefined =
+              options.xrayCapture === true ? { partition: null } : undefined;
             const longTerm = await this.deps.applyColdFallbackPipeline({
               prompt: retrievalQuery,
               recallNamespaces,
@@ -4551,9 +4617,11 @@ export class RecallInternalCoordinator {
                 backendDegradations.push(degradation);
               },
               xrayPoolSizeSink: xrayColdPoolSink,
+              resultPartitionSink: coldPartitionSink,
               trustByPathSink,
               deadlineAtMs: enrichmentAssemblyDeadlineAtMs,
               asOfMs,
+              requestingConnector: options.sourceConnector,
               ...(options.includeLowConfidence === true ? { includeLowConfidence: true } : {}),
             });
             // Issue #1577 — read the cold pipeline's trust map back (rule 41).
@@ -4561,6 +4629,7 @@ export class RecallInternalCoordinator {
             if (longTerm.length > 0) {
               recallSource = "cold_fallback";
               recalledMemoryCount = longTerm.length;
+              selectedResultPartition = coldPartitionSink?.partition ?? null;
               this.deps.publishRecallResults({
                 title: "Long-Term Memories (Fallback)",
                 results: longTerm,
@@ -4608,7 +4677,7 @@ export class RecallInternalCoordinator {
                     recallNamespaces,
                     retrievalQuery,
                     preloadedMap,
-                    { asOfMs },
+                    { asOfMs, requestingConnector: options.sourceConnector },
                   )
                 ).sort((a, b) => b.score - a.score);
                 // MMR runs on the pre-truncation pool so diverse candidates just
@@ -4617,16 +4686,29 @@ export class RecallInternalCoordinator {
                   xrayBranchPoolSize.recent_scan,
                   boostedRecent.length,
                 );
-                return this.deps.diversifyAndLimitRecallResults(
-                  "memories",
-                  boostedRecent,
-                  recallResultLimit,
-                  retrievalQuery,
-                  caps,
-                );
+                return boostedRecent;
               },
               [] as QmdSearchResult[],
             );
+            const recentPartition =
+              options.xrayCapture === true
+                ? this.deps.recallRerankCoordinator.diversifyRecallResultsWithHeadroom(
+                    "memories",
+                    recent,
+                    recallResultLimit,
+                    retrievalQuery,
+                    caps,
+                  )
+                : null;
+            recent =
+              recentPartition?.appliedResults ??
+              this.deps.diversifyAndLimitRecallResults(
+                "memories",
+                recent,
+                recallResultLimit,
+                retrievalQuery,
+                caps,
+              );
             // Issue #1577 — apply TrustScore on the recent-scan path so the
             // feature gate is consistent across ALL recall paths (rule 41).
             {
@@ -4673,6 +4755,7 @@ export class RecallInternalCoordinator {
               }
               recallSource = "recent_scan";
               recalledMemoryCount = recent.length;
+              selectedResultPartition = reconcileRecallResultPartition(recentPartition, recent);
               this.deps.publishRecallResults({
                 title: "Recent Memories",
                 results: recent,
@@ -4691,6 +4774,8 @@ export class RecallInternalCoordinator {
                 .filter(Boolean);
               xrayRecalledResults = recent;
             } else {
+              const coldPartitionSink: RecallResultPartitionSink | undefined =
+                options.xrayCapture === true ? { partition: null } : undefined;
               const longTerm = await this.deps.applyColdFallbackPipeline({
                 prompt: retrievalQuery,
                 recallNamespaces,
@@ -4704,9 +4789,11 @@ export class RecallInternalCoordinator {
                   backendDegradations.push(degradation);
                 },
                 xrayPoolSizeSink: xrayColdPoolSink,
+                resultPartitionSink: coldPartitionSink,
                 trustByPathSink,
                 deadlineAtMs: enrichmentAssemblyDeadlineAtMs,
                 asOfMs,
+                requestingConnector: options.sourceConnector,
                 ...(options.includeLowConfidence === true ? { includeLowConfidence: true } : {}),
               });
               // Issue #1577 — read the cold pipeline's trust map back (rule 41).
@@ -4721,6 +4808,7 @@ export class RecallInternalCoordinator {
                 }
                 recallSource = "cold_fallback";
                 recalledMemoryCount = longTerm.length;
+                selectedResultPartition = coldPartitionSink?.partition ?? null;
                 this.deps.publishRecallResults({
                   title: "Long-Term Memories (Fallback)",
                   results: longTerm,
@@ -4742,6 +4830,8 @@ export class RecallInternalCoordinator {
             }
           }
         } else {
+          const coldPartitionSink: RecallResultPartitionSink | undefined =
+            options.xrayCapture === true ? { partition: null } : undefined;
           const longTerm = await this.deps.applyColdFallbackPipeline({
             prompt: retrievalQuery,
             recallNamespaces,
@@ -4755,9 +4845,11 @@ export class RecallInternalCoordinator {
               backendDegradations.push(degradation);
             },
             xrayPoolSizeSink: xrayColdPoolSink,
+            resultPartitionSink: coldPartitionSink,
             trustByPathSink,
             deadlineAtMs: enrichmentAssemblyDeadlineAtMs,
             asOfMs,
+            requestingConnector: options.sourceConnector,
             ...(options.includeLowConfidence === true ? { includeLowConfidence: true } : {}),
           });
           // Issue #1577 — read the cold pipeline's trust map back (rule 41).
@@ -4771,6 +4863,7 @@ export class RecallInternalCoordinator {
             }
             recallSource = "cold_fallback";
             recalledMemoryCount = longTerm.length;
+            selectedResultPartition = coldPartitionSink?.partition ?? null;
             this.deps.publishRecallResults({
               title: "Long-Term Memories (Fallback)",
               results: longTerm,
@@ -5013,6 +5106,31 @@ export class RecallInternalCoordinator {
     ) {
       try {
         const servedBy = mapRecallSourceToXrayServedBy(recallSource);
+        const toPartitionXrayResult = (
+          candidate: QmdSearchResult,
+        ): RecallXrayResult => {
+          const scoreDecomposition: RecallXrayScoreDecomposition = {
+            final: candidate.score,
+          };
+          if (
+            candidate.explain?.reinforcementBoost !== undefined &&
+            candidate.explain.reinforcementBoost > 0
+          ) {
+            scoreDecomposition.reinforcementBoost =
+              candidate.explain.reinforcementBoost;
+          }
+          return {
+            memoryId: candidate.docid,
+            path: candidate.path,
+            servedBy,
+            scoreDecomposition,
+            admittedBy: [],
+          };
+        };
+        const appliedResults =
+          selectedResultPartition?.appliedResults.map(toPartitionXrayResult) ?? [];
+        const headroomResults =
+          selectedResultPartition?.headroomResults.map(toPartitionXrayResult) ?? [];
         // Derive xray results from `recalledMemoryPaths` as the single
         // source of truth — `recalledMemoryIds` and `recalledMemoryPaths`
         // are built with two independent filters upstream
@@ -5173,6 +5291,9 @@ export class RecallInternalCoordinator {
           query: retrievalQuery,
           tierExplain: null,
           results: [...results, ...lcmStructuredXrayResults],
+          appliedResultLimit: recallResultLimit,
+          appliedResults,
+          headroomResults,
           filters,
           budget: {
             chars: this.deps.getRecallBudgetChars(options.budgetCharsOverride),

package/src/orchestration/recall-rerank-coordinator.ts

@@ -35,6 +35,23 @@ import { reorderRecallResultsWithMmr } from "../recall-mmr.js";
 import { applyReasoningTraceBoost } from "../reasoning-trace-recall.js";
 import { memoryMapKey } from "../recall-memory-map.js";
 
+export interface RecallResultPartition {
+  appliedResults: QmdSearchResult[];
+  headroomResults: QmdSearchResult[];
+}
+export interface RecallResultPartitionSink {
+  partition: RecallResultPartition | null;
+}
+
+export function reconcileRecallResultPartition(
+  partition: RecallResultPartition | null | undefined,
+  appliedResults: QmdSearchResult[],
+): RecallResultPartition | null {
+  return partition
+    ? { appliedResults, headroomResults: partition.headroomResults }
+    : null;
+}
+
 /**
  * Coordinator for the recall-result reranking subsystem.
  *
@@ -479,40 +496,58 @@ export class RecallRerankCoordinator {
     return { results, trustByPath: null };
   }
 
-  diversifyAndLimitRecallResults(
+  diversifyRecallResultsWithHeadroom(
     sectionId: string,
     results: QmdSearchResult[],
     limit: number,
     retrievalQuery?: string,
-    // `caps` is additive AND last (issue #1523) so the positional call shape
-    // stays backward-compatible: the recall pipeline threads a resolved set,
-    // but callers that omit it (e.g. direct unit-test invocations) get an
-    // equivalent set derived from the same config — behavior-preserving.
     caps: CapabilitySet = resolveCapabilities(this.getConfig()),
-  ): QmdSearchResult[] {
+  ): RecallResultPartition {
     const safeLimit =
       typeof limit === "number" && Number.isFinite(limit)
         ? Math.max(0, Math.floor(limit))
         : 0;
-    if (!Array.isArray(results) || results.length === 0) return [];
-    // `recallResultLimit === 0` is a true zero limit (e.g. when
-    // `memoriesSectionEnabled` is false) and must return an empty array so
-    // the memories section is genuinely skipped. This mirrors the
-    // `slice(0, 0)` semantics of every call site this helper replaced.
-    if (safeLimit === 0) return [];
-    // Issue #564 PR 3: when the feature flag is on, boost reasoning_trace
-    // memories for problem-solving asks so they bubble up ahead of ordinary
-    // facts/decisions before MMR picks the final section. No-op when the
-    // flag is off or the query is not a problem-solving ask.
-    const boosted =
-      caps.recallReasoningTraceBoost && typeof retrievalQuery === "string"
-        ? applyReasoningTraceBoost(results, {
-            enabled: true,
-            query: retrievalQuery,
-          })
-        : results;
-    const diversified = this.applyMmrToQmdResults(sectionId, boosted, caps);
-    return diversified.slice(0, safeLimit);
+    const candidates = Array.isArray(results) ? results : [];
+    let orderedPool: QmdSearchResult[] | undefined;
+    const resolveOrderedPool = (): QmdSearchResult[] => {
+      if (orderedPool) return orderedPool;
+      const boosted =
+        caps.recallReasoningTraceBoost && typeof retrievalQuery === "string"
+          ? applyReasoningTraceBoost(candidates, {
+              enabled: true,
+              query: retrievalQuery,
+            })
+          : candidates;
+      orderedPool = this.applyMmrToQmdResults(sectionId, boosted, caps);
+      return orderedPool;
+    };
+
+    return {
+      get appliedResults(): QmdSearchResult[] {
+        if (safeLimit === 0 || candidates.length === 0) return [];
+        return resolveOrderedPool().slice(0, safeLimit);
+      },
+      get headroomResults(): QmdSearchResult[] {
+        if (candidates.length === 0) return [];
+        return resolveOrderedPool().slice(safeLimit);
+      },
+    };
+  }
+
+  diversifyAndLimitRecallResults(
+    sectionId: string,
+    results: QmdSearchResult[],
+    limit: number,
+    retrievalQuery?: string,
+    caps: CapabilitySet = resolveCapabilities(this.getConfig()),
+  ): QmdSearchResult[] {
+    return this.diversifyRecallResultsWithHeadroom(
+      sectionId,
+      results,
+      limit,
+      retrievalQuery,
+      caps,
+    ).appliedResults;
   }
 
   /**

package/src/orchestration/recall-search-pipeline.test.ts

@@ -28,12 +28,16 @@ function memory(path: string, status: string): MemoryFile {
   };
 }
 
-async function makeCoordinator(memoryDir: string): Promise<RecallSearchPipelineCoordinator> {
+async function makeCoordinator(
+  memoryDir: string,
+  extractionScopeClassificationEnabled = true,
+): Promise<RecallSearchPipelineCoordinator> {
   const config = parseConfig({
     openaiApiKey: "sk-test",
     memoryDir,
     workspaceDir: path.join(memoryDir, "workspace"),
     namespaces: true,
+    extractionScopeClassificationEnabled,
   });
   const deps = {
     config,
@@ -104,6 +108,76 @@ test("recall safety derives sourceConnector exclusively from the hydrated memory
   }
 });
 
+test("recall safety partitions tool-scoped memories by requesting connector", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-connector-partition-"));
+  try {
+    const coordinator = await makeCoordinator(memoryDir);
+    const memories = [
+      {
+        path: "facts/same-tool.md",
+        content: "Use the search tool with a path.",
+        frontmatter: { status: "active", sourceConnector: "chatgpt", toolScoped: true },
+      },
+      {
+        path: "facts/other-tool.md",
+        content: "Use the search tool with a path.",
+        frontmatter: { status: "active", sourceConnector: "pi", toolScoped: true },
+      },
+      {
+        path: "facts/portable.md",
+        content: "Prefer focused searches.",
+        frontmatter: { status: "active", sourceConnector: "pi" },
+      },
+      {
+        path: "facts/legacy.md",
+        content: "Use the search tool with a path.",
+        frontmatter: { status: "active", sourceConnector: "pi" },
+      },
+      {
+        path: "facts/unattributed-tool.md",
+        content: "Use the search tool with a path.",
+        frontmatter: { status: "active", toolScoped: true },
+      },
+    ] as unknown as MemoryFile[];
+    const results = memories.map((candidate, index) => ({
+      ...result("default", candidate.path),
+      ...(index === 1 ? { sourceConnector: "chatgpt" } : {}),
+    }));
+    const memoryByPath = new Map(
+      memories.map((candidate) => [`default\0${candidate.path}`, candidate]),
+    );
+
+    const safe = coordinator.filterSearchResultsByRecallSafety(results, memoryByPath, {
+      requestingConnector: "chatgpt",
+    });
+
+    assert.deepEqual(
+      safe.map((candidate) => candidate.path),
+      [
+        "facts/same-tool.md",
+        "facts/portable.md",
+        "facts/legacy.md",
+        "facts/unattributed-tool.md",
+      ],
+    );
+    assert.equal(safe[0]?.sourceConnector, "chatgpt");
+    assert.equal(results[1]?.sourceConnector, "chatgpt");
+    assert.equal(
+      coordinator.filterSearchResultsByRecallSafety(results, memoryByPath).length,
+      results.length,
+    );
+    const gateDisabled = await makeCoordinator(memoryDir, false);
+    assert.equal(
+      gateDisabled.filterSearchResultsByRecallSafety(results, memoryByPath, {
+        requestingConnector: "chatgpt",
+      }).length,
+      results.length,
+    );
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
 function scopedCandidatesStub(
   seed: QmdSearchResult[],
 ): RecallSearchPipelineDeps["searchScopedMemoryCandidates"] {