@remnic/core 9.48.1 → 9.49.1

package/dist/chunk-CMQZNEIF.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/schemas.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const MemoryActionTypeSchema = z.enum([\n  \"store_episode\",\n  \"store_note\",\n  \"update_note\",\n  \"create_artifact\",\n  \"summarize_node\",\n  \"discard\",\n  \"link_graph\",\n]);\n\nexport const MemoryActionEligibilityContextSchema = z\n  .object({\n    confidence: z.number().min(0).max(1),\n    lifecycleState: z.enum([\"active\", \"validated\", \"candidate\", \"stale\", \"archived\"]),\n    importance: z.number().min(0).max(1),\n    source: z.enum([\"extraction\", \"consolidation\", \"replay\", \"manual\", \"unknown\"]),\n  })\n  .strict();\n\nexport function parseMemoryActionType(value: unknown): z.infer<typeof MemoryActionTypeSchema> {\n  const parsed = MemoryActionTypeSchema.safeParse(value);\n  return parsed.success ? parsed.data : \"discard\";\n}\n\nexport function parseMemoryActionEligibilityContext(\n  value: unknown,\n): z.infer<typeof MemoryActionEligibilityContextSchema> {\n  const parsed = MemoryActionEligibilityContextSchema.safeParse(value);\n  if (parsed.success) return parsed.data;\n  return {\n    confidence: 0,\n    lifecycleState: \"candidate\",\n    importance: 0,\n    source: \"unknown\",\n  };\n}\n\nexport const ProcedureStepExtractSchema = z.object({\n  order: z.number(),\n  intent: z.string(),\n  toolCall: z\n    .object({\n      kind: z.string(),\n      signature: z.string(),\n    })\n    .optional()\n    .nullable(),\n  expectedOutcome: z.string().optional().nullable(),\n  optional: z.boolean().optional().nullable(),\n});\n\nexport const ExtractedFactSchema = z.object({\n  category: z.enum([\n    \"fact\",\n    \"preference\",\n    \"correction\",\n    \"entity\",\n    \"decision\",\n    \"relationship\",\n    \"principle\",\n    \"commitment\",\n    \"moment\",\n    \"skill\",\n    \"rule\",\n    \"procedure\",\n    \"reasoning_trace\",\n  ]),\n  content: z\n    .string()\n    .describe(\"The memory content — a clear, standalone statement\"),\n  confidence: z\n    .number()\n    .min(0)\n    .max(1)\n    .describe(\"How confident are you this is correct (0-1)\"),\n  tags: z.array(z.string()).describe(\"Relevant tags for categorization\"),\n  entityRef: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\"If about an entity, its normalized name (e.g. person-jane-doe)\"),\n  promptedByQuestion: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\"Optional proactive follow-up question that surfaced this fact.\"),\n  scope: z\n    .enum([\"project\", \"global\"])\n    .optional()\n    .nullable()\n    .describe(\n      'Scope classification: \"global\" for cross-project knowledge (framework bugs, library behavior, API patterns, user preferences, general coding patterns); \"project\" for project-specific knowledge (file paths, env configs, deployment details, project workarounds) and for tool, command, or CLI-flag instructions tied to one agent, since the same tool name can mean different things across agents. When keeping such an agent-tied instruction, begin the fact with a leading \"In <agent>,\" clause naming that agent. Defaults to \"project\" when a coding context is active.',\n    ),\n  quote: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\n      \"The EXACT verbatim words from the conversation that support this fact. Copy a contiguous span from a single speaker turn (not a paraphrase). Cap at ~300 characters. This is the grounding evidence for downstream faithfulness verification (issue #1575).\",\n    ),\n  structuredAttributes: z\n    .record(z.string(), z.string())\n    .optional()\n    .nullable()\n    .describe(\"Structured key-value attributes when the fact contains measurable or categorical data (e.g., {\\\"price\\\": \\\"29.99\\\", \\\"color\\\": \\\"blue\\\", \\\"date\\\": \\\"2024-03-15\\\"}).\"),\n  procedureSteps: z\n    .array(ProcedureStepExtractSchema)\n    .optional()\n    .nullable()\n    .describe(\n      'For category \"procedure\" only: ordered steps (intent per step). At least two steps; include explicit trigger phrasing in content (e.g. \"When you deploy…\").',\n    ),\n  reasoningTrace: z\n    .object({\n      steps: z\n        .array(\n          z.object({\n            order: z.number(),\n            description: z.string(),\n          }),\n        )\n        // Prompts and normalizer require >=2 ordered steps; enforce it at\n        // the schema layer so gateway-path parsing rejects malformed traces\n        // rather than persisting them (local/direct-client normalization\n        // already enforces this, keeping the two paths symmetric).\n        .min(2)\n        .describe(\"Ordered reasoning steps the user walked through (require >=2).\"),\n      // Accept snake_case aliases so a loose gateway model using\n      // `final_answer` / `observed_outcome` does not fail schema parsing\n      // and drop the entire extraction result. Local/direct-client\n      // normalization already tolerates these keys; the gateway path must\n      // too. Zod's `union` keeps the parse successful either way.\n      finalAnswer: z\n        .string()\n        .optional()\n        .nullable()\n        .describe(\"The conclusion, decision, or answer the chain arrived at.\"),\n      final_answer: z\n        .string()\n        .optional()\n        .nullable()\n        .describe(\"Alias for finalAnswer (snake_case). Gateway-tolerance shim.\"),\n      observedOutcome: z\n        .string()\n        .optional()\n        .nullable()\n        .describe(\"Optional note about how the answer actually played out.\"),\n      observed_outcome: z\n        .string()\n        .optional()\n        .nullable()\n        .describe(\"Alias for observedOutcome (snake_case). Gateway-tolerance shim.\"),\n    })\n    // Either finalAnswer OR final_answer must be present — enforce here so\n    // the rest of the pipeline can assume a usable string downstream.\n    .refine(\n      (v) =>\n        (typeof v.finalAnswer === \"string\" && v.finalAnswer.trim().length > 0) ||\n        (typeof v.final_answer === \"string\" && v.final_answer.trim().length > 0),\n      { message: \"reasoningTrace requires finalAnswer (or final_answer)\" },\n    )\n    .optional()\n    .nullable()\n    .describe(\n      'For category \"reasoning_trace\" only: a stored solution chain with ordered steps, a final answer, and an optional observed outcome. Require at least two steps.',\n    ),\n  eventTime: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\n      'Optional event-time expression for bi-temporal validity (#1578). An ISO date (\"2025-03-01\") or a relative expression verbatim (\"last March\", \"yesterday\", \"since 2024\", \"until 2025-06-01\"). Resolved against the source turn timestamp at write time — NOT wall-clock. Omit when the fact has no explicit temporal anchor.',\n    ),\n  event_time: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\"Alias for eventTime (snake_case). Gateway-tolerance shim (#1578).\"),\n}).superRefine((value, ctx) => {\n  if (value.category === \"procedure\" && (!Array.isArray(value.procedureSteps) || value.procedureSteps.length < 2)) {\n    ctx.addIssue({\n      code: z.ZodIssueCode.custom,\n      path: [\"procedureSteps\"],\n      message: \"procedure facts require at least two procedureSteps\",\n    });\n  }\n\n  if (value.category === \"reasoning_trace\" && value.reasoningTrace == null) {\n    ctx.addIssue({\n      code: z.ZodIssueCode.custom,\n      path: [\"reasoningTrace\"],\n      message: \"reasoning_trace facts require reasoningTrace\",\n    });\n  }\n});\n\nexport const EntityMentionSchema = z.object({\n  name: z\n    .string()\n    .describe(\"Normalized entity name (e.g. jane-doe, acme-corp, my-project)\"),\n  type: z.enum([\"person\", \"project\", \"tool\", \"company\", \"place\", \"other\"]),\n  facts: z\n    .array(z.string())\n    .describe(\"New facts learned about this entity in this conversation\"),\n  promptedByQuestion: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\"Optional proactive follow-up question that surfaced this entity.\"),\n  structuredSections: z\n    .array(z.object({\n      key: z.string(),\n      title: z.string(),\n      facts: z.array(z.string()),\n    }))\n    .optional()\n    .nullable()\n    .describe(\"Optional named sections for entity-specific facts. Use when facts clearly belong under a durable heading such as Beliefs or Building / Working On.\"),\n});\n\nexport const ExtractedQuestionSchema = z.object({\n  question: z.string().describe(\"A genuine question the AI is curious about based on this conversation\"),\n  context: z.string().describe(\"Why this question matters or what prompted it\"),\n  priority: z.number().min(0).max(1).describe(\"How important/urgent this question is (0-1)\"),\n});\n\nexport const ProactiveQuestionsResultSchema = z.object({\n  questions: z\n    .array(ExtractedQuestionSchema)\n    .describe(\"Additional follow-up questions discovered in a proactive second-pass extraction.\"),\n});\n\nexport const ExtractedRelationshipSchema = z.object({\n  source: z.string().describe(\"Source entity name (normalized, e.g. person-jane-doe)\"),\n  target: z.string().describe(\"Target entity name (normalized, e.g. company-acme-corp)\"),\n  label: z.string().describe(\"Relationship label (e.g. 'works at', 'created', 'manages')\"),\n  promptedByQuestion: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\"Optional proactive follow-up question that surfaced this relationship.\"),\n});\n\nexport const ProactiveExtractionResultSchema = z.object({\n  facts: z\n    .array(ExtractedFactSchema)\n    .describe(\n      \"Additional high-confidence memories recovered only after answering proactive follow-up questions from the same buffered conversation.\",\n    ),\n  profileUpdates: z\n    .array(z.string())\n    .describe(\n      \"Additional profile updates directly supported by the buffered conversation. Omit anything speculative.\",\n    ),\n  entities: z\n    .array(EntityMentionSchema)\n    .describe(\n      \"Additional entities or entity facts surfaced by the proactive follow-up pass.\",\n    ),\n  relationships: z\n    .array(ExtractedRelationshipSchema)\n    .optional()\n    .nullable()\n    .describe(\n      \"Additional relationships surfaced by the proactive follow-up pass.\",\n    ),\n});\n\nexport const ExtractionResultSchema = z.object({\n  facts: z\n    .array(ExtractedFactSchema)\n    .describe(\n      \"Extracted memories from the conversation. Include facts, preferences, corrections, and decisions. Only extract genuinely new, durable information — skip transient task state.\",\n    ),\n  profileUpdates: z\n    .array(z.string())\n    .describe(\n      \"Updates to the user's behavioral profile. Each string is a standalone statement about the user's preferences, habits, or personality. Only include genuinely new insights.\",\n    ),\n  entities: z\n    .array(EntityMentionSchema)\n    .describe(\n      \"Entities mentioned in the conversation with new facts about them.\",\n    ),\n  questions: z\n    .array(ExtractedQuestionSchema)\n    .describe(\n      \"Zero to three source-grounded questions useful in future sessions. Return an empty array when the conversation supports none.\",\n    ),\n  identityReflection: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\n      \"A brief reflection on what you learned about yourself as an agent in this interaction — patterns in your behavior, growth, things you did well or could improve.\",\n    ),\n  relationships: z\n    .array(ExtractedRelationshipSchema)\n    .optional()\n    .nullable()\n    .describe(\n      \"Relationships between entities discovered in this conversation. Max 5 per extraction. Format: {source, target, label}.\",\n    ),\n});\n\nexport const ConsolidationItemSchema = z.object({\n  existingId: z\n    .string()\n    .describe(\"The ID of the existing memory being evaluated\"),\n  action: z.enum([\"ADD\", \"MERGE\", \"UPDATE\", \"INVALIDATE\", \"SKIP\"]),\n  mergeWith: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\"If MERGE, the ID of the memory to merge with\"),\n  updatedContent: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\"If UPDATE or MERGE, the new content\"),\n  reason: z.string().describe(\"Brief reason for this decision\"),\n});\n\nexport const ConsolidationResultSchema = z.object({\n  items: z\n    .array(ConsolidationItemSchema)\n    .describe(\n      \"Decisions for each existing memory: ADD (keep as-is), MERGE (combine with another), UPDATE (revise content), INVALIDATE (mark as outdated/wrong), SKIP (no action needed)\",\n    ),\n  profileUpdates: z\n    .array(z.string())\n    .describe(\"New profile statements to add or update\"),\n  entityUpdates: z\n    .array(EntityMentionSchema)\n    .describe(\"Entity updates from consolidation analysis\"),\n});\n\nexport function buildProfileConsolidationResultSchema(targetLines: number) {\n  return z.object({\n    consolidatedProfile: z\n      .string()\n      .describe(\n        `The full consolidated profile as markdown. Preserve all ## section headers. Merge duplicate or near-duplicate bullets into single clear statements. Remove stale or superseded information. Keep the most important and durable observations. Target roughly ${targetLines} lines.`,\n      ),\n    removedCount: z\n      .number()\n      .describe(\"Number of bullets removed or merged during consolidation\"),\n    summary: z\n      .string()\n      .describe(\"Brief summary of what was consolidated\"),\n  });\n}\n\nexport const ProfileConsolidationResultSchema = buildProfileConsolidationResultSchema(50);\n\nexport const IdentityConsolidationResultSchema = z.object({\n  learnedPatterns: z\n    .array(z.string())\n    .describe(\n      \"Consolidated behavioral patterns and lessons learned, each a concise standalone statement\",\n    ),\n  summary: z\n    .string()\n    .describe(\n      \"A brief paragraph summarizing the agent's core identity insights\",\n    ),\n});\n\nexport type IdentityConsolidationResultParsed = z.infer<\n  typeof IdentityConsolidationResultSchema\n>;\n\n// Contradiction Verification (Phase 2B)\nexport const ContradictionVerificationSchema = z.object({\n  isContradiction: z\n    .boolean()\n    .describe(\"Whether the two memories truly contradict each other\"),\n  confidence: z\n    .number()\n    .min(0)\n    .max(1)\n    .describe(\"How confident are you in this assessment (0-1)\"),\n  reasoning: z\n    .string()\n    .describe(\"Explanation of why these are or are not contradictory\"),\n  whichIsNewer: z\n    .enum([\"first\", \"second\", \"unclear\"])\n    .describe(\"Which memory represents the more recent/current state\"),\n});\n\nexport type ContradictionVerificationResult = z.infer<\n  typeof ContradictionVerificationSchema\n>;\n\n// Memory Linking (Phase 3A)\nexport const MemoryLinkSchema = z.object({\n  targetId: z\n    .string()\n    .describe(\"The ID of the memory this links to\"),\n  linkType: z\n    .enum([\"follows\", \"references\", \"contradicts\", \"supports\", \"related\"])\n    .describe(\"The type of relationship\"),\n  strength: z\n    .number()\n    .min(0)\n    .max(1)\n    .describe(\"How strong is this relationship (0-1)\"),\n  reason: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\"Why this link exists\"),\n});\n\nexport const SuggestedLinksSchema = z.object({\n  links: z\n    .array(MemoryLinkSchema)\n    .describe(\"Suggested links between memories based on semantic analysis\"),\n});\n\nexport type MemoryLink = z.infer<typeof MemoryLinkSchema>;\nexport type SuggestedLinks = z.infer<typeof SuggestedLinksSchema>;\n\n// Memory Summarization (Phase 4A)\nexport const MemorySummarySchema = z.object({\n  summaryText: z\n    .string()\n    .describe(\"A concise summary of the batch of memories\"),\n  keyFacts: z\n    .array(z.string())\n    .describe(\"The most important facts extracted from these memories\"),\n  keyEntities: z\n    .array(z.string())\n    .describe(\"Key entities mentioned across these memories\"),\n});\n\nexport type MemorySummaryResult = z.infer<typeof MemorySummarySchema>;\n\nexport const DaySummaryResultSchema = z.object({\n  summary: z.string().min(1).describe(\"A concise end-of-day summary paragraph.\"),\n  bullets: z.array(z.string()).default([]).describe(\"The most important moments from the day.\"),\n  next_actions: z.array(z.string()).default([]).describe(\"Concrete next actions for tomorrow.\"),\n  risks_or_open_loops: z.array(z.string()).default([]).describe(\"Open loops, blockers, or fragile assumptions still needing attention.\"),\n});\n\n// v8.15 behavior-loop auto-tuning state contracts\nexport const BehaviorLoopAdjustmentSchema = z.object({\n  parameter: z.string().min(1),\n  previousValue: z.number(),\n  nextValue: z.number(),\n  delta: z.number(),\n  evidenceCount: z.number().int().min(0),\n  confidence: z.number().min(0).max(1),\n  reason: z.string(),\n  appliedAt: z.string(),\n});\n\nexport const BehaviorLoopPolicyStateSchema = z.object({\n  version: z.number().int().min(0),\n  windowDays: z.number().int().min(0),\n  minSignalCount: z.number().int().min(0),\n  maxDeltaPerCycle: z.number().min(0).max(1),\n  protectedParams: z.array(z.string()),\n  adjustments: z.array(BehaviorLoopAdjustmentSchema),\n  updatedAt: z.string(),\n});\n\nexport type BehaviorLoopAdjustmentParsed = z.infer<typeof BehaviorLoopAdjustmentSchema>;\nexport type BehaviorLoopPolicyStateParsed = z.infer<typeof BehaviorLoopPolicyStateSchema>;\n\nexport type MemoryActionTypeParsed = z.infer<typeof MemoryActionTypeSchema>;\nexport type MemoryActionEligibilityContextParsed = z.infer<typeof MemoryActionEligibilityContextSchema>;\nexport type ExtractedFactParsed = z.infer<typeof ExtractedFactSchema>;\nexport type EntityMentionParsed = z.infer<typeof EntityMentionSchema>;\nexport type ExtractedQuestionParsed = z.infer<typeof ExtractedQuestionSchema>;\nexport type ProactiveQuestionsResultParsed = z.infer<typeof ProactiveQuestionsResultSchema>;\nexport type ExtractionResultParsed = z.infer<typeof ExtractionResultSchema>;\nexport type ConsolidationItemParsed = z.infer<typeof ConsolidationItemSchema>;\nexport type ConsolidationResultParsed = z.infer<\n  typeof ConsolidationResultSchema\n>;\n"],"mappings":"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","names":[]}

package/dist/chunk-DNHVPZOD.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/temporal-supersession.ts"],"sourcesContent":["/**\n * Temporal Supersession (issue #375)\n *\n * When a new fact lands with `structuredAttributes` keyed on a known\n * `entityRef`, any prior fact whose supersession key collides with the new\n * fact's key is marked `status: \"superseded\"` and linked via\n * `supersededBy` / `supersededAt`.  Recall filters those superseded memories\n * by default so agents see only the \"current\" value per entity attribute.\n *\n * The algorithm is intentionally O(N) over the memory corpus per write, but\n * skips cheaply when the new fact has no structuredAttributes.  It reuses the\n * cached `readAllMemories()` path so cost is amortized with the rest of the\n * write pipeline.\n */\nimport type { MemoryFile, MemoryFrontmatter } from \"./types.js\";\nimport type { StorageManager } from \"./storage.js\";\nimport { log } from \"./logger.js\";\nimport { effectiveValidAt } from \"./temporal-validity.js\";\n\n/**\n * Shared normalization for supersession key components.\n *\n * Trims surrounding whitespace, lowercases, then collapses any run of\n * whitespace OR hyphens to a single hyphen, and strips any leading/trailing\n * hyphens that result.  Both `computeSupersessionKey` and\n * `lookupAttributeByNormalizedKey` must use this so that keys produced at\n * write time and keys used at lookup time are identical regardless of how\n * the LLM encoded whitespace, hyphens, or casing (Finding B fix).\n *\n * Symmetry guarantee: `\"foo bar\"`, `\"foo-bar\"`, `\"foo - bar\"`, and\n * `\"foo  bar\"` all canonicalize to `\"foo-bar\"`.\n *\n * Exported so external tests can verify the canonical form.\n */\nexport function normalizeSupersessionKey(raw: string): string {\n  return raw\n    .trim()\n    .toLowerCase()\n    .replace(/[\\s\\-]+/g, \"-\")\n    // The previous line already collapsed runs to single hyphens, so ^-|-$ is\n    // equivalent to ^-+|-+$ here and drops the anchored quantifier flagged by\n    // CodeQL js/polynomial-redos.\n    .replace(/^-|-$/g, \"\");\n}\n\n/**\n * Stable supersession key for an (entityRef, attributeName) pair.\n *\n * The algorithm is:\n *  - normalize the entityRef (trim, lower-case, collapse whitespace)\n *  - normalize the attributeName the same way\n *  - join with `::`\n *\n * Exported so tests and tools can recompute it without depending on storage.\n */\nexport function computeSupersessionKey(\n  entityRef: string | undefined,\n  attributeName: string,\n): string | null {\n  if (!entityRef || typeof entityRef !== \"string\") return null;\n  if (!attributeName || typeof attributeName !== \"string\") return null;\n  const entity = normalizeSupersessionKey(entityRef);\n  const attr = normalizeSupersessionKey(attributeName);\n  if (entity.length === 0 || attr.length === 0) return null;\n  return `${entity}::${attr}`;\n}\n\n/**\n * Compute the full set of supersession keys for a fact with structured\n * attributes.  Returns an empty array if no keys can be derived.\n */\nexport function supersessionKeysForFact(spec: {\n  entityRef?: string;\n  structuredAttributes?: Record<string, string>;\n}): string[] {\n  if (!spec.entityRef) return [];\n  if (!spec.structuredAttributes) return [];\n  const keys: string[] = [];\n  for (const attrName of Object.keys(spec.structuredAttributes)) {\n    const key = computeSupersessionKey(spec.entityRef, attrName);\n    if (key) keys.push(key);\n  }\n  return keys;\n}\n\n/**\n * Look up a structured-attribute value by a raw key, normalizing both sides\n * with `normalizeSupersessionKey` before comparing.  This ensures that keys\n * written by the LLM with mixed case, surrounding whitespace, or internal\n * whitespace (e.g. `\"City\"`, `\" city \"`, `\"job   title\"`, `\"job-title\"`)\n * are all matched against normalized keys produced by `computeSupersessionKey`\n * (Finding B fix — uses the same helper so both sides are identical).\n *\n * The storage format is NOT changed — we only normalize at lookup time.\n */\nexport function lookupAttributeByNormalizedKey(\n  attributes: Record<string, unknown>,\n  rawKey: string,\n): unknown {\n  const normalizedTarget = normalizeSupersessionKey(rawKey);\n  for (const [k, v] of Object.entries(attributes)) {\n    if (normalizeSupersessionKey(k) === normalizedTarget) return v;\n  }\n  return undefined;\n}\n\n/**\n * Decide whether an existing memory should be superseded by a newly-written\n * memory that carries the supplied supersession key set.\n *\n * Only memories that:\n *  - are currently `active`\n *  - share an `entityRef` with the new fact\n *  - share at least one supersession key with the new fact\n *  - are older than the new fact\n *  - have a conflicting value (different string) for the overlapping key\n * are eligible.  This keeps supersession local to the attribute that actually\n * changed — if fact A sets `{city: Austin, tool: vim}` and fact B sets\n * `{city: NYC}`, only the city attribute is superseded, not the tool.\n */\nexport function shouldSupersedeExisting(args: {\n  candidate: MemoryFrontmatter;\n  newEntityRef: string;\n  newAttributes: Record<string, string>;\n  newCreatedAt: string;\n  newMemoryId: string;\n}): { matchedKeys: string[] } | null {\n  const { candidate, newEntityRef, newAttributes, newCreatedAt, newMemoryId } = args;\n\n  if (candidate.id === newMemoryId) return null;\n  if (candidate.status && candidate.status !== \"active\") return null;\n  if (!candidate.entityRef) return null;\n  if (!candidate.structuredAttributes) return null;\n\n  // Reuse the shared `normalizeSupersessionKey` helper so this comparison\n  // cannot drift from the canonical form used to build supersession keys\n  // elsewhere in this file.\n  const candidateEntityNorm = normalizeSupersessionKey(candidate.entityRef);\n  const newEntityNorm = normalizeSupersessionKey(newEntityRef);\n  if (candidateEntityNorm !== newEntityNorm) return null;\n\n  // Must be older than the new fact's effective validity start — equal\n  // timestamps are ignored to avoid races within the same millisecond. When\n  // replay/import supplies source time, valid_at must drive ordering instead\n  // of wall-clock persistence time.\n  const candidateCreated = Date.parse(effectiveValidAt(candidate));\n  const newCreated = Date.parse(newCreatedAt);\n  if (!Number.isFinite(candidateCreated) || !Number.isFinite(newCreated)) return null;\n  if (candidateCreated >= newCreated) return null;\n\n  const matchedKeys: string[] = [];\n  for (const [attrName, newValue] of Object.entries(newAttributes)) {\n    // Use normalized key lookup so mixed-case or whitespace-padded keys\n    // stored by the LLM are matched correctly (Finding 2 fix).\n    const candidateValue = lookupAttributeByNormalizedKey(\n      candidate.structuredAttributes,\n      attrName,\n    );\n    if (candidateValue === undefined) continue;\n    // Only supersede on conflicting values — identical values are a no-op.\n    if (normalizeValue(String(candidateValue)) === normalizeValue(newValue)) continue;\n    const key = computeSupersessionKey(newEntityRef, attrName);\n    if (key) matchedKeys.push(key);\n  }\n\n  return matchedKeys.length > 0 ? { matchedKeys } : null;\n}\n\nfunction normalizeValue(v: string): string {\n  return v.trim().toLowerCase();\n}\n\nasync function expireChildChunksForSupersededParent(args: {\n  storage: StorageManager;\n  allCandidates: MemoryFile[];\n  parentId: string;\n  newMemoryId: string;\n  supersededAt: string;\n  invalidAt?: string;\n}): Promise<void> {\n  const processedChunkIds = new Set<string>();\n  const chunks = args.allCandidates.filter(\n    (candidate) => candidate.frontmatter.parentId === args.parentId,\n  );\n\n  for (const chunk of chunks) {\n    const chunkKey = chunk.frontmatter.id ?? chunk.path;\n    if (processedChunkIds.has(chunkKey)) continue;\n\n    try {\n      const freshChunk = await args.storage.readMemoryByPath(chunk.path);\n      if (!freshChunk) continue;\n      processedChunkIds.add(chunkKey);\n      const freshStatus = freshChunk.frontmatter.status ?? \"active\";\n      if (freshStatus !== \"active\" || freshChunk.frontmatter.supersededBy) continue;\n\n      await args.storage.writeMemoryFrontmatter(\n        freshChunk,\n        {\n          status: \"superseded\",\n          supersededBy: args.newMemoryId,\n          supersededAt: args.supersededAt,\n          updated: args.supersededAt,\n          ...(args.invalidAt && !freshChunk.frontmatter.invalid_at\n            ? { invalid_at: args.invalidAt }\n            : {}),\n        },\n        {\n          actor: \"temporal-supersession\",\n          reasonCode: \"structured-attribute-update-child-chunk\",\n          relatedMemoryIds: [args.newMemoryId, args.parentId],\n        },\n      );\n    } catch (err) {\n      log.warn(\n        `temporal-supersession: failed to expire child chunk ${chunk.frontmatter.id} for parent ${args.parentId}: ${err}`,\n      );\n    }\n  }\n}\n\nexport interface TemporalSupersessionResult {\n  supersededIds: string[];\n  matchedKeys: string[];\n}\n\n/**\n * Scan existing memories and mark any that are superseded by the\n * just-written memory.  Fails open on I/O errors — the new memory is already\n * on disk, and supersession is a best-effort hygiene step.\n */\nexport async function applyTemporalSupersession(args: {\n  storage: StorageManager;\n  newMemoryId: string;\n  entityRef?: string;\n  structuredAttributes?: Record<string, string>;\n  createdAt: string;\n  enabled: boolean;\n  /**\n   * When true, skip the persisted `frontmatter.created` lookup and use\n   * `args.createdAt` directly as the ordering anchor.  Set this on the\n   * hash-dedup short-circuit path where `newMemoryId` points to an existing\n   * OLD fact (no new file is written) and its persisted timestamp would be\n   * stale relative to the incoming promotion event (PR #402 Finding Uyui).\n   */\n  useCallerTimestamp?: boolean;\n}): Promise<TemporalSupersessionResult> {\n  const empty: TemporalSupersessionResult = { supersededIds: [], matchedKeys: [] };\n  if (!args.enabled) return empty;\n  if (!args.entityRef) return empty;\n  if (!args.structuredAttributes) return empty;\n  if (Object.keys(args.structuredAttributes).length === 0) return empty;\n\n  const newKeys = supersessionKeysForFact({\n    entityRef: args.entityRef,\n    structuredAttributes: args.structuredAttributes,\n  });\n  if (newKeys.length === 0) return empty;\n\n  let hotMemories: MemoryFile[];\n  try {\n    hotMemories = await args.storage.readAllMemories();\n  } catch (err) {\n    log.warn(`temporal-supersession: readAllMemories failed: ${err}`);\n    return empty;\n  }\n\n  // Finding 1 fix: use the on-disk effective validity start of the\n  // newly-written memory rather than a wall-clock timestamp sampled after\n  // `writeMemory` returns.  In concurrent writers the two can differ by enough\n  // to cause wrong-direction supersession.  If source replay/import provided\n  // valid_at, it must drive ordering; otherwise created remains the legacy\n  // fallback.  If the memory is not yet visible in the cache (edge case during\n  // fast concurrent writes) fall back to args.createdAt.\n  //\n  // PR #402 round-12 (Finding Uyui): on the hash-dedup early-return path the\n  // caller supplies the OLD matching fact's id as `newMemoryId` (no new file is\n  // written).  That makes `newMemoryFile.frontmatter.created` an arbitrarily\n  // old timestamp.  When `args.useCallerTimestamp` is set the caller explicitly\n  // opts out of the persisted-timestamp lookup so `args.createdAt` (the\n  // incoming event time: source valid_at when present, otherwise wall-clock) is\n  // used directly, keeping ordering correct regardless of how old the matching\n  // fact is.\n  const newMemoryFile = hotMemories.find((m) => m.frontmatter.id === args.newMemoryId);\n  const persistedCreatedAt = args.useCallerTimestamp\n    ? args.createdAt\n    : (newMemoryFile ? effectiveValidAt(newMemoryFile.frontmatter) : args.createdAt);\n\n  const supersededIds: string[] = [];\n  const matchedKeys = new Set<string>();\n\n  // Process hot then cold.  Hot-then-cold ordering is safer because hot\n  // writes are more frequent and the CAS re-read guards against double-writes.\n  // A Set<string> of already-processed ids ensures that a memory visible in\n  // both tiers (same logical memory with different filesystem paths during a\n  // migration race) is processed at most once.  Keying on `frontmatter.id`\n  // is correct because the same logical memory has the same id regardless of\n  // which tier's directory it currently lives in (PR #402 Finding 1 fix).\n  // Fall back to path-based keying when id is absent (defensive).\n  const processedIds = new Set<string>();\n\n  // Finding UOGi fix (round-6): readAllColdMemories() performs a full uncached\n  // recursive directory scan of cold/.  After Finding UTsP broadened the scan\n  // to cover the entire cold root (not just facts/+corrections/), the per-call\n  // cost grows with the cold tree size.\n  //\n  // The fix is a TTL-based in-memory cache inside StorageManager\n  // (readAllColdMemories caches its result for COLD_SCAN_CACHE_TTL_MS) that is\n  // shared across consecutive supersession calls within the same write burst.\n  // The cache is invalidated automatically on any hot→cold demotion (which\n  // calls invalidateAllMemoriesCache, which also clears the cold cache) and\n  // expires after the TTL as a safety net.\n  //\n  // This means back-to-back structured-attribute writes in the same burst\n  // (e.g. batch extraction) pay the cold I/O cost at most once, not N times.\n  // Correctness is preserved because the cache TTL ensures eventual consistency\n  // and the invalidation hook covers the hot→cold path.\n\n  let coldMemories: MemoryFile[];\n  try {\n    coldMemories = await args.storage.readAllColdMemories();\n  } catch (err) {\n    log.warn(`temporal-supersession: readAllColdMemories failed: ${err}`);\n    coldMemories = [];\n  }\n\n  // Combine hot and cold memories into a single scan.  New memory itself is\n  // excluded inline.  We do NOT skip cold scan when hot produced zero\n  // supersessions — the P1 finding is precisely that stale cold facts leak\n  // when hot has no hits.\n  const allCandidates: MemoryFile[] = [...hotMemories, ...coldMemories];\n\n  for (const memory of allCandidates) {\n    if (memory.frontmatter.id === args.newMemoryId) continue;\n    const dedupeKey = memory.frontmatter.id ?? memory.path;\n    if (processedIds.has(dedupeKey)) continue;\n    const snapshotStatus = memory.frontmatter.status ?? \"active\";\n    if (snapshotStatus !== \"active\") {\n      // A stale non-active snapshot entry must not suppress an active copy of\n      // the same logical memory that appears later in another tier.  This can\n      // happen during hot/cold migration races where the hot snapshot is already\n      // superseded but the cold copy is still active and should be evaluated.\n      continue;\n    }\n    // NOTE: do NOT call processedIds.add(dedupeKey) here.  We defer marking\n    // the id as processed until AFTER the CAS re-read succeeds.  If we mark\n    // it here and the re-read fails (e.g. the hot entry has already been\n    // migrated to cold storage), the same logical id that appears later in\n    // the cold tier scan would be silently skipped, leaving a stale cold\n    // fact unsuperseded.  Deferring ensures that a failed primary-tier read\n    // grants the alternate tier a chance to process the same id (PR #402\n    // round-6 Finding 1 fix).\n\n    const decision = shouldSupersedeExisting({\n      candidate: memory.frontmatter,\n      newEntityRef: args.entityRef,\n      newAttributes: args.structuredAttributes,\n      newCreatedAt: persistedCreatedAt,\n      newMemoryId: args.newMemoryId,\n    });\n    if (!decision) {\n      // No supersession decision — safe to mark as processed now so the\n      // alternate tier doesn't re-evaluate an identical non-matching entry.\n      processedIds.add(dedupeKey);\n      continue;\n    }\n\n    try {\n      // CAS-style re-read immediately before the write.  `readAllMemories()`\n      // is a snapshot — with concurrent writers, another run may have already\n      // superseded this candidate since we loaded it.  If we blindly trust the\n      // snapshot we can clobber a newer `supersededBy` link with a stale one.\n      //\n      // File storage offers no true locking, so the best we can do is:\n      //   1. re-read the exact file we're about to mutate\n      //   2. verify status is still \"active\" and no `supersededBy` is set\n      //   3. only then issue the write\n      // If the re-read shows a newer concurrent writer beat us to it, skip.\n      // This CAS pattern applies equally to hot and cold tier candidates.\n      // Mark as processed AFTER confirming the candidate is readable so that\n      // a migration-race read failure on the hot entry does not silently\n      // prevent the cold entry from being evaluated (Finding 1, round 6).\n      const fresh = await args.storage.readMemoryByPath(memory.path);\n      if (!fresh) {\n        log.debug(\n          `[engram] temporal supersession skipped candidate ${memory.frontmatter.id}: no longer readable at ${memory.path} — leaving id available for alternate tier`,\n        );\n        // Do NOT add to processedIds — allow the cold-tier copy to be\n        // evaluated in the next iteration of the same scan.\n        continue;\n      }\n      // Candidate is readable — mark the id as processed now to prevent the\n      // alternate tier from double-writing.\n      processedIds.add(dedupeKey);\n      const freshStatus = fresh.frontmatter.status ?? \"active\";\n      if (freshStatus !== \"active\" || fresh.frontmatter.supersededBy) {\n        log.debug(\n          `[engram] temporal supersession skipped candidate ${memory.frontmatter.id}: already superseded by concurrent writer`,\n        );\n        continue;\n      }\n\n      // Finding 2 fix: the `supersededAt` / `updated` timestamps written to the\n      // old fact must never run backwards relative to its own persisted\n      // `created` timestamp.  If the caller-supplied `args.createdAt` (which\n      // represents \"when the new replacing fact was authored\") is earlier than\n      // either the new fact's persisted `created` (T_new) or the old fact's\n      // persisted `created` (T_old), we'd be writing a nonsensical\n      // `supersededAt` that precedes the old memory's own creation.  Clamp to\n      // the monotonic maximum so time only moves forward.\n      // This monotonic clamp is applied for both hot and cold tier writes.\n      const oldCreatedMs = new Date(fresh.frontmatter.created).getTime();\n      const newCreatedMs = new Date(persistedCreatedAt).getTime();\n      const argCreatedMs = new Date(args.createdAt).getTime();\n      const maxMs = Math.max(\n        Number.isFinite(oldCreatedMs) ? oldCreatedMs : 0,\n        Number.isFinite(newCreatedMs) ? newCreatedMs : 0,\n        Number.isFinite(argCreatedMs) ? argCreatedMs : 0,\n      );\n      const supersededAt = new Date(maxMs).toISOString();\n\n      // Issue #680 — explicit fact lifecycle.  When the new fact\n      // supersedes this one, set the predecessor's `invalid_at` to the\n      // successor's effective valid_at.  Skip when the predecessor\n      // already carries an `invalid_at` so manual / earlier values\n      // are preserved (idempotent).\n      //\n      // Codex P1 on PR #713: in the hash-dedup early-return path\n      // (`useCallerTimestamp: true`), `newMemoryFile` is actually the\n      // OLD matching fact — no new file was written — so its\n      // `valid_at` is the predecessor's own old timestamp, not the\n      // successor's effective time. Use `persistedCreatedAt`\n      // directly in that path so the predecessor's invalid_at lines\n      // up with the caller's wall-clock, not the matching fact's old\n      // valid_at. The non-dedup path keeps the previous behavior\n      // (prefer the new file's explicit valid_at, fall back to its\n      // persisted created).\n      let invalidAtPatch: string | undefined;\n      if (!fresh.frontmatter.invalid_at) {\n        if (args.useCallerTimestamp) {\n          invalidAtPatch = persistedCreatedAt;\n        } else {\n          const newValidAt = newMemoryFile?.frontmatter.valid_at?.trim();\n          invalidAtPatch =\n            newValidAt && newValidAt.length > 0 ? newValidAt : persistedCreatedAt;\n        }\n      }\n      const wrote = await args.storage.writeMemoryFrontmatter(\n        fresh,\n        {\n          status: \"superseded\",\n          supersededBy: args.newMemoryId,\n          supersededAt,\n          updated: supersededAt,\n          ...(invalidAtPatch ? { invalid_at: invalidAtPatch } : {}),\n        },\n        {\n          actor: \"temporal-supersession\",\n          reasonCode: \"structured-attribute-update\",\n          relatedMemoryIds: [args.newMemoryId],\n        },\n      );\n      if (wrote) {\n        supersededIds.push(memory.frontmatter.id);\n        for (const key of decision.matchedKeys) matchedKeys.add(key);\n        await expireChildChunksForSupersededParent({\n          storage: args.storage,\n          allCandidates,\n          parentId: fresh.frontmatter.id,\n          newMemoryId: args.newMemoryId,\n          supersededAt,\n          invalidAt: invalidAtPatch ?? fresh.frontmatter.invalid_at,\n        });\n        // Issue #1579 — emit a tombstone for the superseded memory so it\n        // cannot resurrect through re-extraction / import / consolidation /\n        // dreams / pattern-reinforcement. The supersession key is the first\n        // matched key (the write-time supersession identity). Best-effort:\n        // a tombstone append failure is logged but never fails supersession\n        // (gotcha #13).\n        // Issue #1579 thread ObteS: persist ALL matched supersession keys, not\n        // just the first. A later paraphrased re-observation may derive the\n        // same entity but place the tombstoned attribute at a different\n        // position in structuredAttributes; without an entry for every matched\n        // key, the keyed tier would miss and the fact could resurrect as\n        // active. Pass the canonical contentHash from the retired memory's\n        // frontmatter so the tombstone's exact tier matches re-extraction\n        // (review: citation-hash alignment). The rawContent is the stored body;\n        // the StorageManager.appendTombstone chokepoint strips citation\n        // annotations for the normalized-text tier.\n        const keysToTombstone =\n          decision.matchedKeys.length > 0 ? decision.matchedKeys : [undefined];\n        for (const key of keysToTombstone) {\n          try {\n            await args.storage.appendTombstone({\n              reason: \"supersession\",\n              createdBy: \"supersession\",\n              sourceMemoryId: fresh.frontmatter.id,\n              ...(fresh.frontmatter.contentHash\n                ? { contentHash: fresh.frontmatter.contentHash }\n                : {}),\n              rawContent: fresh.content,\n              ...(fresh.frontmatter.entityRef ? { entityRef: fresh.frontmatter.entityRef } : {}),\n              ...(key ? { supersessionKey: key } : {}),\n              createdAt: supersededAt,\n            });\n          } catch (tombErr) {\n            log.warn(\n              `temporal-supersession: tombstone emit failed for ${fresh.frontmatter.id}${key ? ` (key=${key})` : \"\"} : ${tombErr}`,\n            );\n          }\n        }\n      }\n    } catch (err) {\n      log.warn(\n        `temporal-supersession: failed to mark ${memory.frontmatter.id} superseded: ${err}`,\n      );\n    }\n  }\n\n  if (supersededIds.length > 0) {\n    log.debug(\n      `temporal-supersession: marked ${supersededIds.length} memories superseded by ${args.newMemoryId} (keys=${Array.from(matchedKeys).join(\",\")})`,\n    );\n  }\n\n  return { supersededIds, matchedKeys: Array.from(matchedKeys) };\n}\n\n/**\n * Recall-side filter: returns true when the candidate should be excluded\n * from recall because it has been temporally superseded.  When\n * `includeInRecall` is true, this always returns false (the fact is kept),\n * matching the audit/history opt-in described in the config.\n */\nexport function shouldFilterSupersededFromRecall(\n  frontmatter: MemoryFrontmatter,\n  options: { enabled: boolean; includeInRecall: boolean },\n): boolean {\n  if (!options.enabled) return false;\n  if (options.includeInRecall) return false;\n  return frontmatter.status === \"superseded\";\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-FZZ2QTJI.js

@@ -1,111 +0,0 @@
-import {
-  assertIsoRecordedAt,
-  assertSafePathSegment,
-  assertString,
-  isRecord,
-  optionalStringArray,
-  validateStringRecord
-} from "./chunk-A2IYSXDQ.js";
-import {
-  listJsonFiles,
-  readJsonFile
-} from "./chunk-LPSF4OQH.js";
-
-// src/cue-anchors.ts
-import path from "path";
-import { mkdir, writeFile } from "fs/promises";
-function validateAnchorType(raw) {
-  const value = assertString(raw, "anchorType");
-  if (!["entity", "file", "tool", "outcome", "constraint", "date"].includes(value)) {
-    throw new Error("anchorType must be one of entity|file|tool|outcome|constraint|date");
-  }
-  return value;
-}
-function validateNodeRefs(raw) {
-  const nodeRefs = optionalStringArray(raw, "nodeRefs");
-  if (!nodeRefs || nodeRefs.length === 0) {
-    throw new Error("nodeRefs must contain at least one node reference");
-  }
-  return nodeRefs.map((nodeRef, index) => assertSafePathSegment(nodeRef, `nodeRefs[${index}]`));
-}
-function resolveCueAnchorStoreDir(abstractionNodeStoreDir, overrideDir) {
-  if (typeof overrideDir === "string" && overrideDir.trim().length > 0) {
-    return overrideDir.trim();
-  }
-  return path.join(abstractionNodeStoreDir, "anchors");
-}
-function validateCueAnchor(raw) {
-  if (!isRecord(raw)) throw new Error("cue anchor must be an object");
-  if (raw.schemaVersion !== 1) throw new Error("schemaVersion must be 1");
-  return {
-    schemaVersion: 1,
-    anchorId: assertSafePathSegment(assertString(raw.anchorId, "anchorId"), "anchorId"),
-    anchorType: validateAnchorType(raw.anchorType),
-    anchorValue: assertString(raw.anchorValue, "anchorValue"),
-    normalizedCue: assertString(raw.normalizedCue, "normalizedCue"),
-    recordedAt: assertIsoRecordedAt(assertString(raw.recordedAt, "recordedAt")),
-    sessionKey: assertString(raw.sessionKey, "sessionKey"),
-    nodeRefs: validateNodeRefs(raw.nodeRefs),
-    tags: optionalStringArray(raw.tags, "tags"),
-    metadata: validateStringRecord(raw.metadata, "metadata")
-  };
-}
-async function recordCueAnchor(options) {
-  const abstractionNodeStoreDir = options.abstractionNodeStoreDir?.trim().length ? options.abstractionNodeStoreDir.trim() : path.join(options.memoryDir, "state", "abstraction-nodes");
-  const rootDir = resolveCueAnchorStoreDir(abstractionNodeStoreDir, options.cueAnchorStoreDir);
-  const validated = validateCueAnchor(options.anchor);
-  const anchorDir = path.join(rootDir, validated.anchorType);
-  const filePath = path.join(anchorDir, `${validated.anchorId}.json`);
-  await mkdir(anchorDir, { recursive: true });
-  await writeFile(filePath, JSON.stringify(validated, null, 2), "utf8");
-  return filePath;
-}
-async function getCueAnchorStoreStatus(options) {
-  const abstractionNodeStoreDir = options.abstractionNodeStoreDir?.trim().length ? options.abstractionNodeStoreDir.trim() : path.join(options.memoryDir, "state", "abstraction-nodes");
-  const rootDir = resolveCueAnchorStoreDir(abstractionNodeStoreDir, options.cueAnchorStoreDir);
-  const files = await listJsonFiles(rootDir);
-  const anchors = [];
-  const invalidAnchors = [];
-  for (const filePath of files) {
-    try {
-      anchors.push(validateCueAnchor(await readJsonFile(filePath)));
-    } catch (error) {
-      invalidAnchors.push({
-        path: filePath,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  anchors.sort((a, b) => b.recordedAt.localeCompare(a.recordedAt));
-  const byType = {};
-  let totalNodeRefs = 0;
-  for (const anchor of anchors) {
-    byType[anchor.anchorType] = (byType[anchor.anchorType] ?? 0) + 1;
-    totalNodeRefs += anchor.nodeRefs.length;
-  }
-  return {
-    enabled: options.enabled,
-    anchorsEnabled: options.anchorsEnabled,
-    rootDir,
-    anchors: {
-      total: files.length,
-      valid: anchors.length,
-      invalid: invalidAnchors.length,
-      byType,
-      totalNodeRefs,
-      latestAnchorId: anchors[0]?.anchorId,
-      latestRecordedAt: anchors[0]?.recordedAt,
-      latestSessionKey: anchors[0]?.sessionKey
-    },
-    latestAnchor: anchors[0],
-    invalidAnchors
-  };
-}
-
-export {
-  resolveCueAnchorStoreDir,
-  validateCueAnchor,
-  recordCueAnchor,
-  getCueAnchorStoreStatus
-};
-//# sourceMappingURL=chunk-FZZ2QTJI.js.map

package/dist/chunk-FZZ2QTJI.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/cue-anchors.ts"],"sourcesContent":["import path from \"node:path\";\nimport { mkdir, writeFile } from \"node:fs/promises\";\nimport { listJsonFiles, readJsonFile } from \"./json-store.js\";\nimport {\n  assertIsoRecordedAt,\n  assertSafePathSegment,\n  assertString,\n  isRecord,\n  optionalStringArray,\n  validateStringRecord,\n} from \"./store-contract.js\";\n\nexport type CueAnchorType = \"entity\" | \"file\" | \"tool\" | \"outcome\" | \"constraint\" | \"date\";\n\nexport interface CueAnchor {\n  schemaVersion: 1;\n  anchorId: string;\n  anchorType: CueAnchorType;\n  anchorValue: string;\n  normalizedCue: string;\n  recordedAt: string;\n  sessionKey: string;\n  nodeRefs: string[];\n  tags?: string[];\n  metadata?: Record<string, string>;\n}\n\nexport interface CueAnchorStoreStatus {\n  enabled: boolean;\n  anchorsEnabled: boolean;\n  rootDir: string;\n  anchors: {\n    total: number;\n    valid: number;\n    invalid: number;\n    byType: Partial<Record<CueAnchorType, number>>;\n    totalNodeRefs: number;\n    latestAnchorId?: string;\n    latestRecordedAt?: string;\n    latestSessionKey?: string;\n  };\n  latestAnchor?: CueAnchor;\n  invalidAnchors: Array<{\n    path: string;\n    error: string;\n  }>;\n}\n\nfunction validateAnchorType(raw: unknown): CueAnchorType {\n  const value = assertString(raw, \"anchorType\");\n  if (![\"entity\", \"file\", \"tool\", \"outcome\", \"constraint\", \"date\"].includes(value)) {\n    throw new Error(\"anchorType must be one of entity|file|tool|outcome|constraint|date\");\n  }\n  return value as CueAnchorType;\n}\n\nfunction validateNodeRefs(raw: unknown): string[] {\n  const nodeRefs = optionalStringArray(raw, \"nodeRefs\");\n  if (!nodeRefs || nodeRefs.length === 0) {\n    throw new Error(\"nodeRefs must contain at least one node reference\");\n  }\n  return nodeRefs.map((nodeRef, index) => assertSafePathSegment(nodeRef, `nodeRefs[${index}]`));\n}\n\nexport function resolveCueAnchorStoreDir(\n  abstractionNodeStoreDir: string,\n  overrideDir?: string,\n): string {\n  if (typeof overrideDir === \"string\" && overrideDir.trim().length > 0) {\n    return overrideDir.trim();\n  }\n  return path.join(abstractionNodeStoreDir, \"anchors\");\n}\n\nexport function validateCueAnchor(raw: unknown): CueAnchor {\n  if (!isRecord(raw)) throw new Error(\"cue anchor must be an object\");\n  if (raw.schemaVersion !== 1) throw new Error(\"schemaVersion must be 1\");\n\n  return {\n    schemaVersion: 1,\n    anchorId: assertSafePathSegment(assertString(raw.anchorId, \"anchorId\"), \"anchorId\"),\n    anchorType: validateAnchorType(raw.anchorType),\n    anchorValue: assertString(raw.anchorValue, \"anchorValue\"),\n    normalizedCue: assertString(raw.normalizedCue, \"normalizedCue\"),\n    recordedAt: assertIsoRecordedAt(assertString(raw.recordedAt, \"recordedAt\")),\n    sessionKey: assertString(raw.sessionKey, \"sessionKey\"),\n    nodeRefs: validateNodeRefs(raw.nodeRefs),\n    tags: optionalStringArray(raw.tags, \"tags\"),\n    metadata: validateStringRecord(raw.metadata, \"metadata\"),\n  };\n}\n\nexport async function recordCueAnchor(options: {\n  memoryDir: string;\n  abstractionNodeStoreDir?: string;\n  cueAnchorStoreDir?: string;\n  anchor: CueAnchor;\n}): Promise<string> {\n  const abstractionNodeStoreDir = options.abstractionNodeStoreDir?.trim().length\n    ? options.abstractionNodeStoreDir.trim()\n    : path.join(options.memoryDir, \"state\", \"abstraction-nodes\");\n  const rootDir = resolveCueAnchorStoreDir(abstractionNodeStoreDir, options.cueAnchorStoreDir);\n  const validated = validateCueAnchor(options.anchor);\n  const anchorDir = path.join(rootDir, validated.anchorType);\n  const filePath = path.join(anchorDir, `${validated.anchorId}.json`);\n  await mkdir(anchorDir, { recursive: true });\n  await writeFile(filePath, JSON.stringify(validated, null, 2), \"utf8\");\n  return filePath;\n}\n\nexport async function getCueAnchorStoreStatus(options: {\n  memoryDir: string;\n  abstractionNodeStoreDir?: string;\n  cueAnchorStoreDir?: string;\n  enabled: boolean;\n  anchorsEnabled: boolean;\n}): Promise<CueAnchorStoreStatus> {\n  const abstractionNodeStoreDir = options.abstractionNodeStoreDir?.trim().length\n    ? options.abstractionNodeStoreDir.trim()\n    : path.join(options.memoryDir, \"state\", \"abstraction-nodes\");\n  const rootDir = resolveCueAnchorStoreDir(abstractionNodeStoreDir, options.cueAnchorStoreDir);\n  const files = await listJsonFiles(rootDir);\n  const anchors: CueAnchor[] = [];\n  const invalidAnchors: Array<{ path: string; error: string }> = [];\n\n  for (const filePath of files) {\n    try {\n      anchors.push(validateCueAnchor(await readJsonFile(filePath)));\n    } catch (error) {\n      invalidAnchors.push({\n        path: filePath,\n        error: error instanceof Error ? error.message : String(error),\n      });\n    }\n  }\n\n  anchors.sort((a, b) => b.recordedAt.localeCompare(a.recordedAt));\n\n  const byType: Partial<Record<CueAnchorType, number>> = {};\n  let totalNodeRefs = 0;\n  for (const anchor of anchors) {\n    byType[anchor.anchorType] = (byType[anchor.anchorType] ?? 0) + 1;\n    totalNodeRefs += anchor.nodeRefs.length;\n  }\n\n  return {\n    enabled: options.enabled,\n    anchorsEnabled: options.anchorsEnabled,\n    rootDir,\n    anchors: {\n      total: files.length,\n      valid: anchors.length,\n      invalid: invalidAnchors.length,\n      byType,\n      totalNodeRefs,\n      latestAnchorId: anchors[0]?.anchorId,\n      latestRecordedAt: anchors[0]?.recordedAt,\n      latestSessionKey: anchors[0]?.sessionKey,\n    },\n    latestAnchor: anchors[0],\n    invalidAnchors,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-J7T4MX7P.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/extraction-prompt.ts"],"sourcesContent":["/**\n * Extraction prompt construction (issue #1995 sibling extraction).\n *\n * The system prompt, its JSON response shape, and the placeholder table\n * derived from that shape are prompt DATA, not engine behavior. They live here\n * so `extraction.ts` holds the pipeline and one module owns the text every\n * extraction path — local LLM, direct client, gateway fallback — sends.\n */\n\nimport { AMBIENT_CAPTURE_PROMPT_SECTION, AMBIENT_SPECULATIVE_TIER_CLAUSE } from \"./ambient-provenance.js\";\nimport { resolveMemoryLifecycleCapabilities, resolveRecallAuxiliaryCapabilities } from \"./capabilities.js\";\nimport type { PluginConfig } from \"./types.js\";\n\nexport const EXTRACTION_RESPONSE_SHAPE = `{\n  \"facts\": [{\n    \"category\": \"<category>\",\n    \"content\": \"<source-grounded statement>\",\n    \"confidence\": 0.0,\n    \"tags\": [\"<tag>\"],\n    \"entityRef\": \"<optional normalized-name>\",\n    \"promptedByQuestion\": \"<optional source-grounded question>\",\n    \"quote\": \"<optional exact contiguous source span>\",\n    \"scope\": \"<optional project-or-global>\",\n    \"structuredAttributes\": {\"<key>\": \"<value>\"},\n    \"procedureSteps\": [{\"order\": 1, \"intent\": \"<step>\"}, {\"order\": 2, \"intent\": \"<step>\"}],\n    \"reasoningTrace\": {\n      \"steps\": [{\"order\": 1, \"description\": \"<step>\"}, {\"order\": 2, \"description\": \"<step>\"}],\n      \"finalAnswer\": \"<answer>\",\n      \"observedOutcome\": \"<optional outcome>\"\n    },\n    \"eventTime\": \"<optional source temporal expression>\"\n  }],\n  \"entities\": [{\n    \"name\": \"<normalized-name>\",\n    \"type\": \"<entity-type>\",\n    \"facts\": [\"<source-grounded statement>\"],\n    \"promptedByQuestion\": \"<optional source-grounded question>\",\n    \"structuredSections\": [{\"key\": \"<section-key>\", \"title\": \"<section-title>\", \"facts\": [\"<source-grounded statement>\"]}]\n  }],\n  \"profileUpdates\": [\"<source-grounded profile update>\"],\n  \"questions\": [{\"question\": \"<source-grounded unresolved question>\", \"context\": \"<source-grounded context>\", \"priority\": 0.0}],\n  \"identityReflection\": \"<conversation-grounded agent reflection>\",\n  \"relationships\": [{\"source\": \"<normalized-name>\", \"target\": \"<normalized-name>\", \"label\": \"<source-grounded relationship>\"}]\n}`;\nexport const EXTRACTION_RESPONSE_PLACEHOLDERS: Record<string, true> = {};\nfor (const placeholder of EXTRACTION_RESPONSE_SHAPE.match(/<[^<>\\r\\n]+>/g) ?? []) {\n  EXTRACTION_RESPONSE_PLACEHOLDERS[placeholder] = true;\n}\n\n/**\n * Bi-temporal event-time extraction instruction (#1578 PR2). Emitted on\n * every extraction entry path when `temporal.biTemporal` is on so the LLM\n * emits an optional per-fact `eventTime` expression. The expression is\n * resolved against the source turn timestamp at write time — never\n * wall-clock — so replay/import of old transcripts anchors correctly.\n * Returns an empty string when the gate is off (byte-identical prompt).\n */\nexport function eventTimePromptInstruction(config: PluginConfig): string {\n  if (!config.temporalBiTemporal) return \"\";\n  return `\nWhen a fact states when it became or stopped being true, copy that explicit temporal expression verbatim into \"eventTime\". Omit \"eventTime\" when no such expression appears; never infer dates.`;\n}\n\n/**\n * Build extraction instructions shared between local and cloud LLM.\n *\n * `ambientCapture` marks input from an always-on recorder, which may carry\n * speech the user never authored (issue #2294).\n */\nexport function buildExtractionInstructions(config: PluginConfig, existingEntities?: string[], ambientCapture = false): string {\n  const lifecycleCaps = resolveMemoryLifecycleCapabilities(config);\n  return `You are a memory extraction system. Analyze the following conversation and extract durable, reusable memories.\n\nMemory categories:\n- fact: Objective information about the world\n- preference: User likes, dislikes, or stylistic choices\n- correction: User correcting a mistake or misconception (highest priority)\n- entity: Information about a specific person, project, tool, or company\n- decision: A choice that was made with rationale\n- relationship: How two entities relate to each other (e.g., \"Alice is Bob's manager\", \"Acme Corp uses Shopify\")\n- principle: Durable rules, values, or operating beliefs (e.g., \"never use Chat Completions API\")\n- commitment: Promises, obligations, or deadlines (e.g., \"deploy by Friday\", \"call accountant Monday\")\n- moment: Emotionally significant events or milestones (e.g., \"first successful deployment of engram\")\n- skill: Capabilities the user or agent has demonstrated (e.g., \"user is proficient with Kubernetes\")${resolveRecallAuxiliaryCapabilities(config).causalRuleExtraction ? `\n- rule: Causal rules discovered through experience (format: \"IF <condition> THEN <action/outcome>\", e.g., \"IF Shopify API returns 401 THEN the admin token is missing read_products scope\")` : \"\"}\n- procedure: A reusable workflow the user wants remembered the same way across sessions. Set category to \"procedure\". Use \"content\" for a short title that includes explicit trigger phrasing (e.g. \"When you deploy to production…\", \"Whenever you ship a release…\"). Add \"procedureSteps\": an array of at least two objects {\"order\": number, \"intent\": \"concrete step description\"} in execution order. Optional per-step \"toolCall\": {\"kind\": \"…\", \"signature\": \"…\"}, \"expectedOutcome\", \"optional\": true.\n- reasoning_trace: A stored solution chain / chain-of-thought the user walked through to solve a problem (e.g. \"Here's how I debugged the latency spike: first I checked…, then I…, finally I…\"). Set category to \"reasoning_trace\". Use \"content\" for a short title summarising the problem (e.g. \"How I debugged the staging latency spike\"). Add \"reasoningTrace\": {\"steps\": [{\"order\": number, \"description\": \"what happened at this step\"}, …], \"finalAnswer\": \"the conclusion or answer\", \"observedOutcome\": \"optional confirmation of how it played out\"}. Require at least two ordered steps AND a finalAnswer. Use this category only when the user explicitly narrates their reasoning — not for ordinary decisions (use \"decision\") or reusable workflows (use \"procedure\").\n\nRules:\n- Only extract genuinely new information worth remembering across sessions.\n- Statements must be grounded in the conversation.\n- Do not treat instruction text, schema placeholders, or examples as conversation evidence.\n- Lines labelled [context user] or [context assistant] are reference context only. They may resolve references or complete a question-and-answer pair in a normal turn, but never alone establish durable information.\n- Skip transient task details and operational noise, including routine scheduler, monitoring, or automation status.\n- Priority: corrections > principles${resolveRecallAuxiliaryCapabilities(config).causalRuleExtraction ? \" > rules\" : \"\"} > preferences > commitments > decisions > relationships > entities > moments > skills > facts\n- Corrections get highest confidence.\n- Each fact should be a standalone, self-contained statement.\n- Entity references should use normalized names (lowercase, hyphenated: \"jane-doe\", \"acme-corp\")\n- CRITICAL: Entity names must be CANONICAL. Always use the hyphenated multi-word form: \"acme-corp\" NOT \"acmecorp\" or \"acme\". \"jane-doe\" NOT \"janedoe\" or \"jane\". If unsure, prefer the most specific full name.\n- Avoid creating entities typed as \"other\" when a more specific type fits (company, project, tool, person, place)\n- When entity facts clearly belong under a durable named heading, add them to entity.structuredSections as {key, title, facts}. Example person headings: \"Beliefs\", \"Communication Style\", \"Building / Working On\". Leave structuredSections empty when no stable heading fits.\n- Tags should be concise and reusable (e.g., \"coding-style\", \"personal\", \"tools\")\n- When a fact contains measurable, categorical, or precisely valued data, include a \"structuredAttributes\" field with key-value string pairs (e.g., {\"price\": \"29.99\", \"brand\": \"Sony\"}, {\"date\": \"2024-03-15\", \"location\": \"SF\"}, {\"chosen\": \"PostgreSQL\", \"rejected\": \"MongoDB\"}). Only for concrete values, not narrative content.\n- Set confidence using these tiers:\n  * Explicit (0.95-1.0): Direct user statements — \"I prefer X\", \"my name is Y\"\n  * Implied (0.70-0.94): Strong contextual inference — user consistently does X, clear from conversation flow\n  * Inferred (0.40-0.69): Pattern recognition — reasonable guess from limited evidence\n  * Speculative (0.00-0.39): Tentative hypothesis — weak signal, needs future confirmation. Speculative memories auto-expire after 30 days if not confirmed.${ambientCapture ? AMBIENT_SPECULATIVE_TIER_CLAUSE : \"\"}${config.provenance?.enabled ? `\n- Source quotes: For each fact, include a \"quote\" field containing the EXACT verbatim words from the conversation that support the fact. Copy a contiguous span from a single speaker turn (not a paraphrase, not a summary). Cap at ~300 characters. This grounds every memory in the literal utterance that created it.` : \"\"}\n- For commitments: include any deadline or timeframe mentioned${lifecycleCaps.extractionScopeClassification ? `\n\nScope classification:\nFor each fact, set \"scope\" to one of:\n- \"global\" — knowledge that applies across projects: core framework/library bugs, API behavior patterns, user preferences (editor, language, style), general coding patterns, infrastructure knowledge, technology facts not tied to one codebase\n- \"project\" — knowledge specific to one codebase: file paths, environment configs, deployment details, project-specific workarounds, team/stakeholder info tied to one project, repo-specific conventions. Tool, command, or CLI-flag instructions TIED TO ONE AGENT are also \"project\", because the same tool name means different things in different agent integrations (a \"search\" tool may search repository code in one agent and the web in another); when keeping such an agent-tied instruction, the fact text MUST name the originating agent as a leading \"In <agent>,\" clause (e.g. \"In Pi, use the search tool with a repository path.\"). A tool/command fact that holds in every agent and every repo is NOT agent-tied — leave it \"global\" and do not add a qualifier (e.g. \"\\`git status --short\\` emits compact output\"). Examples: \"In Pi, the search tool takes a repository path\" -> \"project\"; \"\\`git status --short\\` emits compact output\" -> \"global\".\nWhen in doubt, prefer \"project\" — it is safer to keep knowledge scoped narrowly.` : \"\"}\n${ambientCapture ? `${AMBIENT_CAPTURE_PROMPT_SECTION}\n` : \"\"}\nEntity creation rules (STRICT):\n- Only create entities for DURABLE things: real people, companies, products, tools, ongoing projects\n- NEVER create entities for transient items: individual PRs, branches, Jira tickets, meetings, agent task IDs, log files, database tables, cron job runs, sessions\n- When you learn something about a transient item (e.g., PR #58 fixed a bug), store it as a FACT with an entityRef to the parent project — do NOT create an entity for the PR itself\n- Prefer attaching facts to broad parent entities rather than creating sub-entities. E.g., \"acme-store uses Algolia for search\" is a fact on entity \"acme-store\", NOT a new entity \"acme-store-algolia-connector\"\n- The entity list should be SHORT — think \"things that would have their own Wikipedia page\" not \"things mentioned in passing\"\n\n${existingEntities && existingEntities.length > 0 ? `\nKNOWN ENTITIES (use these exact names when referencing existing things):\n${existingEntities.join(\", \")}\n\nWhen you see something that matches a known entity, use THAT name exactly. Only create a NEW entity if nothing in this list represents it.\n` : \"\"}\n${eventTimePromptInstruction(config)}\nAlso extract relationships between entities mentioned in the conversation.\n- Format: {source: \"entity-name\", target: \"entity-name\", label: \"relationship description\"}\n- Max 5 relationships per extraction\n- Only include clear, durable relationships (e.g., \"works at\", \"created\", \"manages\", \"uses\")\n- Use normalized entity names (e.g., \"person-jane-doe\", \"company-acme-corp\")\n\nQuestions are optional. Include only source-grounded unresolved questions that would be useful in future sessions; otherwise return an empty array.\n\nFinally, write a brief identity reflection about the agent who had this conversation, based only on the conversation. Do not write about the extraction process.`;\n}\n"],"mappings":";;;;;;;;;;AAaO,IAAM,4BAA4B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA+BlC,IAAM,mCAAyD,CAAC;AACvE,WAAW,eAAe,0BAA0B,MAAM,eAAe,KAAK,CAAC,GAAG;AAChF,mCAAiC,WAAW,IAAI;AAClD;AAUO,SAAS,2BAA2B,QAA8B;AACvE,MAAI,CAAC,OAAO,mBAAoB,QAAO;AACvC,SAAO;AAAA;AAET;AAQO,SAAS,4BAA4B,QAAsB,kBAA6B,iBAAiB,OAAe;AAC7H,QAAM,gBAAgB,mCAAmC,MAAM;AAC/D,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uGAY8F,mCAAmC,MAAM,EAAE,uBAAuB;AAAA,+LACsB,EAAE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sCAU3J,mCAAmC,MAAM,EAAE,uBAAuB,aAAa,EAAE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mKAauC,iBAAiB,kCAAkC,EAAE,GAAG,OAAO,YAAY,UAAU;AAAA,6TAC0E,EAAE;AAAA,gEAC/P,cAAc,gCAAgC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yFAM1B,EAAE;AAAA,EACpF,iBAAiB,GAAG,8BAA8B;AAAA,IAChD,EAAE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQJ,oBAAoB,iBAAiB,SAAS,IAAI;AAAA;AAAA,EAElD,iBAAiB,KAAK,IAAI,CAAC;AAAA;AAAA;AAAA,IAGzB,EAAE;AAAA,EACJ,2BAA2B,MAAM,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUpC;","names":[]}