@herbertgao/pi-extensions 2026.9.5 → 2026.9.7

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

@@ -1,319 +0,0 @@
-import type { ResolvedConfig } from "../types.js";
-import {
-  PI_HINDSIGHT_CLIENT_PACKAGE,
-  PI_HINDSIGHT_CLIENT_RANGE,
-  PI_HINDSIGHT_SUPPORTED_NODE,
-  PI_HINDSIGHT_SUPPORTED_NPM,
-  PI_HINDSIGHT_SUPPORTED_TYPEBOX,
-  PI_HINDSIGHT_USER_AGENT,
-  PI_HINDSIGHT_VERSION,
-} from "../version.js";
-import {
-  baseTags,
-  findRepoRoot,
-  formatProjectIdentityForStatus,
-  resolveProjectIdentity,
-} from "../banks/banking.js";
-import { stableSessionId } from "./session.js";
-import { createMemoryIdentity } from "../operations/memory-identity.js";
-import { expandObservationScopes } from "../lifecycle/observation-scopes.js";
-import type { ImportManifestEntry } from "../imports/import-plan.js";
-import {
-  formatHindsightActivity,
-  formatHindsightStatus,
-  type HindsightActivity,
-} from "./status.js";
-import { buildStatusFields } from "./status-fields.js";
-import type { ScopeMigratePlan } from "../operations/scope-migrate.js";
-
-export interface DebugReportArgs {
-  cwd: string;
-  sessionFile?: string;
-  projectBankId: string;
-  config: ResolvedConfig;
-  queueLength: number;
-  queuePath?: string;
-  queueMalformedLines?: number;
-  queueReadError?: string | null;
-  deadLetterPath?: string;
-  deadLetterLength?: number;
-  deadLetterMalformedLines?: number;
-  deadLetterReadError?: string | null;
-  importManifestPath?: string;
-  importManifestError?: string | null;
-  importManifestAction?: string | null;
-  importCount?: number;
-  latestImport?: ImportManifestEntry;
-  health?: { ok: boolean; error?: string };
-  activity?: HindsightActivity;
-  memoryCount?: number;
-  queueRemaining?: number;
-  scopeMigrate?: ScopeMigratePlan;
-  /** Memory readiness: queue, git seed receipt, knowledge-page capability. */
-  sync?: unknown;
-}
-
-export function bankSelectionMessage(projectBankId: string, config: ResolvedConfig): string {
-  if (!config.banks.project.enabled) {
-    return config.banks.user.enabled && config.banks.user.bankId
-      ? `Hindsight life/user bank: ${config.banks.user.bankId}`
-      : "Hindsight coding bank disabled and no life/user bank configured.";
-  }
-  const mode = config.scope.mode;
-  if (config.banks.project.bankId) {
-    return mode === "isolated-bank"
-      ? `Hindsight isolated bank: ${projectBankId}`
-      : `Hindsight coding bank (domain-tagged): ${projectBankId}`;
-  }
-  return mode === "isolated-bank"
-    ? `Hindsight isolated bank auto-selected: ${projectBankId}. Set banks.project.bankId to pin.`
-    : `Hindsight coding bank path-derived (set banks.project.bankId for a shared domain bank): ${projectBankId}`;
-}
-
-export function memoryProfile(
-  config: ResolvedConfig,
-): "project-only" | "project+global" | "global-only" | "none" {
-  if (!config.banks.project.enabled) return config.banks.user.enabled ? "global-only" : "none";
-  if (config.banks.user.enabled) return "project+global";
-  return "project-only";
-}
-
-export function safeConfig(config: ResolvedConfig): ResolvedConfig {
-  return {
-    ...config,
-    hindsight: {
-      ...config.hindsight,
-      ...(config.hindsight.apiKey ? { apiKey: "[set]" } : {}),
-      ...(config.hindsight.apiKeyRef ? { apiKeyRef: config.hindsight.apiKeyRef } : {}),
-    },
-  };
-}
-
-export function observationScopeDiagnostics(args: {
-  cwd: string;
-  sessionFile?: string;
-  projectBankId: string;
-  config: ResolvedConfig;
-}): { enabled: boolean; scopes: string[][] | null; error: string | null; action: string | null } {
-  const identity = {
-    ...createMemoryIdentity(args.cwd, args.config, args.sessionFile),
-    projectBankId: args.projectBankId,
-  };
-  try {
-    return {
-      enabled: args.config.observations.enabled,
-      scopes: args.config.observations.enabled
-        ? expandObservationScopes(args.config.observations.scopes, identity)
-        : [],
-      error: null,
-      action: null,
-    };
-  } catch (error) {
-    return {
-      enabled: args.config.observations.enabled,
-      scopes: null,
-      error: error instanceof Error ? error.message : String(error),
-      action: "Fix observations.scopes placeholders or disable observations.enabled.",
-    };
-  }
-}
-
-export function formatDebugReport(args: DebugReportArgs): string {
-  const sessionId = stableSessionId(args.sessionFile, args.cwd);
-  const projectIdentity = resolveProjectIdentity(args.cwd, args.config);
-  const tags = baseTags(args.cwd, sessionId, args.config);
-  const observationScopes = observationScopeDiagnostics(args);
-  const health = args.health
-    ? args.health.ok
-      ? "reachable"
-      : `unreachable: ${args.health.error}`
-    : "not checked";
-  const activity = args.activity ?? "idle";
-  return JSON.stringify(
-    {
-      enabled: args.config.enabled,
-      integration: {
-        packageVersion: PI_HINDSIGHT_VERSION,
-        userAgent: PI_HINDSIGHT_USER_AGENT,
-        hindsightBaseUrl: args.config.hindsight.baseUrl,
-        clientPackage: PI_HINDSIGHT_CLIENT_PACKAGE,
-        clientRange: PI_HINDSIGHT_CLIENT_RANGE,
-        compatibility: {
-          node: PI_HINDSIGHT_SUPPORTED_NODE,
-          npm: PI_HINDSIGHT_SUPPORTED_NPM,
-          typebox: PI_HINDSIGHT_SUPPORTED_TYPEBOX,
-          hindsightServer:
-            "Hindsight 0.8+ with append update_mode support; advanced tools are capability-gated.",
-          policy: "Pi-first 1.0 integration; global platform admin parity is out of scope.",
-        },
-      },
-      health,
-      ...(args.sync !== undefined ? { sync: args.sync } : {}),
-      cwd: args.cwd,
-      repoRoot: findRepoRoot(args.cwd),
-      sessionFile: args.sessionFile ?? null,
-      sessionId,
-      statusFields: buildStatusFields(args.config, {
-        cwd: args.cwd,
-        projectBankId: args.projectBankId,
-        queueLength: args.queueLength,
-        ...(args.deadLetterLength !== undefined ? { deadLetterLength: args.deadLetterLength } : {}),
-        ...(args.health
-          ? {
-              healthOk: args.health.ok,
-              ...(args.health.error ? { healthError: args.health.error } : {}),
-            }
-          : {}),
-      }),
-      projectScope: {
-        projectId: projectIdentity.projectId,
-        basis: projectIdentity.basis,
-        source: projectIdentity.source,
-        tag: `project:${projectIdentity.projectId}`,
-        legacyRepoTag: `repo:${projectIdentity.legacyRepoKey}`,
-        summary: formatProjectIdentityForStatus(projectIdentity),
-        dualTagWindow:
-          "Retain and recall dual-tag project:<id> and legacy repo:<path-hash> so path moves and older banks stay recoverable.",
-      },
-      scopeMigrate: args.scopeMigrate ?? null,
-      memoryProfile: memoryProfile(args.config),
-      projectBankId: args.projectBankId,
-      projectBankSelection: args.config.banks.project.bankId
-        ? "configured"
-        : args.config.banks.project.derive,
-      bankMissions: {
-        projectConfigured: Boolean(
-          args.config.banks.project.retainMission ||
-          args.config.banks.project.reflectMission ||
-          args.config.banks.project.observationsMission,
-        ),
-        globalConfigured: Boolean(
-          args.config.banks.user.retainMission ||
-          args.config.banks.user.reflectMission ||
-          args.config.banks.user.observationsMission,
-        ),
-      },
-      observations: observationScopes,
-      overrideProjectBankId:
-        "Set PI_HINDSIGHT_PROJECT_BANK_ID or .pi/hindsight.json banks.project.bankId",
-      globalBankId: args.config.banks.user.enabled ? (args.config.banks.user.bankId ?? null) : null,
-      memoryRoutes: {
-        recall: [
-          ...(args.config.banks.project.enabled ? ["project"] : []),
-          ...(args.config.banks.user.enabled && args.config.banks.user.bankId ? ["global"] : []),
-        ],
-        autoRetain: args.config.banks.project.enabled ? "project" : null,
-      },
-      tags,
-      queuePath: args.config.retain.queuePath,
-      queueLength: args.queueLength,
-      queue: {
-        path: args.queuePath ?? args.config.retain.queuePath,
-        active: args.queueLength,
-        malformedLines: args.queueMalformedLines ?? 0,
-        error: args.queueReadError ?? null,
-        deadLetterPath: args.deadLetterPath ?? null,
-        deadLetter: args.deadLetterLength ?? 0,
-        deadLetterMalformedLines: args.deadLetterMalformedLines ?? 0,
-        deadLetterError: args.deadLetterReadError ?? null,
-        action:
-          args.queueReadError ||
-          args.deadLetterReadError ||
-          (args.queueMalformedLines ?? 0) > 0 ||
-          (args.deadLetterMalformedLines ?? 0) > 0 ||
-          (args.deadLetterLength ?? 0) > 0
-            ? "Inspect queue files, fix malformed JSONL offline if needed, then open /hindsight and press f to flush after Hindsight is reachable."
-            : null,
-      },
-      serverRequirements: {
-        appendUpdateMode: "required (Hindsight 0.8+)",
-        clientPackage: PI_HINDSIGHT_CLIENT_PACKAGE,
-        clientRange: PI_HINDSIGHT_CLIENT_RANGE,
-        action: "Upgrade to Hindsight 0.8+ if live append retain fails.",
-      },
-      imports: {
-        manifestPath: args.importManifestPath ?? args.config.import.manifestPath,
-        error: args.importManifestError ?? null,
-        action: args.importManifestError
-          ? (args.importManifestAction ??
-            "Move or repair the import manifest, then open /hindsight and press i to re-run import.")
-          : null,
-        count: args.importCount ?? 0,
-        latest: args.latestImport
-          ? {
-              documentId: args.latestImport.documentId,
-              sourceFile: args.latestImport.sourceFile,
-              importedAt: args.latestImport.importedAt,
-              messageCount: args.latestImport.messageCount,
-              leafId: args.latestImport.leafId,
-              sessionId: args.latestImport.sessionId,
-              contentHash: args.latestImport.contentHash,
-              ...(args.latestImport.importMode ? { importMode: args.latestImport.importMode } : {}),
-              ...(args.latestImport.toolResults
-                ? { toolResults: args.latestImport.toolResults }
-                : {}),
-              ...(args.latestImport.importQualityProfile
-                ? { importQualityProfile: args.latestImport.importQualityProfile }
-                : {}),
-              ...(args.latestImport.projectionVersion
-                ? { projectionVersion: args.latestImport.projectionVersion }
-                : {}),
-              ...(args.latestImport.importProfile
-                ? { importProfile: args.latestImport.importProfile }
-                : {}),
-              ...(args.latestImport.chunkIndex !== undefined
-                ? { chunkIndex: args.latestImport.chunkIndex }
-                : {}),
-              ...(args.latestImport.messageRange
-                ? { messageRange: args.latestImport.messageRange }
-                : {}),
-              ...(args.latestImport.updateMode ? { updateMode: args.latestImport.updateMode } : {}),
-            }
-          : null,
-      },
-      status: args.config.status,
-      statusPreview:
-        formatHindsightStatus(args.config, {
-          cwd: args.cwd,
-          projectBankId: args.projectBankId,
-          activity,
-          ...(args.memoryCount !== undefined ? { memoryCount: args.memoryCount } : {}),
-          ...(args.queueRemaining !== undefined ? { queueRemaining: args.queueRemaining } : {}),
-        }) ?? null,
-      activity: formatHindsightActivity(activity, args.memoryCount, args.queueRemaining),
-      recall: {
-        enabled: args.config.recall.enabled,
-        budget: args.config.recall.budget,
-        maxTokens: args.config.recall.maxTokens,
-        types: args.config.recall.types,
-        contextTurns: args.config.recall.contextTurns,
-        roles: args.config.recall.roles,
-        maxQueryChars: args.config.recall.maxQueryChars,
-        queryPreamble: args.config.recall.queryPreamble,
-        projectQueryPreamble: args.config.recall.projectQueryPreamble,
-        globalQueryPreamble: args.config.recall.globalQueryPreamble,
-        includeDateInQuery: args.config.recall.includeDateInQuery,
-        includeRepoHintsInQuery: args.config.recall.includeRepoHintsInQuery,
-        storeLastRecall: args.config.recall.storeLastRecall,
-        storeLastRecallFailures: args.config.recall.storeLastRecallFailures,
-        lastRecallPath: args.config.recall.lastRecallPath,
-        topK: args.config.recall.topK,
-        timeoutMs: args.config.recall.timeoutMs,
-        injectionPosition: args.config.recall.injectionPosition,
-        minScores: args.config.recall.minScores,
-      },
-      retain: {
-        enabled: args.config.retain.enabled,
-        async: args.config.retain.async,
-        updateMode: args.config.retain.updateMode,
-        redactSecrets: args.config.retain.redactSecrets,
-        content: args.config.retain.content,
-        toolFilter: args.config.retain.toolFilter,
-        strip: args.config.retain.strip,
-      },
-      config: safeConfig(args.config),
-    },
-    null,
-    2,
-  );
-}

package/node_modules/@luxusai/pi-hindsight/extensions/utils/messages.ts

@@ -1,325 +0,0 @@
-import type { AgentMessage } from "@earendil-works/pi-agent-core";
-import type { ResolvedConfig } from "../types.js";
-
-function stringValue(value: unknown, fallback = ""): string {
-  if (typeof value === "string") return value;
-  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
-    return String(value);
-  }
-  return fallback;
-}
-
-function toolName(message: Record<string, unknown>, part?: Record<string, unknown>): string {
-  return stringValue(part?.name ?? message.toolName ?? message.name, "unknown");
-}
-
-function toolAllowed(name: string, filter: { include?: string[]; exclude?: string[] }): boolean {
-  if (filter.include && !filter.include.includes(name)) return false;
-  return !filter.exclude?.includes(name);
-}
-
-/** Keys tried, in order, for a compact tool-action target (coding-agents write-back discipline). */
-const TOOL_TARGET_KEYS = [
-  "file_path",
-  "path",
-  "notebook_path",
-  "command",
-  "pattern",
-  "query",
-  "url",
-  "name",
-  "id",
-] as const;
-
-const ACTION_TARGET_CAP = 100;
-
-/**
- * Compact tool input to a primary target string (file path, command, pattern, …).
- * Full args/outputs bury decisions in mechanical noise; retain only WHAT was touched.
- */
-export function toolActionTarget(input: unknown): string {
-  let target = "";
-  if (input && typeof input === "object") {
-    const rec = input as Record<string, unknown>;
-    for (const key of TOOL_TARGET_KEYS) {
-      const value = rec[key];
-      if (typeof value === "string" && value.trim()) {
-        target = value.trim().split("\n")[0] ?? "";
-        break;
-      }
-    }
-  } else if (typeof input === "string") {
-    target = input.trim().split("\n")[0] ?? "";
-  }
-  if (target.length > ACTION_TARGET_CAP) target = `${target.slice(0, ACTION_TARGET_CAP)}…`;
-  return target;
-}
-
-function compactToolCallPart(name: string, args: unknown): Record<string, unknown> {
-  const target = toolActionTarget(args);
-  return {
-    type: "toolCall",
-    name,
-    // Compact form: name + primary target only (no full argument object / no outputs).
-    arguments: target ? { target } : {},
-  };
-}
-
-function textFromContent(
-  content: unknown,
-  options: {
-    includeText: boolean;
-    includeThinking: boolean;
-    includeToolCall: boolean;
-    includeUnknownJson?: boolean;
-    toolCallFilter?: { include?: string[]; exclude?: string[] };
-    /** When true (default), tool calls become name+target only. */
-    compactToolCalls?: boolean;
-  },
-): string {
-  if (typeof content === "string") return options.includeText ? content : "";
-  if (!Array.isArray(content)) return options.includeText ? JSON.stringify(content ?? "") : "";
-  return content
-    .map((part) => {
-      if (part && typeof part === "object" && "type" in part) {
-        const p = part as Record<string, unknown>;
-        if (p.type === "text") return options.includeText ? stringValue(p.text) : "";
-        if (p.type === "thinking")
-          return options.includeThinking ? stringValue(p.thinking ?? p.text) : "";
-        if (p.type === "toolCall") {
-          if (!options.includeToolCall) return "";
-          const name = stringValue(p.name, "unknown");
-          if (options.toolCallFilter && !toolAllowed(name, options.toolCallFilter)) return "";
-          if (options.compactToolCalls !== false) {
-            const target = toolActionTarget(p.arguments);
-            return target ? `[action ${name} ${target}]` : `[action ${name}]`;
-          }
-          return `[toolCall ${name}] ${JSON.stringify(p.arguments ?? {})}`;
-        }
-        if (p.type === "image") return options.includeText ? "[image omitted]" : "";
-      }
-      return options.includeText && options.includeUnknownJson !== false
-        ? JSON.stringify(part)
-        : "";
-    })
-    .filter(Boolean)
-    .join("\n");
-}
-
-function projectContent(
-  content: unknown,
-  options: {
-    includeText: boolean;
-    includeThinking: boolean;
-    includeToolCall: boolean;
-    toolCallFilter?: { include?: string[]; exclude?: string[] };
-    compactToolCalls?: boolean;
-  },
-): unknown {
-  if (typeof content === "string") return options.includeText ? content : "";
-  if (!Array.isArray(content)) return options.includeText ? (content ?? "") : "";
-  const projected = content
-    .map((part) => {
-      if (part && typeof part === "object" && "type" in part) {
-        const p = part as Record<string, unknown>;
-        if (p.type === "text") return options.includeText ? part : undefined;
-        if (p.type === "thinking") return options.includeThinking ? part : undefined;
-        if (p.type === "toolCall") {
-          if (!options.includeToolCall) return undefined;
-          const name = stringValue(p.name, "unknown");
-          if (options.toolCallFilter && !toolAllowed(name, options.toolCallFilter))
-            return undefined;
-          if (options.compactToolCalls !== false) {
-            return compactToolCallPart(name, p.arguments);
-          }
-          return part;
-        }
-        if (p.type === "image") return options.includeText ? part : undefined;
-      }
-      return options.includeText ? part : undefined;
-    })
-    .filter((part): part is unknown => part !== undefined);
-  return projected.length ? projected : "";
-}
-
-function stripFields(record: Record<string, unknown>, fields: string[]): Record<string, unknown> {
-  const out = { ...record };
-  fields.forEach((field) => delete out[field]);
-  return out;
-}
-
-function messageTimestamp(message: Record<string, unknown>): string {
-  return new Date(
-    typeof message.timestamp === "number" ? message.timestamp : Date.now(),
-  ).toISOString();
-}
-
-export function projectMessage(
-  message: AgentMessage,
-  config?: ResolvedConfig,
-): Record<string, unknown> {
-  const m = message as unknown as Record<string, unknown>;
-  const role = stringValue(m.role, "unknown");
-  const retain = config?.retain;
-  const isAssistant = role === "assistant";
-  const includeAssistantText = retain?.content.assistant.includes("text") ?? true;
-  const includeThinking = retain?.content.assistant.includes("thinking") ?? false;
-  const includeToolCall = retain?.content.assistant.includes("toolCall") ?? true;
-  const compactToolCalls = retain?.compactToolCalls !== false;
-  const base: Record<string, unknown> = {
-    role,
-    timestamp: messageTimestamp(m),
-    content: projectContent(m.content, {
-      includeText: !isAssistant || includeAssistantText,
-      includeThinking: isAssistant && includeThinking,
-      includeToolCall: isAssistant && includeToolCall,
-      compactToolCalls,
-      ...(retain ? { toolCallFilter: retain.toolFilter.toolCall } : {}),
-    }),
-  };
-  if (role === "toolResult") {
-    base.toolName = m.toolName;
-    base.isError = m.isError;
-  }
-  if (role === "assistant") {
-    base.model = m.model;
-    base.stopReason = m.stopReason;
-  }
-  return stripFields(base, retain?.strip.message ?? []);
-}
-
-export function projectMessageText(
-  message: AgentMessage,
-  config?: ResolvedConfig,
-): Record<string, unknown> {
-  const m = message as unknown as Record<string, unknown>;
-  const role = stringValue(m.role, "unknown");
-  const retain = config?.retain;
-  const isAssistant = role === "assistant";
-  const includeAssistantText = retain?.content.assistant.includes("text") ?? true;
-  const includeThinking = retain?.content.assistant.includes("thinking") ?? false;
-  const includeToolCall = retain?.content.assistant.includes("toolCall") ?? true;
-  const compactToolCalls = retain?.compactToolCalls !== false;
-  const base: Record<string, unknown> = {
-    role,
-    timestamp: messageTimestamp(m),
-    content: textFromContent(m.content, {
-      includeText: !isAssistant || includeAssistantText,
-      includeThinking: isAssistant && includeThinking,
-      includeToolCall: isAssistant && includeToolCall,
-      includeUnknownJson: false,
-      compactToolCalls,
-      ...(retain ? { toolCallFilter: retain.toolFilter.toolCall } : {}),
-    }),
-  };
-  if (role === "toolResult") {
-    base.toolName = m.toolName;
-    base.isError = m.isError;
-  }
-  if (role === "assistant") {
-    base.model = m.model;
-    base.stopReason = m.stopReason;
-  }
-  return stripFields(base, retain?.strip.message ?? []);
-}
-
-export function isInjectedHindsightMemory(message: unknown): boolean {
-  const record = message as { content?: unknown; customType?: unknown; type?: unknown };
-  if (
-    record.customType === "hindsight-recall" ||
-    record.type === "hindsight-recall" ||
-    record.customType === "hindsight-mental-models" ||
-    record.type === "hindsight-mental-models"
-  ) {
-    return true;
-  }
-  const text = textFromContent(record.content, {
-    includeText: true,
-    includeThinking: false,
-    includeToolCall: true,
-  }).trim();
-  // Only prefix matches: substring contains would drop legitimate discussion of these tags.
-  return (
-    text.startsWith("<hindsight-memory>") ||
-    text.startsWith("<hindsight_memories>") ||
-    text.startsWith("<hindsight-mental-models>") ||
-    text.startsWith("<mental_models>")
-  );
-}
-
-function toolResultContent(
-  message: Record<string, unknown>,
-  mode: "error" | "summary" | "content",
-): string {
-  const text = textFromContent(message.content, {
-    includeText: true,
-    includeThinking: false,
-    includeToolCall: false,
-  });
-  if (mode === "summary") return text.length > 500 ? `${text.slice(0, 500)}…` : text;
-  return text;
-}
-
-function projectToolResult(
-  message: AgentMessage,
-  config: ResolvedConfig,
-): Record<string, unknown> | undefined {
-  const m = message as unknown as Record<string, unknown>;
-  const name = toolName(m);
-  if (!toolAllowed(name, config.retain.toolFilter.toolResult)) return undefined;
-  const modes = config.retain.content.toolResult;
-  if (m.isError) {
-    if (!modes.includes("error")) return undefined;
-    return stripFields(
-      {
-        role: "toolResult",
-        timestamp: messageTimestamp(m),
-        toolName: name,
-        isError: true,
-        content: toolResultContent(m, "error"),
-      },
-      config.retain.strip.message,
-    );
-  }
-  if (modes.includes("content")) return projectMessage(message, config);
-  if (modes.includes("summary")) {
-    return stripFields(
-      {
-        role: "toolResult",
-        timestamp: messageTimestamp(m),
-        toolName: name,
-        isError: false,
-        content: toolResultContent(m, "summary"),
-      },
-      config.retain.strip.message,
-    );
-  }
-  return undefined;
-}
-
-function hasAssistantContentToRetain(message: AgentMessage, config: ResolvedConfig): boolean {
-  return Boolean(projectMessage(message, config).content);
-}
-
-export function projectMessages(
-  messages: AgentMessage[],
-  config: ResolvedConfig,
-): Record<string, unknown>[] {
-  return messages
-    .filter((message) => !isInjectedHindsightMemory(message))
-    .map((message) => {
-      const role = (message as unknown as { role?: string }).role;
-      if (role === "user")
-        return config.retain.content.user.includes("text")
-          ? projectMessage(message, config)
-          : undefined;
-      if (role === "assistant") {
-        if (!hasAssistantContentToRetain(message, config)) return undefined;
-        return projectMessage(message, config);
-      }
-      if (role === "toolResult") return projectToolResult(message, config);
-      return projectMessage(message, config);
-    })
-    .filter((message): message is Record<string, unknown> => Boolean(message))
-    .map((message) => stripFields(message, config.retain.strip.topLevel));
-}

package/node_modules/@luxusai/pi-hindsight/extensions/utils/sanitize.ts

@@ -1,42 +0,0 @@
-const SECRET_PATTERNS: Array<[RegExp, string]> = [
-  [/\b(Bearer\s+)[A-Za-z0-9._~+/=-]{12,}/gi, "$1[REDACTED]"],
-  [/\b(sk-[A-Za-z0-9_-]{12,})\b/g, "[REDACTED_API_KEY]"],
-  [/\b(ghp_[A-Za-z0-9_]{12,})\b/g, "[REDACTED_GITHUB_TOKEN]"],
-  [
-    /\b([A-Z0-9_]*(?:API_KEY|TOKEN|SECRET|PASSWORD)[A-Z0-9_]*\s*=\s*)[^\s\n"',}]+/gi,
-    "$1[REDACTED]",
-  ],
-  [
-    /\b((?:api[_-]?key|token|secret|password|authorization)\s*:\s*)["']?[^\s\n"',}]+["']?/gi,
-    "$1[REDACTED]",
-  ],
-  [
-    /(["'](?:api[_-]?key|token|secret|password|authorization)["']\s*:\s*)["'][^"']+["']/gi,
-    '$1"[REDACTED]"',
-  ],
-  [/\b((?:Cookie|Set-Cookie)\s*:\s*)[^\r\n]+/gi, "$1[REDACTED]"],
-  [/(https?:\/\/)([^\s/@]+):([^\s/@]+)@/gi, "$1[REDACTED]@"],
-];
-
-const SENSITIVE_QUERY_PARAM = /(?:token|key|secret|password|api[_-]?key|apikey)/i;
-
-function redactUrlQuerySecrets(input: string): string {
-  return input.replace(/https?:\/\/[^\s"'<>]+/gi, (url) =>
-    url.replace(/([?&])([^=&#\s]+)=([^&#\s]+)/g, (match, separator, key) => {
-      if (!SENSITIVE_QUERY_PARAM.test(String(key))) return String(match);
-      return `${String(separator)}${String(key)}=[REDACTED]`;
-    }),
-  );
-}
-
-export function redactSecrets(input: string): string {
-  const text = SECRET_PATTERNS.reduce(
-    (current, [pattern, replacement]) => current.replace(pattern, replacement),
-    input,
-  );
-  return redactUrlQuerySecrets(text);
-}
-
-export function redactError(error: unknown): string {
-  return redactSecrets(error instanceof Error ? error.message : String(error));
-}