@remnic/core 9.3.704 → 9.3.706

package/dist/{chunk-7G4KPGR3.js → chunk-3PTOZJOI.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-ZFXCQPNO.js";
 import {
   StorageManager
-} from "./chunk-NMW3T6T6.js";
+} from "./chunk-2VQYHHWB.js";
 import {
   MutationSerializer
 } from "./chunk-LTJAMRGI.js";
@@ -336,4 +336,4 @@ export {
   resolveNamespaceStorageRoot,
   NamespaceStorageRouter
 };
-//# sourceMappingURL=chunk-7G4KPGR3.js.map
+//# sourceMappingURL=chunk-3PTOZJOI.js.map

package/dist/{chunk-PJ5MDXOF.js → chunk-4DZATVK5.js}

@@ -10,10 +10,17 @@ import {
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
-} from "./chunk-K7QRDDSR.js";
+} from "./chunk-ESMY4RJ4.js";
 import {
   StorageManager
-} from "./chunk-NMW3T6T6.js";
+} from "./chunk-2VQYHHWB.js";
+import {
+  MEMORY_LIFECYCLE_EVENT_SORT_ORDER,
+  buildLifecycleEventsForMemory,
+  inferMemoryStatus,
+  sortMemoryLifecycleEvents,
+  toMemoryPathRel
+} from "./chunk-RULE4VG5.js";
 import {
   normalizeProjectionPreview,
   normalizeProjectionTags
@@ -32,13 +39,6 @@ import {
 import {
   openBetterSqlite3
 } from "./chunk-6KYMPV2O.js";
-import {
-  MEMORY_LIFECYCLE_EVENT_SORT_ORDER,
-  buildLifecycleEventsForMemory,
-  inferMemoryStatus,
-  sortMemoryLifecycleEvents,
-  toMemoryPathRel
-} from "./chunk-RULE4VG5.js";
 
 // src/maintenance/rebuild-memory-projection.ts
 import path from "path";
@@ -929,4 +929,4 @@ export {
   verifyMemoryProjection,
   repairMemoryProjection
 };
-//# sourceMappingURL=chunk-PJ5MDXOF.js.map
+//# sourceMappingURL=chunk-4DZATVK5.js.map

package/dist/{chunk-UOIRJ45Z.js → chunk-4E2QCH46.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-3UXOZBHV.js";
 import {
   StorageManager
-} from "./chunk-NMW3T6T6.js";
+} from "./chunk-2VQYHHWB.js";
 import {
   isSafeRouteNamespace
 } from "./chunk-U3PN77QT.js";
@@ -118,4 +118,4 @@ export {
   runCodexMaterialize,
   runPostConsolidationMaterialize
 };
-//# sourceMappingURL=chunk-UOIRJ45Z.js.map
+//# sourceMappingURL=chunk-4E2QCH46.js.map

package/dist/{chunk-KKK7YTYN.js → chunk-5GSUBCZM.js}

@@ -91,7 +91,11 @@ var ExtractedFactSchema = z.object({
     { message: "reasoningTrace requires finalAnswer (or final_answer)" }
   ).optional().nullable().describe(
     '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.'
-  )
+  ),
+  eventTime: z.string().optional().nullable().describe(
+    '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 \u2014 NOT wall-clock. Omit when the fact has no explicit temporal anchor.'
+  ),
+  event_time: z.string().optional().nullable().describe("Alias for eventTime (snake_case). Gateway-tolerance shim (#1578).")
 }).superRefine((value, ctx) => {
   if (value.category === "procedure" && (!Array.isArray(value.procedureSteps) || value.procedureSteps.length < 2)) {
     ctx.addIssue({
@@ -271,4 +275,4 @@ export {
   BehaviorLoopAdjustmentSchema,
   BehaviorLoopPolicyStateSchema
 };
-//# sourceMappingURL=chunk-KKK7YTYN.js.map
+//# sourceMappingURL=chunk-5GSUBCZM.js.map

package/dist/chunk-5GSUBCZM.js.map

@@ -0,0 +1 @@
+{"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, tool configs, general coding patterns); \"project\" for project-specific knowledge (file paths, env configs, deployment details, project workarounds). 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      \"1-3 genuine questions you're curious about from this conversation. These should be things you'd actually want to know the answer to in future sessions.\",\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-RYDT7LAI.js → chunk-66TSLESZ.js}

@@ -1,6 +1,6 @@
 import {
   EngramAccessInputError
-} from "./chunk-ZXFNSKPY.js";
+} from "./chunk-STYMKPFT.js";
 import {
   expandTildePath
 } from "./chunk-EYIEWJNI.js";
@@ -104,4 +104,4 @@ export {
   listRegisteredOperations,
   __resetRegistryForTest
 };
-//# sourceMappingURL=chunk-RYDT7LAI.js.map
+//# sourceMappingURL=chunk-66TSLESZ.js.map

package/dist/chunk-66TSLESZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/access-boundary.ts"],"sourcesContent":["/**\n * Single input-validation and error boundary for the CLI/MCP/HTTP access\n * surfaces (issue #1525, epic #1520 Phase 1).\n *\n * Every operation that crosses the access-service facade passes through ONE\n * registry entry: a zod-validated request envelope, a shared error mapper,\n * and the \"reject invalid input and list valid options\" behavior that\n * CLAUDE.md rules 14/17/24/28/36/48/51 previously had to be re-implemented\n * per handler. The three surfaces become thin adapters — one operation\n * definition, three transports — so a validation fix lands everywhere at\n * once.\n *\n * Host-agnostic (rule 31): operation names carry no `openclaw-*`/`engram-*`\n * prefix. Session/namespace tenancy stays in the handler layer (resolved via\n * ScopePlan #1521); the boundary validates SHAPE, not tenancy.\n */\n\nimport { z } from \"zod\";\nimport { EngramAccessInputError, type EngramAccessService } from \"./access-service.js\";\nimport { expandTildePath } from \"./utils/path.js\";\n\n// ---------------------------------------------------------------------------\n// Canonical operation names — host-agnostic (rule 31)\n// ---------------------------------------------------------------------------\n\n/**\n * Canonical operation ids. One id is shared by the MCP tool, the HTTP route,\n * and the CLI command that expose the same operation. Add to this union as\n * each domain-group migration PR (memory ops → connectors → namespaces …)\n * lands; the fitness test in `access-surface-catalog.test.ts` treats the\n * registered set as the migration state.\n */\nexport type OperationName =\n  | \"memory_get\"\n  | \"memory_search\"\n  | \"memory_store\"\n  | \"coding_decision\"\n  | \"coding_architecture\"\n  // codegraph parity tools (issue #1554) -- each maps to one codegraph_*\n  // boundary operation that delegates to the surface handler in\n  // coding/codegraph-surfaces.ts. Names match the external tool suffixes.\n  | \"codegraph_index\"\n  | \"codegraph_list_projects\"\n  | \"codegraph_delete_project\"\n  | \"codegraph_index_status\"\n  | \"codegraph_search_graph\"\n  | \"codegraph_trace_path\"\n  | \"codegraph_detect_changes\"\n  | \"codegraph_query_graph\"\n  | \"codegraph_get_schema\"\n  | \"codegraph_get_snippet\"\n  | \"codegraph_get_architecture\"\n  | \"codegraph_search_code\"\n  | \"codegraph_manage_adr\"\n  | \"codegraph_ingest_traces\"\n  | \"coding_delta\"\n  // Remaining MCP/HTTP handlers migrated through the boundary (issue #1525).\n  | \"recall\"\n  | \"recall_explain\"\n  | \"set_coding_context\"\n  | \"recall_tier_explain\"\n  | \"recall_xray\"\n  | \"wearables_status\"\n  | \"wearables_sync\"\n  | \"transcript_day\"\n  | \"transcript_search\"\n  | \"transcript_memories\"\n  | \"action_confidence\"\n  | \"chatgpt_memory_inspector\"\n  | \"day_summary\"\n  | \"capsule_export\"\n  | \"capsule_import\"\n  | \"capsule_list\"\n  | \"memory_governance_run\"\n  | \"procedure_mining_run\"\n  | \"pattern_reinforcement_run\"\n  | \"procedural_stats\"\n  | \"memory_timeline\"\n  | \"suggestion_submit\"\n  | \"entity_get\"\n  | \"review_queue_list\"\n  | \"observe\"\n  | \"lcm_search\"\n  | \"lcm_compaction_flush\"\n  | \"lcm_compaction_record\"\n  | \"continuity_audit_generate\"\n  | \"continuity_incident_open\"\n  | \"continuity_incident_close\"\n  | \"continuity_incident_list\"\n  | \"continuity_loop_add_or_update\"\n  | \"continuity_loop_review\"\n  | \"identity_anchor_get\"\n  | \"identity_anchor_update\"\n  | \"memory_identity\"\n  | \"work_task\"\n  | \"work_project\"\n  | \"work_board\"\n  | \"shared_context_write_output\"\n  | \"shared_feedback_record\"\n  | \"shared_priorities_append\"\n  | \"shared_context_cross_signals_run\"\n  | \"shared_context_curate_daily\"\n  | \"compounding_weekly_synthesize\"\n  | \"compounding_promote_candidate\"\n  | \"compression_guidelines_optimize\"\n  | \"compression_guidelines_activate\"\n  | \"memory_profile\"\n  | \"memory_entities_list\"\n  | \"memory_questions\"\n  | \"memory_last_recall\"\n  | \"memory_intent_debug\"\n  | \"memory_qmd_debug\"\n  | \"memory_graph_explain\"\n  | \"graph_snapshot\"\n  | \"memory_feedback\"\n  | \"memory_promote\"\n  | \"memory_outcome\"\n  | \"memory_action_apply\"\n  | \"context_checkpoint\"\n  | \"briefing\"\n  | \"review_list\"\n  | \"review_resolve\"\n  | \"contradiction_scan_run\"\n  | \"memory_summarize_hourly\"\n  | \"conversation_index_update\"\n  | \"profiling_report\"\n  | \"graph_edge_decay_run\"\n  | \"live_connectors_run\"\n  | \"peer_list\"\n  | \"peer_get\"\n  | \"peer_set\"\n  | \"peer_delete\"\n  | \"peer_profile_get\"\n  | \"peer_forget\"\n  | \"console_state\"\n  | \"dreams_status\"\n  | \"dreams_run\"\n  // HTTP-only routes (no direct MCP tool equivalent).\n  | \"offline_sync_snapshot\"\n  | \"offline_sync_snapshot_stream\"\n  | \"offline_sync_files\"\n  | \"offline_sync_file_content\"\n  | \"offline_sync_apply_file_content\"\n  | \"offline_sync_apply\"\n  | \"lcm_status\"\n  | \"memory_list\"\n  | \"entity_list\"\n  | \"maintenance_status\"\n  | \"quality_status\"\n  | \"trust_zones_status\"\n  | \"trust_zones_records\"\n  | \"review_disposition\"\n  | \"trust_zones_promote\"\n  | \"trust_zones_demo_seed\"\n  | \"citations_observed\"\n  | \"contradiction_detail\"\n  | \"graph_events\";\n\n// ---------------------------------------------------------------------------\n// Operation context — what every handler receives\n// ---------------------------------------------------------------------------\n\n/**\n * Per-call context. `service` is the facade the handler delegates to; the\n * boundary never reaches past it. `authenticatedPrincipal` is resolved by\n * the SURFACE (MCP header / HTTP identity / CLI flag) before the boundary\n * runs, so handlers stay principal-source-agnostic. `hooks` carries\n * transport-level callbacks (e.g. HTTP write-quota enforcement) that must\n * fire atomically inside the service call; surfaces that have no such hook\n * leave it undefined.\n */\nexport interface OperationContext {\n  readonly service: EngramAccessService;\n  readonly authenticatedPrincipal?: string;\n  readonly hooks?: OperationHooks;\n}\n\n/**\n * Transport-level callbacks a handler forwards into the service call. Kept\n * narrow on purpose: the boundary owns validation + dispatch shape, not\n * transport policy. Add fields here only when a surface genuinely needs a\n * callback the service itself consumes.\n */\nexport interface OperationHooks {\n  /** HTTP write-quota gate; throws to reject the write when exhausted. */\n  readonly enforceWriteQuota?: () => void | Promise<void>;\n}\n\n// ---------------------------------------------------------------------------\n// Operation spec + bound operation\n// ---------------------------------------------------------------------------\n\nexport interface OperationSpec<In, Out> {\n  /** Canonical operation id; matches an {@link OperationName}. */\n  readonly name: OperationName;\n  readonly description: string;\n  /** Zod schema validating the raw request envelope. */\n  readonly schema: z.ZodType<In>;\n  /** Handler invoked with the parsed input; throws EngramAccessInputError for domain faults. */\n  readonly handler: (input: In, ctx: OperationContext) => Promise<Out>;\n}\n\nexport interface BoundOperation<In = unknown, Out = unknown> {\n  readonly spec: OperationSpec<In, Out>;\n  /** Validate the raw envelope, then invoke the handler. Throws EngramAccessInputError on any validation failure. */\n  readonly run: (rawInput: unknown, ctx: OperationContext) => Promise<Out>;\n}\n\n// ---------------------------------------------------------------------------\n// Shared normalizers the boundary owns (rules 17, 28, 36, 48, 51)\n// ---------------------------------------------------------------------------\n\n/**\n * Coerce boolean-like strings at the edge (rule 36). Accepts actual booleans\n * and the string spellings clients send (\"true\"/\"false\"/\"1\"/\"0\"/\"yes\"/\"no\"/\n * \"on\"/\"off\", case-insensitive). Rejects anything else loudly — `Boolean(\"false\")`\n * would silently be `true`, which is the bug rule 36 exists to prevent.\n *\n * `undefined`/`null`/`\"\"` → `undefined`, so callers can keep treating an\n * absent flag as \"use the default\" without a separate presence check.\n */\nexport function coerceBooleanLike(value: unknown): boolean | undefined {\n  if (value === undefined || value === null || value === \"\") return undefined;\n  if (typeof value === \"boolean\") return value;\n  if (typeof value === \"string\") {\n    const lower = value.trim().toLowerCase();\n    if (lower === \"true\" || lower === \"1\" || lower === \"yes\" || lower === \"on\") return true;\n    if (lower === \"false\" || lower === \"0\" || lower === \"no\" || lower === \"off\") return false;\n  }\n  throw new EngramAccessInputError(\n    `expected a boolean-like value (true|false|1|0|yes|no|on|off); got ${JSON.stringify(value)}`,\n  );\n}\n\n/**\n * Coerce + validate a positive integer from a numeric string or number\n * (rule 28). Loosely-typed MCP/CLI clients send `\"5\"`; `typeof saved === \"number\"`\n * on read-back would reject it later, so we coerce at the edge and reject\n * booleans/objects loudly (`Number(true) === 1` would silently pass otherwise).\n *\n * `undefined`/`null`/`\"\"` → `undefined`.\n */\nexport function coercePositiveInteger(value: unknown, label: string): number | undefined {\n  if (value === undefined || value === null || value === \"\") return undefined;\n  if (typeof value === \"number\") {\n    if (!Number.isFinite(value) || value <= 0 || !Number.isInteger(value)) {\n      throw new EngramAccessInputError(`${label} expects a positive integer; got ${JSON.stringify(value)}`);\n    }\n    return value;\n  }\n  if (typeof value === \"string\") {\n    const trimmed = value.trim();\n    if (!/^[+-]?\\d+$/.test(trimmed)) {\n      throw new EngramAccessInputError(`${label} expects a positive integer; got ${JSON.stringify(value)}`);\n    }\n    const parsed = Number(trimmed);\n    if (!Number.isSafeInteger(parsed) || parsed <= 0) {\n      throw new EngramAccessInputError(`${label} expects a positive integer; got ${JSON.stringify(value)}`);\n    }\n    return parsed;\n  }\n  throw new EngramAccessInputError(`${label} expects a positive integer; got ${JSON.stringify(value)}`);\n}\n\n/**\n * Expand `~` in a path-shaped input (rule 17). Node `fs` does NOT expand `~`;\n * ad-hoc regex drifts. `undefined`/`null`/`\"\"` → `undefined`.\n */\nexport function normalizeOptionalPath(value: unknown): string | undefined {\n  if (value === undefined || value === null || value === \"\") return undefined;\n  if (typeof value !== \"string\") {\n    throw new EngramAccessInputError(`expected a path string; got ${JSON.stringify(value)}`);\n  }\n  return expandTildePath(value);\n}\n\n// ---------------------------------------------------------------------------\n// Error formatting — rule 51: list valid options, never silently default\n// ---------------------------------------------------------------------------\n\n/**\n * Turn a zod failure into an {@link EngramAccessInputError} whose message\n * names the offending field and — for enum/union issues — lists the valid\n * options, so the caller can correct rather than guess (rule 51).\n */\nexport function formatZodIssues(error: z.ZodError): string {\n  const parts: string[] = [];\n  for (const issue of error.issues) {\n    const path = issue.path.length > 0 ? issue.path.join(\".\") : \"(root)\";\n    const options = enumOptionsFromIssue(issue);\n    const suffix = options ? `. Valid: ${options.join(\", \")}` : \"\";\n    parts.push(`${path}: ${issue.message}${suffix}`);\n  }\n  return parts.length > 0\n    ? `request validation failed: ${parts.join(\"; \")}`\n    : \"request validation failed\";\n}\n\nfunction enumOptionsFromIssue(issue: z.ZodIssue): readonly string[] | undefined {\n  // zod exposes accepted enum values on the issue for ZodEnum / ZodNativeEnum\n  // and on the options of invalid_union discriminators. Reading them here\n  // keeps \"list valid options\" in ONE place rather than per handler.\n  if (issue.code === z.ZodIssueCode.invalid_enum_value) {\n    const rawOptions = (issue as { options?: unknown }).options;\n    if (Array.isArray(rawOptions)) {\n      return rawOptions.map((opt) => String(opt));\n    }\n  }\n  return undefined;\n}\n\n// ---------------------------------------------------------------------------\n// Registry\n// ---------------------------------------------------------------------------\n\nconst registry = new Map<OperationName, BoundOperation>();\n\n/**\n * Register an operation. Throws if the name is already registered — duplicate\n * registration is a programming error, not a runtime input fault, so it throws\n * a plain Error (not the input-error class surfaces translate for clients).\n */\nexport function defineOperation<In, Out>(spec: OperationSpec<In, Out>): BoundOperation<In, Out> {\n  if (registry.has(spec.name)) {\n    throw new Error(`access-boundary: operation already registered: ${spec.name}`);\n  }\n  const bound: BoundOperation<In, Out> = {\n    spec,\n    run: async (rawInput, ctx) => {\n      const parseResult = spec.schema.safeParse(rawInput);\n      if (!parseResult.success) {\n        throw new EngramAccessInputError(formatZodIssues(parseResult.error));\n      }\n      return spec.handler(parseResult.data, ctx);\n    },\n  };\n  // Store under the canonical name; the cast is safe because In/Out are\n  // erased at the registry boundary and recovered by callers via getOperation.\n  registry.set(spec.name, bound as unknown as BoundOperation);\n  return bound;\n}\n\n/** Look up a registered operation by canonical name. */\nexport function getOperation(name: OperationName): BoundOperation | undefined {\n  return registry.get(name);\n}\n\n/** All registered operation names. */\nexport function listRegisteredOperations(): readonly OperationName[] {\n  return [...registry.keys()];\n}\n\n/** Test-only: clear the registry so pilot definitions can be re-registered. */\nexport function __resetRegistryForTest(): void {\n  registry.clear();\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-IREVVFTM.js → chunk-6CIAGZ6X.js}

@@ -15,6 +15,14 @@ function effectiveInvalidAt(fm) {
 }
 function isValidAsOf(fm, asOfMs) {
   if (!Number.isFinite(asOfMs)) return true;
+  const explicitValidAt = fm.valid_at?.trim();
+  if ((!explicitValidAt || explicitValidAt.length === 0) && fm.eventTimeSource === "extracted") {
+    const invalidAt2 = effectiveInvalidAt(fm);
+    if (invalidAt2 !== void 0) {
+      const invalidAtMs2 = Date.parse(invalidAt2);
+      if (Number.isFinite(invalidAtMs2)) return invalidAtMs2 > asOfMs;
+    }
+  }
   const validAtMs = Date.parse(effectiveValidAt(fm));
   if (!Number.isFinite(validAtMs)) return false;
   if (validAtMs > asOfMs) return false;
@@ -54,4 +62,4 @@ export {
   isValidityExpiredNow,
   parseAsOfTimestamp
 };
-//# sourceMappingURL=chunk-IREVVFTM.js.map
+//# sourceMappingURL=chunk-6CIAGZ6X.js.map

package/dist/chunk-6CIAGZ6X.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/temporal-validity.ts"],"sourcesContent":["/**\n * Temporal validity helpers (issue #680).\n *\n * `valid_at` / `invalid_at` are explicit ISO 8601 timestamps that mark when a\n * fact begins and ends being authoritative.  These helpers centralize the\n * read-time defaulting rules so every call site (recall filter, supersession\n * write, tests) agrees on the canonical semantics:\n *\n *   - `effectiveValidAt(fm)` — the moment this fact starts being true.\n *     Falls back to `created` when `valid_at` is absent so legacy memories\n *     written before #680 still participate in `as_of` filtering without\n *     a backfill migration.\n *   - `effectiveInvalidAt(fm)` — the moment this fact stops being true.\n *     Returns `undefined` when no `invalid_at` is set; supersession logic\n *     populates it on the older fact when a newer one replaces it.\n *   - `isValidAsOf(fm, asOfMs)` — true when the fact was authoritative at\n *     `asOfMs` (a numeric timestamp in ms).  Half-open interval semantics:\n *     `valid_at <= asOf < invalid_at`.  Strings are parsed via\n *     `Date.parse()` so timezone-suffixed ISO strings compare correctly\n *     (CLAUDE.md gotcha — never compare ISO strings lexicographically).\n *\n * Boundary case: when `invalid_at === asOf`, the fact is treated as NOT\n * valid (the upper bound is exclusive), which matches the supersession\n * model — at the instant a successor's `valid_at` fires, the predecessor\n * is no longer authoritative.\n */\nimport type { MemoryFrontmatter } from \"./types.js\";\n\nexport function effectiveValidAt(fm: Pick<MemoryFrontmatter, \"valid_at\" | \"created\">): string {\n  // `created` is required on every memory (see types.ts), so the fallback\n  // chain always terminates.  Trimming guards against whitespace-only\n  // overrides written by legacy tooling.\n  const explicit = fm.valid_at?.trim();\n  if (explicit && explicit.length > 0) return explicit;\n  return fm.created;\n}\n\nexport function effectiveInvalidAt(\n  fm: Pick<MemoryFrontmatter, \"invalid_at\" | \"supersededAt\" | \"status\">,\n): string | undefined {\n  const explicit = fm.invalid_at?.trim();\n  if (explicit && explicit.length > 0) return explicit;\n  // Cursor Medium rounds 1+2 on PR #713: legacy data written before\n  // #680 has `status: superseded` and `supersededAt` populated, but\n  // no `invalid_at`. With the new `as_of` filter bypassing the\n  // supersession status check, those legacy predecessors would\n  // otherwise be treated as \"always valid\" and surface alongside\n  // their successors at every historical pin. Fall back to\n  // `supersededAt` so the half-open `[valid_at, invalid_at)`\n  // interval still terminates for legacy supersedes without\n  // requiring a backfill migration.\n  //\n  // BOUNDARY APPROXIMATION: `supersededAt` is when the supersession\n  // write fired, which may post-date the successor's true\n  // `valid_at` (consolidation runs on its own cadence). So the\n  // legacy predecessor stays visible from `valid_at` through\n  // `supersededAt` rather than the tighter `valid_at` through\n  // successor-`valid_at` window. We accept this intentionally: the\n  // alternative — successor-aware coordination — would require\n  // threading the successor through every call site, and \"show the\n  // legacy fact a bit too long\" is a clear win over \"drop legacy\n  // facts entirely from `as_of`\". New data (post-#680) writes\n  // `invalid_at` directly and is unaffected.\n  if (fm.status === \"superseded\") {\n    const legacy = fm.supersededAt?.trim();\n    if (legacy && legacy.length > 0) return legacy;\n  }\n  return undefined;\n}\n\n/**\n * Returns true when the fact was authoritative at `asOfMs` (parsed\n * milliseconds since epoch).  Half-open semantics: a fact is valid in\n * `[valid_at, invalid_at)`.\n *\n * If `valid_at` cannot be parsed, the fact is conservatively treated as\n * NOT valid at the requested point — we never silently default a corrupt\n * timestamp to \"always true\" because that would let bad data leak past\n * the historical filter (CLAUDE.md gotcha #34: distinguish empty from\n * malformed).\n */\nexport function isValidAsOf(\n  fm: Pick<\n    MemoryFrontmatter,\n    | \"valid_at\"\n    | \"invalid_at\"\n    | \"created\"\n    | \"supersededAt\"\n    | \"status\"\n    | \"eventTimeSource\"\n  >,\n  asOfMs: number,\n): boolean {\n  if (!Number.isFinite(asOfMs)) return true;\n  // Open-start bi-temporal interval (#1578 r3): an extracted end-only bound\n  // (eventTimeSource \"extracted\", no valid_at, has invalid_at) is true from\n  // the indefinite past. Without this, effectiveValidAt falls back to\n  // `created` and a historical as_of before ingestion hides a fact that was\n  // actually true up until invalid_at (chatgpt-codex thread on\n  // orchestrator.ts:15533). Gated on eventTimeSource so legacy memories\n  // (no bi-temporal provenance) keep the created-anchor fallback.\n  const explicitValidAt = fm.valid_at?.trim();\n  if (\n    (!explicitValidAt || explicitValidAt.length === 0) &&\n    fm.eventTimeSource === \"extracted\"\n  ) {\n    const invalidAt = effectiveInvalidAt(fm);\n    if (invalidAt !== undefined) {\n      const invalidAtMs = Date.parse(invalidAt);\n      if (Number.isFinite(invalidAtMs)) return invalidAtMs > asOfMs;\n    }\n  }\n  const validAtMs = Date.parse(effectiveValidAt(fm));\n  if (!Number.isFinite(validAtMs)) return false;\n  if (validAtMs > asOfMs) return false;\n  const invalidAt = effectiveInvalidAt(fm);\n  if (invalidAt === undefined) return true;\n  const invalidAtMs = Date.parse(invalidAt);\n  // Unparseable invalid_at — conservatively keep the fact (we can read\n  // valid_at, so we know the fact was at some point true; corrupt\n  // invalid_at is not a reason to hide it).\n  if (!Number.isFinite(invalidAtMs)) return true;\n  // Half-open: at exactly invalid_at, the fact is no longer valid.\n  return invalidAtMs > asOfMs;\n}\n\n/**\n * Bi-temporal injection filter (issue #1578).\n *\n * Returns `true` when the fact's event-time interval has already ended before\n * `nowMs` — i.e. it is no longer *true in the world* and should leave the\n * default injection candidate set (it remains findable by explicit search\n * and `as_of` queries, mirroring the lifecycle-filter escape-hatch principle\n * in AGENTS.md §16).  Gated by `temporalBiTemporal`; the escape hatch\n * `temporalExpiredInInjection` re-admits expired facts when a deployment\n * prefers the older always-inject behavior.\n *\n * Semantics: a fact is expired-now when `invalid_at` is present and\n * `invalid_at <= nowMs` (the exclusive upper bound has passed).  Absent\n * `invalid_at` means \"still valid\" — never expired.  This is the\n * status-orthogonal complement of `isValidAsOf` for the wall-clock instant:\n * an `active` memory can be validity-expired, and a `superseded` one can\n * still be validity-valid within its historical window (issue pitfall: the\n * filter is status-orthogonal).\n */\nexport function isValidityExpiredNow(\n  fm: Pick<MemoryFrontmatter, \"invalid_at\">,\n  nowMs: number,\n): boolean {\n  if (!Number.isFinite(nowMs)) return false;\n  const invalidAt = fm.invalid_at?.trim();\n  if (!invalidAt || invalidAt.length === 0) return false;\n  const invalidAtMs = Date.parse(invalidAt);\n  // Unparseable invalid_at — conservatively keep the fact (do not filter on\n  // corrupt data; the as_of path already handles malformed bounds).\n  if (!Number.isFinite(invalidAtMs)) return false;\n  // Half-open interval end has passed: [valid_at, invalid_at) ended.\n  return invalidAtMs <= nowMs;\n}\n\n/**\n * Parse and validate an `as_of` value supplied at an input boundary\n * (CLI flag, HTTP query param, MCP field).  Returns parsed milliseconds\n * on success; throws a `RangeError` with a helpful message on malformed\n * input.  CLAUDE.md rule 51 — never silently default invalid input.\n */\nexport function parseAsOfTimestamp(raw: unknown): number {\n  if (typeof raw !== \"string\" || raw.trim().length === 0) {\n    throw new RangeError(\n      `as_of must be a non-empty ISO 8601 timestamp string (got: ${typeof raw === \"string\" ? `\"${raw}\"` : typeof raw})`,\n    );\n  }\n  const ms = Date.parse(raw);\n  if (!Number.isFinite(ms)) {\n    throw new RangeError(\n      `as_of must be a parseable ISO 8601 timestamp (got: \"${raw}\")`,\n    );\n  }\n  return ms;\n}\n"],"mappings":";AA4BO,SAAS,iBAAiB,IAA6D;AAI5F,QAAM,WAAW,GAAG,UAAU,KAAK;AACnC,MAAI,YAAY,SAAS,SAAS,EAAG,QAAO;AAC5C,SAAO,GAAG;AACZ;AAEO,SAAS,mBACd,IACoB;AACpB,QAAM,WAAW,GAAG,YAAY,KAAK;AACrC,MAAI,YAAY,SAAS,SAAS,EAAG,QAAO;AAsB5C,MAAI,GAAG,WAAW,cAAc;AAC9B,UAAM,SAAS,GAAG,cAAc,KAAK;AACrC,QAAI,UAAU,OAAO,SAAS,EAAG,QAAO;AAAA,EAC1C;AACA,SAAO;AACT;AAaO,SAAS,YACd,IASA,QACS;AACT,MAAI,CAAC,OAAO,SAAS,MAAM,EAAG,QAAO;AAQrC,QAAM,kBAAkB,GAAG,UAAU,KAAK;AAC1C,OACG,CAAC,mBAAmB,gBAAgB,WAAW,MAChD,GAAG,oBAAoB,aACvB;AACA,UAAMA,aAAY,mBAAmB,EAAE;AACvC,QAAIA,eAAc,QAAW;AAC3B,YAAMC,eAAc,KAAK,MAAMD,UAAS;AACxC,UAAI,OAAO,SAASC,YAAW,EAAG,QAAOA,eAAc;AAAA,IACzD;AAAA,EACF;AACA,QAAM,YAAY,KAAK,MAAM,iBAAiB,EAAE,CAAC;AACjD,MAAI,CAAC,OAAO,SAAS,SAAS,EAAG,QAAO;AACxC,MAAI,YAAY,OAAQ,QAAO;AAC/B,QAAM,YAAY,mBAAmB,EAAE;AACvC,MAAI,cAAc,OAAW,QAAO;AACpC,QAAM,cAAc,KAAK,MAAM,SAAS;AAIxC,MAAI,CAAC,OAAO,SAAS,WAAW,EAAG,QAAO;AAE1C,SAAO,cAAc;AACvB;AAqBO,SAAS,qBACd,IACA,OACS;AACT,MAAI,CAAC,OAAO,SAAS,KAAK,EAAG,QAAO;AACpC,QAAM,YAAY,GAAG,YAAY,KAAK;AACtC,MAAI,CAAC,aAAa,UAAU,WAAW,EAAG,QAAO;AACjD,QAAM,cAAc,KAAK,MAAM,SAAS;AAGxC,MAAI,CAAC,OAAO,SAAS,WAAW,EAAG,QAAO;AAE1C,SAAO,eAAe;AACxB;AAQO,SAAS,mBAAmB,KAAsB;AACvD,MAAI,OAAO,QAAQ,YAAY,IAAI,KAAK,EAAE,WAAW,GAAG;AACtD,UAAM,IAAI;AAAA,MACR,6DAA6D,OAAO,QAAQ,WAAW,IAAI,GAAG,MAAM,OAAO,GAAG;AAAA,IAChH;AAAA,EACF;AACA,QAAM,KAAK,KAAK,MAAM,GAAG;AACzB,MAAI,CAAC,OAAO,SAAS,EAAE,GAAG;AACxB,UAAM,IAAI;AAAA,MACR,uDAAuD,GAAG;AAAA,IAC5D;AAAA,EACF;AACA,SAAO;AACT;","names":["invalidAt","invalidAtMs"]}

package/dist/{chunk-QHNJVWF6.js → chunk-6HPJMR5I.js}

@@ -1,14 +1,14 @@
+import {
+  countRecallTokenOverlap,
+  normalizeRecallTokens
+} from "./chunk-ZBJMUXZH.js";
 import {
   StorageManager
-} from "./chunk-NMW3T6T6.js";
+} from "./chunk-2VQYHHWB.js";
 import {
   getCachedRuleMemories,
   setCachedRuleMemories
 } from "./chunk-AWJ2FHCF.js";
-import {
-  countRecallTokenOverlap,
-  normalizeRecallTokens
-} from "./chunk-ZBJMUXZH.js";
 
 // src/semantic-rule-verifier.ts
 var DEFAULT_MIN_EFFECTIVE_CONFIDENCE = 0.45;
@@ -117,4 +117,4 @@ export {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
 };
-//# sourceMappingURL=chunk-QHNJVWF6.js.map
+//# sourceMappingURL=chunk-6HPJMR5I.js.map

package/dist/{chunk-4NFVPDIL.js → chunk-74MYJSKB.js}

@@ -3,13 +3,13 @@ import {
 } from "./chunk-7FL4CNPV.js";
 import {
   resolveCausalTrajectoryStoreDir
-} from "./chunk-YN4ZT4CW.js";
-import {
-  log
-} from "./chunk-NU3CSQ4H.js";
+} from "./chunk-YI7RZO7Y.js";
 import {
   normalizeRecallTokens
 } from "./chunk-ZBJMUXZH.js";
+import {
+  log
+} from "./chunk-NU3CSQ4H.js";
 import {
   assertIsoRecordedAt,
   assertString,
@@ -339,4 +339,4 @@ export {
   scoreStitchCandidate,
   stitchCausalChain
 };
-//# sourceMappingURL=chunk-4NFVPDIL.js.map
+//# sourceMappingURL=chunk-74MYJSKB.js.map

package/dist/{chunk-PKMQK2WY.js → chunk-773DPI6T.js}

@@ -1,3 +1,6 @@
+import {
+  LcmDag
+} from "./chunk-7N4KAIGN.js";
 import {
   LcmWorkQueue
 } from "./chunk-TPDBFYEG.js";
@@ -14,9 +17,6 @@ import {
 import {
   LcmArchive
 } from "./chunk-HW5EF6LV.js";
-import {
-  LcmDag
-} from "./chunk-7N4KAIGN.js";
 import {
   log
 } from "./chunk-NU3CSQ4H.js";
@@ -513,4 +513,4 @@ export {
   extractLcmConfig,
   LcmEngine
 };
-//# sourceMappingURL=chunk-PKMQK2WY.js.map
+//# sourceMappingURL=chunk-773DPI6T.js.map

package/dist/{chunk-AGNBY3VG.js → chunk-APJQ6UEA.js}

@@ -1,10 +1,10 @@
-import {
-  SQLITE_SCHEMA_VERSION
-} from "./chunk-Z734BLO3.js";
 import {
   parseConflictPolicy,
   validateManifestRecords
 } from "./chunk-G4IAEX6D.js";
+import {
+  SQLITE_SCHEMA_VERSION
+} from "./chunk-Z734BLO3.js";
 import {
   openBetterSqlite3
 } from "./chunk-6KYMPV2O.js";
@@ -84,4 +84,4 @@ async function importSqlite(opts) {
 export {
   importSqlite
 };
-//# sourceMappingURL=chunk-AGNBY3VG.js.map
+//# sourceMappingURL=chunk-APJQ6UEA.js.map

package/dist/{chunk-UNNDFYUX.js → chunk-ARV3AUOM.js}

@@ -1,13 +1,13 @@
 import {
   createVersion
 } from "./chunk-VF4XKTX3.js";
-import {
-  decryptCapsuleFileInMemory,
-  isEncryptedCapsuleFile
-} from "./chunk-UVYI6VIX.js";
 import {
   parseExportBundle
 } from "./chunk-WEHSQBFR.js";
+import {
+  decryptCapsuleFileInMemory,
+  isEncryptedCapsuleFile
+} from "./chunk-X7Y7WX73.js";
 import {
   assertIsDirectoryNotSymlink,
   assertRealpathInsideRoot,
@@ -227,4 +227,4 @@ function mintForkId(capsuleId, originalId, now) {
 export {
   importCapsule
 };
-//# sourceMappingURL=chunk-UNNDFYUX.js.map
+//# sourceMappingURL=chunk-ARV3AUOM.js.map

package/dist/{chunk-XXDOJ5NL.js → chunk-BGAHTI4C.js}

@@ -1,6 +1,6 @@
 import {
   listNamespaces
-} from "./chunk-S24J5LLQ.js";
+} from "./chunk-NM6TSEGQ.js";
 import {
   runConsolidationProvenanceCheck
 } from "./chunk-7XH7VJN4.js";
@@ -9,7 +9,7 @@ import {
 } from "./chunk-YBPYIAA5.js";
 import {
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-6Q7JFY4P.js";
+} from "./chunk-Y6YHAGQP.js";
 import {
   analyzeSessionIntegrity,
   applySessionRepair,
@@ -39,13 +39,13 @@ import {
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
-} from "./chunk-K7QRDDSR.js";
+} from "./chunk-ESMY4RJ4.js";
 import {
   analyzeGraphHealth
-} from "./chunk-KF74X62T.js";
+} from "./chunk-YGKUAX2B.js";
 import {
   StorageManager
-} from "./chunk-NMW3T6T6.js";
+} from "./chunk-2VQYHHWB.js";
 import {
   lintWorkspaceFiles
 } from "./chunk-DM2T26WE.js";
@@ -789,7 +789,7 @@ async function summarizeBufferSurpriseDistribution(storage, config) {
   }
 }
 async function summarizeGraphEdgeDecayStatus(config) {
-  const { readGraphEdgeDecayStatus } = await import("./graph-edge-decay-D7OESCBR.js");
+  const { readGraphEdgeDecayStatus } = await import("./graph-edge-decay-JLOF3YW4.js");
   const enabled = config.graphEdgeDecayEnabled === true;
   if (!enabled) {
     return {
@@ -1395,4 +1395,4 @@ export {
   runBenchmarkRecall,
   runOperatorRepair
 };
-//# sourceMappingURL=chunk-XXDOJ5NL.js.map
+//# sourceMappingURL=chunk-BGAHTI4C.js.map

package/dist/{chunk-6GHWF4QH.js → chunk-C63MK3WL.js}

@@ -10,7 +10,7 @@ import {
 import {
   planNamespaceMaintenance,
   runNamespaceMaintenanceBatchPlan
-} from "./chunk-QV5WFNZ2.js";
+} from "./chunk-W2S3Z5MT.js";
 import {
   resolveHomeDir
 } from "./chunk-JUC24CTX.js";
@@ -441,4 +441,4 @@ var MaintenanceScheduler = class {
 export {
   MaintenanceScheduler
 };
-//# sourceMappingURL=chunk-6GHWF4QH.js.map
+//# sourceMappingURL=chunk-C63MK3WL.js.map

package/dist/{chunk-VKJHM6PL.js → chunk-DGTDRIUO.js}

@@ -16,6 +16,10 @@ import {
   WearablesInputError,
   describeErrorForOperator
 } from "./chunk-7WV3F5DQ.js";
+import {
+  countRecallTokenOverlap,
+  normalizeRecallTokens
+} from "./chunk-ZBJMUXZH.js";
 import {
   composeDayTranscriptBody,
   composeDayTranscriptMeta,
@@ -25,10 +29,6 @@ import {
   resolveSpeaker,
   serializeDayTranscript
 } from "./chunk-M7XQSUBB.js";
-import {
-  countRecallTokenOverlap,
-  normalizeRecallTokens
-} from "./chunk-ZBJMUXZH.js";
 
 // src/wearables/trust.ts
 var TRUST_JUDGE_ACCEPT_BOOST = 0.15;
@@ -1161,4 +1161,4 @@ export {
   syncWearableSource,
   defaultTimezone
 };
-//# sourceMappingURL=chunk-VKJHM6PL.js.map
+//# sourceMappingURL=chunk-DGTDRIUO.js.map