@herbertgao/pi-extensions 2026.9.5 → 2026.9.7

package/node_modules/@luxusai/pi-hindsight/extensions/operations/memory-diagnostics-operations.ts

@@ -1,105 +0,0 @@
-import { checkHindsight } from "../client/client.js";
-import { formatDebugReport } from "../utils/diagnostics.js";
-import { resolveQueuePath, summarizeRetainQueue } from "../queue/queue.js";
-import {
-  importManifestSummary,
-  readImportManifestSafe,
-  resolveImportManifestPath,
-} from "../imports/import-plan.js";
-import { buildSyncStatus, DEFAULT_GIT_SEED_LIMIT, seedGitLog } from "../lifecycle/git-seed.js";
-import type { MemoryOperationsDeps } from "./memory-operation-types.js";
-import {
-  buildScopeMigratePlan,
-  writeScopeMigrateReceipt,
-  type ScopeMigratePlan,
-} from "./scope-migrate.js";
-
-export function createDiagnosticsOperations(deps: MemoryOperationsDeps) {
-  return {
-    async doctor(cwd: string, sessionFile?: string): Promise<string> {
-      const config = deps.getConfig();
-      const projectBankId = deps.getProjectBankId();
-      const manifestPath = resolveImportManifestPath(cwd, config.import.manifestPath);
-      const [health, queueSummary, manifestResult, sync] = await Promise.all([
-        checkHindsight(deps.getClient(), projectBankId),
-        summarizeRetainQueue(resolveQueuePath(cwd, config.retain.queuePath)),
-        readImportManifestSafe(manifestPath),
-        buildSyncStatus({
-          cwd,
-          config,
-          client: deps.getClient(),
-          bankId: projectBankId,
-        }),
-      ]);
-      const imports = importManifestSummary(manifestResult.manifest);
-      const scopeMigrate = buildScopeMigratePlan({ cwd, config, projectBankId });
-      return formatDebugReport({
-        cwd,
-        ...(sessionFile ? { sessionFile } : {}),
-        projectBankId,
-        config,
-        queueLength: queueSummary.active.valid,
-        queuePath: queueSummary.active.path,
-        queueMalformedLines: queueSummary.active.malformed,
-        queueReadError: queueSummary.active.error,
-        deadLetterPath: queueSummary.deadLetter.path,
-        deadLetterLength: queueSummary.deadLetter.valid,
-        deadLetterMalformedLines: queueSummary.deadLetter.malformed,
-        deadLetterReadError: queueSummary.deadLetter.error,
-        importManifestPath: manifestPath,
-        importManifestError: manifestResult.error,
-        importManifestAction: manifestResult.action,
-        importCount: imports.count,
-        ...(imports.latest ? { latestImport: imports.latest } : {}),
-        health,
-        scopeMigrate,
-        sync,
-      });
-    },
-
-    /** Memory readiness: queue depth, git seed receipt, knowledge-page capability. */
-    async syncStatus(cwd: string) {
-      return buildSyncStatus({
-        cwd,
-        config: deps.getConfig(),
-        client: deps.getClient(),
-        bankId: deps.getProjectBankId(),
-      });
-    },
-
-    /**
-     * Opt-in cold-repo gitlog seed (commit messages only). dryRun defaults true.
-     * Does not auto-run on session start — conversation retain remains the product core.
-     */
-    async seedGitLog(args: { cwd: string; limit?: number; dryRun?: boolean; flush?: boolean }) {
-      return seedGitLog({
-        cwd: args.cwd,
-        bankId: deps.getProjectBankId(),
-        config: deps.getConfig(),
-        client: deps.getClient(),
-        limit: args.limit ?? DEFAULT_GIT_SEED_LIMIT,
-        dryRun: args.dryRun ?? true,
-        ...(args.flush !== undefined ? { flush: args.flush } : {}),
-      });
-    },
-
-    /**
-     * Dry-run only: plan dual-tag / legacy repo-tag migration guidance and write a local receipt.
-     * Never rewrites Hindsight tags or documents.
-     */
-    async scopeMigrateDryRun(
-      cwd: string,
-      options: { bankTags?: string[]; writeReceipt?: boolean } = {},
-    ): Promise<ScopeMigratePlan | import("./scope-migrate.js").ScopeMigrateReceipt> {
-      const config = deps.getConfig();
-      const plan = buildScopeMigratePlan({
-        cwd,
-        config,
-        projectBankId: deps.getProjectBankId(),
-        ...(options.bankTags ? { bankTags: options.bankTags } : {}),
-      });
-      if (options.writeReceipt === false) return plan;
-      return writeScopeMigrateReceipt(cwd, plan);
-    },
-  };
-}

package/node_modules/@luxusai/pi-hindsight/extensions/operations/memory-identity.ts

@@ -1,68 +0,0 @@
-import type { ResolvedConfig } from "../types.js";
-import {
-  baseTags,
-  deriveProjectBankId,
-  recallScopeTags,
-  resolveProjectIdentity,
-  type ProjectIdBasis,
-} from "../banks/banking.js";
-import { importDocumentId, liveDocumentId, stableSessionId } from "../utils/session.js";
-
-export interface MemoryIdentity {
-  cwd: string;
-  sessionFile?: string;
-  /** Stable project id (pin / remote / basename). */
-  projectId: string;
-  projectIdBasis: ProjectIdBasis;
-  projectIdSource: string;
-  /** Legacy path-hash key; still dual-tagged during migration. */
-  repoKey: string;
-  sessionId: string;
-  projectBankId: string;
-  liveDocumentId: string;
-  baseTags: string[];
-  projectRecallTags: string[];
-  globalRecallTags: string[];
-}
-
-export function uniqueTags(tags: string[]): string[] {
-  return [...new Set(tags.filter(Boolean))];
-}
-
-export function mergeBaseAndExtraTags(base: string[], extra: string[] | undefined): string[] {
-  return uniqueTags([...base, ...(extra ?? [])]);
-}
-
-export function createMemoryIdentity(
-  cwd: string,
-  config: ResolvedConfig,
-  sessionFile?: string,
-): MemoryIdentity {
-  const sessionId = stableSessionId(sessionFile, cwd);
-  const project = resolveProjectIdentity(cwd, config);
-  return {
-    cwd,
-    ...(sessionFile ? { sessionFile } : {}),
-    projectId: project.projectId,
-    projectIdBasis: project.basis,
-    projectIdSource: project.source,
-    repoKey: project.legacyRepoKey,
-    sessionId,
-    projectBankId: deriveProjectBankId(cwd, config),
-    liveDocumentId: liveDocumentId(sessionFile, cwd),
-    baseTags: baseTags(cwd, sessionId, config),
-    projectRecallTags: recallScopeTags(cwd, config),
-    globalRecallTags: ["source:pi"],
-  };
-}
-
-export function explicitRetainTags(
-  cwd: string,
-  sessionFile: string | undefined,
-  extraTags: string[] | undefined,
-  config?: ResolvedConfig,
-): string[] {
-  return mergeBaseAndExtraTags(baseTags(cwd, stableSessionId(sessionFile, cwd), config), extraTags);
-}
-
-export { importDocumentId, liveDocumentId, stableSessionId };

package/node_modules/@luxusai/pi-hindsight/extensions/operations/memory-operation-service.ts

@@ -1,71 +0,0 @@
-import type { MemoryOperationsDeps } from "./memory-operation-types.js";
-import {
-  importMemoryChatTranscript,
-  importMemoryProjectSessions,
-  importMemorySession,
-} from "../imports/import-sessions.js";
-import { createBankTemplateOperations } from "./memory-bank-template-operations.js";
-import { createConfigOperations } from "./memory-config-operations.js";
-import { createControlOperations } from "./memory-control-operations.js";
-import { createDiagnosticsOperations } from "./memory-diagnostics-operations.js";
-import { createQueueOperations } from "../queue/queue-operations.js";
-import { createRecallOperations } from "./memory-recall-operations.js";
-import { createRetainOperations } from "./memory-retain-operations.js";
-import { createSessionOperations } from "./memory-session-operations.js";
-import type { ResolvedConfig } from "../types.js";
-import type { ImportProgressReporter } from "../imports/import-sessions.js";
-
-export type { ConfigureMemoryArgs, MemoryOperationsDeps } from "./memory-operation-types.js";
-
-function createImportOperations(deps: MemoryOperationsDeps) {
-  return {
-    async importSession(args: {
-      sessionFile: string;
-      cwd?: string;
-      bank?: string;
-      dryRun?: boolean;
-      includeBranches?: ResolvedConfig["import"]["includeBranches"];
-      onProgress?: ImportProgressReporter;
-    }) {
-      return importMemorySession(args, deps);
-    },
-
-    async importChatTranscript(args: {
-      sourceFile: string;
-      cwd: string;
-      bank?: string;
-      dryRun?: boolean;
-      onProgress?: ImportProgressReporter;
-    }) {
-      return importMemoryChatTranscript(args, deps);
-    },
-
-    async importProjectSessions(args: {
-      cwd: string;
-      currentSessionFile?: string;
-      searchDir?: string;
-      bank?: string;
-      dryRun?: boolean;
-      includeBranches?: ResolvedConfig["import"]["includeBranches"];
-      onProgress?: ImportProgressReporter;
-    }) {
-      return importMemoryProjectSessions(args, deps);
-    },
-  };
-}
-
-export function createMemoryOperations(deps: MemoryOperationsDeps) {
-  return {
-    ...createRecallOperations(deps),
-    ...createRetainOperations(deps),
-    ...createConfigOperations(deps),
-    ...createImportOperations(deps),
-    ...createQueueOperations(deps),
-    ...createSessionOperations(),
-    ...createDiagnosticsOperations(deps),
-    ...createBankTemplateOperations(deps),
-    ...createControlOperations(deps),
-  };
-}
-
-export type MemoryOperations = ReturnType<typeof createMemoryOperations>;

package/node_modules/@luxusai/pi-hindsight/extensions/operations/memory-operation-types.ts

@@ -1,13 +0,0 @@
-import type { HindsightLikeClient, ResolvedConfig } from "../types.js";
-import type { ProjectConfigPatchInput } from "../config/config-writer.js";
-import type { InitHealth } from "../lifecycle/memory-lifecycle.js";
-
-export interface MemoryOperationsDeps {
-  getClient(): HindsightLikeClient;
-  getConfig(): ResolvedConfig;
-  getProjectBankId(): string;
-  getInitHealth?(): InitHealth | undefined;
-  reloadConfig?(cwd: string): void;
-}
-
-export type ConfigureMemoryArgs = ProjectConfigPatchInput;

package/node_modules/@luxusai/pi-hindsight/extensions/operations/memory-recall-operations.ts

@@ -1,162 +0,0 @@
-import type { MemoryOperationsDeps } from "./memory-operation-types.js";
-import { composeScopedTagFilter, scopeTagsForBank } from "./memory-scope.js";
-import { resolveOperationBank } from "../banks/bank-selection.js";
-import { readLastRecallSnapshot, resolveLastRecallPath } from "../lifecycle/recall-visibility.js";
-import {
-  pruneTranscriptRecallBlocks,
-  scanTranscriptForRecallBlocks,
-} from "../lifecycle/recall-cleanup.js";
-import {
-  getEffectiveSessionMemoryMode,
-  readSessionMemoryMeta,
-} from "../utils/session-memory-meta.js";
-import type { HindsightTagGroup, TagsMatch } from "../types.js";
-import type { MinScores } from "@vectorize-io/hindsight-client";
-
-interface ExplicitRecallFilters {
-  budget?: import("../types.js").Budget;
-  maxTokens?: number;
-  queryTimestamp?: string;
-  types?: string[];
-  preferObservations?: boolean;
-  minScores?: MinScores;
-  trace?: boolean;
-  includeEntities?: boolean;
-  maxEntityTokens?: number;
-  includeChunks?: boolean;
-  maxChunkTokens?: number;
-  includeSourceFacts?: boolean;
-  maxSourceFactsTokens?: number;
-  tags?: string[];
-  tagsMatch?: TagsMatch;
-  tagGroups?: HindsightTagGroup[];
-  /** Override config.scope.includeSharedObservations for this call when set. */
-  includeSharedObservations?: boolean;
-  signal?: AbortSignal;
-}
-
-interface ExplicitReflectFilters extends Omit<ExplicitRecallFilters, "queryTimestamp" | "types"> {
-  includeFacts?: boolean;
-  includeToolCalls?: boolean;
-  includeToolCallOutput?: boolean;
-  factTypes?: Array<"world" | "experience" | "observation">;
-  excludeMentalModels?: boolean;
-  excludeMentalModelIds?: string[];
-}
-
-export function createRecallOperations(deps: MemoryOperationsDeps) {
-  return {
-    async recall(
-      cwd: string,
-      query: string,
-      bank?: string,
-      sessionFile?: string,
-      filters: ExplicitRecallFilters = {},
-    ) {
-      const meta = await readSessionMemoryMeta(cwd, sessionFile);
-      if (!getEffectiveSessionMemoryMode(meta).recall)
-        throw new Error("Hindsight recall is disabled for this session");
-      const config = deps.getConfig();
-      const bankId = resolveOperationBank({
-        requestedBank: bank,
-        config,
-        projectBankId: deps.getProjectBankId(),
-      });
-      const scopeTags = scopeTagsForBank(cwd, config, bankId);
-      const includeShared =
-        filters.includeSharedObservations ?? config.scope.includeSharedObservations;
-      const result = await deps.getClient().recall(bankId, query, {
-        budget: filters.budget ?? config.recall.budget,
-        maxTokens: filters.maxTokens ?? config.recall.maxTokens,
-        ...(filters.queryTimestamp || config.recall.queryTimestamp
-          ? { queryTimestamp: filters.queryTimestamp ?? config.recall.queryTimestamp }
-          : {}),
-        ...(filters.types ? { types: filters.types } : {}),
-        preferObservations: config.recall.preferObservations,
-        ...(filters.preferObservations !== undefined
-          ? { preferObservations: filters.preferObservations }
-          : {}),
-        ...(filters.minScores !== undefined ? { minScores: filters.minScores } : {}),
-        ...(filters.trace !== undefined ? { trace: filters.trace } : {}),
-        ...(filters.includeEntities !== undefined
-          ? { includeEntities: filters.includeEntities }
-          : {}),
-        ...(filters.maxEntityTokens !== undefined
-          ? { maxEntityTokens: filters.maxEntityTokens }
-          : {}),
-        ...(filters.includeChunks !== undefined ? { includeChunks: filters.includeChunks } : {}),
-        ...(filters.maxChunkTokens !== undefined ? { maxChunkTokens: filters.maxChunkTokens } : {}),
-        ...(filters.includeSourceFacts !== undefined
-          ? { includeSourceFacts: filters.includeSourceFacts }
-          : {}),
-        ...(filters.maxSourceFactsTokens !== undefined
-          ? { maxSourceFactsTokens: filters.maxSourceFactsTokens }
-          : {}),
-        ...composeScopedTagFilter(scopeTags, {
-          ...filters,
-          includeSharedObservations: includeShared,
-        }),
-        ...(filters.signal ? { signal: filters.signal } : {}),
-      });
-      return { bankId, result };
-    },
-
-    async reflect(
-      cwd: string,
-      query: string,
-      context?: string,
-      bank?: string,
-      responseSchema?: Record<string, unknown>,
-      filters: ExplicitReflectFilters = {},
-    ) {
-      const config = deps.getConfig();
-      const bankId = resolveOperationBank({
-        requestedBank: bank,
-        config,
-        projectBankId: deps.getProjectBankId(),
-      });
-      const scopeTags = scopeTagsForBank(cwd, config, bankId);
-      const includeShared =
-        filters.includeSharedObservations ?? config.scope.includeSharedObservations;
-      const result = await deps.getClient().reflect(bankId, query, {
-        ...(context ? { context } : {}),
-        budget: filters.budget ?? config.recall.budget,
-        ...(filters.maxTokens !== undefined ? { maxTokens: filters.maxTokens } : {}),
-        ...(responseSchema ? { responseSchema } : {}),
-        ...(filters.includeFacts !== undefined ? { includeFacts: filters.includeFacts } : {}),
-        ...(filters.includeToolCalls !== undefined
-          ? { includeToolCalls: filters.includeToolCalls }
-          : {}),
-        ...(filters.includeToolCallOutput !== undefined
-          ? { includeToolCallOutput: filters.includeToolCallOutput }
-          : {}),
-        ...(filters.factTypes ? { factTypes: filters.factTypes } : {}),
-        ...(filters.excludeMentalModels !== undefined
-          ? { excludeMentalModels: filters.excludeMentalModels }
-          : {}),
-        ...(filters.excludeMentalModelIds
-          ? { excludeMentalModelIds: filters.excludeMentalModelIds }
-          : {}),
-        ...composeScopedTagFilter(scopeTags, {
-          ...filters,
-          includeSharedObservations: includeShared,
-        }),
-        ...(filters.signal ? { signal: filters.signal } : {}),
-      });
-      return { bankId, result };
-    },
-
-    async lastRecall(cwd: string) {
-      const config = deps.getConfig();
-      const path = resolveLastRecallPath(cwd, config.recall.lastRecallPath);
-      const snapshot = await readLastRecallSnapshot(cwd, config.recall.lastRecallPath);
-      return { path, snapshot };
-    },
-
-    async recallCleanup(sessionFile: string, prune: boolean) {
-      return prune
-        ? pruneTranscriptRecallBlocks(sessionFile)
-        : scanTranscriptForRecallBlocks(sessionFile);
-    },
-  };
-}

package/node_modules/@luxusai/pi-hindsight/extensions/operations/memory-retain-operations.ts

@@ -1,131 +0,0 @@
-import type { MemoryOperationsDeps } from "./memory-operation-types.js";
-import { flushRetain } from "../queue/queue.js";
-import { resolveOperationBank } from "../banks/bank-selection.js";
-import { explicitMemoryDocumentId } from "../utils/session.js";
-import { createMemoryIdentity, explicitRetainTags } from "./memory-identity.js";
-import { expandObservationScopes } from "../lifecycle/observation-scopes.js";
-import { retainDurably } from "../lifecycle/retain.js";
-import { appendRetainReceipt, listRetainReceipts } from "../lifecycle/retain-receipts.js";
-import {
-  getEffectiveSessionMemoryMode,
-  readSessionMemoryMeta,
-} from "../utils/session-memory-meta.js";
-import type { HindsightObservationScopes, ResolvedConfig, UpdateMode } from "../types.js";
-
-const RESERVED_EXPLICIT_RETAIN_METADATA_KEYS = new Set([
-  "cwd",
-  "pi_session_file",
-  "source",
-  "retainSource",
-]);
-
-function callerMetadata(
-  metadata: Record<string, string> | undefined,
-): Record<string, string> | undefined {
-  if (!metadata) return undefined;
-  const entries = Object.entries(metadata).filter(
-    ([key]) => !RESERVED_EXPLICIT_RETAIN_METADATA_KEYS.has(key),
-  );
-  return entries.length ? Object.fromEntries(entries) : undefined;
-}
-
-export function createRetainOperations(deps: MemoryOperationsDeps) {
-  return {
-    async retainExplicit(args: {
-      cwd: string;
-      sessionFile?: string;
-      content: string;
-      context: string;
-      bank?: string;
-      tags?: string[];
-      entities?: ResolvedConfig["retain"]["entities"];
-      documentId?: string;
-      timestamp?: string;
-      metadata?: Record<string, string>;
-      updateMode?: UpdateMode;
-      observationScopes?: HindsightObservationScopes;
-      documentTags?: string[];
-      async?: boolean;
-    }) {
-      const meta = await readSessionMemoryMeta(args.cwd, args.sessionFile);
-      if (!getEffectiveSessionMemoryMode(meta).retain)
-        throw new Error("Hindsight retain is disabled for this session");
-      const config = deps.getConfig();
-      const bankId = resolveOperationBank({
-        requestedBank: args.bank,
-        config,
-        projectBankId: deps.getProjectBankId(),
-      });
-      const tags = explicitRetainTags(args.cwd, args.sessionFile, [
-        ...(args.tags ?? []),
-        ...meta.tags,
-      ]);
-      const identity = createMemoryIdentity(args.cwd, config, args.sessionFile);
-      const defaultObservationScopes = config.observations.enabled
-        ? expandObservationScopes(config.observations.scopes, {
-            ...identity,
-            projectBankId: bankId,
-          })
-        : [];
-      const observationScopes = args.observationScopes ?? defaultObservationScopes;
-      const result = await retainDurably({
-        cwd: args.cwd,
-        config,
-        client: deps.getClient(),
-        bankId,
-        content: args.content,
-        context: args.context,
-        tags,
-        updateMode: args.updateMode ?? "replace",
-        documentId:
-          args.documentId ??
-          explicitMemoryDocumentId({
-            cwd: args.cwd,
-            ...(args.sessionFile ? { sessionFile: args.sessionFile } : {}),
-            bankId,
-            content: args.content,
-            context: args.context,
-          }),
-        metadata: {
-          ...callerMetadata(args.metadata),
-          cwd: args.cwd,
-          ...(args.sessionFile ? { pi_session_file: args.sessionFile } : {}),
-        },
-        ...(args.timestamp ? { timestamp: args.timestamp } : {}),
-        source: "tool",
-        ...(hasObservationScopes(observationScopes) ? { observationScopes } : {}),
-        ...(args.documentTags?.length ? { documentTags: args.documentTags } : {}),
-        ...(args.entities?.length ? { entities: args.entities } : {}),
-        ...(args.async !== undefined ? { async: args.async } : {}),
-      });
-      const response = { ...result, tags, queued: result.enqueued };
-      await appendRetainReceipt(
-        args.cwd,
-        {
-          bankId: result.bankId,
-          documentId: result.documentId,
-          queueJobId: result.queueJobId,
-          updateMode: result.updateMode,
-          source: "tool",
-          context: args.context,
-          tags,
-          ...(result.outcome ? { outcome: result.outcome } : {}),
-        },
-        { redactSecrets: config.retain.redactSecrets },
-      );
-      return response;
-    },
-
-    async listRetainReceipts(cwd: string, limit?: number) {
-      return listRetainReceipts(cwd, limit);
-    },
-
-    async flush(cwd: string) {
-      return flushRetain(cwd, deps.getConfig(), deps.getClient());
-    },
-  };
-}
-
-function hasObservationScopes(scopes: HindsightObservationScopes): boolean {
-  return typeof scopes === "string" ? scopes.length > 0 : scopes.length > 0;
-}

package/node_modules/@luxusai/pi-hindsight/extensions/operations/memory-scope.ts

@@ -1,104 +0,0 @@
-import type { HindsightTagGroup, TagsMatch, ResolvedConfig } from "../types.js";
-import { recallScopeTags } from "../banks/banking.js";
-import { createMemoryIdentity } from "./memory-identity.js";
-
-export interface MemoryRecallScope {
-  kind: "project" | "global";
-  bankId: string;
-  tagGroups: HindsightTagGroup[];
-}
-
-export function scopeTagsForBank(cwd: string, config: ResolvedConfig, bankId: string): string[] {
-  return config.banks.user.enabled && bankId === config.banks.user.bankId
-    ? ["source:pi"]
-    : recallScopeTags(cwd, config);
-}
-
-export interface ScopedTagFilterInput {
-  tags?: string[];
-  tagsMatch?: TagsMatch;
-  tagGroups?: HindsightTagGroup[];
-  /**
-   * When true, OR exact-empty (shared/untagged) observations with the project scope filter.
-   * Default follows config.scope.includeSharedObservations when composed via recall paths.
-   */
-  includeSharedObservations?: boolean;
-}
-
-/** Hindsight exact-empty leaf: only untagged/shared observation-scope memories. */
-export const SHARED_UNTAGGED_TAG_GROUP: HindsightTagGroup = { tags: [], match: "exact" };
-
-/**
- * OR project/user scope isolation with exact-empty shared observations.
- * Used when includeSharedObservations is opted in.
- */
-export function withSharedObservations(scopeGroup: HindsightTagGroup): HindsightTagGroup {
-  return { or: [scopeGroup, SHARED_UNTAGGED_TAG_GROUP] };
-}
-
-export function composeScopedTagFilter(
-  scopeTags: string[],
-  filters: ScopedTagFilterInput = {},
-): { tagGroups: HindsightTagGroup[] } | Record<string, never> {
-  const includeShared = filters.includeSharedObservations === true;
-  const groups: HindsightTagGroup[] = [];
-
-  if (filters.tags?.length && filters.tagsMatch === "exact") {
-    // "exact" is set-equality: a memory's tag set must equal this group's tags exactly.
-    // AND-ing it with a separate mandatory scope-tag group (any_strict) would require the
-    // memory to have the scope tags AND have exactly the caller's tags, which is
-    // unsatisfiable unless the caller already knows the opaque scope tags. Fold the scope
-    // tags into the exact set instead so scope isolation is preserved and the filter stays
-    // satisfiable.
-    const exactLeaf: HindsightTagGroup = {
-      tags: [...new Set([...scopeTags, ...filters.tags])],
-      match: "exact",
-    };
-    groups.push(includeShared ? withSharedObservations(exactLeaf) : exactLeaf);
-  } else {
-    if (scopeTags.length) {
-      const scopeLeaf: HindsightTagGroup = { tags: scopeTags, match: "any_strict" };
-      groups.push(includeShared ? withSharedObservations(scopeLeaf) : scopeLeaf);
-    } else if (includeShared) {
-      // No project scope tags (unusual) but shared opt-in: only untagged.
-      groups.push(SHARED_UNTAGGED_TAG_GROUP);
-    }
-    if (filters.tags?.length)
-      groups.push({ tags: filters.tags, match: filters.tagsMatch ?? "any_strict" });
-  }
-  if (filters.tagGroups?.length) groups.push(...filters.tagGroups);
-  return groups.length ? { tagGroups: groups } : {};
-}
-
-function scopeTagGroups(scopeTags: string[], includeShared: boolean): HindsightTagGroup[] {
-  const composed = composeScopedTagFilter(scopeTags, {
-    includeSharedObservations: includeShared,
-  });
-  return "tagGroups" in composed ? composed.tagGroups : [];
-}
-
-export function selectMemoryScopes(cwd: string, config: ResolvedConfig): MemoryRecallScope[] {
-  const identity = createMemoryIdentity(cwd, config);
-  const scopes: MemoryRecallScope[] = [];
-  // Shared observations apply only to the coding/project bank (cross-project prefs
-  // inside one bank). Life/user bank keeps source:pi isolation only.
-  const includeShared = config.scope.includeSharedObservations === true;
-
-  if (config.banks.project.enabled) {
-    scopes.push({
-      kind: "project",
-      bankId: identity.projectBankId,
-      tagGroups: scopeTagGroups(identity.projectRecallTags, includeShared),
-    });
-  }
-
-  if (config.banks.user.enabled && config.banks.user.bankId) {
-    scopes.push({
-      kind: "global",
-      bankId: config.banks.user.bankId,
-      tagGroups: scopeTagGroups(identity.globalRecallTags, false),
-    });
-  }
-
-  return scopes;
-}