pi-automem-bridge 0.2.0 → 0.2.2

package/src/tools/relationship-tools.ts

@@ -1,114 +1,121 @@
-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 },
-      };
-    },
-  });
-}
+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";
+      // Store the normalized candidate so corrections get the same alwaysTag,
+      // source, and content normalization as every other write path.
+      const storeResult = await automemStore(
+        decision.normalized.content,
+        decision.normalized.type,
+        decision.normalized.tags,
+        {
+          source: decision.normalized.source,
+          importance: decision.normalized.importance,
+          confidence: decision.normalized.confidence,
+          metadata: decision.normalized.metadata,
+        },
+      );
+
+      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 +1,148 @@
-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));
-}
+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[] = [];
+  // Scan content, tags, AND metadata — metadata is model-supplied (Type.Any)
+  // and is stored verbatim, so a secret placed there must not bypass the scan.
+  let metadataText = "";
+  if (normalized.metadata) {
+    try { metadataText = "\n" + JSON.stringify(normalized.metadata); } catch (_e) { /* unserializable */ }
+  }
+  const findings = scanForSecrets(normalized.content + "\n" + normalized.tags.join("\n") + metadataText);
+  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));
+}