@remnic/core 10.0.49 → 10.0.51

package/dist/chunk-7XFQSQYS.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/access-http-briefing.ts"],"sourcesContent":["import { getOperation } from \"./access-boundary.js\";\nimport { EngramAccessInputError, type EngramAccessService } from \"./access-service.js\";\n\ntype JsonResponder = (status: number, payload: unknown) => void;\n\nexport interface BriefingHttpOptions {\n  /** Request body already run through the namespace gate (gatedBodyNamespace). */\n  gatedBody: Record<string, unknown>;\n  service: EngramAccessService;\n  principal: string | undefined;\n  respondJson: JsonResponder;\n}\n\n/**\n * POST /engram/v1/briefing — daily briefing over the access HTTP boundary.\n *\n * Dispatches the registered `briefing` boundary operation (the one the MCP\n * tool uses) so schema validation, namespace gating, and principal\n * propagation reach every HTTP briefing call — the same shape as the\n * coding/delta read dispatch. Pure read: nothing persists, so no\n * write-quota accounting. The operation result already carries both\n * renderings (markdown + json sections) in one response, letting thin\n * clients render without a CLI subprocess.\n */\nexport async function respondBriefingHttp(options: BriefingHttpOptions): Promise<void> {\n  const op = getOperation(\"briefing\");\n  if (!op) {\n    throw new EngramAccessInputError(\"access-boundary: operation not registered: briefing\");\n  }\n  const output = (await op.run(options.gatedBody, {\n    service: options.service,\n    authenticatedPrincipal: options.principal,\n  })) as { result: unknown };\n  options.respondJson(200, output.result);\n}\n"],"mappings":";;;;;;;;AAwBA,eAAsB,oBAAoB,SAA6C;AACrF,QAAM,KAAK,aAAa,UAAU;AAClC,MAAI,CAAC,IAAI;AACP,UAAM,IAAI,uBAAuB,qDAAqD;AAAA,EACxF;AACA,QAAM,SAAU,MAAM,GAAG,IAAI,QAAQ,WAAW;AAAA,IAC9C,SAAS,QAAQ;AAAA,IACjB,wBAAwB,QAAQ;AAAA,EAClC,CAAC;AACD,UAAQ,YAAY,KAAK,OAAO,MAAM;AACxC;","names":[]}

package/dist/chunk-BMG3SAXA.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/access-schema.ts"],"sourcesContent":["// Request/response schema validation for the Remnic HTTP API.\n// Uses zod for runtime validation — returns structured 400 errors with\n// field-level detail so consumers get clear feedback on malformed requests.\n\nimport { z } from \"zod\";\n\nimport type { MemoryCategory } from \"./types.js\";\nimport {\n  ACTION_CONFIDENCE_CONTEXT_READINESS,\n  ACTION_CONFIDENCE_RISK_CATEGORIES,\n  ACTION_CONFIDENCE_RULE_KINDS,\n} from \"./action-confidence.js\";\nimport { isValidCapsuleSince } from \"./transfer/capsule-export.js\";\nimport { validateArchiveRelativePath } from \"./transfer/fs-utils.js\";\nimport { CAPSULE_ID_PATTERN } from \"./transfer/types.js\";\nimport {\n  OFFLINE_SYNC_FILE_CONTENT_MAX_CHUNK_BYTES,\n  OFFLINE_SYNC_MAX_MTIME_MS,\n} from \"./offline-sync.js\";\n\n// ---------------------------------------------------------------------------\n// Error formatting\n// ---------------------------------------------------------------------------\n\nexport interface SchemaValidationError {\n  error: string;\n  code: \"validation_error\";\n  details: Array<{ field: string; message: string }>;\n}\n\nexport function formatZodError(error: z.ZodError): SchemaValidationError {\n  return {\n    error: \"request validation failed\",\n    code: \"validation_error\",\n    details: error.issues.map((issue) => ({\n      field: issue.path.join(\".\") || \"(root)\",\n      message: issue.message,\n    })),\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Shared fields\n// ---------------------------------------------------------------------------\n\nconst namespaceSchema = z.string().trim().max(256).optional();\nconst sessionKeySchema = z.string().trim().min(1).max(512).optional();\nconst idempotencyKeySchema = z.string().trim().min(1).max(256).optional();\nconst cwdSchema = z.string().trim().min(1, \"cwd must be non-empty when provided\").max(2048).optional();\nconst projectTagSchema = z\n  .string()\n  .trim()\n  .min(1, \"projectTag must be non-empty when provided\")\n  .max(256)\n  .optional();\nconst deadlineMsSchema = z.number().finite().min(0).max(Number.MAX_SAFE_INTEGER).optional();\nconst dryRunSchema = z.boolean().optional();\nconst schemaVersionSchema = z.number().int().optional();\nconst timeZoneSchema = z\n  .string()\n  .trim()\n  .min(1)\n  .max(128)\n  .refine((value) => {\n    try {\n      Intl.DateTimeFormat(undefined, { timeZone: value });\n      return true;\n    } catch {\n      return false;\n    }\n  }, \"must be a valid IANA timezone\");\n\n// ---------------------------------------------------------------------------\n// Recall\n// ---------------------------------------------------------------------------\n\n/**\n * Coding-agent context (issue #569). Optional payload that connectors may\n * ship with a recall request so the project/branch namespace overlay\n * applies to that recall. All fields are validated per CLAUDE.md #51 —\n * empty-string projectId / rootPath is rejected, not silently accepted.\n */\nexport const codingContextSchema = z\n  .object({\n    projectId: z.string().trim().min(1, \"codingContext.projectId is required\").max(128),\n    branch: z.string().trim().max(256).nullable(),\n    rootPath: z.string().trim().min(1, \"codingContext.rootPath is required\").max(1024),\n    defaultBranch: z.string().trim().max(256).nullable(),\n  })\n  .nullable();\n\n/**\n * Recall disclosure depth (issue #677).  Mirrors the `RecallDisclosure`\n * type in `types.ts` — keep these in sync.  Default-application happens\n * inside `EngramAccessService.recall()`; the schema only accepts/rejects.\n * Invalid values throw a structured 400 instead of silently defaulting,\n * per CLAUDE.md rule 51.\n */\nexport const recallDisclosureSchema = z.enum([\"chunk\", \"section\", \"raw\"]);\n\n/**\n * Tag-match semantics (issue #689). `any` (default when `tags` is provided\n * and `tagMatch` is omitted) admits a result when it carries at least one\n * of the filter tags. `all` requires every filter tag to be present.\n * Schema rejects unknown values up front — never silently defaults\n * (CLAUDE.md rule 51).\n */\nexport const tagMatchSchema = z.enum([\"any\", \"all\"]);\n\nexport const recallRequestSchema = z.object({\n  query: z.string().min(1, \"query is required\"),\n  sessionKey: sessionKeySchema,\n  namespace: namespaceSchema,\n  topK: z.number().int().min(0).max(200).optional(),\n  mode: z.enum([\"auto\", \"no_recall\", \"minimal\", \"full\", \"graph_mode\"]).optional(),\n  includeDebug: z.boolean().optional(),\n  idempotencyKey: idempotencyKeySchema,\n  disclosure: recallDisclosureSchema.optional(),\n  codingContext: codingContextSchema.optional(),\n  /** Working directory for auto git-context resolution (issue #569). */\n  cwd: cwdSchema,\n  /**\n   * Arbitrary project tag for non-git-based project scoping (issue #569).\n   * Creates a coding context with `projectId: \"tag:<projectTag>\"`.\n   */\n  projectTag: projectTagSchema,\n  /**\n   * Historical recall pin (issue #680).  ISO 8601 timestamp.  The\n   * schema only enforces the basic shape; the access service runs\n   * `Date.parse` and emits a structured 400 on malformed input\n   * (CLAUDE.md rule 51).\n   */\n  asOf: z.string().trim().min(1, \"asOf must be a non-empty ISO 8601 timestamp\").max(64).optional(),\n  /**\n   * Free-form recall tag filter (issue #689). When provided, recall results\n   * whose frontmatter `tags` do not match the filter are removed before the\n   * response is returned. Comparison is case-sensitive exact match.\n   */\n  tags: z.array(z.string().trim().min(1).max(256)).max(50).optional(),\n  /**\n   * Match mode for `tags` (issue #689). Defaults to `\"any\"` when `tags` is\n   * provided and `tagMatch` is omitted. Ignored when `tags` is absent.\n   */\n  tagMatch: tagMatchSchema.optional(),\n  /**\n   * Include graph edges below `graphTraversalConfidenceFloor` for diagnostic\n   * recall traversal (issue #681). Defaults to false.\n   */\n  includeLowConfidence: z.boolean().optional(),\n  /**\n   * #1952 — per-call opt-in to state-aware recall views for this recall.\n   * ORs with the `recallStateViews` config flag; a change-intent query\n   * (e.g. \"when did\", \"used to\", \"switched\") is still required for any\n   * effect, so this can never perturb ordinary recalls.\n   */\n  stateView: z.boolean().optional(),\n});\n\nexport const recallExplainRequestSchema = z.object({\n  sessionKey: sessionKeySchema,\n  namespace: namespaceSchema,\n});\n\n/**\n * Standalone \"set coding context\" request. Used by the HTTP endpoint\n * `POST /engram/v1/coding-context` and the MCP `remnic.set_coding_context`\n * tool (PR 7). `codingContext: null` clears the attached context.\n */\nexport const setCodingContextRequestSchema = z\n  .object({\n    sessionKey: z.string().trim().min(1, \"sessionKey is required\").max(512),\n    codingContext: codingContextSchema.optional(),\n    /**\n     * Project tag shorthand for non-git-based project scoping. When\n     * `codingContext` is omitted, this becomes\n     * `{ projectId: \"tag:<projectTag>\", branch: null, rootPath: \"tag:<projectTag>\", defaultBranch: null }`.\n     */\n    projectTag: z.string().trim().min(1, \"projectTag must be non-empty when provided\").max(256).optional(),\n  })\n  .superRefine((value, ctx) => {\n    if (value.codingContext === undefined && value.projectTag === undefined) {\n      ctx.addIssue({\n        code: z.ZodIssueCode.custom,\n        message: \"codingContext or projectTag is required\",\n        path: [\"codingContext\"],\n      });\n    }\n  });\n\n// ---------------------------------------------------------------------------\n// Observe\n// ---------------------------------------------------------------------------\n\nconst messageSchema = z.object({\n  role: z.enum([\"user\", \"assistant\"]),\n  content: z.string().min(1, \"message content must be non-empty\"),\n  sourceFormat: z\n    .enum([\"openai\", \"anthropic\", \"openclaw\", \"pi\", \"lossless-claw\", \"remnic\"])\n    .nullable()\n    .optional(),\n  rawContent: z.unknown().nullable().optional(),\n  parts: z\n    .array(\n      z.object({\n        ordinal: z.number().int().min(0).nullable().optional(),\n        kind: z.enum([\n          \"text\",\n          \"tool_call\",\n          \"tool_result\",\n          \"patch\",\n          \"file_read\",\n          \"file_write\",\n          \"step_start\",\n          \"step_finish\",\n          \"snapshot\",\n          \"retry\",\n        ]),\n        payload: z.record(z.string(), z.unknown()),\n        toolName: z.string().nullable().optional(),\n        tool_name: z.string().nullable().optional(),\n        filePath: z.string().nullable().optional(),\n        file_path: z.string().nullable().optional(),\n        createdAt: z.string().nullable().optional(),\n        created_at: z.string().nullable().optional(),\n      }),\n    )\n    .nullable()\n    .optional(),\n});\n\nexport const observeRequestSchema = z.object({\n  sessionKey: z.string().trim().min(1, \"sessionKey is required\").max(512),\n  messages: z.array(messageSchema).min(1, \"messages must be a non-empty array\"),\n  namespace: namespaceSchema,\n  skipExtraction: z.boolean().optional(),\n  /**\n   * Optional idempotency key for server-side dedup of retried observe POSTs\n   * (issue #1649). A retry that reaches the daemon after the first attempt\n   * already processed is replayed from cache instead of re-ingested. When the\n   * key is reused with a DIFFERENT payload the request is rejected as a\n   * conflict (same contract as memory_store/suggestion_submit).\n   */\n  idempotencyKey: idempotencyKeySchema,\n  /** Working directory for auto git-context resolution (issue #569). */\n  cwd: cwdSchema,\n  /**\n   * Arbitrary project tag for non-git-based project scoping (issue #569).\n   * Creates a coding context with `projectId: \"tag:<projectTag>\"`.\n   */\n  projectTag: projectTagSchema,\n});\n\n// ---------------------------------------------------------------------------\n// Deep recall (issue #2332)\n// ---------------------------------------------------------------------------\n\nexport const deepRecallRequestSchema = z.object({\n  query: z.string().trim().min(1, \"query is required\").max(2000),\n  /** Optional policy-step ceiling; validated against the configured maximum in the service. */\n  maxSteps: z.union([z.number().int().min(0), z.string()]).optional(),\n  namespace: namespaceSchema,\n  sessionKey: z.string().optional(),\n});\n\n// ---------------------------------------------------------------------------\n// Memory store / suggestion submit\n// ---------------------------------------------------------------------------\n\nconst writeContentSchema = z.string().min(1, \"content is required\").max(50000);\n// ---------------------------------------------------------------------------\n// Category wire contract (issue #2829): truthful input/output modeling.\n// ---------------------------------------------------------------------------\n\n/** Canonical input spellings — exactly the `MemoryCategory` union. */\nconst MEMORY_CATEGORY_CANONICAL_INPUT = [\n  \"fact\", \"preference\", \"correction\", \"entity\", \"decision\",\n  \"relationship\", \"principle\", \"commitment\", \"moment\", \"skill\", \"rule\", \"procedure\",\n  \"reasoning_trace\",\n] as const satisfies readonly MemoryCategory[];\n\n/**\n * Compatibility alias spellings admitted on input. The four project-shaped\n * categories fleet telemetry actually shows do not exist in the taxonomy;\n * they parse to the canonical \"fact\". Exact match only — no trimming, no\n * case folding, so near-misses like `projection` or `Project_State` reject\n * like any other invalid category, with the full valid list in the error.\n */\nconst MEMORY_CATEGORY_ALIAS_INPUT = [\n  \"project\",\n  \"project_state\",\n  \"project-state\",\n  \"project_update\",\n] as const;\n\nexport type MemoryCategoryAlias = (typeof MEMORY_CATEGORY_ALIAS_INPUT)[number];\n\nconst MEMORY_CATEGORY_ALIAS_TO_CANONICAL: Readonly<\n  Record<MemoryCategoryAlias, Extract<MemoryCategory, \"fact\">>\n> = {\n  project: \"fact\",\n  project_state: \"fact\",\n  \"project-state\": \"fact\",\n  project_update: \"fact\",\n};\n\nexport function isMemoryCategoryAlias(value: string): value is MemoryCategoryAlias {\n  return Object.prototype.hasOwnProperty.call(MEMORY_CATEGORY_ALIAS_TO_CANONICAL, value);\n}\n\n/**\n * Canonical category for an accepted alias spelling; undefined for anything\n * else (canonical spellings and near-misses map to nothing). Service-boundary\n * consumers that receive `category` without a prior wire parse use this to\n * match the transport contract (#2962).\n */\nexport function canonicalCategoryForAlias(value: string): \"fact\" | undefined {\n  return isMemoryCategoryAlias(value) ? MEMORY_CATEGORY_ALIAS_TO_CANONICAL[value] : undefined;\n}\n\n/** Coercion diagnostic for a write whose input category was a compat alias. */\nexport interface CategoryAliasCoercion {\n  from: MemoryCategoryAlias;\n  to: \"fact\";\n}\n\n/** Boundary-derived coercion note for a retained raw spelling. */\nexport function categoryAliasCoercion(rawCategory: string | undefined): CategoryAliasCoercion | undefined {\n  return rawCategory !== undefined && isMemoryCategoryAlias(rawCategory)\n    ? { from: rawCategory, to: \"fact\" }\n    : undefined;\n}\n\n/**\n * Recover the retained alias spelling from a pre-parse raw envelope: the\n * `rawCategory` minted by a previous parse of the same schema (the HTTP/MCP\n * validate-then-dispatch double pass), or — for single-parse callers like the\n * CLI store command — the as-yet-untransformed alias still sitting on\n * `category` (issue #2889). A minted `rawCategory` always wins: it names the\n * spelling the transform actually canonicalized.\n */\nexport function retainedCategoryAlias(rawInput: unknown): MemoryCategoryAlias | undefined {\n  if (!rawInput || typeof rawInput !== \"object\") return undefined;\n  const envelope = rawInput as Record<string, unknown>;\n  const minted = envelope.rawCategory;\n  if (typeof minted === \"string\" && isMemoryCategoryAlias(minted)) return minted;\n  const category = envelope.category;\n  return typeof category === \"string\" && isMemoryCategoryAlias(category) ? category : undefined;\n}\n\n/**\n * An idempotent replay returns the FIRST request's stored response, whose\n * coercion note names that request's spelling. Rewrite the note from the\n * CURRENT request's retained spelling so every response identifies what its\n * caller actually sent; the stored idempotent result is reused untouched.\n */\nexport function reapplyCategoryCoercion<T extends object>(\n  response: T,\n  categoryCoercion: CategoryAliasCoercion | undefined,\n): T & { categoryCoercion?: CategoryAliasCoercion } {\n  const restamped: T & { categoryCoercion?: CategoryAliasCoercion } = { ...response };\n  if (categoryCoercion !== undefined) {\n    restamped.categoryCoercion = categoryCoercion;\n  } else {\n    delete restamped.categoryCoercion;\n  }\n  return restamped;\n}\n\nconst categoryWireSchema = z.enum(\n  [...MEMORY_CATEGORY_CANONICAL_INPUT, ...MEMORY_CATEGORY_ALIAS_INPUT],\n  {\n    errorMap: () => ({\n      message:\n        `category must be one of: ${[...MEMORY_CATEGORY_CANONICAL_INPUT, ...MEMORY_CATEGORY_ALIAS_INPUT].join(\", \")}; ` +\n        'for project state/facts use \"fact\"',\n    }),\n  },\n);\n\nconst confidenceSchema = z.number().min(0).max(1).optional();\nconst tagsSchema = z.array(z.string().max(256)).max(50).optional();\nconst entityRefSchema = z.string().trim().max(512).optional();\nconst ttlSchema = z.string().trim().max(128).optional();\nconst sourceReasonSchema = z.string().trim().max(2000).optional();\n\nconst memoryStoreRequestShape = z.object({\n  schemaVersion: schemaVersionSchema,\n  idempotencyKey: idempotencyKeySchema,\n  dryRun: dryRunSchema,\n  sessionKey: sessionKeySchema,\n  content: writeContentSchema,\n  category: categoryWireSchema.optional(),\n  confidence: confidenceSchema,\n  namespace: namespaceSchema,\n  tags: tagsSchema,\n  entityRef: entityRefSchema,\n  ttl: ttlSchema,\n  sourceReason: sourceReasonSchema,\n  // Git/project context for project-scoped writes (#1434). When no explicit\n  // `namespace` is given, these route the write to the same project namespace\n  // recall/observe resolve from `cwd`/`projectTag` (issue #569, rule 42). Also\n  // lets MCP clients that auto-inject `cwd` (e.g. Pi MCPorter) call write tools.\n  cwd: cwdSchema,\n  projectTag: projectTagSchema,\n});\n\n/**\n * Parsed memory-store request (issue #2829): the category transform maps\n * compat aliases to the canonical \"fact\" DURING parsing, so the output type\n * stays the finite `MemoryCategory` union — never an alias spelling. The raw\n * spelling travels separately on `rawCategory`, minted only by the transform\n * (zod strips it from client bodies), for the write surface's coercion note\n * and idempotent-replay rebuild.\n */\nexport type MemoryStoreParsedRequest = Omit<z.infer<typeof memoryStoreRequestShape>, \"category\"> & {\n  category?: MemoryCategory;\n  rawCategory?: MemoryCategoryAlias;\n};\n\nexport const memoryStoreRequestSchema = memoryStoreRequestShape.transform(\n  (request): MemoryStoreParsedRequest => {\n    if (request.category === undefined || !isMemoryCategoryAlias(request.category)) {\n      // Spread so the narrowed canonical category, not the wide wire union,\n      // becomes the output type.\n      return { ...request, category: request.category };\n    }\n    return {\n      ...request,\n      category: MEMORY_CATEGORY_ALIAS_TO_CANONICAL[request.category],\n      rawCategory: request.category,\n    };\n  },\n);\n\nexport const suggestionSubmitRequestSchema = memoryStoreRequestSchema;\n\n// ---------------------------------------------------------------------------\n// Review disposition\n// ---------------------------------------------------------------------------\n\nexport const reviewDispositionRequestSchema = z.object({\n  memoryId: z.string().trim().min(1, \"memoryId is required\"),\n  status: z.enum([\n    \"active\", \"pending_review\", \"quarantined\", \"rejected\", \"superseded\", \"archived\",\n  ]),\n  reasonCode: z.string().trim().min(1, \"reasonCode is required\"),\n  namespace: namespaceSchema,\n});\n\n// ---------------------------------------------------------------------------\n// Trust-zone promote\n// ---------------------------------------------------------------------------\n\nexport const trustZonePromoteRequestSchema = z.object({\n  recordId: z.string().trim().min(1, \"recordId is required\"),\n  targetZone: z.enum([\"working\", \"trusted\"], {\n    errorMap: () => ({ message: \"targetZone must be 'working' or 'trusted'\" }),\n  }),\n  promotionReason: z.string().trim().min(1, \"promotionReason is required\"),\n  recordedAt: z.string().trim().optional(),\n  summary: z.string().trim().max(5000).optional(),\n  dryRun: dryRunSchema,\n  namespace: namespaceSchema,\n});\n\n// ---------------------------------------------------------------------------\n// Trust-zone demo-seed\n// ---------------------------------------------------------------------------\n\nexport const trustZoneDemoSeedRequestSchema = z.object({\n  scenario: z.string().trim().max(256).optional(),\n  recordedAt: z.string().trim().optional(),\n  dryRun: dryRunSchema,\n  namespace: namespaceSchema,\n});\n\n// ---------------------------------------------------------------------------\n// LCM search\n// ---------------------------------------------------------------------------\n\nexport const lcmSearchRequestSchema = z.object({\n  query: z.string().min(1, \"query is required\"),\n  sessionKey: sessionKeySchema,\n  sessionPrefix: z.string().trim().min(1).max(512).optional(),\n  namespace: namespaceSchema,\n  limit: z.number().int().min(1).max(100).optional(),\n});\n\nexport const lcmCompactionFlushRequestSchema = z\n  .object({\n    sessionKey: z.string().trim().min(1, \"sessionKey is required\").max(512),\n    namespace: namespaceSchema,\n    cwd: cwdSchema,\n    projectTag: projectTagSchema,\n    /**\n     * Optional multi-namespace flush used by delegate lifecycle replay. The\n     * server handles the whole list as one quota-counted write.\n     */\n    namespaces: z.array(z.string().trim().max(256)).min(1).max(64).optional(),\n  })\n  .superRefine((value, ctx) => {\n    if (value.namespace !== undefined && value.namespaces !== undefined) {\n      ctx.addIssue({\n        code: z.ZodIssueCode.custom,\n        message: \"namespace and namespaces are mutually exclusive\",\n        path: [\"namespaces\"],\n      });\n    }\n    if (\n      value.namespaces !== undefined &&\n      new Set(value.namespaces).size !== value.namespaces.length\n    ) {\n      ctx.addIssue({\n        code: z.ZodIssueCode.custom,\n        message: \"namespaces must not contain duplicates\",\n        path: [\"namespaces\"],\n      });\n    }\n  });\n\nexport const extractionForceFlushRequestSchema = z.object({\n  sessionKey: z.string().trim().min(1, \"sessionKey is required\").max(512),\n  namespace: namespaceSchema,\n  cwd: cwdSchema,\n  projectTag: projectTagSchema,\n  deadlineMs: deadlineMsSchema,\n});\n\nexport const lcmCompactionRecordRequestSchema = z.object({\n  sessionKey: z.string().trim().min(1, \"sessionKey is required\").max(512),\n  namespace: namespaceSchema,\n  tokensBefore: z.number().int().min(0, \"tokensBefore must be a non-negative integer\"),\n  tokensAfter: z.number().int().min(0, \"tokensAfter must be a non-negative integer\"),\n});\n\n// ---------------------------------------------------------------------------\n// Day summary\n// ---------------------------------------------------------------------------\n\nexport const daySummaryRequestSchema = z.object({\n  memories: z.string().max(100000).optional(),\n  includeLocation: z.boolean().optional(),\n  sessionKey: sessionKeySchema,\n  namespace: namespaceSchema,\n  timeZone: timeZoneSchema.optional(),\n});\n\n// ---------------------------------------------------------------------------\n// Capsule export\n// ---------------------------------------------------------------------------\n\nconst capsuleTopLevelSegmentSchema = z\n  .string()\n  .trim()\n  .min(1)\n  .max(128)\n  .refine(\n    (value) => !value.includes(\"/\") && !value.includes(\"\\\\\"),\n    \"must be a top-level directory name without path separators\",\n  );\n\nconst capsulePeerIdSchema = z\n  .string()\n  .trim()\n  .min(1)\n  .max(256)\n  .refine(\n    (value) => value !== \".\" && value !== \"..\" && !value.includes(\"/\") && !value.includes(\"\\\\\"),\n    \"must be a plain peer id without path separators\",\n  );\n\nconst capsuleIsoSinceSchema = z\n  .string()\n  .trim()\n  .min(1, \"since must be a non-empty ISO 8601 timestamp\")\n  .max(128)\n  .refine(\n    isValidCapsuleSince,\n    \"since must be a valid ISO 8601 timestamp with no calendar overflow\",\n  );\n\nexport const capsuleExportRequestSchema = z\n  .object({\n    name: z\n      .string()\n      .trim()\n      .min(1, \"name is required\")\n      .max(64, \"name must be 64 characters or fewer\")\n      .regex(\n        CAPSULE_ID_PATTERN,\n        \"name must be alphanumeric with single dashes (no spaces, no leading/trailing dashes)\",\n      ),\n    namespace: namespaceSchema,\n    since: capsuleIsoSinceSchema.optional(),\n    includeKinds: z.array(capsuleTopLevelSegmentSchema).max(50).optional(),\n    peerIds: z.array(capsulePeerIdSchema).max(100).optional(),\n    includeTranscripts: z.boolean().optional(),\n    encrypt: z.boolean().optional(),\n  });\n\nexport const capsuleImportRequestSchema = z\n  .object({\n    archivePath: z.string().trim().min(1, \"archivePath is required\").max(4096),\n    namespace: namespaceSchema,\n    mode: z.enum([\"skip\", \"overwrite\", \"fork\"]).optional(),\n    passphrase: z.string().min(1, \"passphrase must not be empty\").max(4096).optional(),\n  });\n\nexport const capsuleListRequestSchema = z\n  .object({\n    namespace: namespaceSchema,\n    sessionKey: sessionKeySchema,\n  });\n\n// ---------------------------------------------------------------------------\n// Offline sync\n// ---------------------------------------------------------------------------\n\nfunction isValidOfflineSyncPath(value: string): boolean {\n  try {\n    validateArchiveRelativePath(value, \"path\");\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nconst offlineSyncPathSchema = z\n  .string()\n  .trim()\n  .min(1, \"path must be non-empty\")\n  .max(4096)\n  .refine(\n    isValidOfflineSyncPath,\n    \"path must be a POSIX relative path without unsafe segments\",\n  );\n\nconst offlineSyncFileStateSchema = z.object({\n  path: offlineSyncPathSchema,\n  sha256: z.string().regex(/^[a-f0-9]{64}$/i, \"sha256 must be a 64-character hex digest\"),\n  bytes: z.number().int().min(0),\n  mtimeMs: z.number().finite().min(0).max(OFFLINE_SYNC_MAX_MTIME_MS),\n});\n\nconst offlineSyncBaseCapturedAtSchema = z\n  .string()\n  .trim()\n  .min(1, \"baseCapturedAt must be non-empty when provided\")\n  .max(64)\n  .refine((value) => Number.isFinite(Date.parse(value)), {\n    message: \"baseCapturedAt must be a valid ISO 8601 timestamp\",\n  });\n\nexport const offlineSyncSnapshotRequestSchema = z.object({\n  namespace: namespaceSchema,\n  includeTranscripts: z.boolean().optional(),\n  includeContent: z.boolean().optional(),\n  baseCapturedAt: offlineSyncBaseCapturedAtSchema.optional(),\n  baseFiles: z\n    .array(offlineSyncFileStateSchema)\n    .max(300_000, \"baseFiles must contain 300000 or fewer entries\")\n    .optional(),\n});\n\nexport const offlineSyncApplyRequestSchema = z\n  .object({\n    namespace: namespaceSchema,\n    changeset: z.unknown(),\n    returnCurrentFiles: z.boolean().optional(),\n  })\n  .refine((value) => value.changeset !== undefined && value.changeset !== null, {\n    message: \"changeset is required\",\n    path: [\"changeset\"],\n  });\n\nexport const offlineSyncFilesRequestSchema = z.object({\n  namespace: namespaceSchema,\n  includeTranscripts: z.boolean().optional(),\n  paths: z\n    .array(offlineSyncPathSchema)\n    .max(5000, \"paths must contain 5000 or fewer entries\"),\n});\n\nexport const offlineSyncFileContentRequestSchema = z.object({\n  namespace: namespaceSchema,\n  includeTranscripts: z.boolean().optional(),\n  path: offlineSyncPathSchema,\n  offset: z.number().int().min(0).optional(),\n  length: z.number().int().min(1).max(OFFLINE_SYNC_FILE_CONTENT_MAX_CHUNK_BYTES).optional(),\n});\n\n// ---------------------------------------------------------------------------\n// Action confidence\n// ---------------------------------------------------------------------------\n\nconst nullableOptional = <T extends z.ZodTypeAny>(schema: T) =>\n  schema.optional().nullable().transform((value) => value ?? undefined);\n\nconst actionConfidenceRuleSchema = z\n  .object({\n    kind: z.enum(ACTION_CONFIDENCE_RULE_KINDS),\n    description: nullableOptional(z.string().trim().min(1).max(2000)),\n    matched: nullableOptional(z.boolean()),\n  })\n  .strict();\n\nconst actionConfidenceMemorySchema = z\n  .object({\n    source: nullableOptional(z.string().trim().min(1).max(256)),\n    created: nullableOptional(z.string().trim().min(1).max(128)),\n    updated: nullableOptional(z.string().trim().min(1).max(128)),\n    scope: nullableOptional(z.string().trim().min(1).max(512)),\n    userContextScopes: nullableOptional(z.array(z.string().trim().min(1).max(128)).max(50)),\n    retrievalReason: nullableOptional(z.string().trim().min(1).max(2000)),\n    confidence: nullableOptional(z.number().min(0).max(1)),\n    stale: nullableOptional(z.boolean()),\n    corrected: nullableOptional(z.boolean()),\n    correctionState: nullableOptional(z.enum([\"none\", \"correction\", \"superseded\", \"disputed\", \"forgotten\"])),\n    safeToUse: nullableOptional(z.boolean()),\n    safety: nullableOptional(z.enum([\"safe\", \"requires-review\", \"blocked\"])),\n    safetyReasons: nullableOptional(z.array(z.string().trim().min(1).max(1000)).max(50)),\n  })\n  .strict();\n\nexport const actionConfidenceRequestSchema = z\n  .object({\n    intendedAction: nullableOptional(z.string().trim().min(1).max(1000)),\n    confidence: nullableOptional(z.number().min(0).max(1)),\n    risk: nullableOptional(z.enum(ACTION_CONFIDENCE_RISK_CATEGORIES)),\n    contextReadiness: nullableOptional(z.enum(ACTION_CONFIDENCE_CONTEXT_READINESS)),\n    currentContextScopes: nullableOptional(z.array(z.string().trim().min(1).max(128)).max(50)),\n    userRules: nullableOptional(z.array(actionConfidenceRuleSchema).max(100)),\n    retrievedMemories: nullableOptional(z.array(actionConfidenceMemorySchema).max(200)),\n  })\n  .strict();\n\n// ---------------------------------------------------------------------------\n// Inferred types\n// ---------------------------------------------------------------------------\n\nexport type RecallRequest = z.infer<typeof recallRequestSchema>;\nexport type RecallExplainRequest = z.infer<typeof recallExplainRequestSchema>;\nexport type SetCodingContextRequest = z.infer<typeof setCodingContextRequestSchema>;\nexport type ObserveRequest = z.infer<typeof observeRequestSchema>;\nexport type MemoryStoreRequest = z.infer<typeof memoryStoreRequestSchema>;\nexport type SuggestionSubmitRequest = z.infer<typeof suggestionSubmitRequestSchema>;\nexport type ReviewDispositionRequest = z.infer<typeof reviewDispositionRequestSchema>;\nexport type TrustZonePromoteRequest = z.infer<typeof trustZonePromoteRequestSchema>;\nexport type TrustZoneDemoSeedRequest = z.infer<typeof trustZoneDemoSeedRequestSchema>;\nexport type LcmSearchRequest = z.infer<typeof lcmSearchRequestSchema>;\nexport type LcmCompactionFlushRequest = z.infer<typeof lcmCompactionFlushRequestSchema>;\nexport type ExtractionForceFlushRequest = z.infer<typeof extractionForceFlushRequestSchema>;\nexport type LcmCompactionRecordRequest = z.infer<typeof lcmCompactionRecordRequestSchema>;\nexport type DaySummaryRequest = z.infer<typeof daySummaryRequestSchema>;\nexport type CapsuleExportRequest = z.infer<typeof capsuleExportRequestSchema>;\nexport type CapsuleImportRequest = z.infer<typeof capsuleImportRequestSchema>;\nexport type CapsuleListRequest = z.infer<typeof capsuleListRequestSchema>;\nexport type OfflineSyncApplyRequest = z.infer<typeof offlineSyncApplyRequestSchema>;\nexport type OfflineSyncSnapshotRequest = z.infer<typeof offlineSyncSnapshotRequestSchema>;\nexport type OfflineSyncFilesRequest = z.infer<typeof offlineSyncFilesRequestSchema>;\nexport type OfflineSyncFileContentRequest = z.infer<typeof offlineSyncFileContentRequestSchema>;\nexport type ActionConfidenceRequest = z.infer<typeof actionConfidenceRequestSchema>;\n\n// ---------------------------------------------------------------------------\n// Validation helper\n// ---------------------------------------------------------------------------\n\nexport type SchemaName =\n  | \"recall\"\n  | \"recallExplain\"\n  | \"setCodingContext\"\n  | \"observe\"\n  | \"memoryStore\"\n  | \"suggestionSubmit\"\n  | \"reviewDisposition\"\n  | \"trustZonePromote\"\n  | \"trustZoneDemoSeed\"\n  | \"lcmSearch\"\n  | \"lcmCompactionFlush\"\n  | \"extractionForceFlush\"\n  | \"lcmCompactionRecord\"\n  | \"daySummary\"\n  | \"capsuleExport\"\n  | \"capsuleImport\"\n  | \"capsuleList\"\n  | \"offlineSyncSnapshot\"\n  | \"offlineSyncFiles\"\n  | \"offlineSyncFileContent\"\n  | \"offlineSyncApply\"\n  | \"actionConfidence\";\n\nexport type SchemaTypeFor<N extends SchemaName> =\n  N extends \"recall\" ? RecallRequest\n  : N extends \"recallExplain\" ? RecallExplainRequest\n  : N extends \"setCodingContext\" ? SetCodingContextRequest\n  : N extends \"observe\" ? ObserveRequest\n  : N extends \"memoryStore\" ? MemoryStoreRequest\n  : N extends \"suggestionSubmit\" ? SuggestionSubmitRequest\n  : N extends \"reviewDisposition\" ? ReviewDispositionRequest\n  : N extends \"trustZonePromote\" ? TrustZonePromoteRequest\n  : N extends \"trustZoneDemoSeed\" ? TrustZoneDemoSeedRequest\n  : N extends \"lcmSearch\" ? LcmSearchRequest\n  : N extends \"lcmCompactionFlush\" ? LcmCompactionFlushRequest\n  : N extends \"extractionForceFlush\" ? ExtractionForceFlushRequest\n  : N extends \"lcmCompactionRecord\" ? LcmCompactionRecordRequest\n  : N extends \"daySummary\" ? DaySummaryRequest\n  : N extends \"capsuleExport\" ? CapsuleExportRequest\n  : N extends \"capsuleImport\" ? CapsuleImportRequest\n  : N extends \"capsuleList\" ? CapsuleListRequest\n  : N extends \"offlineSyncSnapshot\" ? OfflineSyncSnapshotRequest\n  : N extends \"offlineSyncFiles\" ? OfflineSyncFilesRequest\n  : N extends \"offlineSyncFileContent\" ? OfflineSyncFileContentRequest\n  : N extends \"offlineSyncApply\" ? OfflineSyncApplyRequest\n  : N extends \"actionConfidence\" ? ActionConfidenceRequest\n  : never;\n\nconst schemas: Record<SchemaName, z.ZodTypeAny> = {\n  recall: recallRequestSchema,\n  recallExplain: recallExplainRequestSchema,\n  setCodingContext: setCodingContextRequestSchema,\n  observe: observeRequestSchema,\n  memoryStore: memoryStoreRequestSchema,\n  suggestionSubmit: suggestionSubmitRequestSchema,\n  reviewDisposition: reviewDispositionRequestSchema,\n  trustZonePromote: trustZonePromoteRequestSchema,\n  trustZoneDemoSeed: trustZoneDemoSeedRequestSchema,\n  lcmSearch: lcmSearchRequestSchema,\n  lcmCompactionFlush: lcmCompactionFlushRequestSchema,\n  extractionForceFlush: extractionForceFlushRequestSchema,\n  lcmCompactionRecord: lcmCompactionRecordRequestSchema,\n  daySummary: daySummaryRequestSchema,\n  capsuleExport: capsuleExportRequestSchema,\n  capsuleImport: capsuleImportRequestSchema,\n  capsuleList: capsuleListRequestSchema,\n  offlineSyncSnapshot: offlineSyncSnapshotRequestSchema,\n  offlineSyncFiles: offlineSyncFilesRequestSchema,\n  offlineSyncFileContent: offlineSyncFileContentRequestSchema,\n  offlineSyncApply: offlineSyncApplyRequestSchema,\n  actionConfidence: actionConfidenceRequestSchema,\n};\n\n/**\n * Validate a request body against the named schema.\n * Returns `{ success: true, data }` on pass or\n * `{ success: false, error }` on failure with field-level detail.\n */\nexport function validateRequest<T = unknown>(\n  schemaName: SchemaName,\n  body: unknown,\n): { success: true; data: T } | { success: false; error: SchemaValidationError } {\n  const schema = schemas[schemaName];\n  if (!schema) {\n    return {\n      success: false,\n      error: {\n        error: `unknown schema: ${schemaName}`,\n        code: \"validation_error\",\n        details: [],\n      },\n    };\n  }\n  const result = schema.safeParse(stripNullsExceptCodingContext(body));\n  if (result.success) {\n    return { success: true, data: result.data as T };\n  }\n  return { success: false, error: formatZodError(result.error) };\n}\n\nfunction stripNullsExceptCodingContext(data: unknown): unknown {\n  if (!data || typeof data !== \"object\" || Array.isArray(data)) return data;\n  const cleaned: Record<string, unknown> = {};\n  for (const [key, value] of Object.entries(data as Record<string, unknown>)) {\n    if (value === null && key !== \"codingContext\") continue;\n    cleaned[key] = value;\n  }\n  return cleaned;\n}\n\n"],"mappings":"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","names":[]}

package/dist/chunk-FRXS6SC7.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/briefing-window.ts"],"sourcesContent":["import { log } from \"./logger.js\";\nimport type { MemoryFile } from \"./types.js\";\nimport { isAbortError } from \"./abort-error.js\";\nimport type { CorpusReadOptions } from \"./corpus-read-cancellation.js\";\nimport type { ParsedBriefingWindow } from \"./briefing.js\";\n\ntype BriefingMemoryReader = {\n  readMemoriesWindow?: (options: { updatedAfter?: Date }) => Promise<{ memories: MemoryFile[] }>;\n  readAllMemories: ((options?: CorpusReadOptions) => Promise<MemoryFile[]>) & {\n    supportsAbortSignal?: boolean;\n  };\n  supportsAbortSignal?: boolean;\n  supportsCancellation?: boolean;\n  cancellable?: boolean;\n};\n\n/**\n * Deadline for the legacy full-read fallback (issue #2779). Storage doubles\n * that predate `readMemoriesWindow()` can only answer with a full-corpus\n * `readAllMemories()`, which is unbounded work; on a large corpus that read\n * alone can outlast the 60s MCP client timeout. Arm an AbortController with\n * this budget (well under 60s, leaving room for entity reads and follow-ups)\n * and fail open with an empty read. The deadline reaches the read as an\n * abort signal (the #2307 corpus-read contract), so the scan stops at its\n * next boundary instead of being abandoned to run on in the background.\n */\nexport const BRIEFING_FULL_READ_FALLBACK_MS = 30_000;\n\n/** Options for {@link safeReadMemories}. */\nexport interface SafeReadMemoriesOptions {\n  /** Test seam overriding {@link BRIEFING_FULL_READ_FALLBACK_MS}. */\n  fallbackDeadlineMs?: number;\n}\n\ntype BriefingReadMode = \"windowed\" | \"full-read-fallback\";\ntype BriefingReadOutcome = \"success\" | \"timeout\" | \"error\";\n\n/** Internal marker: the fallback deadline fired and the read was aborted. */\nclass BriefingReadTimedOut extends Error {\n  constructor(readonly deadlineMs: number) {\n    super(\"briefing full-read fallback timed out\");\n    this.name = \"BriefingReadTimedOut\";\n  }\n}\n\n/** Internal marker: the adapter's readAllMemories predates the signal contract. */\nclass LegacyReadUnsupported extends Error {\n  constructor() {\n    super(\"readAllMemories does not accept an abort signal\");\n    this.name = \"LegacyReadUnsupported\";\n  }\n}\n\nconst SAFE_ERROR_CLASSES: Record<string, true> = {\n  Error: true,\n  TypeError: true,\n  RangeError: true,\n  ReferenceError: true,\n  SyntaxError: true,\n  URIError: true,\n  EvalError: true,\n  AggregateError: true,\n  AbortError: true,\n  TimeoutError: true,\n  SystemError: true,\n  BriefingReadTimedOut: true,\n  LegacyReadUnsupported: true,\n  StorageError: true,\n  EngramAccessInputError: true,\n};\n\n/**\n * Sanitize adapter-controlled Error.name before structured discriminator logs\n * (issue #2827). Allow-lists known system/remnic error names and maps any\n * unrecognized or backend-controlled names to a safe bounded class (\"CustomError\").\n */\nfunction errorClass(err: unknown): string {\n  if (err instanceof Error) {\n    const name = err.name;\n    if (typeof name === \"string\" && SAFE_ERROR_CLASSES[name] === true) {\n      return name;\n    }\n    return \"CustomError\";\n  }\n  return typeof err === \"string\"\n    ? \"string\"\n    : typeof err === \"object\" && err !== null\n      ? \"object\"\n      : typeof err;\n}\n\nfunction bestEffortLog(level: \"info\" | \"warn\", message: string): void {\n  try {\n    log[level](message);\n  } catch {\n    // Diagnostics must never turn a successful or fail-open briefing read into\n    // a request failure when a host logger transport is unavailable.\n  }\n}\n\n/**\n * One structured, content-free discriminator per briefing memory read\n * (issue #2779): `mode`, `durationMs`, `count` when known, `outcome`, and on\n * failure a safe error class — never error messages or memory content.\n */\nfunction logBriefingMemoryRead(\n  mode: BriefingReadMode,\n  outcome: BriefingReadOutcome,\n  durationMs: number,\n  resultCount: number | undefined,\n  errClass: string | undefined,\n): void {\n  const fields = [\n    `mode=${mode}`,\n    `durationMs=${durationMs}`,\n    ...(resultCount === undefined ? [] : [`count=${resultCount}`]),\n    `outcome=${outcome}`,\n    ...(errClass === undefined ? [] : [`err=${errClass}`]),\n  ];\n  bestEffortLog(\"info\", `briefing: memory read ${fields.join(\" \")}`);\n}\n\n/** Read only the memories needed by a briefing, with compatibility fallback. */\nexport async function safeReadMemories(\n  storage: BriefingMemoryReader,\n  window: ParsedBriefingWindow,\n  options: SafeReadMemoriesOptions = {},\n): Promise<MemoryFile[]> {\n  const startedAt = Date.now();\n  const mode: BriefingReadMode =\n    typeof storage.readMemoriesWindow === \"function\" ? \"windowed\" : \"full-read-fallback\";\n  let outcome: BriefingReadOutcome = \"error\";\n  let resultCount: number | undefined;\n  let errClass: string | undefined;\n  try {\n    const memories = await readBriefingMemories(storage, window, mode, options);\n    outcome = \"success\";\n    resultCount = memories.length;\n    return memories;\n  } catch (err) {\n    if (err instanceof BriefingReadTimedOut) {\n      outcome = \"timeout\";\n      bestEffortLog(\n        \"warn\",\n        `briefing: memory read mode=full-read-fallback timed out after ${err.deadlineMs}ms — ` +\n          `returning no memories (storage adapter lacks readMemoriesWindow; upgrade it to ` +\n          `windowed or signal-aware reads)`,\n      );\n    } else if (err instanceof LegacyReadUnsupported) {\n      errClass = errorClass(err);\n      bestEffortLog(\n        \"warn\",\n        `briefing: memory read mode=full-read-fallback refused: readAllMemories() takes no abort ` +\n          `signal, so its scan could not be stopped at the deadline — returning no memories ` +\n          `(upgrade the storage adapter to readMemoriesWindow or a signal-aware readAllMemories)`,\n      );\n    } else {\n      errClass = errorClass(err);\n      bestEffortLog(\"warn\", `briefing: read memories failed (${errClass}) — returning no memories`);\n    }\n    return [];\n  } finally {\n    logBriefingMemoryRead(mode, outcome, Date.now() - startedAt, resultCount, errClass);\n  }\n}\n\nasync function readBriefingMemories(\n  storage: BriefingMemoryReader,\n  window: ParsedBriefingWindow,\n  mode: BriefingReadMode,\n  options: SafeReadMemoriesOptions,\n): Promise<MemoryFile[]> {\n  // A briefing only needs memories inside its lookback window. Avoid parsing\n  // the full corpus on cache misses; keep the full-read fallback for custom\n  // StorageManager-compatible callers that predate readMemoriesWindow().\n  if (mode === \"windowed\") {\n    const result = await storage.readMemoriesWindow!({ updatedAfter: window.from });\n    return result.memories;\n  }\n  // Refuse legacy adapters that do not explicitly declare cancellation support (#2827).\n  // Require affirmative cancellation support (`true` on one explicit marker) before fallback.\n  // Do not rely on Function.length, which is zero for default/rest/bound functions.\n  const isCancellable =\n    storage.supportsAbortSignal === true ||\n    storage.supportsCancellation === true ||\n    storage.cancellable === true ||\n    storage.readAllMemories?.supportsAbortSignal === true;\n  if (!isCancellable) {\n    throw new LegacyReadUnsupported();\n  }\n  const deadlineMs = options.fallbackDeadlineMs ?? BRIEFING_FULL_READ_FALLBACK_MS;\n  const controller = new AbortController();\n  let deadlineFired = false;\n  const timer = setTimeout(() => {\n    deadlineFired = true;\n    controller.abort();\n  }, deadlineMs);\n  try {\n    // Direct await, no Promise.race: the signal IS the deadline. A\n    // signal-aware read settles on abort (AbortError at its next scan\n    // boundary, #2307), so nothing is left scanning in the background once\n    // this function returns.\n    const memories = await storage.readAllMemories({ abortSignal: controller.signal });\n    if (deadlineFired) {\n      // A double that resolves partial rows instead of rejecting on abort\n      // must not have them served as a complete corpus.\n      throw new BriefingReadTimedOut(deadlineMs);\n    }\n    return memories;\n  } catch (err) {\n    if (isAbortError(err) && deadlineFired) throw new BriefingReadTimedOut(deadlineMs);\n    throw err;\n  } finally {\n    clearTimeout(timer);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-LWRIGKFM.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/storage/entity-canonical-id-lock.ts","../src/storage/entity-id-safety.ts","../src/storage/entity-canonical-id-references.ts"],"sourcesContent":["import { appendFileSync, mkdirSync, realpathSync } from \"node:fs\";\nimport path from \"node:path\";\nimport { invalidateForScope } from \"../memory-cache.js\";\nimport { serializeMutations, withHeldFileLock } from \"../utils/serialize-mutations.js\";\n\nconst ENTITY_CANONICAL_ID_MUTATION_LOCK_STALE_MS = 60_000;\nconst ENTITY_CANONICAL_ID_MUTATION_LOCK_MAX_WAIT_MS = 300_000;\n\nexport function isEntityPagePath(baseDir: string, filePath: string): boolean {\n  if (path.extname(filePath) !== \".md\") return false;\n  const parentDir = path.dirname(path.resolve(filePath));\n  const entitiesDir = path.resolve(baseDir, \"entities\");\n  if (parentDir === entitiesDir) return true;\n  try {\n    return realpathSync(parentDir) === path.join(realpathSync(baseDir), \"entities\");\n  } catch {\n    return false;\n  }\n}\n\nfunction recordRawEntityMutation(baseDir: string, stateDir: string): void {\n  invalidateForScope(baseDir, \"entity-write\");\n  mkdirSync(stateDir, { recursive: true });\n  appendFileSync(path.join(stateDir, \".entity-mutation-version.log\"), \"x\");\n}\n\nexport function withEntityCanonicalMutationLock<T>(\n  stateDir: string,\n  task: (refreshLock: () => Promise<boolean>) => Promise<T>,\n): Promise<T> {\n  const lockPath = path.join(stateDir, \"entity-canonical-id-mutation.lock\");\n  return serializeMutations(lockPath, () =>\n    withHeldFileLock(\n      lockPath,\n      {\n        staleMs: ENTITY_CANONICAL_ID_MUTATION_LOCK_STALE_MS,\n        maxWaitMs: ENTITY_CANONICAL_ID_MUTATION_LOCK_MAX_WAIT_MS,\n      },\n      async (acquired, lock) => {\n        if (!acquired) throw new Error(\"Timed out waiting for entity mutation lock.\");\n        return task(() => lock.refresh());\n      },\n    ),\n  );\n}\n\nexport async function withRawEntityPageMutation<T>(\n  baseDir: string,\n  filePath: string,\n  task: (refreshLock: () => Promise<boolean>) => Promise<T>,\n): Promise<T> {\n  if (!isEntityPagePath(baseDir, filePath)) {\n    return task(async () => true);\n  }\n  const stateDir = path.join(baseDir, \"state\");\n  return withEntityCanonicalMutationLock(stateDir, async (refreshLock) => {\n    try {\n      return await task(refreshLock);\n    } finally {\n      recordRawEntityMutation(baseDir, stateDir);\n    }\n  });\n}\n","const UNSAFE_ENTITY_ID_PATTERN = /[\\/\\\\\\p{Cc}\\p{Zl}\\p{Zp}]/u;\n\nexport function assertSafeEntityId(entityId: string): void {\n  if (UNSAFE_ENTITY_ID_PATTERN.test(entityId)) {\n    throw new Error(\"Refusing unsafe entity id containing a path separator or control character.\");\n  }\n}\n","import { statSync } from \"node:fs\";\n/**\n * Write-boundary surface of the entity canonical-id migration (issue #2213).\n *\n * The migration itself (entity-canonical-id-migration.ts) renames legacy\n * entity files and rewrites references ONCE, to convergence, then retires.\n * Everything here exists so nothing can re-introduce a legacy reference\n * afterwards without the migration having to rescan the corpus:\n *\n * - store-mediated writes canonicalize the caller-supplied `entityRef`\n *   ({@link canonicalizeEntityRefOption});\n * - bulk writers that persist raw record bytes (capsule import/merge)\n *   canonicalize the frontmatter line ({@link canonicalizeEntityRefFrontmatter});\n * - raw-byte writers that CANNOT parse what they write (offline sync,\n *   consolidation-undo, governance restores) request one bounded\n *   reconciliation pass instead ({@link requestEntityCanonicalIdReconcile}).\n */\nimport path from \"node:path\";\nimport {\n  closeSync,\n  constants,\n  fstatSync,\n  lstatSync,\n  realpathSync,\n  openSync,\n  readFileSync,\n  renameSync,\n  rmSync,\n  writeFileSync,\n} from \"node:fs\";\nimport { randomUUID } from \"node:crypto\";\nimport { log } from \"../logger.js\";\nimport { isErrnoCode } from \"../utils/errno.js\";\nimport { RECALL_FALLBACK_DIRS } from \"../utils/category-dir.js\";\nimport { withEntityCanonicalMutationLock } from \"./entity-canonical-id-lock.js\";\nimport { assertSafeEntityId } from \"./entity-id-safety.js\";\nimport { normalizeSupersessionKey } from \"../temporal-supersession.js\";\n\nexport const ENTITY_CANONICAL_ID_MIGRATION_FILE = \"entity-canonical-id-migration-v1.json\";\n\n/**\n * Parse a journal document into a mapping table. A document without a valid\n * `mappings` object is a LEGITIMATELY empty table; an unreadable/unparsable\n * document THROWS so callers can distinguish \"empty\" from \"failed\".\n */\nfunction parseJournalMappings(raw: string): Readonly<Record<string, string>> {\n  const parsed: unknown = JSON.parse(raw);\n  if (!parsed || typeof parsed !== \"object\" || Array.isArray(parsed) || !(\"mappings\" in parsed)) return {};\n  const mappings = parsed.mappings;\n  if (!mappings || typeof mappings !== \"object\" || Array.isArray(mappings)) return {};\n  // Null prototype: journal-supplied ids like `constructor` must be own\n  // entries, never collide with Object.prototype (Codex P2, round 20).\n  const cleaned: Record<string, string> = Object.create(null) as Record<string, string>;\n  for (const [legacyId, canonicalId] of Object.entries(mappings)) {\n    if (legacyId.length > 0 && typeof canonicalId === \"string\" && canonicalId.length > 0) {\n      assertSafeEntityId(legacyId);\n      assertSafeEntityId(canonicalId);\n      cleaned[legacyId] = canonicalId;\n    }\n  }\n  return cleaned;\n}\n\n/** Whether the journal says its migration completed. Throws like the mapping parser. */\nfunction parseJournalComplete(raw: string): boolean {\n  // SAFETY: JSON.parse output is unknown; the shape is validated on access.\n  const parsed = JSON.parse(raw) as { complete?: unknown };\n  return parsed !== null && parsed.complete === true;\n}\n\ntype JournalRead =\n  | { kind: \"ok\"; raw: string; key: string }\n  | { kind: \"missing\" }\n  | { kind: \"refused\" }\n  | { kind: \"error\" };\n\n/**\n * Open the journal WITHOUT following symlinks and read content + identity\n * from the same opened inode (repo rule: reject symlink traversal from\n * memory directories). O_NOFOLLOW makes the open refuse a symlinked FINAL\n * component (ELOOP); the parent `state/` directory is verified AFTER the\n * open, together with a path↔fd identity pairing, so a parent swapped\n * around the open cannot hold: a swap still in place fails the parent\n * lstat, and a swap reverted fails the dev/ino pairing against the real\n * journal. Platforms without O_NOFOLLOW get the same post-open checks.\n */\nfunction readJournalFileNoFollow(statePath: string): JournalRead {\n  let fd: number;\n  try {\n    fd = openSync(statePath, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));\n  } catch (error) {\n    if (isErrnoCode(error, \"ENOENT\")) return { kind: \"missing\" };\n    if (isErrnoCode(error, \"ELOOP\")) return { kind: \"refused\" };\n    return { kind: \"error\" };\n  }\n  try {\n    const s = fstatSync(fd);\n    if (!s.isFile()) return { kind: \"refused\" };\n    const parent = lstatSync(path.dirname(statePath));\n    if (parent.isSymbolicLink() || !parent.isDirectory()) return { kind: \"refused\" };\n    const l = lstatSync(statePath);\n    if (l.isSymbolicLink() || l.dev !== s.dev || l.ino !== s.ino) return { kind: \"refused\" };\n    return {\n      kind: \"ok\",\n      raw: readFileSync(fd, \"utf-8\"),\n      key: `${s.dev}:${s.ino}:${s.mtimeMs}:${s.ctimeMs}:${s.size}`,\n    };\n  } catch {\n    return { kind: \"error\" };\n  } finally {\n    closeSync(fd);\n  }\n}\n\nexport function loadHistoricalEntityCanonicalIds(stateDir: string): Readonly<Record<string, string>> {\n  const result = readJournalFileNoFollow(path.join(stateDir, ENTITY_CANONICAL_ID_MIGRATION_FILE));\n  if (result.kind !== \"ok\") return {};\n  try {\n    return parseJournalMappings(result.raw);\n  } catch {\n    return {};\n  }\n}\n\n/**\n * Append a tombstone with its identity canonicalized against the CURRENT\n * journal, then recheck: a peer publishing a mapping inside the\n * resolve-to-append window would leave the guard under the legacy id while\n * lookups canonicalize. Each identity change appends the replacement FIRST\n * (AGENTS.md §14 — the retired fact must never be without an active guard),\n * then revokes the superseded one — a park makes the prior canonical\n * claimant a distinct entity, and a stale keyed guard under it would\n * suppress that entity's facts. When the journal will not settle, one final\n * replacement runs under the entity MUTATION lock (parks publish under it).\n */\nexport async function appendCanonicalizedTombstone(\n  stateDir: string,\n  input: { entityRef?: string; supersessionKey?: string },\n  currentIds: () => Readonly<Record<string, string>>,\n  append: (identity: TombstoneIdentity) => Promise<string | null>,\n  revoke: (tombstoneId: string) => Promise<unknown>,\n  label: string,\n): Promise<string | null> {\n  let refIds = currentIds();\n  let identity = canonicalizeTombstoneIdentity(input.entityRef, input.supersessionKey, refIds);\n  let result = await append(identity);\n  const replaceIfChanged = async (next: TombstoneIdentity): Promise<boolean> => {\n    if (next.entityRef === identity.entityRef && next.supersessionKey === identity.supersessionKey) {\n      return false;\n    }\n    identity = next;\n    const superseded = result;\n    result = await append(next);\n    if (superseded !== null) {\n      try {\n        await revoke(superseded);\n      } catch (err) {\n        log.warn(`failed to revoke superseded tombstone ${superseded} for ${label}: ${err}`);\n      }\n    }\n    return true;\n  };\n  for (let attempt = 0; attempt < 3; attempt += 1) {\n    const fresh = currentIds();\n    if (fresh === refIds) return result;\n    refIds = fresh;\n    if (!(await replaceIfChanged(canonicalizeTombstoneIdentity(input.entityRef, input.supersessionKey, fresh)))) {\n      return result;\n    }\n  }\n  await withEntityCanonicalMutationLock(stateDir, async () => {\n    await replaceIfChanged(canonicalizeTombstoneIdentity(input.entityRef, input.supersessionKey, currentIds()));\n  });\n  return result;\n}\n\n/**\n * Journal mapping table keyed by the journal FILE's identity, so a long-lived\n * StorageManager never canonicalizes against a stale snapshot after ANY other\n * writer changes the journal — a peer process completing a migration, or\n * `pruneBlocked()` parking a contested mapping (which rewrites the journal\n * without bumping any shared version). `writeState` publishes via\n * temp-file-plus-rename, so every journal write swaps the inode and the key\n * always moves — the identity is taken from the fstat of the SAME opened\n * inode the content is read from (no stat→read window). Reload cost is one\n * open per lookup and one journal parse per actual change.\n *\n * Failure semantics: last-known data is served ONLY for the SAME state dir\n * (module-level instances can face several stores — another store's table\n * must never leak in), and a failed read/parse never commits the journal's\n * identity, so the next lookup retries instead of caching an empty table\n * under a valid key.\n */\n\n/** Journal lookup result: mapping table plus its completion flag. */\nexport type HistoricalEntityIdsEntry = {\n  mappings: Readonly<Record<string, string>>;\n  complete: boolean;\n};\n\n\n\n/**\n * Memoized journal-completion view keyed on the journal file's stat identity.\n * entityList consults completion once per listed entity; without this each\n * consult re-opens and re-reads the journal (quadratic I/O on large corpora).\n */\nexport function memoizedJournalCompletion(\n  cache: HistoricalEntityCanonicalIdCache,\n  stateDir: () => string,\n): () => boolean {\n  let memo: { key: string; complete: boolean } | undefined;\n  return (): boolean => {\n    let key = \"missing\";\n    try {\n      const journalPath = path.join(stateDir(), ENTITY_CANONICAL_ID_MIGRATION_FILE);\n      const j = statSync(journalPath);\n      key = `${j.dev}:${j.ino}:${j.mtimeMs}:${j.ctimeMs}:${j.size}`;\n    } catch {\n      key = \"missing\";\n    }\n    if (memo && memo.key === key) return memo.complete;\n    const entry = cache.getEntry(stateDir());\n    memo = { key, complete: entry.complete };\n    return memo.complete;\n  };\n}\n\nexport class HistoricalEntityCanonicalIdCache {\n  private mappings: Readonly<Record<string, string>> = {};\n  private complete = false;\n  private key: string | null = null;\n  private stateDir: string | null = null;\n\n  get(stateDir: string): Readonly<Record<string, string>> {\n    return this.getEntry(stateDir).mappings;\n  }\n\n\n  /** Table plus the journal's completion flag, cached under one identity. */\n  getEntry(stateDir: string): HistoricalEntityIdsEntry {\n    const lastKnownMappings = this.stateDir === stateDir ? this.mappings : {};\n    const lastKnownComplete = this.stateDir === stateDir ? this.complete : false;\n    const lastKnown: HistoricalEntityIdsEntry = { mappings: lastKnownMappings, complete: lastKnownComplete };\n    const result = readJournalFileNoFollow(path.join(stateDir, ENTITY_CANONICAL_ID_MIGRATION_FILE));\n    if (result.kind === \"refused\") {\n      // Symlinked/non-regular journal: never follow it, never adopt its\n      // identity — serve this store's last-known table. If it later becomes\n      // a regular file its identity differs from the stored key and reloads.\n      log.warn(\"ignoring non-regular entity canonical-id journal (symlink refused)\");\n      return lastKnown;\n    }\n    if (result.kind === \"error\") {\n      // A TRANSIENT open/read failure (EACCES/EIO) must not dump a valid\n      // table for {}: a write during the outage would skip canonicalization\n      // AND its post-write identity check would compare equal. Serve this\n      // store's last-known table; only a genuine ENOENT means \"no journal\".\n      return lastKnown;\n    }\n    const key = result.kind === \"missing\" ? \"missing\" : result.key;\n    if (key !== this.key || stateDir !== this.stateDir) {\n      let table: Readonly<Record<string, string>> = {};\n      let complete = false;\n      if (result.kind === \"ok\") {\n        try {\n          table = parseJournalMappings(result.raw);\n          complete = parseJournalComplete(result.raw);\n        } catch {\n          // Parse failed under a VALID identity: do not commit the key —\n          // the next lookup retries instead of pinning an empty table.\n          return lastKnown;\n        }\n      }\n      this.mappings = table;\n      this.complete = complete;\n      this.key = key;\n      this.stateDir = stateDir;\n    }\n    return { mappings: this.mappings, complete: this.complete };\n  }\n}\n\nexport function resolveHistoricalEntityCanonicalId(\n  normalized: string,\n  mappings: Readonly<Record<string, string>>,\n): string {\n  let current = normalized;\n  const seen = new Set<string>();\n  while (!seen.has(current)) {\n    seen.add(current);\n    // Own properties only: an unmapped id like `constructor` must not read\n    // Object.prototype and return a function (Codex P2, round 20).\n    const next = Object.hasOwn(mappings, current) ? mappings[current] : undefined;\n    if (!next || next === current) break;\n    current = next;\n  }\n  return current;\n}\n\n/**\n * Canonicalize the `entityRef` a memory-write caller supplied (issue #2213).\n *\n * Extraction and capture callers pass whatever id the LLM or user produced,\n * which can name a legacy id this migration already renamed. Resolving at the\n * WRITE boundary means store-mediated writes can never re-introduce legacy\n * references — which is what let the completed migration retire its recurring\n * full-corpus reference rewrite. It also keeps write-time tombstone lookups on\n * the same id space as migrated tombstones. Unknown ids pass through verbatim.\n */\nexport function canonicalizeEntityRefOption<T extends { entityRef?: string }>(\n  options: T,\n  mappings: Readonly<Record<string, string>>,\n): T {\n  // Non-strings (absent, or a JS caller's null/junk) pass through untouched:\n  // this boundary canonicalizes ids, it does not take over input validation\n  // the write path never performed — serialization already drops falsy refs.\n  if (typeof options.entityRef !== \"string\") return options;\n  return { ...options, entityRef: resolveHistoricalEntityCanonicalId(options.entityRef, mappings) };\n}\n\n/**\n * Canonicalize the effective `entityRef:` line inside a raw memory record's\n * leading frontmatter block (issue #2213). Bulk writers that persist record\n * bytes verbatim — capsule import/merge — are a write boundary too: a capsule\n * can carry pre-migration memories whose refs the target's completed journal\n * already renamed, and no later reconciliation pass exists to absorb them.\n *\n * Line selection mirrors the frontmatter parser and the migration's own\n * serializer: the LAST `entityRef` key wins (indentation tolerated), its\n * indent is preserved, and CRLF records keep their line endings. The closing\n * delimiter must be a standalone `---` line. Non-frontmatter content, records\n * without an `entityRef` line, and ids the journal does not map all pass\n * through byte-identical.\n */\nexport function canonicalizeEntityRefFrontmatter(\n  content: string,\n  mappings: Readonly<Record<string, string>>,\n): string {\n  if (Object.keys(mappings).length === 0) return content;\n  const loc = locateEntityRefLine(content);\n  if (loc === null) return content;\n  const canonical = resolveHistoricalEntityCanonicalId(loc.value, mappings);\n  if (canonical === loc.value) return content;\n  const line = loc.lines[loc.index]!;\n  const indent = /^\\s*/.exec(line)?.[0] ?? \"\";\n  loc.lines[loc.index] = `${indent}entityRef: ${canonical}${line.endsWith(\"\\r\") ? \"\\r\" : \"\"}`;\n  return loc.lines.join(\"\\n\") + content.slice(loc.closeIndex);\n}\n\n/** The raw `entityRef` value in a record's leading frontmatter, or null. */\nexport function readEntityRefFromFrontmatter(content: string): string | null {\n  return locateEntityRefLine(content)?.value ?? null;\n}\n\nfunction locateEntityRefLine(\n  content: string,\n): { lines: string[]; index: number; value: string; closeIndex: number } | null {\n  if (!/^---\\r?\\n/.test(content)) return null;\n  const close = /\\r?\\n---(?:\\r?\\n|$)/g;\n  close.lastIndex = content.indexOf(\"\\n\") + 1;\n  const closeMatch = close.exec(content);\n  if (!closeMatch) return null;\n  const lines = content.slice(0, closeMatch.index).split(\"\\n\");\n  let index = -1;\n  for (let i = 1; i < lines.length; i += 1) {\n    if (/^\\s*entityRef\\s*:/.test(lines[i] ?? \"\")) index = i;\n  }\n  if (index === -1) return null;\n  const line = lines[index]!;\n  const value = line.slice(line.indexOf(\":\") + 1).replace(/\\r$/, \"\").trim();\n  if (value.length === 0) return null;\n  return { lines, index, value, closeIndex: closeMatch.index };\n}\n\n/**\n * Reconcile-pending marker (issue #2213). Raw-byte memory writers that CANNOT\n * canonicalize inline — offline-sync file replication (opaque, possibly\n * encrypted buffers), consolidation-undo restores, governance-run restores —\n * touch this marker instead. The next migration invocation honors it by\n * running ONE bounded reference-reconciliation pass over the completed\n * journal's retained mappings, then clears it. This replaces the retired\n * every-run corpus rewrite with a signal that fires only when a raw writer\n * actually landed unvetted bytes.\n */\nexport const ENTITY_CANONICAL_ID_RECONCILE_MARKER = \"entity-canonical-id-reconcile.pending\";\n/** The generation a migration run renamed aside for consumption; a crash can strand it. */\nexport const ENTITY_CANONICAL_ID_RECONCILE_CONSUMING_MARKER = `${ENTITY_CANONICAL_ID_RECONCILE_MARKER}.consuming`;\n\nexport function requestEntityCanonicalIdReconcileSync(stateDir: string): void {\n  const markerPath = path.join(stateDir, ENTITY_CANONICAL_ID_RECONCILE_MARKER);\n  const temporary = `${markerPath}.${process.pid}.${randomUUID()}.tmp`;\n  try {\n    // Never write THROUGH a symlinked marker OR a symlinked state dir (repo\n    // rule: reject symlink traversal from memory directories). The parent is\n    // lstat-verified as a real directory — direct restore/import callers can\n    // reach this helper without validateRoots() — and temp-file-plus-rename\n    // handles the final component: rename() replaces a planted link ITSELF\n    // rather than following it, with no O_NOFOLLOW dependency.\n    const parent = lstatSync(stateDir);\n    if (parent.isSymbolicLink() || !parent.isDirectory()) {\n      log.warn(`refusing to write entity canonical-id reconcile marker: ${stateDir} is not a real directory`);\n      return;\n    }\n    const parentRealPath = realpathSync(stateDir);\n    writeFileSync(temporary, `${new Date().toISOString()}\\n`, { mode: 0o600 });\n    // Revalidate the parent between the temp write and publication (Codex\n    // P2, round 20): a state-dir swapped for a symlink after the check above\n    // would have landed the temp file through the link. Node has no openat,\n    // so the residual window is the realpath→rename gap — this recheck\n    // reduces check-then-use to the platform primitive's own atomicity.\n    const recheck = lstatSync(stateDir);\n    if (recheck.isSymbolicLink() || !recheck.isDirectory() || realpathSync(stateDir) !== parentRealPath) {\n      rmSync(temporary, { force: true });\n      log.warn(`refusing to publish entity canonical-id reconcile marker: ${stateDir} changed during write`);\n      return;\n    }\n    renameSync(temporary, markerPath);\n  } catch (error) {\n    rmSync(temporary, { force: true });\n    // Best effort by design: a marker failure must not fail the restore/sync\n    // that requested it (AGENTS.md §4). The reference stays legacy-but-readable\n    // until the next mapping change.\n    log.warn(`could not request entity canonical-id reconcile: ${error}`);\n  }\n}\n\nexport async function requestEntityCanonicalIdReconcile(stateDir: string): Promise<void> {\n  requestEntityCanonicalIdReconcileSync(stateDir);\n}\n\n/**\n * Post-persist TOCTOU guard (issue #2213). A writer resolves `entityRef`\n * against one journal generation, then awaits (snapshots, locks, fsyncs)\n * before its bytes land — a peer migration can publish AND finish its final\n * reference scan inside that window, leaving the just-written file behind.\n * Callers pass the mapping table captured at resolve time plus a fresh cache\n * read taken AFTER the write: the cache returns the identical object while\n * the journal file is unchanged, so an identity mismatch means the journal\n * moved mid-write and one bounded reconcile pass is requested.\n */\nexport function reconcileIfJournalMovedSync(\n  stateDir: string,\n  idsAtResolve: Readonly<Record<string, string>>,\n  idsAfterWrite: Readonly<Record<string, string>>,\n): void {\n  if (idsAtResolve === idsAfterWrite) return;\n  requestEntityCanonicalIdReconcileSync(stateDir);\n}\n\nexport async function reconcileIfJournalMoved(\n  stateDir: string,\n  idsAtResolve: Readonly<Record<string, string>>,\n  idsAfterWrite: Readonly<Record<string, string>>,\n): Promise<void> {\n  reconcileIfJournalMovedSync(stateDir, idsAtResolve, idsAfterWrite);\n}\n\n/**\n * Classify a raw write target for entity-reference handling (issue #2213):\n * - `\"memory\"` — hot recall / cold / archive record whose FRONTMATTER\n *   `entityRef` the writer must canonicalize at the write (and repair after).\n * - `\"entity\"` — an `entities/` page. Its migrated surface is relationship\n *   TARGETS in the body, which only `rewriteRelationshipTargets` understands;\n *   raw writers persist bytes faithfully and request the bounded reconcile\n *   pass instead of attempting a frontmatter rewrite.\n * - `\"outside\"` — transcripts, profiles, runtime state, and every other file\n *   outside the migration's scan scope: write byte-identical, no marker.\n */\nexport type EntityRefWritePathKind = \"memory\" | \"entity\" | \"outside\";\n\nexport function classifyEntityRefWritePath(baseDir: string, filePath: string): EntityRefWritePathKind {\n  if (!filePath.endsWith(\".md\")) return \"outside\";\n  const rel = path.relative(baseDir, filePath);\n  if (rel.startsWith(\"..\") || path.isAbsolute(rel)) return \"outside\";\n  const top = rel.split(path.sep)[0] ?? \"\";\n  if (top === \"entities\") return \"entity\";\n  return RECALL_FALLBACK_DIRS.includes(top) || top === \"cold\" || top === \"archive\" ? \"memory\" : \"outside\";\n}\n\n/** True when `filePath` is in the migration's scan scope at all. */\nexport function pathMayCarryEntityRefs(baseDir: string, filePath: string): boolean {\n  return classifyEntityRefWritePath(baseDir, filePath) !== \"outside\";\n}\n\n/**\n * Canonicalize a tombstone's identity fields at the append chokepoint\n * (issue #2213): emitters (forget, temporal supersession, pattern\n * reinforcement, supersede) build inputs from records that may have been\n * read before a peer migration completed. The supersession key embeds the\n * NORMALIZED entity segment (`entity::attr`), so it is re-prefixed when the\n * ref moved — otherwise the keyed guard lands in the legacy id space while\n * write-time lookups canonicalize, and a paraphrase resurrects.\n */\nexport interface TombstoneIdentity {\n  entityRef: string | undefined;\n  supersessionKey: string | undefined;\n}\n\nexport function canonicalizeTombstoneIdentity(\n  entityRef: string | undefined,\n  supersessionKey: string | undefined,\n  refIds: Readonly<Record<string, string>>,\n): TombstoneIdentity {\n  if (typeof entityRef !== \"string\") return { entityRef, supersessionKey };\n  const canonical = resolveHistoricalEntityCanonicalId(entityRef, refIds);\n  if (canonical === entityRef) return { entityRef, supersessionKey };\n  if (supersessionKey) {\n    const stalePrefix = `${normalizeSupersessionKey(entityRef)}::`;\n    if (supersessionKey.startsWith(stalePrefix)) {\n      supersessionKey = `${normalizeSupersessionKey(canonical)}::${supersessionKey.slice(stalePrefix.length)}`;\n    }\n  }\n  return { entityRef: canonical, supersessionKey };\n}\n\n/**\n * Post-persist repair (issue #2213): when the journal moved across a persist,\n * re-resolve the caller's ORIGINAL ref against the fresh table and rewrite\n * the file in place (bounded). When the journal will not settle, take the\n * entity MUTATION lock — parks/removals (the direction the reconcile pass\n * cannot repair, because the removed mapping is gone from the table) publish\n * under it — settle once, then request the marker for additive moves only.\n */\nexport async function repairEntityRefAfterJournalMove(options: {\n  stateDir: string;\n  currentIds: () => Readonly<Record<string, string>>;\n  idsAtResolve: Readonly<Record<string, string>>;\n  rawRef: string;\n  frontmatter: { entityRef?: string };\n  rewrite: () => Promise<void>;\n}): Promise<void> {\n  let refIds = options.idsAtResolve;\n  for (let attempt = 0; attempt < 3; attempt += 1) {\n    const fresh = options.currentIds();\n    if (fresh === refIds) return;\n    refIds = fresh;\n    const desired = resolveHistoricalEntityCanonicalId(options.rawRef, fresh);\n    if (desired === options.frontmatter.entityRef) return;\n    options.frontmatter.entityRef = desired;\n    await options.rewrite();\n  }\n  await withEntityCanonicalMutationLock(options.stateDir, async () => {\n    const desired = resolveHistoricalEntityCanonicalId(options.rawRef, options.currentIds());\n    if (desired !== options.frontmatter.entityRef) {\n      options.frontmatter.entityRef = desired;\n      await options.rewrite();\n    }\n  });\n  await requestEntityCanonicalIdReconcile(options.stateDir);\n}\n\n/**\n * Content-form counterpart of {@link repairEntityRefAfterJournalMove} for\n * async writers that persist raw record bytes (capsule import/merge,\n * binary-lifecycle redirects): same bounded loop, same locked settle.\n */\nexport async function repairContentAfterJournalMove(options: {\n  stateDir: string;\n  cache: HistoricalEntityCanonicalIdCache;\n  idsAtWrite: Readonly<Record<string, string>>;\n  rawContent: string;\n  lastWritten: string;\n  rewrite: (content: string) => Promise<void>;\n}): Promise<void> {\n  let refIds = options.idsAtWrite;\n  let written = options.lastWritten;\n  for (let attempt = 0; attempt < 3; attempt += 1) {\n    const fresh = options.cache.get(options.stateDir);\n    if (fresh === refIds) return;\n    refIds = fresh;\n    const desired = canonicalizeEntityRefFrontmatter(options.rawContent, fresh);\n    if (desired === written) return;\n    written = desired;\n    await options.rewrite(desired);\n  }\n  await withEntityCanonicalMutationLock(options.stateDir, async () => {\n    const desired = canonicalizeEntityRefFrontmatter(options.rawContent, options.cache.get(options.stateDir));\n    if (desired !== written) {\n      written = desired;\n      await options.rewrite(desired);\n    }\n  });\n  await requestEntityCanonicalIdReconcile(options.stateDir);\n}\n\n/**\n * Sync variant (space promotion, curation, review actions). Sync callers\n * cannot take the async mutation lock, so exhaustion surfaces a retryable\n * error after requesting the marker — a silent return could leave the bytes\n * on a parked canonical claimant the reconcile pass cannot restore.\n */\nexport function repairContentAfterJournalMoveSync(options: {\n  stateDir: string;\n  cache: HistoricalEntityCanonicalIdCache;\n  idsAtWrite: Readonly<Record<string, string>>;\n  rawContent: string;\n  lastWritten: string;\n  rewrite: (content: string) => void;\n}): void {\n  let refIds = options.idsAtWrite;\n  let written = options.lastWritten;\n  for (let attempt = 0; attempt < 3; attempt += 1) {\n    const fresh = options.cache.get(options.stateDir);\n    if (fresh === refIds) return;\n    refIds = fresh;\n    const desired = canonicalizeEntityRefFrontmatter(options.rawContent, fresh);\n    if (desired === written) return;\n    written = desired;\n    options.rewrite(desired);\n  }\n  requestEntityCanonicalIdReconcileSync(options.stateDir);\n  throw new Error(\n    \"entity canonical-id journal kept changing during post-write repair; retry the write\",\n  );\n}\n"],"mappings":"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","names":["path","realpathSync","path","path","realpathSync","path"]}