@remnic/core 9.64.0 → 9.64.2

package/dist/{chunk-5SZ6CLGJ.js → chunk-2QI2JBLQ.js}

@@ -17,14 +17,14 @@ import {
 } from "./chunk-46WM6JX2.js";
 import {
   normalizeQmdResultPath
-} from "./chunk-E7MYSCSL.js";
+} from "./chunk-IJXECCUV.js";
 import {
   withholdToolScopedFromSharedNamespace
 } from "./chunk-S2V7RUCL.js";
 import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier
-} from "./chunk-AR253JBM.js";
+} from "./chunk-VRYEXPRX.js";
 import {
   normalizeProjectionPreview,
   normalizeProjectionTags
@@ -259,7 +259,7 @@ import {
 } from "fs/promises";
 import { appendFileSync, createReadStream, mkdirSync, statSync as statSync2 } from "fs";
 import { createHash as createHash6 } from "crypto";
-import path12 from "path";
+import path14 from "path";
 
 // src/storage/tombstone-migration-sources.ts
 import { statSync } from "fs";
@@ -1587,6 +1587,107 @@ function renderProfileWithLastUpdated(content, updatedAt) {
   insertHeaderAfter(lines, titleIndex, header);
   return renderProfileLines(lines);
 }
+function withOkfProfileFrontmatter(content, timestamp, enabled) {
+  if (!enabled || stripOkfProfileFrontmatter(content) !== content) return content;
+  return `---
+type: Profile
+title: User Profile
+timestamp: ${timestamp}
+---
+${content}`;
+}
+function stripOkfProfileFrontmatter(content) {
+  if (!content.startsWith("---\n") && !content.startsWith("---\r\n")) return content;
+  const lines = content.split("\n");
+  for (let index = 1; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (line === "---" || line === "---\r") {
+      return lines.slice(1, index).some((l) => l.startsWith("type: Profile")) ? lines.slice(index + 1).join("\n") : content;
+    }
+    if (line === "" || line === "\r" || line === "...") return content;
+  }
+  return content;
+}
+
+// src/storage/questions-file.ts
+import path4 from "path";
+function parseQuestionFile(raw, filePath) {
+  if (!raw.startsWith("---\n")) return null;
+  const close = raw.indexOf("\n---\n\n", 4);
+  if (close === -1) return null;
+  const frontmatterStr = raw.slice(4, close);
+  const body = raw.slice(close + 6).trim();
+  const id = extractFrontmatterValue(frontmatterStr, "id") ?? path4.basename(filePath, ".md");
+  const created = extractFrontmatterValue(frontmatterStr, "created") ?? "";
+  const priority = parseFloat(extractFrontmatterValue(frontmatterStr, "priority") ?? "0.5");
+  const resolved = extractFrontmatterValue(frontmatterStr, "resolved") === "true";
+  const contextMarker = "**Context:**";
+  const contextAt = body.indexOf(contextMarker);
+  const question = contextAt === -1 ? body : body.slice(0, contextAt).trim();
+  const context = contextAt === -1 ? "" : body.slice(contextAt + contextMarker.length).trim();
+  return { id, question, context, priority, resolved, created, filePath };
+}
+function extractFrontmatterValue(frontmatter, key) {
+  const prefix = `${key}:`;
+  for (const line of frontmatter.split("\n")) {
+    if (!line.startsWith(prefix)) continue;
+    let value = line.slice(prefix.length).trim();
+    if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) {
+      value = value.slice(1, -1);
+    }
+    return value;
+  }
+  return null;
+}
+
+// src/okf/type-mapping.ts
+import path5 from "path";
+var OKF_TYPE_BY_CATEGORY = Object.freeze({
+  fact: "Memory Fact",
+  decision: "Decision",
+  preference: "Preference",
+  commitment: "Commitment",
+  relationship: "Relationship",
+  principle: "Principle",
+  moment: "Moment",
+  skill: "Skill",
+  correction: "Correction",
+  rule: "Rule"
+});
+var OKF_TYPE_FALLBACK = "Memory";
+function okfTypeForCategory(category) {
+  return OKF_TYPE_BY_CATEGORY[category] ?? OKF_TYPE_FALLBACK;
+}
+function okfTypeForMemory(fm) {
+  return fm.artifactType ? "Artifact" : okfTypeForCategory(fm.category);
+}
+var OKF_TYPE_BY_ENTITY_KIND = Object.freeze({
+  person: "Person",
+  company: "Company",
+  organization: "Organization",
+  project: "Project",
+  topic: "Topic",
+  technology: "Technology",
+  place: "Place",
+  event: "Event"
+});
+function okfTypeForEntityKind(kind) {
+  const normalized = kind?.trim().toLowerCase();
+  return normalized !== void 0 && OKF_TYPE_BY_ENTITY_KIND[normalized] || "Entity";
+}
+var OKF_QUESTION_TYPE = "Question";
+var OKF_RESERVED_BASENAMES = Object.freeze({
+  "index.md": true,
+  "log.md": true
+});
+function assertNotOkfReservedBasename(filePath) {
+  const basename = path5.basename(filePath);
+  if (OKF_RESERVED_BASENAMES[basename] === true) {
+    throw new Error(
+      `OKF reserved basename '${basename}' is not a valid memory file target (${filePath}); OKF \xA76/\xA77 reserves it for bundle-level files.`
+    );
+  }
+}
 
 // src/orchestration/self-deps.ts
 function selfDeps(self) {
@@ -1609,7 +1710,7 @@ function selfDeps(self) {
 
 // src/storage/entity-store.ts
 import { readdir as readdir2, unlink } from "fs/promises";
-import path4 from "path";
+import path6 from "path";
 var EntityStore = class {
   constructor(deps) {
     this.deps = deps;
@@ -1629,7 +1730,7 @@ var EntityStore = class {
   async readEntityForMutation(name, method, historicalIds) {
     const canonical = resolveHistoricalEntityCanonicalId(name, historicalIds);
     for (const candidate of canonical === name ? [name] : [canonical, name]) {
-      const filePath = path4.join(this.deps.entitiesDir, `${candidate}.md`);
+      const filePath = path6.join(this.deps.entitiesDir, `${candidate}.md`);
       try {
         const entity = parseEntityFile(await this.deps.readStorageSecureFile(filePath), this.deps.entitySchemas);
         return { filePath, entity };
@@ -1654,7 +1755,7 @@ var EntityStore = class {
    * `mutate` returns false to skip the write. Resolves true when written.
    */
   async mutateEntityFile(name, method, mutate) {
-    const stateDir = path4.join(this.deps.baseDir, "state");
+    const stateDir = path6.join(this.deps.baseDir, "state");
     return withEntityCanonicalMutationLock(stateDir, async () => {
       for (let attempt = 0; attempt < 3; attempt += 1) {
         const idsAtResolve = this.deps.currentHistoricalIds();
@@ -1665,7 +1766,7 @@ var EntityStore = class {
         located.entity.updated = (/* @__PURE__ */ new Date()).toISOString();
         await this.deps.writeStorageSecureFile(
           located.filePath,
-          serializeEntityFile(located.entity, this.deps.entitySchemas)
+          serializeEntityFile(located.entity, this.deps.entitySchemas, this.deps.okfConformanceEnabled())
         );
         reconcileIfJournalMovedSync(stateDir, idsAtResolve, this.deps.currentHistoricalIds());
         this.deps.invalidateKnowledgeIndexCache();
@@ -1709,7 +1810,7 @@ var EntityStore = class {
   async writeEntity(name, type, facts, options = {}) {
     await this.deps.ensureDirectories();
     return withEntityCanonicalMutationLock(
-      path4.join(this.deps.baseDir, "state"),
+      path6.join(this.deps.baseDir, "state"),
       () => this.writeEntityUnlocked(name, type, facts, options)
     );
   }
@@ -1730,7 +1831,7 @@ var EntityStore = class {
       log.debug(`fuzzy match: "${normalized}" \u2192 existing "${match}"`);
       normalized = match;
     }
-    const filePath = path4.join(this.deps.entitiesDir, `${normalized}.md`);
+    const filePath = path6.join(this.deps.entitiesDir, `${normalized}.md`);
     let entity = {
       name,
       type,
@@ -1819,7 +1920,7 @@ var EntityStore = class {
     entity.created = entity.created || timestamp;
     entity.updated = (/* @__PURE__ */ new Date()).toISOString();
     await this.deps.snapshotBeforeWrite(filePath, "write");
-    await this.deps.writeStorageSecureFile(filePath, serializeEntityFile(entity, this.deps.entitySchemas));
+    await this.deps.writeStorageSecureFile(filePath, serializeEntityFile(entity, this.deps.entitySchemas, this.deps.okfConformanceEnabled()));
     this.deps.invalidateKnowledgeIndexCache();
     this.deps.bumpMemoryStatusVersion();
     this.deps.bumpEntityMutationVersion();
@@ -1851,13 +1952,13 @@ var EntityStore = class {
   /** Re-serialize every entity file into the compiled-truth timeline shape. */
   async migrateEntityFilesToCompiledTruthTimeline() {
     const entityNames = await this.listEntityNames();
-    const stateDir = path4.join(this.deps.baseDir, "state");
+    const stateDir = path6.join(this.deps.baseDir, "state");
     let migrated = 0;
     for (const entityName of entityNames) {
       const wrote = await withEntityCanonicalMutationLock(stateDir, async () => {
         const raw = await this.readEntity(entityName);
         if (!raw) return false;
-        const serialized = serializeEntityFile(parseEntityFile(raw, this.deps.entitySchemas), this.deps.entitySchemas);
+        const serialized = serializeEntityFile(parseEntityFile(raw, this.deps.entitySchemas), this.deps.entitySchemas, this.deps.okfConformanceEnabled());
         if (raw.trimEnd() === serialized.trimEnd()) return false;
         const filePath = this.deps.resolveEntityFilePath(entityName);
         if (filePath === null) return false;
@@ -1878,12 +1979,12 @@ var EntityStore = class {
    */
   async updateEntitySynthesis(name, synthesis, options = {}) {
     return withEntityCanonicalMutationLock(
-      path4.join(this.deps.baseDir, "state"),
+      path6.join(this.deps.baseDir, "state"),
       () => this.updateEntitySynthesisUnlocked(name, synthesis, options)
     );
   }
   async updateEntitySynthesisUnlocked(name, synthesis, options = {}) {
-    const filePath = path4.join(this.deps.entitiesDir, `${name}.md`);
+    const filePath = path6.join(this.deps.entitiesDir, `${name}.md`);
     let entity;
     try {
       const content = await this.deps.readStorageSecureFile(filePath);
@@ -1907,7 +2008,7 @@ var EntityStore = class {
     entity.synthesisStructuredFactDigest = synthesisStructuredFactDigest;
     entity.synthesisVersion = Math.max(0, entity.synthesisVersion ?? 0) + (options.incrementVersion === false ? 0 : 1);
     entity.updated = entityUpdatedAt;
-    await this.deps.writeStorageSecureFile(filePath, serializeEntityFile(entity, this.deps.entitySchemas));
+    await this.deps.writeStorageSecureFile(filePath, serializeEntityFile(entity, this.deps.entitySchemas, this.deps.okfConformanceEnabled()));
     await this.deps.removeEntitySynthesisQueueEntries([
       .../* @__PURE__ */ new Set([name, this.deps.normalizeEntityName(entity.name, entity.type)])
     ]);
@@ -1941,7 +2042,7 @@ var EntityStore = class {
         const results = await Promise.all(
           batch.map(async (entry) => {
             try {
-              return await this.deps.readStorageSecureFile(path4.join(this.deps.entitiesDir, entry));
+              return await this.deps.readStorageSecureFile(path6.join(this.deps.entitiesDir, entry));
             } catch (err) {
               if (err instanceof SecureStoreLockedError) throw err;
               if (!isErrnoCode(err, "ENOENT")) throw err;
@@ -2016,7 +2117,7 @@ ${rows.join("\n")}
    */
   async mergeFragmentedEntities() {
     return withEntityCanonicalMutationLock(
-      path4.join(this.deps.baseDir, "state"),
+      path6.join(this.deps.baseDir, "state"),
       () => this.mergeFragmentedEntitiesUnlocked()
     );
   }
@@ -2061,7 +2162,7 @@ ${rows.join("\n")}
           extraSections: []
         };
         for (const file of files) {
-          const filePath = path4.join(this.deps.entitiesDir, file);
+          const filePath = path6.join(this.deps.entitiesDir, file);
           try {
             const content = await this.deps.readStorageSecureFile(filePath);
             const parsed = parseEntityFile(content, this.deps.entitySchemas);
@@ -2214,11 +2315,11 @@ ${rows.join("\n")}
         }
         mergedEntity.created = mergedEntity.created || mergedEntity.updated || (/* @__PURE__ */ new Date()).toISOString();
         mergedEntity.updated = mergedEntity.updated || (/* @__PURE__ */ new Date()).toISOString();
-        const canonicalPath = path4.join(this.deps.entitiesDir, `${canonical}.md`);
-        await this.deps.writeStorageSecureFile(canonicalPath, serializeEntityFile(mergedEntity, this.deps.entitySchemas));
+        const canonicalPath = path6.join(this.deps.entitiesDir, `${canonical}.md`);
+        await this.deps.writeStorageSecureFile(canonicalPath, serializeEntityFile(mergedEntity, this.deps.entitySchemas, this.deps.okfConformanceEnabled()));
         this.deps.bumpEntityMutationVersion();
         for (const file of files) {
-          const filePath = path4.join(this.deps.entitiesDir, file);
+          const filePath = path6.join(this.deps.entitiesDir, file);
           if (filePath !== canonicalPath) {
             try {
               await unlink(filePath);
@@ -2238,7 +2339,7 @@ ${rows.join("\n")}
 
 // src/storage/identity-continuity-store.ts
 import { readdir as readdir3 } from "fs/promises";
-import path5 from "path";
+import path7 from "path";
 var IdentityContinuityStore = class {
   constructor(deps) {
     this.deps = deps;
@@ -2263,7 +2364,7 @@ var IdentityContinuityStore = class {
     const date = nowIso.slice(0, 10);
     const id = this.deps.generateId("incident");
     const incident = createContinuityIncidentRecord(id, input, nowIso);
-    const filePath = path5.join(this.deps.identityIncidentsDir, `${date}-${id}.md`);
+    const filePath = path7.join(this.deps.identityIncidentsDir, `${date}-${id}.md`);
     await this.deps.writeStorageSecureFile(filePath, serializeContinuityIncident(incident));
     return { ...incident, filePath };
   }
@@ -2276,7 +2377,7 @@ var IdentityContinuityStore = class {
       const incidents = [];
       for (const file of candidates) {
         if (incidents.length >= cappedLimit) break;
-        const filePath = path5.join(this.deps.identityIncidentsDir, file);
+        const filePath = path7.join(this.deps.identityIncidentsDir, file);
         try {
           const raw = await this.deps.readStorageSecureFile(filePath);
           const parsed = parseContinuityIncident(raw);
@@ -2307,7 +2408,7 @@ var IdentityContinuityStore = class {
     await this.deps.ensureDirectories();
     const safeKey = this.sanitizeIdentityAuditKey(key);
     const dir = period === "weekly" ? this.deps.identityAuditsWeeklyDir : this.deps.identityAuditsMonthlyDir;
-    const filePath = path5.join(dir, `${safeKey}.md`);
+    const filePath = path7.join(dir, `${safeKey}.md`);
     await this.deps.writeStorageSecureFile(filePath, content);
     return filePath;
   }
@@ -2315,7 +2416,7 @@ var IdentityContinuityStore = class {
     try {
       const safeKey = this.sanitizeIdentityAuditKey(key);
       const dir = period === "weekly" ? this.deps.identityAuditsWeeklyDir : this.deps.identityAuditsMonthlyDir;
-      return await this.deps.readStorageSecureFile(path5.join(dir, `${safeKey}.md`));
+      return await this.deps.readStorageSecureFile(path7.join(dir, `${safeKey}.md`));
     } catch (err) {
       if (err instanceof Error && err.message === "Invalid identity audit key") return null;
       if (!isErrnoCode(err, "ENOENT")) throw err;
@@ -2371,12 +2472,12 @@ var IdentityContinuityStore = class {
     const fileNames = await this.readContinuityIncidentFileNames();
     const directMatch = fileNames.find((name) => name.endsWith(`-${id}.md`));
     if (directMatch) {
-      const directPath = path5.join(this.deps.identityIncidentsDir, directMatch);
+      const directPath = path7.join(this.deps.identityIncidentsDir, directMatch);
       const parsed = await this.readContinuityIncidentFile(directPath);
       if (parsed?.id === id) return directPath;
     }
     for (const fileName of fileNames) {
-      const filePath = path5.join(this.deps.identityIncidentsDir, fileName);
+      const filePath = path7.join(this.deps.identityIncidentsDir, fileName);
       const parsed = await this.readContinuityIncidentFile(filePath);
       if (parsed?.id === id) return filePath;
     }
@@ -2404,7 +2505,7 @@ import {
   unlink as unlink2,
   writeFile
 } from "fs/promises";
-import path6 from "path";
+import path8 from "path";
 import { z } from "zod";
 var ENTITY_CANONICAL_ID_MIGRATION_VERSION = 1;
 var ENTITY_CANONICAL_ID_MIGRATION_LOCK_STALE_MS = 6e4;
@@ -2438,7 +2539,7 @@ async function fingerprintPath(filePath) {
 async function fingerprintEntityEntries(entitiesDir) {
   let names;
   try {
-    names = (await readdir4(entitiesDir)).filter((name) => path6.extname(name) === ".md").sort();
+    names = (await readdir4(entitiesDir)).filter((name) => path8.extname(name) === ".md").sort();
   } catch (error) {
     if (isErrnoCode(error, "ENOENT")) return "missing";
     throw error;
@@ -2447,7 +2548,7 @@ async function fingerprintEntityEntries(entitiesDir) {
   for (const name of names) {
     hash.update(`${name.length}:${name}:`);
     try {
-      const entry = await lstat2(path6.join(entitiesDir, name), { bigint: true });
+      const entry = await lstat2(path8.join(entitiesDir, name), { bigint: true });
       hash.update(`${entry.dev}:${entry.ino}:${entry.size}:${entry.mtimeNs}:${entry.ctimeNs}`);
     } catch (error) {
       if (!isErrnoCode(error, "ENOENT")) throw error;
@@ -2467,9 +2568,9 @@ async function getFingerprint(baseDir, entitiesDir, getEntityMutationVersion) {
   ] = await Promise.all([
     fingerprintPath(entitiesDir),
     fingerprintEntityEntries(entitiesDir),
-    fingerprintPath(path6.join(baseDir, "config", "aliases.json")),
-    fingerprintPath(path6.join(baseDir, "state", ENTITY_CANONICAL_ID_RECONCILE_MARKER)),
-    fingerprintPath(path6.join(baseDir, "state", ENTITY_CANONICAL_ID_RECONCILE_CONSUMING_MARKER))
+    fingerprintPath(path8.join(baseDir, "config", "aliases.json")),
+    fingerprintPath(path8.join(baseDir, "state", ENTITY_CANONICAL_ID_RECONCILE_MARKER)),
+    fingerprintPath(path8.join(baseDir, "state", ENTITY_CANONICAL_ID_RECONCILE_CONSUMING_MARKER))
   ]);
   return [
     entityDirectoryFingerprint,
@@ -2495,8 +2596,8 @@ async function validateRoots(baseDir, entitiesDir, stateDir, archiveDir) {
   const roots = [
     entitiesDir,
     stateDir,
-    ...RECALL_FALLBACK_DIRS.map((directory) => path6.join(baseDir, directory)),
-    path6.join(baseDir, "cold"),
+    ...RECALL_FALLBACK_DIRS.map((directory) => path8.join(baseDir, directory)),
+    path8.join(baseDir, "cold"),
     archiveDir
   ];
   for (const root of roots) {
@@ -2514,7 +2615,7 @@ async function validateRoots(baseDir, entitiesDir, stateDir, archiveDir) {
   }
 }
 function statePath(deps) {
-  return path6.join(deps.stateDir, ENTITY_CANONICAL_ID_MIGRATION_FILE);
+  return path8.join(deps.stateDir, ENTITY_CANONICAL_ID_MIGRATION_FILE);
 }
 async function assertSafeMigrationStateFile(deps) {
   const migrationStatePath = statePath(deps);
@@ -2557,7 +2658,7 @@ async function assertSafeTombstoneFile(deps, tombstonePath) {
   return true;
 }
 function lockPath(deps) {
-  return path6.join(deps.stateDir, "entity-canonical-id-migration.lock");
+  return path8.join(deps.stateDir, "entity-canonical-id-migration.lock");
 }
 async function readState(deps) {
   await assertSafeMigrationStateFile(deps);
@@ -2655,7 +2756,7 @@ async function readSafeEntityEntries(entitiesDir) {
   }
   const entries = await readdir4(entitiesDir);
   for (const entry of entries) {
-    await assertNotSymlink(path6.join(entitiesDir, entry), entry);
+    await assertNotSymlink(path8.join(entitiesDir, entry), entry);
   }
   return entries;
 }
@@ -2717,7 +2818,7 @@ async function rewriteReferences(deps, mappings, refreshLock) {
     const seenPaths = /* @__PURE__ */ new Set();
     let rewroteAny = false;
     for (const memory of [...hotMemories, ...coldMemories, ...archivedMemories]) {
-      const memoryPath = path6.resolve(memory.path);
+      const memoryPath = path8.resolve(memory.path);
       if (seenPaths.has(memoryPath)) continue;
       seenPaths.add(memoryPath);
       const previousEntityRef = memory.frontmatter.entityRef;
@@ -2749,7 +2850,7 @@ async function rewriteReferences(deps, mappings, refreshLock) {
         latestCanonicalId
       );
       rewroteAny = true;
-      rewroteColdMemory ||= latestMemory.path.includes(`${path6.sep}cold${path6.sep}`);
+      rewroteColdMemory ||= latestMemory.path.includes(`${path8.sep}cold${path8.sep}`);
     }
     if (!rewroteAny) return { rewroteColdMemory };
   }
@@ -2788,7 +2889,7 @@ function rewriteTombstoneLine(line, mappings, normalizedMappings) {
   return changed ? JSON.stringify(tombstone) : line;
 }
 async function rewriteTombstoneReferences(deps, mappings, refreshLock) {
-  const tombstonePath = path6.join(deps.stateDir, "tombstones.jsonl");
+  const tombstonePath = path8.join(deps.stateDir, "tombstones.jsonl");
   const normalizedMappings = /* @__PURE__ */ new Map();
   for (const [legacyId, canonicalId] of Object.entries(mappings)) {
     const normalizedLegacyId = normalizeSupersessionKey(legacyId);
@@ -2797,7 +2898,7 @@ async function rewriteTombstoneReferences(deps, mappings, refreshLock) {
     }
   }
   await withHeldFileLock(
-    path6.join(deps.stateDir, "tombstones.lock"),
+    path8.join(deps.stateDir, "tombstones.lock"),
     {
       staleMs: TOMBSTONE_LOCK_STALE_MS,
       maxWaitMs: TOMBSTONE_LOCK_MAX_WAIT_MS
@@ -3036,8 +3137,8 @@ async function migrateLegacyEntityCanonicalIds(deps) {
       if (!acquired) throw new Error("Timed out waiting for active entity canonical-id migration.");
       await deps.validateMemoryScanRoots?.();
       await readSafeEntityEntries(deps.entitiesDir);
-      const reconcileMarkerPath = path6.join(deps.stateDir, ENTITY_CANONICAL_ID_RECONCILE_MARKER);
-      const consumingMarkerPath = path6.join(deps.stateDir, ENTITY_CANONICAL_ID_RECONCILE_CONSUMING_MARKER);
+      const reconcileMarkerPath = path8.join(deps.stateDir, ENTITY_CANONICAL_ID_RECONCILE_MARKER);
+      const consumingMarkerPath = path8.join(deps.stateDir, ENTITY_CANONICAL_ID_RECONCILE_CONSUMING_MARKER);
       let reconcileRequested = await fileExists(consumingMarkerPath);
       if (await fileExists(reconcileMarkerPath)) {
         try {
@@ -3433,7 +3534,7 @@ import {
   readFileSync,
   realpathSync
 } from "fs";
-import path7 from "path";
+import path9 from "path";
 function resolveSafeAliasRoots(baseDir, configDir) {
   let baseStat;
   try {
@@ -3460,8 +3561,8 @@ function resolveSafeAliasRoots(baseDir, configDir) {
   return memoryRoot;
 }
 function readEntityAliasConfigSync(baseDir) {
-  const configDir = path7.join(baseDir, "config");
-  const aliasPath = path7.join(configDir, "aliases.json");
+  const configDir = path9.join(baseDir, "config");
+  const aliasPath = path9.join(configDir, "aliases.json");
   let memoryRoot = resolveSafeAliasRoots(baseDir, configDir);
   if (memoryRoot === void 0) return void 0;
   let aliasPreflight;
@@ -3522,7 +3623,7 @@ function decodeYamlScalar(value) {
 }
 
 // src/orchestration/qmd-result-resolver.ts
-import path8 from "path";
+import path10 from "path";
 var INTERNAL_QMD_ROOTS = /* @__PURE__ */ new Set([
   ...ALL_CATEGORY_DIRS,
   "activity",
@@ -3532,6 +3633,7 @@ var INTERNAL_QMD_ROOTS = /* @__PURE__ */ new Set([
   "config",
   "entities",
   "identity",
+  "locations",
   "meetings",
   "namespaces",
   "state",
@@ -3543,7 +3645,7 @@ var INTERNAL_QMD_ROOTS = /* @__PURE__ */ new Set([
 ]);
 var PRIVATE_RESULT_RESOLUTION_CONCURRENCY = 16;
 function qmdCollectionPathParts(resultPath) {
-  if (!resultPath || path8.isAbsolute(resultPath)) return null;
+  if (!resultPath || path10.isAbsolute(resultPath)) return null;
   if (resultPath.trim().startsWith("qmd://")) {
     try {
       const parsed = new URL(resultPath.trim());
@@ -3568,9 +3670,9 @@ function qmdCollectionPathParts(resultPath) {
 }
 function qmdResultPathCandidates(storageDir, resultPath) {
   const candidates = /* @__PURE__ */ new Set();
-  const storageRoot = path8.resolve(storageDir);
+  const storageRoot = path10.resolve(storageDir);
   const addCandidate = (candidate) => {
-    const resolved = path8.resolve(candidate);
+    const resolved = path10.resolve(candidate);
     if (isPathInsideStorageRoot(storageRoot, resolved)) {
       candidates.add(resolved);
     }
@@ -3578,18 +3680,18 @@ function qmdResultPathCandidates(storageDir, resultPath) {
   const addRelativeCandidates = (relativePath) => {
     const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
     if (!normalized) return;
-    addCandidate(path8.join(storageRoot, normalized));
+    addCandidate(path10.join(storageRoot, normalized));
     if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
-      addCandidate(path8.join(storageRoot, "facts", normalized));
+      addCandidate(path10.join(storageRoot, "facts", normalized));
     }
   };
-  if (path8.isAbsolute(resultPath)) {
+  if (path10.isAbsolute(resultPath)) {
     addCandidate(resultPath);
-    const relative2 = path8.relative(storageRoot, path8.resolve(resultPath));
-    if (relative2 && !relative2.startsWith("..") && !path8.isAbsolute(relative2)) {
-      const normalized = relative2.split(path8.sep).join("/");
+    const relative2 = path10.relative(storageRoot, path10.resolve(resultPath));
+    if (relative2 && !relative2.startsWith("..") && !path10.isAbsolute(relative2)) {
+      const normalized = relative2.split(path10.sep).join("/");
       if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
-        addCandidate(path8.join(storageRoot, "facts", normalized));
+        addCandidate(path10.join(storageRoot, "facts", normalized));
       }
     }
   } else {
@@ -3625,7 +3727,7 @@ var QmdResultResolver = class {
       const seenStorageDirs = /* @__PURE__ */ new Set();
       const addStorage = (storage) => {
         const storageDir = storageDirOrNull(storage);
-        const storageKey = storageDir ? path8.resolve(storageDir) : `storage-without-dir-${storages.length}`;
+        const storageKey = storageDir ? path10.resolve(storageDir) : `storage-without-dir-${storages.length}`;
         if (seenStorageDirs.has(storageKey)) return;
         seenStorageDirs.add(storageKey);
         storages.push(storage);
@@ -3655,7 +3757,7 @@ var QmdResultResolver = class {
           continue;
         }
         try {
-          const coldRoot = path8.join(storageDir, "cold");
+          const coldRoot = path10.join(storageDir, "cold");
           for (const candidate of qmdResultPathCandidates(coldRoot, parts.relativePath)) {
             const memory = await storage.readMemoryByPath(candidate);
             if (memory) return memory;
@@ -3705,9 +3807,9 @@ var QmdResultResolver = class {
           error: err.message
         });
       }
-      if (!path8.isAbsolute(fallbackResultPath)) return null;
+      if (!path10.isAbsolute(fallbackResultPath)) return null;
     }
-    if (path8.isAbsolute(fallbackResultPath)) {
+    if (path10.isAbsolute(fallbackResultPath)) {
       if (!fallbackStorageDir) {
         return await fallbackStorage.readMemoryByPath(fallbackResultPath);
       }
@@ -3764,17 +3866,17 @@ var QmdResultResolver = class {
     if (!memory && parts && !collectionIsKnownInternal && !collectionIsConfigured) {
       memory = await this.readQmdResultMemory(parts.relativePath, fallbackStorage, namespaces, result.namespace);
     }
-    const absoluteInsideMemoryRoot = path8.isAbsolute(result.path) && isPathInsideStorageRoot(path8.resolve(config.memoryDir), path8.resolve(result.path));
+    const absoluteInsideMemoryRoot = path10.isAbsolute(result.path) && isPathInsideStorageRoot(path10.resolve(config.memoryDir), path10.resolve(result.path));
     const hasExplicitQmdCollection = result.path.trim().startsWith("qmd://");
     const unresolvedInternalPath = !memory && (absoluteInsideMemoryRoot || collectionIsKnownInternal && (!preserveUnresolved || hasExplicitQmdCollection) || hasExplicitQmdCollection && collectionIsConfigured);
-    const unresolvedExternalCollection = !memory && (parts !== null && !collectionIsKnownInternal && !collectionIsConfigured || path8.isAbsolute(result.path) && !isPathInsideStorageRoot(path8.resolve(config.memoryDir), path8.resolve(result.path)));
+    const unresolvedExternalCollection = !memory && (parts !== null && !collectionIsKnownInternal && !collectionIsConfigured || path10.isAbsolute(result.path) && !isPathInsideStorageRoot(path10.resolve(config.memoryDir), path10.resolve(result.path)));
     return memory !== null && !isSupportPassportPrivateMemory(memory) || !memory && !unresolvedInternalPath && (preserveUnresolved || unresolvedExternalCollection);
   }
   async resolveColdQmdResultForRecall(result, fallbackStorage, recallNamespaces = []) {
     const memory = await this.readQmdResultMemory(result.path, fallbackStorage, recallNamespaces, result.namespace);
     if (!memory) return null;
     let ownerNamespace = null;
-    if (path8.isAbsolute(memory.path)) {
+    if (path10.isAbsolute(memory.path)) {
       const ownerStorage = await this.storageForAbsoluteQmdResultPath(memory.path, fallbackStorage, recallNamespaces);
       ownerNamespace = ownerStorage?.namespace ?? null;
       if (!ownerNamespace && resolveNamespaceCapabilities(this.getConfig()).namespaces) return null;
@@ -3795,17 +3897,17 @@ var QmdResultResolver = class {
     };
   }
   async storageForAbsoluteQmdResultPath(resultPath, fallbackStorage, recallNamespaces = []) {
-    const resolvedPath = path8.resolve(resultPath);
+    const resolvedPath = path10.resolve(resultPath);
     const config = this.getConfig();
-    const memoryRoot = path8.resolve(config.memoryDir);
-    const namespacesRoot = path8.join(memoryRoot, "namespaces");
+    const memoryRoot = path10.resolve(config.memoryDir);
+    const namespacesRoot = path10.join(memoryRoot, "namespaces");
     const fallbackStorageDir = storageDirOrNull(fallbackStorage);
     const matches = [];
     const seenDirs = /* @__PURE__ */ new Set();
     const maybeAddStorage = (storage, namespace) => {
       const storageDir = storageDirOrNull(storage);
       if (!storageDir) return;
-      const candidateRoot = path8.resolve(storageDir);
+      const candidateRoot = path10.resolve(storageDir);
       if (seenDirs.has(candidateRoot)) return;
       if (!isPathInsideStorageRoot(candidateRoot, resolvedPath)) return;
       if (candidateRoot === memoryRoot && isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
@@ -3823,7 +3925,7 @@ var QmdResultResolver = class {
       candidateNamespaces.add(ns);
     }
     if (isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
-      const relativeToNamespaces = path8.relative(namespacesRoot, resolvedPath);
+      const relativeToNamespaces = path10.relative(namespacesRoot, resolvedPath);
       const [namespaceSegment] = relativeToNamespaces.split(/[\\/]/);
       if (namespaceSegment) {
         candidateNamespaces.add(namespaceIdentityFromToken(namespaceSegment) ?? namespaceSegment);
@@ -4469,7 +4571,7 @@ function fuseDay(date, inputs, options = {}) {
 
 // src/wearables/fusion/store.ts
 import { createHash as createHash3 } from "crypto";
-import * as path9 from "path";
+import * as path11 from "path";
 var FUSION_KIND = "wearable-fusion";
 function hashFusionBody(conversations) {
   return createHash3("sha256").update(JSON.stringify(conversations), "utf-8").digest("hex");
@@ -4656,7 +4758,7 @@ var FusionArtifactStore = class {
         `invalid wearable fusion date '${String(date)}' \u2014 expected YYYY-MM-DD`
       );
     }
-    return path9.join(this.wearablesDir, FUSION_DIR_NAME, `${date}.md`);
+    return path11.join(this.wearablesDir, FUSION_DIR_NAME, `${date}.md`);
   }
   async writeFusedDay(date, serialized) {
     const filePath = this.fusedDayPath(date);
@@ -4693,7 +4795,7 @@ var FusionArtifactStore = class {
   }
   /** List dates with stored fused artifacts, newest first. */
   async listFusedDays() {
-    const fusionDir = path9.join(this.wearablesDir, FUSION_DIR_NAME);
+    const fusionDir = path11.join(this.wearablesDir, FUSION_DIR_NAME);
     await this.assertPathContained(fusionDir);
     let entries;
     try {
@@ -4737,10 +4839,10 @@ var FusionArtifactStore = class {
     try {
       rootReal = await this.io.realpath(this.memoryDir);
     } catch {
-      rootReal = path9.resolve(this.memoryDir);
+      rootReal = path11.resolve(this.memoryDir);
     }
     await this.assertNoEscape(rootReal, this.wearablesDir);
-    await this.assertNoEscape(rootReal, path9.dirname(targetPath));
+    await this.assertNoEscape(rootReal, path11.dirname(targetPath));
     await this.assertNoEscape(rootReal, targetPath);
     await this.assertFusionDirNotSymlinked();
   }
@@ -4754,7 +4856,7 @@ var FusionArtifactStore = class {
    * (a fresh write creates a real directory lexically under the root).
    */
   async assertFusionDirNotSymlinked() {
-    const fusionDir = path9.join(this.wearablesDir, FUSION_DIR_NAME);
+    const fusionDir = path11.join(this.wearablesDir, FUSION_DIR_NAME);
     let stat4;
     try {
       stat4 = await this.io.lstat(fusionDir);
@@ -4890,7 +4992,7 @@ function reconstructFusionInputs(date, dayTranscripts) {
 
 // src/meetings/store.ts
 import { createHash as createHash4 } from "crypto";
-import * as path10 from "path";
+import * as path12 from "path";
 var MEETINGS_DIR_NAME = "meetings";
 var MEETING_KIND = "meeting";
 var MEETING_FORMAT_VERSION = 1;
@@ -5059,7 +5161,7 @@ var MeetingRecordStore = class {
   constructor(memoryDir, io) {
     this.memoryDir = memoryDir;
     this.io = io;
-    this.meetingsDir = path10.join(memoryDir, MEETINGS_DIR_NAME);
+    this.meetingsDir = path12.join(memoryDir, MEETINGS_DIR_NAME);
   }
   memoryDir;
   io;
@@ -5075,7 +5177,7 @@ var MeetingRecordStore = class {
     if (idDate !== date) {
       throw new Error(`meeting id '${id}' does not belong to date '${date}'`);
     }
-    return path10.join(this.meetingsDir, date, `${id}.md`);
+    return path12.join(this.meetingsDir, date, `${id}.md`);
   }
   /** Idempotently persist a record: skip the write when contentHash is unchanged. */
   async saveMeetingRecord(record) {
@@ -5106,7 +5208,7 @@ var MeetingRecordStore = class {
     if (!isValidTranscriptDate(date)) {
       throw new Error(`invalid meeting date '${String(date)}' \u2014 expected YYYY-MM-DD`);
     }
-    const dayDir = path10.join(this.meetingsDir, date);
+    const dayDir = path12.join(this.meetingsDir, date);
     await this.assertPathContained(dayDir);
     let entries;
     try {
@@ -5174,10 +5276,10 @@ var MeetingRecordStore = class {
     try {
       rootReal = await this.io.realpath(this.memoryDir);
     } catch {
-      rootReal = path10.resolve(this.memoryDir);
+      rootReal = path12.resolve(this.memoryDir);
     }
     await this.assertNoEscape(rootReal, this.meetingsDir);
-    await this.assertNoEscape(rootReal, path10.dirname(targetPath));
+    await this.assertNoEscape(rootReal, path12.dirname(targetPath));
     await this.assertNoEscape(rootReal, targetPath);
     await this.assertNotSymlink(this.meetingsDir, "directory");
     const dayDir = this.dayDirWithin(targetPath);
@@ -5187,11 +5289,11 @@ var MeetingRecordStore = class {
   /** The `<meetings>/<date>` directory on the path to `targetPath`, or null when
    *  `targetPath` is the meetings root itself. */
   dayDirWithin(targetPath) {
-    const rel = path10.relative(this.meetingsDir, targetPath);
-    if (rel === "" || rel.startsWith("..") || path10.isAbsolute(rel)) return null;
-    const first = rel.split(path10.sep)[0];
+    const rel = path12.relative(this.meetingsDir, targetPath);
+    if (rel === "" || rel.startsWith("..") || path12.isAbsolute(rel)) return null;
+    const first = rel.split(path12.sep)[0];
     if (first === void 0 || first.length === 0) return null;
-    return path10.join(this.meetingsDir, first);
+    return path12.join(this.meetingsDir, first);
   }
   async assertNotSymlink(target, kind) {
     let stat4;
@@ -5202,7 +5304,7 @@ var MeetingRecordStore = class {
       throw err;
     }
     if (stat4.isSymbolicLink) {
-      const label = path10.relative(this.memoryDir, target) || MEETINGS_DIR_NAME;
+      const label = path12.relative(this.memoryDir, target) || MEETINGS_DIR_NAME;
       throw new Error(
         `meetings ${kind} '${label}' is a symbolic link \u2014 refusing to follow it even when it resolves inside the memory dir (AGENTS.md pattern #3)`
       );
@@ -5226,7 +5328,7 @@ var SORT_STR = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 
 // src/storage/supersession-audit.ts
 import { readdir as readdir5 } from "fs/promises";
-import path11 from "path";
+import path13 from "path";
 async function hasSupersessionAudit(lookup, oldMemoryId, newMemoryId, auditBody, structuredAttributes) {
   let entries;
   try {
@@ -5237,7 +5339,7 @@ async function hasSupersessionAudit(lookup, oldMemoryId, newMemoryId, auditBody,
   }
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const memory = await lookup.readMemoryByPath(path11.join(lookup.correctionsDir, entry.name));
+    const memory = await lookup.readMemoryByPath(path13.join(lookup.correctionsDir, entry.name));
     if (memory?.frontmatter.category === "correction" && (memory.frontmatter.sourceMemoryId === oldMemoryId || memory.frontmatter.sourceMemoryId === void 0 && memory.frontmatter.lineage?.includes(oldMemoryId)) && memory.frontmatter.lineage?.includes(newMemoryId) && stripAttributesSuffix(memory.content) === auditBody && (structuredAttributes === void 0 || Object.entries(structuredAttributes).every(
       ([key, value]) => memory.frontmatter.structuredAttributes?.[key] === value
     ))) {
@@ -5827,6 +5929,7 @@ function serializeFrontmatter(fm) {
     `confidenceTier: ${fm.confidenceTier}`,
     `tags: [${fm.tags.map((t) => `"${t}"`).join(", ")}]`
   ];
+  if (fm.type !== void 0) lines.push(`type: ${fm.type}`);
   if (fm.origin) lines.push(`origin: ${/^[A-Za-z0-9:_.*-]+$/.test(fm.origin) ? fm.origin : JSON.stringify(fm.origin)}`);
   if (fm.entityRef) lines.push(`entityRef: ${fm.entityRef}`);
   if (fm.sourceConnector) {
@@ -6218,6 +6321,7 @@ function parseFrontmatter(raw) {
     frontmatter: {
       id: fm.id ?? "",
       category: fm.category ?? "fact",
+      type: parseFrontmatterStringValue(fm.type),
       created: fm.created ?? (/* @__PURE__ */ new Date()).toISOString(),
       updated: fm.updated ?? (/* @__PURE__ */ new Date()).toISOString(),
       source: fm.source ?? "unknown",
@@ -6318,17 +6422,17 @@ function inferEntityTypeFromContent(content) {
 }
 var KNOWN_ENTITY_FILENAME_PREFIXES = /* @__PURE__ */ new Set(["company", "other", "person", "place", "project", "tool", "topic"]);
 function inferEntityTypeFromFilename(pathRel) {
-  const basename = path12.basename(pathRel, ".md").toLowerCase();
+  const basename = path14.basename(pathRel, ".md").toLowerCase();
   const separator = basename.indexOf("-");
   if (separator <= 0) return void 0;
   const candidate = basename.slice(0, separator);
   return KNOWN_ENTITY_FILENAME_PREFIXES.has(candidate) ? candidate : void 0;
 }
 function normalizeFrontmatterForPath(frontmatter, pathRel, content = "") {
-  const normalizedPath = pathRel.split(path12.sep).join("/");
+  const normalizedPath = pathRel.split(path14.sep).join("/");
   let normalizedFrontmatter = frontmatter;
   if (normalizedPath === "entities" || normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/")) {
-    const basename = path12.basename(pathRel, ".md");
+    const basename = path14.basename(pathRel, ".md");
     const inferredType = inferEntityTypeFromContent(content) || inferEntityTypeFromFilename(pathRel) || "entity";
     const existingTags = Array.isArray(frontmatter.tags) ? frontmatter.tags : [];
     normalizedFrontmatter = {
@@ -6376,15 +6480,16 @@ function parseEntityFrontmatter(raw) {
   }
   const values = {};
   const extraLines = [];
-  const recognizedKeys = /* @__PURE__ */ new Set([
-    "created",
-    "updated",
-    "synthesis_updated_at",
-    "synthesis_timeline_count",
-    "synthesis_structured_fact_count",
-    "synthesis_structured_fact_digest",
-    "synthesis_version"
-  ]);
+  const recognizedKeys = {
+    created: true,
+    updated: true,
+    type: true,
+    synthesis_updated_at: true,
+    synthesis_timeline_count: true,
+    synthesis_structured_fact_count: true,
+    synthesis_structured_fact_digest: true,
+    synthesis_version: true
+  };
   for (const line of match[1].split(/\r?\n/)) {
     if (/^\s/.test(line)) {
       extraLines.push(line);
@@ -6396,7 +6501,7 @@ function parseEntityFrontmatter(raw) {
       continue;
     }
     const key = line.slice(0, colonIdx).trim();
-    if (!recognizedKeys.has(key)) {
+    if (recognizedKeys[key] !== true) {
       extraLines.push(line);
       continue;
     }
@@ -6625,7 +6730,7 @@ function parseEntityFile(content, entitySchemas) {
     extraSections: remainingExtraSections
   };
 }
-function serializeEntityFile(entity, entitySchemas) {
+function serializeEntityFile(entity, entitySchemas, okfType) {
   const synthesis = entity.synthesis || entity.summary || "";
   const created = entity.created?.trim() || entity.updated || (/* @__PURE__ */ new Date()).toISOString();
   const updated = entity.updated || created;
@@ -6660,7 +6765,8 @@ function serializeEntityFile(entity, entitySchemas) {
     ...synthesisStructuredFactCount === void 0 ? [] : [`synthesis_structured_fact_count: ${synthesisStructuredFactCount}`],
     ...synthesisStructuredFactDigest ? [`synthesis_structured_fact_digest: "${synthesisStructuredFactDigest}"`] : [],
     `synthesis_version: ${synthesisVersion}`,
-    ...entity.extraFrontmatterLines ?? [],
+    ...okfType === false ? [] : [`type: ${okfTypeForEntityKind(entity.type)}`],
+    ...okfType === false ? entity.extraFrontmatterLines ?? [] : (entity.extraFrontmatterLines ?? []).filter((line) => !line.startsWith("type:")),
     "---",
     "",
     `# ${entity.name}`,
@@ -6799,9 +6905,9 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     this.entitySchemas = entitySchemas;
     this.deletionRevisionStore = new DeletionRevisionStore({
       baseDir,
-      deletionRevisionMetadataPath: path12.join(baseDir, ".offline-sync", "deletion-revisions.v1.json"),
-      invalidationCommitMetadataPath: path12.join(baseDir, ".offline-sync", "invalidation-commits.v1.json"),
-      deletionRevisionLockPath: path12.join(baseDir, ".offline-sync", "deletion-revisions.v1.json.lock"),
+      deletionRevisionMetadataPath: path14.join(baseDir, ".offline-sync", "deletion-revisions.v1.json"),
+      invalidationCommitMetadataPath: path14.join(baseDir, ".offline-sync", "invalidation-commits.v1.json"),
+      deletionRevisionLockPath: path14.join(baseDir, ".offline-sync", "deletion-revisions.v1.json.lock"),
       assertManagedStoragePath: (filePath, method) => this.assertManagedStoragePath(filePath, method)
     });
     this.hotMemoriesCacheEnabled = hotMemoriesCacheEnabledOverride ?? _StorageManager.hotMemoriesCacheDefaultByDir.get(baseDir) ?? _StorageManager.hotMemoriesCacheDefault;
@@ -6985,8 +7091,8 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   }
   /** Whether `filePath` resolves to `stateDir` itself or a path contained in it. */
   isStateFilePath(filePath) {
-    const rel = path12.relative(this.stateDir, path12.resolve(filePath));
-    return rel === "" || !rel.startsWith("..") && !path12.isAbsolute(rel);
+    const rel = path14.relative(this.stateDir, path14.resolve(filePath));
+    return rel === "" || !rel.startsWith("..") && !path14.isAbsolute(rel);
   }
   // ── Tombstone store (issue #1579) ───────────────────────────────────────
   // Instance-scoped (rule 11) + namespace-scoped (rule 42) tombstone index.
@@ -7101,8 +7207,8 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * /srv/cold/remnic), skipping the patch and stranding a stale hot entry.
    */
   isColdOrArchiveTierPath(p) {
-    const rel = path12.relative(this.baseDir, p);
-    return rel === "cold" || rel === "archive" || rel.startsWith(`cold${path12.sep}`) || rel.startsWith(`archive${path12.sep}`);
+    const rel = path14.relative(this.baseDir, p);
+    return rel === "cold" || rel === "archive" || rel.startsWith(`cold${path14.sep}`) || rel.startsWith(`archive${path14.sep}`);
   }
   /**
    * Mark the secure-store as required for this storage instance.
@@ -7189,7 +7295,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
         void 0,
         this.baseDir
       );
-      const rel = path12.relative(this.baseDir, filePath).split(path12.sep).join("/");
+      const rel = path14.relative(this.baseDir, filePath).split(path14.sep).join("/");
       return `${rel}:${version.versionId}`;
     } catch (err) {
       log.warn(
@@ -7225,6 +7331,21 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   static setScopedCacheInvalidationDefault(memoryDir, enabled) {
     _StorageManager.scopedCacheInvalidationByDir.set(memoryDir, enabled !== false);
   }
+  /** OKF `type` emission gate registrations per memory dir (issue #1946). */
+  static okfConformanceByDir = /* @__PURE__ */ new Map();
+  /** Register the OKF conformance gate for a memory dir. Unregistered dirs default to
+   *  conformance-on; namespace child dirs (<memoryDir>/namespaces/<tok>) inherit the
+   *  nearest registered ancestor. Only an explicit `false` disables. */
+  static setOkfConformanceDefault(memoryDir, enabled) {
+    _StorageManager.okfConformanceByDir.set(memoryDir, enabled !== false);
+  }
+  okfConformanceEnabled() {
+    for (let dir = this.baseDir; ; dir = path14.dirname(dir)) {
+      const registered = _StorageManager.okfConformanceByDir.get(dir);
+      if (registered !== void 0) return registered;
+      if (dir === path14.dirname(dir)) return true;
+    }
+  }
   /**
    * The LIVE class object of this instance (issue #1809 review of the
    * storage decomposition): extracted store modules must read/write the
@@ -7269,12 +7390,12 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   }
   identityFilePath(workspaceDir, namespace) {
     const rawNamespace = typeof namespace === "string" ? namespace.trim() : "";
-    if (!rawNamespace) return path12.join(workspaceDir, "IDENTITY.md");
+    if (!rawNamespace) return path14.join(workspaceDir, "IDENTITY.md");
     const safeNamespace = rawNamespace.replace(/[^a-zA-Z0-9._-]/g, "-");
-    return path12.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
+    return path14.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
   }
   versionFilePath(kind) {
-    return path12.join(this.stateDir, `.${kind}-version.log`);
+    return path14.join(this.stateDir, `.${kind}-version.log`);
   }
   bumpSharedVersion(kind, fallbackMap) {
     const filePath = this.versionFilePath(kind);
@@ -7378,7 +7499,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   // memories.
   // -------------------------------------------------------------------------
   get wearablesDir() {
-    return path12.join(this.baseDir, WEARABLES_DIR_NAME);
+    return path14.join(this.baseDir, WEARABLES_DIR_NAME);
   }
   /**
    * Resolve the on-disk path for a source/day transcript. Throws on
@@ -7394,7 +7515,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     if (!isValidTranscriptDate(date)) {
       throw new Error(`invalid wearable transcript date '${String(date)}' \u2014 expected YYYY-MM-DD`);
     }
-    return path12.join(this.wearablesDir, sourceId, `${date}.md`);
+    return path14.join(this.wearablesDir, sourceId, `${date}.md`);
   }
   async writeWearableDayTranscript(sourceId, date, serialized) {
     const targetPath = this.wearableTranscriptPath(sourceId, date);
@@ -7510,25 +7631,25 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     });
   }
   get factsDir() {
-    return path12.join(this.baseDir, "facts");
+    return path14.join(this.baseDir, "facts");
   }
   get correctionsDir() {
-    return path12.join(this.baseDir, "corrections");
+    return path14.join(this.baseDir, "corrections");
   }
   get proceduresDir() {
-    return path12.join(this.baseDir, "procedures");
+    return path14.join(this.baseDir, "procedures");
   }
   get reasoningTracesDir() {
-    return path12.join(this.baseDir, "reasoning-traces");
+    return path14.join(this.baseDir, "reasoning-traces");
   }
   get entitiesDir() {
-    return path12.join(this.baseDir, "entities");
+    return path14.join(this.baseDir, "entities");
   }
   resolveEntityFilePath(name) {
     if (typeof name !== "string") return null;
-    const filePath = path12.resolve(this.entitiesDir, `${name}.md`);
-    const relative2 = path12.relative(this.entitiesDir, filePath);
-    if (relative2 === "" || relative2.startsWith("..") || path12.isAbsolute(relative2)) {
+    const filePath = path14.resolve(this.entitiesDir, `${name}.md`);
+    const relative2 = path14.relative(this.entitiesDir, filePath);
+    if (relative2 === "" || relative2.startsWith("..") || path14.isAbsolute(relative2)) {
       return null;
     }
     return filePath;
@@ -7539,7 +7660,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async readDependencyPropagationQueueFile(filePath) {
     const target = await resolveSafeStoragePath(
       this.baseDir,
-      path12.relative(
+      path14.relative(
         this.baseDir,
         this.assertManagedStoragePath(filePath, "storage.readDependencyPropagationQueueFile")
       )
@@ -7549,7 +7670,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async writeDependencyPropagationQueueFile(filePath, content) {
     const target = await resolveSafeStoragePath(
       this.baseDir,
-      path12.relative(
+      path14.relative(
         this.baseDir,
         this.assertManagedStoragePath(filePath, "storage.writeDependencyPropagationQueueFile")
       )
@@ -7557,16 +7678,17 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     return this.writeStorageSecureFile(target, content);
   }
   writeStorageSecureFile(filePath, content, forceEncrypt = false) {
+    assertNotOkfReservedBasename(filePath);
     const writeKey = this.resolveWriteKey(forceEncrypt);
     return writeMaybeEncryptedFile(filePath, content, writeKey, {}, this.baseDir).then(() => {
       this.notifyCatalogWriteForPath(filePath);
     });
   }
   assertManagedStoragePath(filePath, method) {
-    const resolved = path12.resolve(filePath);
-    const base = path12.resolve(this.baseDir);
-    const rel = path12.relative(base, resolved);
-    if (rel === "" || rel === ".." || rel.startsWith(`..${path12.sep}`) || path12.isAbsolute(rel)) {
+    const resolved = path14.resolve(filePath);
+    const base = path14.resolve(this.baseDir);
+    const rel = path14.relative(base, resolved);
+    if (rel === "" || rel === ".." || rel.startsWith(`..${path14.sep}`) || path14.isAbsolute(rel)) {
       throw new Error(`${method}: file path escapes memory dir`);
     }
     return resolved;
@@ -7599,7 +7721,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async digestOfflineSyncFile(filePath) {
     const target = this.assertManagedStoragePath(filePath, "storage.digestOfflineSyncFile");
     const st = await stat3(target);
-    const relPath = path12.relative(this.baseDir, target).split(path12.sep).join("/");
+    const relPath = path14.relative(this.baseDir, target).split(path14.sep).join("/");
     const cache = await this.loadOfflineSyncDigestCache();
     const cached = cache.get(relPath);
     if (cached && cached.statBytes === st.size && cached.mtimeMs === st.mtimeMs && cached.ctimeMs === st.ctimeMs && !cached.encrypted) {
@@ -7660,7 +7782,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
         const bytes = typeof record.bytes === "number" ? record.bytes : NaN;
         const sha256 = typeof record.sha256 === "string" ? record.sha256 : "";
         const encrypted = record.encrypted === true;
-        if (cachePath.length === 0 || cachePath === ".." || cachePath.startsWith("../") || path12.isAbsolute(cachePath) || !Number.isFinite(statBytes) || !Number.isFinite(mtimeMs) || !Number.isFinite(ctimeMs) || !Number.isFinite(bytes) || !/^[a-f0-9]{64}$/i.test(sha256)) {
+        if (cachePath.length === 0 || cachePath === ".." || cachePath.startsWith("../") || path14.isAbsolute(cachePath) || !Number.isFinite(statBytes) || !Number.isFinite(mtimeMs) || !Number.isFinite(ctimeMs) || !Number.isFinite(bytes) || !/^[a-f0-9]{64}$/i.test(sha256)) {
           continue;
         }
         cache.set(cachePath, { statBytes, mtimeMs, ctimeMs, encrypted, sha256, bytes });
@@ -7702,7 +7824,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
       const cache = this.offlineSyncDigestCache;
       if (!cache) return;
       const entries = [...cache.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([entryPath, entry]) => ({ path: entryPath, ...entry }));
-      await mkdir(path12.dirname(this.offlineSyncDigestCachePath), { recursive: true });
+      await mkdir(path14.dirname(this.offlineSyncDigestCachePath), { recursive: true });
       await writeFile2(this.offlineSyncDigestCachePath, `${JSON.stringify({ version: 1, entries })}
 `, "utf-8");
     }).catch((err) => {
@@ -7791,7 +7913,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   }
   async appendStorageSecureFileUnlocked(filePath, content) {
     const writeKey = this.resolveWriteKey();
-    await mkdir(path12.dirname(filePath), { recursive: true });
+    await mkdir(path14.dirname(filePath), { recursive: true });
     if (writeKey === null) {
       try {
         if (await this.isEncryptedFileHeader(filePath)) {
@@ -7817,13 +7939,13 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     this.notifyCatalogWriteForPath(filePath);
   }
   get stateDir() {
-    return path12.join(this.baseDir, "state");
+    return path14.join(this.baseDir, "state");
   }
   get offlineSyncDigestCachePath() {
-    return path12.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
+    return path14.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
   }
   get entitySynthesisQueuePath() {
-    return path12.join(this.stateDir, "entity-synthesis-queue.json");
+    return path14.join(this.stateDir, "entity-synthesis-queue.json");
   }
   // ── Tombstone store access (issue #1579) ─────────────────────────────────
   /**
@@ -7833,7 +7955,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * helpers are injected into the store).
    */
   get tombstonesPath() {
-    return path12.join(this.stateDir, "tombstones.jsonl");
+    return path14.join(this.stateDir, "tombstones.jsonl");
   }
   /**
    * Configure the tombstone invariant for this storage instance. Installed
@@ -8135,55 +8257,55 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     return legacyMatches.length > 0 ? [...new Set(legacyMatches.map((content) => ContentHashIndex.computeHash(content)))] : [persistedHash];
   }
   get questionsDir() {
-    return path12.join(this.baseDir, "questions");
+    return path14.join(this.baseDir, "questions");
   }
   get artifactsDir() {
-    return path12.join(this.baseDir, "artifacts");
+    return path14.join(this.baseDir, "artifacts");
   }
   get identityDir() {
-    return path12.join(this.baseDir, "identity");
+    return path14.join(this.baseDir, "identity");
   }
   get identityAnchorPath() {
-    return path12.join(this.identityDir, "identity-anchor.md");
+    return path14.join(this.identityDir, "identity-anchor.md");
   }
   get identityIncidentsDir() {
-    return path12.join(this.identityDir, "incidents");
+    return path14.join(this.identityDir, "incidents");
   }
   get identityAuditsWeeklyDir() {
-    return path12.join(this.identityDir, "audits", "weekly");
+    return path14.join(this.identityDir, "audits", "weekly");
   }
   get identityAuditsMonthlyDir() {
-    return path12.join(this.identityDir, "audits", "monthly");
+    return path14.join(this.identityDir, "audits", "monthly");
   }
   get identityImprovementLoopsPath() {
-    return path12.join(this.identityDir, "improvement-loops.md");
+    return path14.join(this.identityDir, "improvement-loops.md");
   }
   get identityReflectionsPath() {
-    return path12.join(this.identityDir, "reflections.md");
+    return path14.join(this.identityDir, "reflections.md");
   }
   get profilePath() {
-    return path12.join(this.baseDir, "profile.md");
+    return path14.join(this.baseDir, "profile.md");
   }
   get memoryActionsPath() {
-    return path12.join(this.stateDir, "memory-actions.jsonl");
+    return path14.join(this.stateDir, "memory-actions.jsonl");
   }
   get memoryLifecycleLedgerPath() {
-    return path12.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
+    return path14.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
   }
   get compressionGuidelinesPath() {
-    return path12.join(this.stateDir, "compression-guidelines.md");
+    return path14.join(this.stateDir, "compression-guidelines.md");
   }
   get compressionGuidelineDraftPath() {
-    return path12.join(this.stateDir, "compression-guidelines.draft.md");
+    return path14.join(this.stateDir, "compression-guidelines.draft.md");
   }
   get compressionGuidelineStatePath() {
-    return path12.join(this.stateDir, "compression-guideline-state.json");
+    return path14.join(this.stateDir, "compression-guideline-state.json");
   }
   get compressionGuidelineDraftStatePath() {
-    return path12.join(this.stateDir, "compression-guideline-draft-state.json");
+    return path14.join(this.stateDir, "compression-guideline-draft-state.json");
   }
   get behaviorSignalsPath() {
-    return path12.join(this.stateDir, "behavior-signals.jsonl");
+    return path14.join(this.stateDir, "behavior-signals.jsonl");
   }
   /**
    * In-memory dedup key set for behavior-signals appends (issue #1909),
@@ -8215,7 +8337,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * governance sweeps can treat it uniformly.
    */
   get bufferSurpriseLedgerPath() {
-    return path12.join(this.stateDir, "buffer-surprise-ledger.jsonl");
+    return path14.join(this.stateDir, "buffer-surprise-ledger.jsonl");
   }
   /**
    * Entity alias table loaded from THIS store's config/aliases.json.
@@ -8276,7 +8398,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     this.loadAliasesSync();
   }
   loadAliasesSync() {
-    const aliasPath = path12.join(this.baseDir, "config", "aliases.json");
+    const aliasPath = path14.join(this.baseDir, "config", "aliases.json");
     this.userAliases = {};
     const raw = readEntityAliasConfigSync(this.baseDir);
     if (raw === void 0) return;
@@ -8305,7 +8427,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     const completionFingerprint = await runLegacyEntityCanonicalIdMigration(
       this,
       (content) => parseEntityFile(content, this.entitySchemas),
-      (entity) => serializeEntityFile(entity, this.entitySchemas),
+      (entity) => serializeEntityFile(entity, this.entitySchemas, this.okfConformanceEnabled()),
       createMemoryEntityRefSerializer(serializeFrontmatter)
     );
     return completionFingerprint;
@@ -8314,9 +8436,9 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     await mkdir(this.baseDir, { recursive: true });
     await validateRoots(this.baseDir, this.entitiesDir, this.stateDir, this.archiveDir);
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    await mkdir(path12.join(this.factsDir, today), { recursive: true });
-    await mkdir(path12.join(this.proceduresDir, today), { recursive: true });
-    await mkdir(path12.join(this.reasoningTracesDir, today), { recursive: true });
+    await mkdir(path14.join(this.factsDir, today), { recursive: true });
+    await mkdir(path14.join(this.proceduresDir, today), { recursive: true });
+    await mkdir(path14.join(this.reasoningTracesDir, today), { recursive: true });
     await mkdir(this.correctionsDir, { recursive: true });
     await mkdir(this.entitiesDir, { recursive: true });
     await mkdir(this.stateDir, { recursive: true });
@@ -8326,7 +8448,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     await mkdir(this.identityIncidentsDir, { recursive: true });
     await mkdir(this.identityAuditsWeeklyDir, { recursive: true });
     await mkdir(this.identityAuditsMonthlyDir, { recursive: true });
-    await mkdir(path12.join(this.baseDir, "config"), { recursive: true });
+    await mkdir(path14.join(this.baseDir, "config"), { recursive: true });
     await this.entityCanonicalIdMigration.ensure();
     if (this.hotMemoriesCacheEnabled && this.getMemoryCorpusVersion() === 0) {
       this.bumpMemoryCorpusVersion();
@@ -8348,11 +8470,11 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async resolveCategoryWritePath(category, id, today) {
     if (category === "correction") {
       await mkdir(this.correctionsDir, { recursive: true });
-      return path12.join(this.correctionsDir, `${id}.md`);
+      return path14.join(this.correctionsDir, `${id}.md`);
     }
-    const datedDir = path12.join(getCategoryDir(this.baseDir, category), today);
+    const datedDir = path14.join(getCategoryDir(this.baseDir, category), today);
     await mkdir(datedDir, { recursive: true });
-    return path12.join(datedDir, `${id}.md`);
+    return path14.join(datedDir, `${id}.md`);
   }
   async findExistingTombstoneBlockedMemory(content, category, sourceConnector) {
     const identity = buildExplicitCaptureDedupKey(content, category, sourceConnector);
@@ -8366,6 +8488,12 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
       ) === identity;
     }) ?? null;
   }
+  /** Derive the inert OKF `type` at the serialization choke point when conformance is on
+   *  and the parsed frontmatter carried none (issue #1946). Never touches `category`. */
+  withOkfType(fm) {
+    if (this.okfConformanceEnabled() && fm.type === void 0) fm.type = okfTypeForMemory(fm);
+    return fm;
+  }
   async writeMemory(category, content, options = {}) {
     await this.ensureDirectories();
     const rawEntityRef = options.entityRef;
@@ -8476,7 +8604,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
       }
     };
     await applyTombstoneGate();
-    const fileContent = `${serializeFrontmatter(fm)}
+    const fileContent = `${serializeFrontmatter(this.withOkfType(fm))}
 
 ${sanitized.text}
 `;
@@ -8503,7 +8631,7 @@ ${sanitized.text}
               await applyTombstoneGate();
               await this.writeTombstoneBlockedMemory(
                 filePath,
-                `${serializeFrontmatter(fm)}
+                `${serializeFrontmatter(this.withOkfType(fm))}
 
 ${sanitized.text}
 `,
@@ -8719,7 +8847,7 @@ ${sanitized.text}
     await this.ensureDirectories();
     const now = /* @__PURE__ */ new Date();
     const day = now.toISOString().slice(0, 10);
-    const dir = path12.join(this.artifactsDir, day);
+    const dir = path14.join(this.artifactsDir, day);
     await mkdir(dir, { recursive: true });
     const id = `artifact-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
     const fm = {
@@ -8746,8 +8874,8 @@ ${sanitized.text}
       log.warn(`artifact content rejected for ${id}; violations=${sanitized.violations.join(", ")}`);
       return "";
     }
-    const filePath = path12.join(dir, `${id}.md`);
-    await this.writeStorageSecureFile(filePath, `${serializeFrontmatter(fm)}
+    const filePath = path14.join(dir, `${id}.md`);
+    await this.writeStorageSecureFile(filePath, `${serializeFrontmatter(this.withOkfType(fm))}
 
 ${sanitized.text}
 `);
@@ -8780,7 +8908,7 @@ ${sanitized.text}
   }
   async readProfile() {
     try {
-      return await readMaybeEncryptedFile(this.profilePath, this._secureStoreKey, this.baseDir);
+      return stripOkfProfileFrontmatter(await readMaybeEncryptedFile(this.profilePath, this._secureStoreKey, this.baseDir));
     } catch (error) {
       if (error instanceof SecureStoreLockedError) {
         throw error;
@@ -8790,7 +8918,12 @@ ${sanitized.text}
     }
   }
   async writeProfile(content) {
-    const stampedContent = renderProfileWithLastUpdated(content, (/* @__PURE__ */ new Date()).toISOString());
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const stampedContent = withOkfProfileFrontmatter(
+      renderProfileWithLastUpdated(content, timestamp),
+      timestamp,
+      this.okfConformanceEnabled()
+    );
     await this.ensureDirectories();
     await this.snapshotBeforeWrite(this.profilePath, "consolidation");
     await this.writeStorageSecureFile(this.profilePath, stampedContent);
@@ -9034,7 +9167,7 @@ ${sanitized.text}
    * per-process in-memory cache safe across process boundaries.
    */
   invalidateColdMemoriesCache() {
-    const coldRoot = path12.join(this.baseDir, "cold");
+    const coldRoot = path14.join(this.baseDir, "cold");
     _StorageManager.coldMemoriesCache.delete(coldRoot);
     this.bumpColdWriteVersion();
     invalidateAllForDir(this.baseDir);
@@ -9154,7 +9287,7 @@ ${sanitized.text}
     const correctionPaths = [];
     const factPaths = [];
     for (const filePath of filePaths) {
-      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path12.sep}`)) {
+      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path14.sep}`)) {
         correctionPaths.push(filePath);
       } else {
         factPaths.push(filePath);
@@ -9217,7 +9350,7 @@ ${sanitized.text}
       try {
         const entries = await readdir6(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path12.join(dir, entry.name);
+          const fullPath = path14.join(dir, entry.name);
           if (entry.isDirectory()) {
             await readDir(fullPath);
           } else if (entry.name.endsWith(".md")) {
@@ -9260,7 +9393,7 @@ ${sanitized.text}
     return this.rememberMemorySnapshot(await this.memoryReadStore.readMemoryByPath(filePath));
   }
   resolveTierRootDir(tier) {
-    return tier === "cold" ? path12.join(this.baseDir, "cold") : this.baseDir;
+    return tier === "cold" ? path14.join(this.baseDir, "cold") : this.baseDir;
   }
   resolveMemoryDateDir(memory) {
     const preferred = memory.frontmatter.created || memory.frontmatter.updated;
@@ -9275,21 +9408,22 @@ ${sanitized.text}
   buildTierMemoryPath(memory, tier) {
     const root = this.resolveTierRootDir(tier);
     if (this.isArtifactMemory(memory)) {
-      return path12.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+      return path14.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
     }
     if (memory.frontmatter.category === "correction") {
-      return path12.join(root, "corrections", `${memory.frontmatter.id}.md`);
+      return path14.join(root, "corrections", `${memory.frontmatter.id}.md`);
     }
     const dir = categoryDirName(memory.frontmatter.category);
-    return path12.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+    return path14.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
   }
   async writeMemoryFileAtomic(targetPath, memory) {
+    assertNotOkfReservedBasename(targetPath);
     const refIdsAtWrite = this.currentHistoricalIds();
     const rawRef = memory.frontmatter.entityRef;
     const frontmatter = canonicalizeEntityRefOption(memory.frontmatter, refIdsAtWrite);
     const persist = () => writeMaybeEncryptedFile(
       targetPath,
-      `${serializeFrontmatter(frontmatter)}
+      `${serializeFrontmatter(this.withOkfType(frontmatter))}
 
 ${memory.content}
 `,
@@ -9359,8 +9493,8 @@ ${memory.content}
               memory.frontmatter.entityRef = current.frontmatter.entityRef;
             }
             durable = true;
-            const sourcePath = path12.resolve(current.path);
-            const destPath = path12.resolve(targetPath);
+            const sourcePath = path14.resolve(current.path);
+            const destPath = path14.resolve(targetPath);
             if (sourcePath !== destPath) {
               await recordArchiveDelete2(this.baseDir, current.path, () => this.deleteManagedStorageFile(current.path));
               this.invalidateAllMemoriesCache();
@@ -9384,8 +9518,8 @@ ${memory.content}
   }
   async migrateMemoryToTier(memory, targetTier) {
     const targetPath = this.buildTierMemoryPath(memory, targetTier);
-    const sourcePath = path12.resolve(memory.path);
-    const destPath = path12.resolve(targetPath);
+    const sourcePath = path14.resolve(memory.path);
+    const destPath = path14.resolve(targetPath);
     if (sourcePath === destPath) {
       return { changed: false, targetPath };
     }
@@ -9395,7 +9529,7 @@ ${memory.content}
     return { changed, targetPath };
   }
   get archiveDir() {
-    return path12.join(this.baseDir, "archive");
+    return path14.join(this.baseDir, "archive");
   }
   /**
    * Archive a memory by moving it from facts/ to archive/YYYY-MM-DD/.
@@ -9408,7 +9542,7 @@ ${memory.content}
       try {
         const now = lifecycle?.at ?? /* @__PURE__ */ new Date();
         const today = now.toISOString().slice(0, 10);
-        const destDir = path12.join(this.archiveDir, today);
+        const destDir = path14.join(this.archiveDir, today);
         await mkdir(destDir, { recursive: true });
         const refIdsAtWrite = this.currentHistoricalIds();
         const updatedFm = canonicalizeEntityRefOption(
@@ -9420,11 +9554,11 @@ ${memory.content}
           },
           refIdsAtWrite
         );
-        const fileContent = `${serializeFrontmatter(updatedFm)}
+        const fileContent = `${serializeFrontmatter(this.withOkfType(updatedFm))}
 
 ${current.content}
 `;
-        const destPath = path12.join(destDir, path12.basename(current.path));
+        const destPath = path14.join(destDir, path14.basename(current.path));
         const priorDest = await this.readStorageSecureFile(destPath).catch(() => null);
         await recordArchiveWrite(this.baseDir, destPath, () => this.writeStorageSecureFile(destPath, fileContent));
         if (typeof current.frontmatter.entityRef === "string") {
@@ -9577,7 +9711,7 @@ ${current.content}
     if (!sanitized.clean) {
       log.warn(`updated memory content sanitized for ${memory.frontmatter.id}; violations=${sanitized.violations.join(", ")}`);
     }
-    const fileContent = `${serializeFrontmatter(updated)}
+    const fileContent = `${serializeFrontmatter(this.withOkfType(updated))}
 
 ${sanitized.text}
 `;
@@ -9651,13 +9785,13 @@ ${sanitized.text}
     );
     const refIds = typeof updated.entityRef === "string" ? resolveIds : null;
     const afterStatus = updated.status ?? "active";
-    const fileContent = `${serializeFrontmatter(updated)}
+    const fileContent = `${serializeFrontmatter(this.withOkfType(updated))}
 
 ${memory.content}
 `;
     await this.writeTombstoneBlockedFrontmatter(memory, fileContent, updated, async () => {
       this.invalidateAllMemoriesCache();
-      if (memory.path.includes(`${path12.sep}cold${path12.sep}`)) {
+      if (memory.path.includes(`${path14.sep}cold${path14.sep}`)) {
         this.invalidateColdMemoriesCache();
       }
     });
@@ -9668,7 +9802,7 @@ ${memory.content}
       });
     }
     await this.patchHotMemoriesCache({ addedPath: memory.path });
-    if (memory.path.includes(`${path12.sep}cold${path12.sep}`)) {
+    if (memory.path.includes(`${path14.sep}cold${path14.sep}`)) {
       this.invalidateColdMemoriesCache();
     }
     try {
@@ -9749,7 +9883,7 @@ ${memory.content}
     return deleted;
   }
   async loadBuffer() {
-    const bufferPath = path12.join(this.stateDir, "buffer.json");
+    const bufferPath = path14.join(this.stateDir, "buffer.json");
     try {
       const raw = await this.readStorageSecureFile(bufferPath);
       return JSON.parse(raw);
@@ -9761,11 +9895,11 @@ ${memory.content}
   }
   async saveBuffer(state) {
     await this.ensureDirectories();
-    const bufferPath = path12.join(this.stateDir, "buffer.json");
+    const bufferPath = path14.join(this.stateDir, "buffer.json");
     await this.writeStorageSecureFile(bufferPath, JSON.stringify(state, null, 2));
   }
   async loadMeta() {
-    const metaPath = path12.join(this.stateDir, "meta.json");
+    const metaPath = path14.join(this.stateDir, "meta.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       const parsed = JSON.parse(raw);
@@ -9798,7 +9932,7 @@ ${memory.content}
   }
   async saveMeta(state) {
     await this.ensureDirectories();
-    const metaPath = path12.join(this.stateDir, "meta.json");
+    const metaPath = path14.join(this.stateDir, "meta.json");
     await this.writeStorageSecureFile(metaPath, JSON.stringify(state, null, 2));
   }
   async appendMemoryActionEvents(events) {
@@ -9862,7 +9996,7 @@ ${memory.content}
       },
       (payload) => this.appendStorageSecureFile(target, payload),
       async () => {
-        await mkdir(path12.dirname(target), { recursive: true });
+        await mkdir(path14.dirname(target), { recursive: true });
       }
     );
   }
@@ -9960,7 +10094,7 @@ ${memory.content}
   async appendReextractJobs(events) {
     if (events.length === 0) return 0;
     await this.ensureDirectories();
-    const filePath = path12.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path14.join(this.stateDir, "reextract-jobs.jsonl");
     const lines = events.map((event) => JSON.stringify(event)).join("\n") + "\n";
     try {
       await this.appendStorageSecureFile(filePath, lines);
@@ -9973,7 +10107,7 @@ ${memory.content}
   }
   async readReextractJobs(limit = 200) {
     const safeLimit = Number.isFinite(limit) ? Math.max(1, Math.min(1e3, Math.floor(limit))) : 200;
-    const filePath = path12.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path14.join(this.stateDir, "reextract-jobs.jsonl");
     try {
       const raw = await this.readStorageSecureFile(filePath);
       const lines = raw.split("\n").filter((line) => line.trim().length > 0);
@@ -10190,7 +10324,8 @@ ${memory.content}
       id,
       created: (/* @__PURE__ */ new Date()).toISOString(),
       priority,
-      resolved: false
+      resolved: false,
+      ...this.okfConformanceEnabled() ? { type: OKF_QUESTION_TYPE } : {}
     };
     const content = `---
 ${Object.entries(frontmatter).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join("\n")}
@@ -10200,7 +10335,7 @@ ${question}
 
 **Context:** ${context}
 `;
-    const filePath = path12.join(this.questionsDir, `${id}.md`);
+    const filePath = path14.join(this.questionsDir, `${id}.md`);
     await this.writeStorageSecureFile(filePath, content);
     log.debug(`wrote question ${id} to ${filePath}`);
     this.invalidateQuestionsCache();
@@ -10214,22 +10349,7 @@ ${question}
     _StorageManager.questionsCache.delete(this.questionsDir);
   }
   parseQuestionFile(raw, filePath) {
-    const match = raw.match(/^---\n([\s\S]*?)\n---\n\n([\s\S]*)$/);
-    if (!match) return null;
-    const frontmatterStr = match[1];
-    const body = match[2].trim();
-    const id = this.extractFrontmatterValue(frontmatterStr, "id") ?? path12.basename(filePath, ".md");
-    const created = this.extractFrontmatterValue(frontmatterStr, "created") ?? "";
-    const priority = parseFloat(this.extractFrontmatterValue(frontmatterStr, "priority") ?? "0.5");
-    const resolved = this.extractFrontmatterValue(frontmatterStr, "resolved") === "true";
-    const contextMatch = body.match(/\*\*Context:\*\*\s*(.*)/);
-    const question = contextMatch ? body.slice(0, contextMatch.index).trim() : body;
-    const context = contextMatch ? contextMatch[1].trim() : "";
-    return { id, question, context, priority, resolved, created, filePath };
-  }
-  extractFrontmatterValue(frontmatter, key) {
-    const match = frontmatter.match(new RegExp(`^${key}:\\s*"?([^"\\n]*)"?`, "m"));
-    return match ? match[1] : null;
+    return parseQuestionFile(raw, filePath);
   }
   async resolveQuestion(id) {
     const questions = await this.readQuestions();
@@ -10274,11 +10394,11 @@ ${question}
     } catch {
     }
     const hygiene = opts?.hygiene;
-    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path12.basename(identityPath));
+    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path14.basename(identityPath));
     if (rotateEnabled) {
       const maxBytes = hygiene.rotateMaxBytes;
       if (existing.length > maxBytes) {
-        const archiveDir = path12.join(workspaceDir, hygiene.archiveDir);
+        const archiveDir = path14.join(workspaceDir, hygiene.archiveDir);
         const { newContent } = await rotateMarkdownFileToArchive({
           filePath: identityPath,
           archiveDir,
@@ -10538,14 +10658,14 @@ ${reflection}
     if (entries.length === 0) return 0;
     const memories = await this.readAllMemories();
     const memoryMap = new Map(memories.map((m) => [m.frontmatter.id, m]));
-    const memoryPathMap = new Map(memories.map((m) => [path12.resolve(m.path), m]));
+    const memoryPathMap = new Map(memories.map((m) => [path14.resolve(m.path), m]));
     let updated = 0;
     const prevVersion = this.getMemoryCorpusVersion();
     const keyId = this.hotCacheKeyId();
     const warm = this.hotMemoriesCacheEnabled && getCachedMemories(this.baseDir, prevVersion, keyId, this.hotCacheTtlMs()) !== null;
     const appliedPatches = /* @__PURE__ */ new Map();
     for (const entry of entries) {
-      const memory = entry.memoryPath ? memoryPathMap.get(path12.resolve(entry.memoryPath)) : memoryMap.get(entry.memoryId);
+      const memory = entry.memoryPath ? memoryPathMap.get(path14.resolve(entry.memoryPath)) : memoryMap.get(entry.memoryId);
       if (!memory) continue;
       try {
         const applied = await this.withTombstoneBlockedMemoryPathLock(memory.path, async (current) => {
@@ -10555,7 +10675,7 @@ ${reflection}
             { ...current.frontmatter, accessCount: entry.newCount, lastAccessed: entry.lastAccessed },
             rowIds
           );
-          const fileContent = `${serializeFrontmatter(newFm)}
+          const fileContent = `${serializeFrontmatter(this.withOkfType(newFm))}
 
 ${current.content}
 `;
@@ -10576,7 +10696,7 @@ ${current.content}
         if (warm) {
           updateCacheOnWrite(this.baseDir, { ...applied.current, frontmatter: applied.newFm }, keyId);
         }
-        appliedPatches.set(path12.resolve(memory.path), {
+        appliedPatches.set(path14.resolve(memory.path), {
           accessCount: entry.newCount,
           lastAccessed: entry.lastAccessed
         });
@@ -10592,7 +10712,7 @@ ${current.content}
         const cur = getCachedMemories(this.baseDir, prevVersion, keyId);
         if (cur) {
           const reapplied = cur.map((m) => {
-            const patch = appliedPatches.get(path12.resolve(m.path));
+            const patch = appliedPatches.get(path14.resolve(m.path));
             return patch ? {
               ...m,
               frontmatter: { ...m.frontmatter, accessCount: patch.accessCount, lastAccessed: patch.lastAccessed }
@@ -10622,7 +10742,7 @@ ${current.content}
     const pathsById = /* @__PURE__ */ new Map();
     const filePathsById = /* @__PURE__ */ new Map();
     for (const filePath of filePaths) {
-      const memoryId = path12.basename(filePath, ".md");
+      const memoryId = path14.basename(filePath, ".md");
       if (!wantedIds.has(memoryId)) continue;
       const paths = filePathsById.get(memoryId) ?? [];
       paths.push(filePath);
@@ -10634,7 +10754,7 @@ ${current.content}
       const preferredMatches = [];
       for (const preferredPath of preferred) {
         const directCandidates = new Set(qmdResultPathCandidates(this.baseDir, preferredPath));
-        const directMatch = existingPaths.find((filePath) => directCandidates.has(path12.resolve(filePath)));
+        const directMatch = existingPaths.find((filePath) => directCandidates.has(path14.resolve(filePath)));
         if (directMatch) {
           preferredMatches.push(directMatch);
           continue;
@@ -10646,7 +10766,7 @@ ${current.content}
             candidates.add(candidate);
           }
         }
-        const match = existingPaths.find((filePath) => candidates.has(path12.resolve(filePath)));
+        const match = existingPaths.find((filePath) => candidates.has(path14.resolve(filePath)));
         if (match) preferredMatches.push(match);
       }
       if (preferredMatches.length > 0) {
@@ -10777,7 +10897,7 @@ ${current.content}
       }) ? { toolScoped: true } : {}
     };
     const filePath = await this.resolveCategoryWritePath(category, id, today);
-    const fileContent = `${serializeFrontmatter(fm)}
+    const fileContent = `${serializeFrontmatter(this.withOkfType(fm))}
 
 ${sanitized.text}
 `;
@@ -10876,7 +10996,7 @@ ${sanitized.text}
           },
           refIdsAtWrite
         );
-        const fileContent = `${serializeFrontmatter(updatedFm)}
+        const fileContent = `${serializeFrontmatter(this.withOkfType(updatedFm))}
 
 ${current.content}
 `;
@@ -10966,11 +11086,11 @@ ${current.content}
     }
   }
   get summariesDir() {
-    return path12.join(this.baseDir, "summaries");
+    return path14.join(this.baseDir, "summaries");
   }
   async writeSummary(summary) {
     await mkdir(this.summariesDir, { recursive: true });
-    const filePath = path12.join(this.summariesDir, `${summary.id}.json`);
+    const filePath = path14.join(this.summariesDir, `${summary.id}.json`);
     await this.writeStorageSecureFile(filePath, JSON.stringify(summary, null, 2));
     log.debug(`wrote summary ${summary.id}`);
   }
@@ -10980,7 +11100,7 @@ ${current.content}
       const summaries = [];
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
-        const filePath = path12.join(this.summariesDir, file);
+        const filePath = path14.join(this.summariesDir, file);
         const raw = await this.readStorageSecureFile(filePath);
         summaries.push(JSON.parse(raw));
       }
@@ -11010,7 +11130,7 @@ ${current.content}
             { ...current.frontmatter, status: "archived", archivedAt: now, updated: now },
             rowIds
           );
-          const fileContent = `${serializeFrontmatter(updatedFm)}
+          const fileContent = `${serializeFrontmatter(this.withOkfType(updatedFm))}
 
 ${current.content}
 `;
@@ -11050,7 +11170,7 @@ ${current.content}
     return archived;
   }
   async saveTopics(topics) {
-    const metaPath = path12.join(this.stateDir, "topics.json");
+    const metaPath = path14.join(this.stateDir, "topics.json");
     await mkdir(this.stateDir, { recursive: true });
     await this.writeStorageSecureFile(
       metaPath,
@@ -11059,7 +11179,7 @@ ${current.content}
     log.debug(`saved ${topics.length} topic scores`);
   }
   async loadTopics() {
-    const metaPath = path12.join(this.stateDir, "topics.json");
+    const metaPath = path14.join(this.stateDir, "topics.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       return JSON.parse(raw);
@@ -11134,6 +11254,8 @@ ${current.content}
 };
 
 export {
+  okfTypeForCategory,
+  OKF_RESERVED_BASENAMES,
   selfDeps,
   qmdCollectionPathParts,
   qmdResultPathCandidates,
@@ -11175,4 +11297,4 @@ export {
   isValidBufferSurpriseEvent,
   StorageManager3 as StorageManager
 };
-//# sourceMappingURL=chunk-5SZ6CLGJ.js.map
+//# sourceMappingURL=chunk-2QI2JBLQ.js.map