pi-automem-core 0.2.0 → 0.2.1

package/src/secret-scan.ts

@@ -1,34 +0,0 @@
-export interface SecretFinding {
-  kind: string;
-  match: string;
-}
-
-const SECRET_PATTERNS: Array<{ kind: string; regex: RegExp }> = [
-  { kind: "private-key", regex: /-----BEGIN\s+(?:RSA\s+|EC\s+|OPENSSH\s+)?PRIVATE\s+KEY-----/i },
-  { kind: "bearer-token", regex: /\bBearer\s+[A-Za-z0-9._~+\/-]+=*/i },
-  { kind: "github-token", regex: /\bgh[pousr]_[A-Za-z0-9_]{20,}\b/ },
-  { kind: "openai-key", regex: /\bsk-[A-Za-z0-9_-]{20,}\b/ },
-  { kind: "aws-access-key", regex: /\bAKIA[0-9A-Z]{16}\b/ },
-  { kind: "secret-assignment", regex: /\b(?:api[_-]?key|token|secret|password|passwd|credential)\b\s*[:=]\s*['\"]?[^\s'\"]{20,}/i },
-  { kind: "connection-string", regex: /\b(?:postgres|mysql|mongodb|redis):\/\/[^\s]+/i },
-];
-
-export function scanForSecrets(text: string): SecretFinding[] {
-  const findings: SecretFinding[] = [];
-  for (const pattern of SECRET_PATTERNS) {
-    const match = text.match(pattern.regex);
-    if (match && match[0]) {
-      findings.push({ kind: pattern.kind, match: redact(match[0]) });
-    }
-  }
-  return findings;
-}
-
-export function hasSecrets(text: string): boolean {
-  return scanForSecrets(text).length > 0;
-}
-
-function redact(value: string): string {
-  if (value.length <= 12) return "[redacted]";
-  return value.slice(0, 6) + "…" + value.slice(-4);
-}

package/src/tools/memory-tools.ts

@@ -1,307 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import { loadConfig, type MemoryType } from "../config";
-import { automemRecall, automemStore, automemUpdate, setAutoMemMcpServerName } from "../mcp-client";
-import { evaluateWritePolicy, formatCandidate, type MemoryCandidate } from "../write-policy";
-import { parseSearchResults } from "../recall";
-
-// ---------------------------------------------------------------------------
-// Shared parameter schemas (plain Type.Object — no Type.Intersect)
-// ---------------------------------------------------------------------------
-
-const CandidateParams = Type.Object({
-  content: Type.String({ description: "Compact memory text. Target 150-300 chars; hard max from config, default 2000." }),
-  type: Type.String({ description: "Memory type: Decision, Pattern, Preference, Style, Habit, Insight, or Context" }),
-  tags: Type.Optional(Type.Array(Type.String(), { description: "Tags such as source:pi, project:<slug>, preference, decision" })),
-  importance: Type.Optional(Type.Number({ description: "Importance 0-1. Use 0.85+ for durable decisions/preferences/corrections." })),
-  confidence: Type.Optional(Type.Number({ description: "Classification confidence 0-1. Default 0.9." })),
-  category: Type.Optional(Type.String({ description: "Write-policy category, e.g. technical-decision, agent-pattern, bug-fix, private" })),
-  source: Type.Optional(Type.String({ description: "Memory source label. Default from config." })),
-  metadata: Type.Optional(Type.Any({ description: "Optional JSON metadata" })),
-});
-
-const CommitParams = Type.Object({
-  content: Type.String({ description: "Compact memory text. Target 150-300 chars; hard max from config, default 2000." }),
-  type: Type.String({ description: "Memory type: Decision, Pattern, Preference, Style, Habit, Insight, or Context" }),
-  tags: Type.Optional(Type.Array(Type.String(), { description: "Tags such as source:pi, project:<slug>, preference, decision" })),
-  importance: Type.Optional(Type.Number({ description: "Importance 0-1. Use 0.85+ for durable decisions/preferences/corrections." })),
-  confidence: Type.Optional(Type.Number({ description: "Classification confidence 0-1. Default 0.9." })),
-  category: Type.Optional(Type.String({ description: "Write-policy category, e.g. technical-decision, agent-pattern, bug-fix, private" })),
-  source: Type.Optional(Type.String({ description: "Memory source label. Default from config." })),
-  metadata: Type.Optional(Type.Any({ description: "Optional JSON metadata" })),
-  approvedByUser: Type.Optional(Type.Boolean({ description: "Set true only after explicit user approval for this exact memory candidate." })),
-  dedupeQuery: Type.Optional(Type.String({ description: "Optional query for similar-memory recall before storing. Defaults to content." })),
-  updateMemoryId: Type.Optional(Type.String({ description: "If set, update this existing memory instead of storing a new one. Use when dedupe found a close match." })),
-});
-
-const UpdateParams = Type.Object({
-  memoryId: Type.String({ description: "ID of the existing AutoMem memory to update." }),
-  content: Type.Optional(Type.String({ description: "New memory content to replace the existing content." })),
-  type: Type.Optional(Type.String({ description: "Updated memory type: Decision, Pattern, Preference, Style, Habit, Insight, or Context" })),
-  tags: Type.Optional(Type.Array(Type.String(), { description: "Updated tags (replaces existing tags on the memory)." })),
-  importance: Type.Optional(Type.Number({ description: "Updated importance 0-1." })),
-  confidence: Type.Optional(Type.Number({ description: "Updated confidence 0-1." })),
-  metadata: Type.Optional(Type.Any({ description: "Updated metadata (merged with existing)." })),
-  approvedByUser: Type.Optional(Type.Boolean({ description: "Set true only after explicit user approval." })),
-});
-
-// ---------------------------------------------------------------------------
-// Registration
-// ---------------------------------------------------------------------------
-
-export function registerMemoryTools(pi: ExtensionAPI) {
-  // ── automem_propose_memory ──────────────────────────────────────────────
-  pi.registerTool({
-    name: "automem_propose_memory",
-    label: "AutoMem Propose Memory",
-    description: "Validate and preview a durable memory candidate without writing it. Runs policy, secret scan, and similar-memory recall.",
-    promptSnippet: "Use before storing durable memories. It does not write; it proposes and checks relevance/safety.",
-    parameters: CandidateParams,
-    async execute(_toolCallId, params) {
-      const config = loadConfig();
-      setAutoMemMcpServerName(config.mcpServerName);
-      const candidate = toCandidate(params);
-      const decision = evaluateWritePolicy(candidate, config);
-      const { text: similarText, matches: similarMatches } = await recallSimilarWithMatches(
-        decision.normalized.content,
-        decision.normalized.tags,
-        config,
-      ).catch(() => ({ text: "Similar recall failed.", matches: [] }));
-
-      return {
-        content: [{ type: "text" as const, text: formatProposal(decision.action, decision.reasons, decision.normalized, similarText, similarMatches) }],
-        details: { action: decision.action, reasons: decision.reasons, findings: decision.findings, candidate: decision.normalized, similarMatches },
-        isError: decision.action === "block",
-      };
-    },
-  });
-
-  // ── automem_commit_memory ───────────────────────────────────────────────
-  pi.registerTool({
-    name: "automem_commit_memory",
-    label: "AutoMem Commit Memory",
-    description: "Store a policy-approved durable memory in AutoMem. If dedupe finds a close match, returns DUPLICATE_DETECTED with the matching memory ID — use updateMemoryId to update instead of creating a duplicate.",
-    promptSnippet: "Use only after automem_propose_memory and explicit approval, unless policy returns safe-auto. If DUPLICATE_DETECTED, consider calling again with updateMemoryId instead.",
-    parameters: CommitParams,
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx: any) {
-      const config = loadConfig();
-      setAutoMemMcpServerName(config.mcpServerName);
-      const candidate = toCandidate(params);
-      const decision = evaluateWritePolicy(candidate, config);
-
-      if (decision.action === "block") {
-        return {
-          content: [{ type: "text" as const, text: "Blocked by AutoMem write policy.\n" + decision.reasons.map((r: string) => "- " + r).join("\n") }],
-          details: { action: decision.action, reasons: decision.reasons, findings: decision.findings },
-          isError: true,
-        };
-      }
-
-      const needsConfirmation = decision.action !== "auto";
-      if (needsConfirmation && !params.approvedByUser) {
-        if (ctx && ctx.ui && typeof ctx.ui.confirm === "function") {
-          const ok = await ctx.ui.confirm("Store AutoMem memory?", formatCandidate(decision.normalized));
-          if (!ok) {
-            return { content: [{ type: "text" as const, text: "AutoMem memory write cancelled." }], details: { cancelled: true } };
-          }
-        } else {
-          return {
-            content: [{ type: "text" as const, text: "Confirmation required before storing this memory. Re-run with approvedByUser=true only after explicit user approval." }],
-            details: { action: decision.action, reasons: decision.reasons, candidate: decision.normalized },
-            isError: true,
-          };
-        }
-      }
-
-      // ── UPDATE path ──────────────────────────────────────────────────────
-      if (params.updateMemoryId) {
-        const result = await automemUpdate(params.updateMemoryId, {
-          content: decision.normalized.content,
-          type: decision.normalized.type,
-          tags: decision.normalized.tags,
-          importance: decision.normalized.importance,
-          confidence: decision.normalized.confidence,
-          metadata: { ...(decision.normalized.metadata || {}), write_policy_action: decision.action, updated_via: "automem_commit_memory" },
-        });
-        const text = result.content?.[0]?.text || "Memory updated.";
-        return {
-          content: [{ type: "text" as const, text: "Updated existing AutoMem memory " + params.updateMemoryId + ".\n\n" + text }],
-          details: { updated: true, memoryId: params.updateMemoryId, candidate: decision.normalized },
-        };
-      }
-
-      // ── DEDUPE CHECK ─────────────────────────────────────────────────────
-      // Skip dedupe if dedupeQuery is explicitly set to empty string
-      const skipDedupe = typeof params.dedupeQuery === "string" && params.dedupeQuery.trim() === "";
-      const dedupeQuery = skipDedupe ? null : (params.dedupeQuery || decision.normalized.content);
-      const { text: similarText, matches: similarMatches } = dedupeQuery
-        ? await recallSimilarWithMatches(dedupeQuery, decision.normalized.tags, config).catch(() => ({ text: "", matches: [] }))
-        : { text: "", matches: [] };
-
-      // Surface a duplicate warning if a close match exists
-      if (!skipDedupe && similarMatches.length > 0 && similarMatches[0].id) {
-        const top = similarMatches[0];
-        return {
-          content: [{
-            type: "text" as const,
-            text: [
-              "DUPLICATE_DETECTED — a similar memory already exists.",
-              "",
-              "Existing memory (ID: " + top.id + "):",
-              "  " + top.content,
-              "",
-              "Your candidate:",
-              "  " + decision.normalized.content,
-              "",
-              "Options:",
-              "  1. Update the existing memory: call automem_commit_memory again with updateMemoryId=\"" + top.id + "\"",
-              "  2. Store anyway (new memory): call automem_commit_memory with dedupeQuery=\"\" to skip dedupe",
-              "  3. Cancel: do nothing if this is not worth storing separately",
-            ].join("\n"),
-          }],
-          details: { duplicateDetected: true, existingMemoryId: top.id, existingContent: top.content, candidate: decision.normalized, allSimilar: similarMatches },
-          isError: false,
-        };
-      }
-
-      // ── STORE path ───────────────────────────────────────────────────────
-      const result = await automemStore(
-        decision.normalized.content,
-        decision.normalized.type,
-        decision.normalized.tags,
-        {
-          source: decision.normalized.source,
-          confidence: decision.normalized.confidence,
-          importance: decision.normalized.importance,
-          metadata: { ...(decision.normalized.metadata || {}), write_policy_action: decision.action },
-        },
-      );
-      const text = result.content?.[0]?.text || "Memory stored.";
-
-      return {
-        content: [{ type: "text" as const, text: "Stored AutoMem memory.\n\n" + text }],
-        details: { result, candidate: decision.normalized, similarPreview: similarText.slice(0, 500) },
-      };
-    },
-  });
-
-  // ── automem_update_memory ───────────────────────────────────────────────
-  pi.registerTool({
-    name: "automem_update_memory",
-    label: "AutoMem Update Memory",
-    description: "Update an existing AutoMem memory by ID. Use when dedupe found a close match and the existing memory needs correction or enrichment rather than a new duplicate being stored.",
-    promptSnippet: "Use after automem_commit_memory returns DUPLICATE_DETECTED, or when correcting a known memory. Requires the existing memory ID.",
-    parameters: UpdateParams,
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx: any) {
-      if (!params.memoryId) {
-        return {
-          content: [{ type: "text" as const, text: "memoryId is required for automem_update_memory." }],
-          isError: true,
-        };
-      }
-
-      if (!params.approvedByUser) {
-        if (ctx && ctx.ui && typeof ctx.ui.confirm === "function") {
-          const preview = [
-            "Memory ID: " + params.memoryId,
-            params.content ? "New content: " + params.content : null,
-            params.type ? "Type: " + params.type : null,
-            params.tags ? "Tags: " + params.tags.join(", ") : null,
-          ].filter(Boolean).join("\n");
-          const ok = await ctx.ui.confirm("Update AutoMem memory?", preview);
-          if (!ok) {
-            return { content: [{ type: "text" as const, text: "AutoMem memory update cancelled." }], details: { cancelled: true } };
-          }
-        } else {
-          return {
-            content: [{ type: "text" as const, text: "Confirmation required before updating this memory. Re-run with approvedByUser=true only after explicit user approval." }],
-            isError: true,
-          };
-        }
-      }
-
-      const result = await automemUpdate(params.memoryId, {
-        content: params.content,
-        type: params.type,
-        tags: Array.isArray(params.tags) ? params.tags : undefined,
-        importance: params.importance,
-        confidence: params.confidence,
-        metadata: params.metadata ? { ...params.metadata, updated_via: "automem_update_memory" } : { updated_via: "automem_update_memory" },
-      });
-
-      const text = result.content?.[0]?.text || "Memory updated.";
-      return {
-        content: [{ type: "text" as const, text: "Updated AutoMem memory " + params.memoryId + ".\n\n" + text }],
-        details: { result, memoryId: params.memoryId },
-      };
-    },
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function toCandidate(params: any): MemoryCandidate {
-  return {
-    content: params.content,
-    type: params.type as MemoryType,
-    tags: Array.isArray(params.tags) ? params.tags : [],
-    importance: params.importance,
-    confidence: params.confidence,
-    source: params.source,
-    category: params.category,
-    metadata: params.metadata,
-  };
-}
-
-interface SimilarResult {
-  text: string;
-  matches: Array<{ id: string; content: string; score?: number }>;
-}
-
-async function recallSimilarWithMatches(query: string, tags: string[], config: any): Promise<SimilarResult> {
-  if (config.writePolicy.dedupeBeforeWrite === false) {
-    return { text: "Dedupe recall disabled.", matches: [] };
-  }
-  const result = await automemRecall(query, {
-    limit: Number((config.writePolicy as any).dedupeLimit || 3),
-    tags,
-    tagMode: "any",
-    contextTypes: ["Decision", "Pattern", "Preference", "Style", "Habit", "Insight", "Context"],
-    expandRelations: false,
-    expandEntities: false,
-  });
-  const text = result.content?.[0]?.text || "No similar memories found.";
-  const parsed = parseSearchResults(text);
-  const matches = parsed
-    .filter(m => m.id)
-    .map(m => ({ id: m.id, content: m.content, score: m.score }));
-  return { text, matches };
-}
-
-function formatProposal(
-  action: string,
-  reasons: string[],
-  candidate: MemoryCandidate,
-  similarText: string,
-  similarMatches: Array<{ id: string; content: string; score?: number }>,
-): string {
-  const dupeWarning = similarMatches.length > 0 && similarMatches[0].id
-    ? "\n⚠️  Possible duplicate detected (ID: " + similarMatches[0].id + "):\n  " + similarMatches[0].content
-    : "";
-
-  return [
-    "# AutoMem memory proposal",
-    "",
-    "Recommended action: " + action,
-    reasons.length ? "\nReasons:\n" + reasons.map((r: string) => "- " + r).join("\n") : "",
-    dupeWarning,
-    "",
-    "## Candidate",
-    formatCandidate(candidate),
-    "",
-    "## Similar-memory check",
-    similarText.slice(0, 2000),
-  ].filter(Boolean).join("\n");
-}

package/src/tools/relationship-tools.ts

@@ -1,114 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import { loadConfig, type MemoryType } from "../config";
-import { automemStore, automemAssociate, setAutoMemMcpServerName } from "../mcp-client";
-import { evaluateWritePolicy, type MemoryCandidate } from "../write-policy";
-
-const LinkParams = Type.Object({
-  memoryId1: Type.String({ description: "ID of the first memory." }),
-  memoryId2: Type.String({ description: "ID of the second memory." }),
-  relationship: Type.String({ description: "Relationship type: RELATES_TO, LEADS_TO, OCCURRED_BEFORE, PREFERS_OVER, EXEMPLIFIES, CONTRADICTS, REINFORCES, INVALIDATED_BY, EVOLVED_INTO, DERIVED_FROM, PART_OF" }),
-  strength: Type.Optional(Type.Number({ description: "Relationship weight 0–1. Default 0.5." })),
-  approvedByUser: Type.Boolean({ description: "Must be true to execute. Prevents accidental linking." }),
-});
-
-const CorrectParams = Type.Object({
-  memoryId: Type.String({ description: "ID of the memory being corrected." }),
-  correction: Type.String({ description: "New correct content to store." }),
-  type: Type.Optional(Type.String({ description: "Memory type for the new memory. Default: Context." })),
-  tags: Type.Optional(Type.Array(Type.String(), { description: "Tags for the new memory." })),
-  importance: Type.Optional(Type.Number({ description: "Importance 0–1 for the new memory." })),
-  relationship: Type.Optional(Type.String({ description: "EVOLVED_INTO or CONTRADICTS. Default: EVOLVED_INTO." })),
-  approvedByUser: Type.Boolean({ description: "Must be true to execute." }),
-});
-
-export function registerRelationshipTools(pi: ExtensionAPI) {
-  pi.registerTool({
-    name: "automem_link_memories",
-    label: "AutoMem Link Memories",
-    description: "Create a typed relationship between two existing AutoMem memories.",
-    promptSnippet: "Use after identifying that two memories are related. Requires both memory IDs and the relationship type.",
-    parameters: LinkParams,
-    async execute(_toolCallId: string, params: any) {
-      const config = loadConfig();
-      setAutoMemMcpServerName(config.mcpServerName);
-
-      if (!params.approvedByUser) {
-        return {
-          content: [{ type: "text" as const, text: "Confirmation required before linking memories. Re-run with approvedByUser=true only after explicit user approval.\n\nWould link:\n  " + params.memoryId1 + " → " + params.relationship + " → " + params.memoryId2 }],
-          isError: true,
-        };
-      }
-
-      const strength = typeof params.strength === "number" ? params.strength : 0.5;
-      const result = await automemAssociate(params.memoryId1, params.memoryId2, params.relationship, strength);
-      const text = result.content?.[0]?.text || "Association created.";
-      return {
-        content: [{ type: "text" as const, text: "Linked " + params.memoryId1 + " → " + params.relationship + " → " + params.memoryId2 + " (strength: " + strength + ").\n\n" + text }],
-        details: { memoryId1: params.memoryId1, memoryId2: params.memoryId2, relationship: params.relationship, strength },
-      };
-    },
-  });
-
-  pi.registerTool({
-    name: "automem_correct_memory",
-    label: "AutoMem Correct Memory",
-    description: "Store a correction to an existing memory and link old → new with a provenance relationship. Preserves history; use automem_update_memory for simple in-place edits.",
-    promptSnippet: "Use when a memory was wrong or outdated and you want to preserve history. Stores new content as a separate memory, then links old → EVOLVED_INTO/CONTRADICTS → new.",
-    parameters: CorrectParams,
-    async execute(_toolCallId: string, params: any) {
-      const config = loadConfig();
-      setAutoMemMcpServerName(config.mcpServerName);
-
-      const candidate: MemoryCandidate = {
-        content: params.correction,
-        type: (params.type || "Context") as MemoryType,
-        tags: Array.isArray(params.tags) ? params.tags : [],
-        importance: params.importance,
-      };
-      const decision = evaluateWritePolicy(candidate, config);
-      if (decision.action === "block") {
-        return {
-          content: [{ type: "text" as const, text: "Blocked by AutoMem write policy.\n" + decision.reasons.map((r: string) => "- " + r).join("\n") }],
-          details: { action: decision.action, reasons: decision.reasons, findings: decision.findings },
-          isError: true,
-        };
-      }
-
-      if (!params.approvedByUser) {
-        return {
-          content: [{ type: "text" as const, text: "Confirmation required before correcting memory. Re-run with approvedByUser=true only after explicit user approval.\n\nWould correct memory " + params.memoryId + " with:\n  " + params.correction }],
-          isError: true,
-        };
-      }
-
-      const rel = params.relationship === "CONTRADICTS" ? "CONTRADICTS" : "EVOLVED_INTO";
-      const storeResult = await automemStore(
-        params.correction,
-        params.type || "Context",
-        Array.isArray(params.tags) ? params.tags : [],
-        { importance: params.importance },
-      );
-
-      const storeText = storeResult.content?.[0]?.text || "";
-      const uuidMatch = storeText.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i);
-
-      if (!uuidMatch) {
-        console.warn("[automem] automem_correct_memory: could not extract new memory ID from store response — skipping link");
-        return {
-          content: [{ type: "text" as const, text: "Stored correction (ID unknown — link not created). Store response: " + storeText.slice(0, 300) }],
-          details: { storeText },
-        };
-      }
-
-      const newId = uuidMatch[0];
-      const assocResult = await automemAssociate(params.memoryId, newId, rel, 0.9);
-      const assocText = assocResult.content?.[0]?.text || "Association created.";
-
-      return {
-        content: [{ type: "text" as const, text: "Stored correction as " + newId + ". Linked " + params.memoryId + " → " + rel + " → " + newId + ".\n\n" + assocText }],
-        details: { originalId: params.memoryId, newId, relationship: rel },
-      };
-    },
-  });
-}

package/src/write-policy.ts

@@ -1,142 +0,0 @@
-import type { AutoMemConfig, MemoryType } from "./config";
-import { scanForSecrets, type SecretFinding } from "./secret-scan";
-
-export type WriteMode = "off" | "propose" | "safe-auto" | "confirm-all";
-export type WriteAction = "block" | "propose" | "confirm" | "auto";
-
-export interface MemoryCandidate {
-  content: string;
-  type: MemoryType;
-  tags: string[];
-  importance: number;
-  confidence?: number;
-  source?: string;
-  category?: string;
-  metadata?: Record<string, unknown>;
-}
-
-export interface PolicyDecision {
-  action: WriteAction;
-  reasons: string[];
-  findings: SecretFinding[];
-  normalized: MemoryCandidate;
-}
-
-const VALID_TYPES = new Set(["Decision", "Pattern", "Preference", "Style", "Habit", "Insight", "Context"]);
-
-export function normalizeCandidate(input: MemoryCandidate, config: AutoMemConfig): MemoryCandidate {
-  const tags = Array.from(new Set([
-    ...(config.writePolicy.alwaysTag || []),
-    ...(input.tags || []),
-  ].map(t => String(t).trim().toLowerCase()).filter(Boolean)));
-
-  return {
-    content: String(input.content || "").replace(/\s+/g, " ").trim(),
-    type: input.type,
-    tags,
-    importance: clampNumber(input.importance, 0, 1, defaultImportanceForType(input.type)),
-    confidence: clampNumber(input.confidence, 0, 1, 0.9),
-    source: input.source || config.writePolicy.defaultSource || "pi-session",
-    category: (input.category || inferCategory(input.type, tags)).toLowerCase(),
-    metadata: input.metadata,
-  };
-}
-
-export function evaluateWritePolicy(input: MemoryCandidate, config: AutoMemConfig): PolicyDecision {
-  const normalized = normalizeCandidate(input, config);
-  const reasons: string[] = [];
-  const findings = scanForSecrets(normalized.content + "\n" + normalized.tags.join("\n"));
-  const mode = ((config.writePolicy as any).mode || "propose") as WriteMode;
-  const preferredMax = config.behavior.preferredContentLength || 500;
-  const hardMax = config.behavior.maxContentLength || 2000;
-  const minImportance = Number((config.writePolicy as any).minImportanceToWrite ?? 0.7);
-
-  if (mode === "off") reasons.push("write policy mode is off");
-  if (!normalized.content) reasons.push("content is empty");
-  if (!VALID_TYPES.has(normalized.type)) reasons.push("invalid memory type");
-  if (normalized.content.length > hardMax) reasons.push("content exceeds hard length limit");
-  if (findings.length > 0) reasons.push("secret/privacy scanner found blocked content");
-  if (normalized.importance < minImportance) reasons.push("importance is below configured write threshold");
-  if (isBlockedCategory(normalized, config)) reasons.push("category is blocked by write policy");
-
-  if (reasons.length > 0) {
-    return { action: "block", reasons, findings, normalized };
-  }
-
-  if (normalized.content.length > preferredMax) {
-    reasons.push("content exceeds preferred embedding length; consider shortening before commit");
-  }
-
-  if (mode === "confirm-all") {
-    return { action: "confirm", reasons: ["write policy requires confirmation for all memories", ...reasons], findings, normalized };
-  }
-
-  if (isConfirmCategory(normalized, config)) {
-    return { action: "confirm", reasons: ["category requires user confirmation", ...reasons], findings, normalized };
-  }
-
-  if (mode === "safe-auto" && isAutoCategory(normalized, config)) {
-    return { action: "auto", reasons: ["category is eligible for safe automatic write", ...reasons], findings, normalized };
-  }
-
-  return { action: "propose", reasons: ["candidate should be proposed for approval before storing", ...reasons], findings, normalized };
-}
-
-export function formatCandidate(candidate: MemoryCandidate): string {
-  return (
-    "Content: " + candidate.content + "\n" +
-    "Type: " + candidate.type + "\n" +
-    "Importance: " + candidate.importance + "\n" +
-    "Tags: " + (candidate.tags.join(", ") || "(none)") + "\n" +
-    "Category: " + (candidate.category || "(inferred)")
-  );
-}
-
-function isBlockedCategory(candidate: MemoryCandidate, config: AutoMemConfig): boolean {
-  const blocked = new Set((config.writePolicy.blockedCategories || []).map(c => c.toLowerCase()));
-  return blocked.has(candidate.category || "") || candidate.tags.some(t => blocked.has(t));
-}
-
-function isConfirmCategory(candidate: MemoryCandidate, config: AutoMemConfig): boolean {
-  const confirm = new Set((config.writePolicy.confirmCategories || []).map(c => c.toLowerCase()));
-  return confirm.has(candidate.category || "") || candidate.tags.some(t => confirm.has(t));
-}
-
-function isAutoCategory(candidate: MemoryCandidate, config: AutoMemConfig): boolean {
-  const auto = new Set((config.writePolicy.autoWriteCategories || []).map(c => c.toLowerCase()));
-  return auto.has(candidate.category || "") || auto.has(candidate.type.toLowerCase()) || candidate.tags.some(t => auto.has(t));
-}
-
-function inferCategory(type: MemoryType, tags: string[]): string {
-  if (tags.includes("preference")) return "preference";
-  if (tags.includes("decision")) return "technical-decision";
-  if (tags.includes("bug-fix")) return "bug-fix";
-  if (tags.includes("pattern")) return "agent-pattern";
-  if (tags.includes("private") || tags.includes("personal")) return "private";
-  switch (type) {
-    case "Decision": return "technical-decision";
-    case "Preference": return "preference";
-    case "Pattern": return "agent-pattern";
-    case "Insight": return "tooling-lesson";
-    default: return "context";
-  }
-}
-
-function defaultImportanceForType(type: MemoryType): number {
-  switch (type) {
-    case "Decision": return 0.9;
-    case "Preference": return 0.85;
-    case "Pattern": return 0.8;
-    case "Insight": return 0.8;
-    case "Style": return 0.7;
-    case "Habit": return 0.65;
-    case "Context": return 0.6;
-    default: return 0.5;
-  }
-}
-
-function clampNumber(value: unknown, min: number, max: number, fallback: number): number {
-  const n = Number(value);
-  if (!Number.isFinite(n)) return fallback;
-  return Math.min(max, Math.max(min, n));
-}