memorix 1.2.0 → 1.2.2

package/dist/index.js

@@ -209,7 +209,11 @@ CREATE TABLE IF NOT EXISTS observations (
   relatedCommits  TEXT,
   relatedEntities TEXT,
   sourceDetail    TEXT,
-  valueCategory   TEXT
+  valueCategory   TEXT,
+  admissionState  TEXT,
+  admissionReason TEXT,
+  visibility      TEXT,
+  sharedWithAgentIds TEXT
 );
 `;
     CREATE_MINI_SKILLS_TABLE = `
@@ -632,6 +636,8 @@ CREATE INDEX IF NOT EXISTS idx_observations_projectId ON observations(projectId)
 CREATE INDEX IF NOT EXISTS idx_observations_topicKey ON observations(projectId, topicKey);
 CREATE INDEX IF NOT EXISTS idx_observations_status ON observations(status);
 CREATE INDEX IF NOT EXISTS idx_observations_project_status_id ON observations(projectId, status, id);
+CREATE INDEX IF NOT EXISTS idx_observations_project_admission ON observations(projectId, status, admissionState, id);
+CREATE INDEX IF NOT EXISTS idx_observations_project_visibility ON observations(projectId, status, visibility, id);
 CREATE INDEX IF NOT EXISTS idx_mini_skills_projectId ON mini_skills(projectId);
 CREATE INDEX IF NOT EXISTS idx_sessions_projectId ON sessions(projectId);
 CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(projectId, status);
@@ -676,6 +682,22 @@ CREATE UNIQUE INDEX IF NOT EXISTS idx_maintenance_jobs_active_dedupe
   WHERE status IN ('pending', 'running', 'retry');
 `;
     SCHEMA_MIGRATIONS = [
+      {
+        id: "1.2.2-observation-admission",
+        apply: (db2) => {
+          addColumnIfMissing(db2, "observations", "admissionState", "admissionState TEXT");
+          addColumnIfMissing(db2, "observations", "admissionReason", "admissionReason TEXT");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_observations_project_admission ON observations(projectId, status, admissionState, id)");
+        }
+      },
+      {
+        id: "1.2.2-observation-visibility",
+        apply: (db2) => {
+          addColumnIfMissing(db2, "observations", "visibility", "visibility TEXT");
+          addColumnIfMissing(db2, "observations", "sharedWithAgentIds", "sharedWithAgentIds TEXT");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_observations_project_visibility ON observations(projectId, status, visibility, id)");
+        }
+      },
       {
         id: "1.2-code-state-snapshots",
         apply: (db2) => {
@@ -2118,6 +2140,58 @@ var init_mini_skills = __esm({
   }
 });
 
+// src/memory/visibility.ts
+function resolveObservationVisibility(record) {
+  switch (record.visibility) {
+    case "personal":
+    case "team":
+    case "project":
+      return record.visibility;
+    default:
+      return "project";
+  }
+}
+function sharedAgentIds(record) {
+  if (Array.isArray(record.sharedWithAgentIds)) return record.sharedWithAgentIds;
+  if (typeof record.sharedWithAgentIds !== "string" || !record.sharedWithAgentIds) return [];
+  try {
+    const parsed = JSON.parse(record.sharedWithAgentIds);
+    return Array.isArray(parsed) ? parsed.filter((id) => typeof id === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function canReadObservation(record, reader) {
+  if (!reader) return true;
+  const sameProject = reader.projectId === record.projectId;
+  const visibility = resolveObservationVisibility(record);
+  if (visibility === "project") return !reader.projectId || sameProject;
+  if (!sameProject || !reader.agentId) return false;
+  if (visibility === "team") return reader.isTeamMember === true;
+  return record.createdByAgentId === reader.agentId || sharedAgentIds(record).includes(reader.agentId);
+}
+function canManageObservation(record, reader) {
+  if (!reader) return true;
+  if (!reader.projectId || reader.projectId !== record.projectId) return false;
+  switch (resolveObservationVisibility(record)) {
+    case "project":
+      return true;
+    case "team":
+      return reader.isTeamMember === true;
+    case "personal":
+      return Boolean(reader.agentId && record.createdByAgentId === reader.agentId);
+  }
+}
+function filterReadableObservations(observations2, reader) {
+  return reader ? observations2.filter((observation) => canReadObservation(observation, reader)) : [...observations2];
+}
+var init_visibility = __esm({
+  "src/memory/visibility.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/config/config-paths.ts
 import { join } from "path";
 function getGlobalConfigTomlPath(homeDir) {
@@ -5345,7 +5419,8 @@ __export(orama_store_exports, {
   makeOramaObservationId: () => makeOramaObservationId,
   removeObservation: () => removeObservation,
   resetDb: () => resetDb,
-  searchObservations: () => searchObservations
+  searchObservations: () => searchObservations,
+  updateObservationMetadata: () => updateObservationMetadata
 });
 import { create, insert as insert2, search, remove as remove2, update, count, getByID } from "@orama/orama";
 function getLastSearchMode(projectId) {
@@ -5423,6 +5498,11 @@ async function initializeDb(options, generation) {
     source: "string",
     sourceDetail: "string",
     valueCategory: "string",
+    admissionState: "string",
+    admissionReason: "string",
+    visibility: "string",
+    createdByAgentId: "string",
+    sharedWithAgentIds: "string",
     documentType: "string",
     knowledgeLayer: "string"
   };
@@ -5561,6 +5641,13 @@ async function hydrateIndex(observations2, options = {}) {
         lastAccessedAt: obs.lastAccessedAt || "",
         status: obs.status ?? "active",
         source: obs.source || "agent",
+        sourceDetail: obs.sourceDetail ?? "",
+        valueCategory: obs.valueCategory ?? "",
+        admissionState: obs.admissionState ?? "",
+        admissionReason: obs.admissionReason ?? "",
+        visibility: obs.visibility ?? "project",
+        createdByAgentId: obs.createdByAgentId ?? "",
+        sharedWithAgentIds: JSON.stringify(obs.sharedWithAgentIds ?? []),
         documentType: "observation",
         knowledgeLayer: resolveKnowledgeLayer("observation", obs.sourceDetail, obs.source),
         ...compatibleVector ? { embedding: compatibleVector } : {}
@@ -5594,6 +5681,16 @@ async function insertObservation(doc) {
   await insert2(database, doc);
   rememberObservationDoc(doc);
 }
+async function updateObservationMetadata(projectId, observationId2, patch) {
+  const database = await getDb();
+  const id = makeOramaObservationId(projectId, observationId2);
+  const existing = getByID(database, id);
+  if (!existing) return false;
+  const next = { ...existing, ...patch };
+  await update(database, id, next);
+  rememberObservationDoc(next);
+  return true;
+}
 async function removeObservation(oramaId) {
   const database = await getDb();
   await remove2(database, oramaId);
@@ -5747,7 +5844,7 @@ async function searchObservations(options) {
     if (!projectIds) return true;
     const doc = hit.document;
     return projectIds.includes(doc.projectId);
-  }).filter((hit) => {
+  }).filter((hit) => canReadObservation(hit.document, options.reader)).filter((hit) => {
     if (statusFilter === "all") return true;
     const doc = hit.document;
     return (doc.status || "active") === statusFilter;
@@ -5778,6 +5875,8 @@ async function searchObservations(options) {
       source: doc.source || "agent",
       sourceDetail: doc.sourceDetail || void 0,
       valueCategory: doc.valueCategory || void 0,
+      admissionState: doc.admissionState || void 0,
+      visibility: doc.visibility || void 0,
       entityName: doc.entityName || void 0,
       documentType: doc.documentType || "observation",
       knowledgeLayer: doc.knowledgeLayer || "project-truth",
@@ -5821,6 +5920,12 @@ async function searchObservations(options) {
       score: isCommandStyleEntry(entry.title) ? entry.score * 0.3 : entry.score
     }));
   }
+  if (hasQuery) {
+    const qualifiedEntries = intermediate.filter(
+      (entry) => entry.admissionState !== "candidate" && entry.admissionState !== "ephemeral"
+    );
+    if (qualifiedEntries.length > 0) intermediate = qualifiedEntries;
+  }
   if (intentResult?.preferChronological) {
     intermediate.sort((a, b) => new Date(b.rawTime).getTime() - new Date(a.rawTime).getTime());
   } else {
@@ -5964,7 +6069,8 @@ async function searchObservations(options) {
   }
   let entries = intermediate.map(({ rawTime: _, _isCommandLog: _c, ...rest }) => rest);
   for (const hit of results.hits) {
-    rememberObservationDoc(hit.document);
+    const doc = hit.document;
+    if (canReadObservation(doc, options.reader)) rememberObservationDoc(doc);
   }
   if (hasQuery && originalQuery) {
     const queryLower = originalQuery.toLowerCase();
@@ -6008,7 +6114,8 @@ async function searchObservations(options) {
     entries = applyTokenBudget(entries, options.maxTokens);
   }
   if (options.trackAccess !== false) {
-    const hitDocs = results.hits.map((h) => ({ id: h.id, doc: h.document }));
+    const returnedKeys = new Set(entries.map((entry) => makeEntryKey(entry.projectId, entry.id)));
+    const hitDocs = results.hits.map((hit) => ({ id: hit.id, doc: hit.document })).filter(({ doc }) => returnedKeys.has(makeEntryKey(doc.projectId, doc.observationId)));
     recordAccessBatch(hitDocs).catch(() => {
     });
   }
@@ -6040,11 +6147,11 @@ async function getObservationsByIds(ids, projectId) {
   }
   return results;
 }
-async function getTimeline(anchorId, projectId, depthBefore = 3, depthAfter = 3) {
+async function getTimeline(anchorId, projectId, depthBefore = 3, depthAfter = 3, reader) {
   const { withFreshIndex: withFreshIndex2 } = await Promise.resolve().then(() => (init_freshness(), freshness_exports));
   const { getAllObservations: getAllObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
   const rawObs = await withFreshIndex2(() => getAllObservations2());
-  const allObs = projectId ? rawObs.filter((o) => o.projectId === projectId) : rawObs;
+  const allObs = (projectId ? rawObs.filter((o) => o.projectId === projectId) : rawObs).filter((observation) => canReadObservation(observation, reader));
   const sorted = allObs.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
   const anchorIndex = sorted.findIndex((o) => o.id === anchorId);
   if (anchorIndex === -1) {
@@ -6061,7 +6168,9 @@ async function getTimeline(anchorId, projectId, depthBefore = 3, depthAfter = 3)
       tokens: obs.tokens,
       source: obs.source || void 0,
       sourceDetail: obs.sourceDetail || void 0,
-      valueCategory: obs.valueCategory || void 0
+      valueCategory: obs.valueCategory || void 0,
+      admissionState: obs.admissionState || void 0,
+      visibility: obs.visibility || void 0
     };
   };
   const before = sorted.slice(Math.max(0, anchorIndex - depthBefore), anchorIndex).map(toIndexEntry);
@@ -6129,6 +6238,7 @@ var init_orama_store = __esm({
     init_esm_shims();
     init_types();
     init_mini_skills();
+    init_visibility();
     init_provider();
     init_project_affinity();
     init_intent_detector();
@@ -6185,6 +6295,10 @@ function obsToRow(obs) {
     relatedEntities: obs.relatedEntities ? JSON.stringify(obs.relatedEntities) : null,
     sourceDetail: obs.sourceDetail ?? null,
     valueCategory: obs.valueCategory ?? null,
+    admissionState: obs.admissionState ?? null,
+    admissionReason: obs.admissionReason ?? null,
+    visibility: obs.visibility ?? null,
+    sharedWithAgentIds: obs.sharedWithAgentIds ? JSON.stringify(obs.sharedWithAgentIds) : null,
     createdByAgentId: obs.createdByAgentId ?? null,
     writeGeneration: obs.writeGeneration ?? 0
   };
@@ -6215,6 +6329,10 @@ function rowToObs(row) {
     ...row.relatedEntities ? { relatedEntities: safeJsonParse3(row.relatedEntities, []) } : {},
     ...row.sourceDetail ? { sourceDetail: row.sourceDetail } : {},
     ...row.valueCategory ? { valueCategory: row.valueCategory } : {},
+    ...row.admissionState ? { admissionState: row.admissionState } : {},
+    ...row.admissionReason ? { admissionReason: row.admissionReason } : {},
+    ...row.visibility ? { visibility: row.visibility } : {},
+    ...row.sharedWithAgentIds ? { sharedWithAgentIds: safeJsonParse3(row.sharedWithAgentIds, []) } : {},
     ...row.createdByAgentId ? { createdByAgentId: row.createdByAgentId } : {},
     ...row.writeGeneration ? { writeGeneration: row.writeGeneration } : {}
   };
@@ -6266,12 +6384,14 @@ var init_sqlite_store = __esm({
         (id, entityName, type, title, narrative, facts, filesModified, concepts, tokens,
          createdAt, updatedAt, projectId, hasCausalLanguage, topicKey, revisionCount,
          sessionId, status, progress, source, commitHash, relatedCommits, relatedEntities,
-         sourceDetail, valueCategory, createdByAgentId, writeGeneration)
+         sourceDetail, valueCategory, admissionState, admissionReason, visibility, sharedWithAgentIds,
+         createdByAgentId, writeGeneration)
       VALUES
         (@id, @entityName, @type, @title, @narrative, @facts, @filesModified, @concepts, @tokens,
          @createdAt, @updatedAt, @projectId, @hasCausalLanguage, @topicKey, @revisionCount,
          @sessionId, @status, @progress, @source, @commitHash, @relatedCommits, @relatedEntities,
-         @sourceDetail, @valueCategory, @createdByAgentId, @writeGeneration)
+         @sourceDetail, @valueCategory, @admissionState, @admissionReason, @visibility, @sharedWithAgentIds,
+         @createdByAgentId, @writeGeneration)
     `);
         this.stmtUpdate = this.stmtInsert;
         this.stmtSetStatus = this.db.prepare(`UPDATE observations SET status = ? WHERE id = ?`);
@@ -6823,6 +6943,7 @@ var init_maintenance_jobs = __esm({
       "retention-archive",
       "consolidation",
       "codegraph-refresh",
+      "observation-qualify",
       "claim-derive",
       "claim-requalification",
       "knowledge-compile",
@@ -7181,7 +7302,8 @@ __export(lifecycle_exports, {
   enqueueClaimDerivation: () => enqueueClaimDerivation,
   enqueueClaimRequalification: () => enqueueClaimRequalification,
   enqueueCodegraphRefresh: () => enqueueCodegraphRefresh,
-  enqueueKnowledgeFollowups: () => enqueueKnowledgeFollowups
+  enqueueKnowledgeFollowups: () => enqueueKnowledgeFollowups,
+  enqueueObservationQualification: () => enqueueObservationQualification
 });
 function queueFor(input) {
   return input.queue ?? new MaintenanceJobStore(input.dataDir);
@@ -7216,6 +7338,14 @@ function enqueueClaimDerivation(input) {
     payload: { observationId: input.observationId }
   });
 }
+function enqueueObservationQualification(input) {
+  queueFor(input).enqueue({
+    projectId: input.projectId,
+    kind: "observation-qualify",
+    dedupeKey: "observation-qualify",
+    payload: { source: input.source, limit: 100 }
+  });
+}
 function enqueueKnowledgeFollowups(input) {
   const queue = queueFor(input);
   const payload = {
@@ -8080,6 +8210,7 @@ __export(observations_exports, {
   resolveObservations: () => resolveObservations,
   storeObservation: () => storeObservation,
   suggestTopicKey: () => suggestTopicKey,
+  updateObservationAdmission: () => updateObservationAdmission,
   withFreshObservations: () => withFreshObservations
 });
 function logEmbeddingFailureOnce(key, message) {
@@ -8146,6 +8277,18 @@ function queueClaimDerivation(observation) {
   } catch {
   }
 }
+function queueObservationQualification(observation) {
+  const dataDir = projectDir;
+  if (!dataDir || observation.admissionState !== "candidate") return;
+  try {
+    enqueueObservationQualification({
+      dataDir,
+      projectId: observation.projectId,
+      source: "automatic-capture:" + observation.id
+    });
+  } catch {
+  }
+}
 function isVectorCompatibleWithCurrentIndex(embedding) {
   if (!embedding) return false;
   const vectorDimensions = getVectorDimensions();
@@ -8201,6 +8344,9 @@ async function storeObservation(input) {
       (o) => o.topicKey === input.topicKey && o.projectId === input.projectId
     );
     if (existing) {
+      if (input.visibilityReader && !canManageObservation(existing, input.visibilityReader)) {
+        throw new Error("Cannot update a memory outside this session's write scope.");
+      }
       return { observation: await upsertObservation(existing, input, now3), upserted: true };
     }
   }
@@ -8237,6 +8383,9 @@ async function storeObservation(input) {
         if (input.topicKey) {
           const diskExisting = await tx.findByTopicKey(input.projectId, input.topicKey);
           if (diskExisting) {
+            if (input.visibilityReader && !canManageObservation(diskExisting, input.visibilityReader)) {
+              throw new Error("Cannot update a memory outside this session's write scope.");
+            }
             upsertedInsideLock = true;
             observation = diskExisting;
             return;
@@ -8267,6 +8416,10 @@ async function storeObservation(input) {
           relatedEntities: input.relatedEntities,
           sourceDetail: input.sourceDetail,
           valueCategory: input.valueCategory,
+          admissionState: input.admissionState,
+          admissionReason: input.admissionReason ? sanitizeCredentials(input.admissionReason) : void 0,
+          visibility: input.visibility ?? "project",
+          sharedWithAgentIds: input.sharedWithAgentIds,
           createdByAgentId: input.createdByAgentId,
           // Predict the generation that atomic() will commit after this callback.
           // bumpGeneration() runs after fn(tx) returns, incrementing by 1.
@@ -8313,6 +8466,10 @@ async function storeObservation(input) {
         relatedEntities: input.relatedEntities,
         sourceDetail: input.sourceDetail,
         valueCategory: input.valueCategory,
+        admissionState: input.admissionState,
+        admissionReason: input.admissionReason ? sanitizeCredentials(input.admissionReason) : void 0,
+        visibility: input.visibility ?? "project",
+        sharedWithAgentIds: input.sharedWithAgentIds,
         createdByAgentId: input.createdByAgentId,
         writeGeneration: 0
       };
@@ -8336,7 +8493,12 @@ async function storeObservation(input) {
       status: "active",
       source: input.source ?? "agent",
       sourceDetail: input.sourceDetail ?? "",
-      valueCategory: input.valueCategory ?? ""
+      valueCategory: input.valueCategory ?? "",
+      admissionState: input.admissionState ?? "",
+      admissionReason: input.admissionReason ? sanitizeCredentials(input.admissionReason) : "",
+      visibility: input.visibility ?? "project",
+      createdByAgentId: input.createdByAgentId ?? "",
+      sharedWithAgentIds: JSON.stringify(input.sharedWithAgentIds ?? [])
     };
     await insertObservation(doc);
   };
@@ -8345,7 +8507,10 @@ async function storeObservation(input) {
     return { observation: await upsertObservation(observation, input, now3), upserted: true };
   }
   await bindObservationCodeRefsBestEffort(observation);
-  queueClaimDerivation(observation);
+  queueObservationQualification(observation);
+  if (resolveObservationVisibility(observation) === "project") {
+    queueClaimDerivation(observation);
+  }
   const obsId = observation.id;
   vectorMissingIds.add(obsId);
   const searchableText = [input.title, input.narrative, ...input.facts ?? []].join(" ");
@@ -8418,6 +8583,10 @@ async function upsertObservation(existing, input, now3) {
   if (input.progress) existing.progress = input.progress;
   if (input.sourceDetail !== void 0) existing.sourceDetail = input.sourceDetail;
   if (input.valueCategory !== void 0) existing.valueCategory = input.valueCategory;
+  if (input.admissionState !== void 0) existing.admissionState = input.admissionState;
+  if (input.admissionReason !== void 0) existing.admissionReason = sanitizeCredentials(input.admissionReason);
+  if (input.visibility !== void 0) existing.visibility = input.visibility;
+  if (input.sharedWithAgentIds !== void 0) existing.sharedWithAgentIds = input.sharedWithAgentIds;
   const doc = {
     id: makeOramaObservationId(existing.projectId, existing.id),
     observationId: existing.id,
@@ -8436,7 +8605,12 @@ async function upsertObservation(existing, input, now3) {
     status: "active",
     source: existing.source ?? "agent",
     sourceDetail: existing.sourceDetail ?? "",
-    valueCategory: existing.valueCategory ?? ""
+    valueCategory: existing.valueCategory ?? "",
+    admissionState: existing.admissionState ?? "",
+    admissionReason: existing.admissionReason ?? "",
+    visibility: existing.visibility ?? "project",
+    createdByAgentId: existing.createdByAgentId ?? "",
+    sharedWithAgentIds: JSON.stringify(existing.sharedWithAgentIds ?? [])
   };
   const oramaId = makeOramaObservationId(existing.projectId, existing.id);
   try {
@@ -8459,7 +8633,10 @@ async function upsertObservation(existing, input, now3) {
     await store.update(existing);
   }
   await bindObservationCodeRefsBestEffort(existing);
-  queueClaimDerivation(existing);
+  queueObservationQualification(existing);
+  if (resolveObservationVisibility(existing) === "project") {
+    queueClaimDerivation(existing);
+  }
   const searchableText = [input.title, input.narrative, ...input.facts ?? []].join(" ");
   const obsId = existing.id;
   vectorMissingIds.add(obsId);
@@ -8498,6 +8675,56 @@ async function upsertObservation(existing, input, now3) {
 function getObservation(id, projectId) {
   return observations.find((o) => o.id === id && (projectId ? o.projectId === projectId : true));
 }
+async function updateObservationAdmission(input) {
+  await ensureFreshObservations();
+  const cached = observations.find(
+    (observation) => observation.id === input.observationId && (!input.projectId || observation.projectId === input.projectId)
+  );
+  if (!cached) return void 0;
+  const now3 = (/* @__PURE__ */ new Date()).toISOString();
+  const admissionReason = sanitizeCredentials(input.admissionReason).slice(0, 240);
+  const apply = (current) => {
+    if (input.projectId && current.projectId !== input.projectId) return void 0;
+    if (input.expectedState && current.admissionState !== input.expectedState) return void 0;
+    return {
+      ...current,
+      admissionState: input.admissionState,
+      admissionReason,
+      ...input.visibility !== void 0 ? { visibility: input.visibility } : {},
+      updatedAt: now3
+    };
+  };
+  let updated;
+  if (projectDir) {
+    const store = getObservationStore();
+    await store.atomic(async (tx) => {
+      const current = await tx.getById(input.observationId);
+      if (!current) return;
+      const next = apply(current);
+      if (!next) return;
+      await tx.update(next);
+      updated = next;
+    });
+  } else {
+    updated = apply(cached);
+  }
+  if (!updated) return void 0;
+  observations = observations.map(
+    (observation) => observation.id === updated.id && observation.projectId === updated.projectId ? updated : observation
+  );
+  try {
+    await updateObservationMetadata(updated.projectId, updated.id, {
+      admissionState: updated.admissionState,
+      admissionReason: updated.admissionReason,
+      ...updated.visibility !== void 0 ? { visibility: updated.visibility } : {}
+    });
+  } catch {
+  }
+  if (updated.admissionState === "qualified" && resolveObservationVisibility(updated) === "project") {
+    queueClaimDerivation(updated);
+  }
+  return updated;
+}
 async function resolveObservations(ids, status = "resolved") {
   const resolved = [];
   const notFound = [];
@@ -8537,7 +8764,12 @@ async function resolveObservations(ids, status = "resolved") {
         status,
         source: obs.source ?? "agent",
         sourceDetail: obs.sourceDetail ?? "",
-        valueCategory: obs.valueCategory ?? ""
+        valueCategory: obs.valueCategory ?? "",
+        admissionState: obs.admissionState ?? "",
+        admissionReason: obs.admissionReason ?? "",
+        visibility: obs.visibility ?? "project",
+        createdByAgentId: obs.createdByAgentId ?? "",
+        sharedWithAgentIds: JSON.stringify(obs.sharedWithAgentIds ?? [])
       };
       await insertObservation(doc);
       const obsId = obs.id;
@@ -8667,6 +8899,11 @@ async function reindexObservations() {
         source: obs.source ?? "agent",
         sourceDetail: obs.sourceDetail ?? "",
         valueCategory: obs.valueCategory ?? "",
+        admissionState: obs.admissionState ?? "",
+        admissionReason: obs.admissionReason ?? "",
+        visibility: obs.visibility ?? "project",
+        createdByAgentId: obs.createdByAgentId ?? "",
+        sharedWithAgentIds: JSON.stringify(obs.sharedWithAgentIds ?? []),
         ...compatibleEmbedding ? { embedding: compatibleEmbedding } : {}
       };
       await insertObservation(doc);
@@ -8739,6 +8976,7 @@ async function probeSearchIndex(projectId) {
   await searchObservations({
     query: "semantic memory retrieval status",
     projectId,
+    reader: { projectId },
     limit: 1,
     status: "all",
     trackAccess: false
@@ -8804,6 +9042,11 @@ async function backfillVectorEmbeddings(options = {}) {
             source: obs.source ?? "agent",
             sourceDetail: obs.sourceDetail ?? "",
             valueCategory: obs.valueCategory ?? "",
+            admissionState: obs.admissionState ?? "",
+            admissionReason: obs.admissionReason ?? "",
+            visibility: obs.visibility ?? "project",
+            createdByAgentId: obs.createdByAgentId ?? "",
+            sharedWithAgentIds: JSON.stringify(obs.sharedWithAgentIds ?? []),
             embedding
           };
           await insertObservation(doc);
@@ -8845,6 +9088,7 @@ var init_observations = __esm({
     init_provider();
     init_secret_filter();
     init_lifecycle();
+    init_visibility();
     observations = [];
     nextId = 1;
     projectDir = null;
@@ -9062,6 +9306,36 @@ var init_session_store = __esm({
   }
 });
 
+// src/memory/graph-scope.ts
+function projectGraphEntityNames(observations2) {
+  const entityNames = /* @__PURE__ */ new Set();
+  for (const observation of observations2) {
+    if ((observation.status ?? "active") !== "active") continue;
+    const entityName = observation.entityName?.trim();
+    if (entityName) entityNames.add(entityName);
+    for (const relatedEntity of observation.relatedEntities ?? []) {
+      const name = relatedEntity.trim();
+      if (name) entityNames.add(name);
+    }
+  }
+  return entityNames;
+}
+function scopeKnowledgeGraphToProject(graph, observations2) {
+  const entityNames = projectGraphEntityNames(observations2);
+  const entities = graph.entities.filter((entity) => entityNames.has(entity.name));
+  const visibleNames = new Set(entities.map((entity) => entity.name));
+  const relations = graph.relations.filter(
+    (relation) => visibleNames.has(relation.from) && visibleNames.has(relation.to)
+  );
+  return { entities, relations, entityNames };
+}
+var init_graph_scope = __esm({
+  "src/memory/graph-scope.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/memory/disclosure-policy.ts
 function resolveEvidenceBasis(fields) {
   if (fields.commitHash || fields.source === "git" || fields.sourceDetail === "git-ingest") {
@@ -9094,8 +9368,9 @@ function resolveSourceDetail(sourceDetail, source) {
   return void 0;
 }
 function classifyLayer(fields) {
-  const { valueCategory } = fields;
+  const { valueCategory, admissionState } = fields;
   const sd = resolveSourceDetail(fields.sourceDetail, fields.source);
+  if (admissionState === "candidate" || admissionState === "ephemeral") return "L1";
   if (valueCategory === "core") return "L2";
   if (sd === "hook") return "L1";
   if (sd === "git-ingest") return "L3";
@@ -9153,6 +9428,7 @@ function getEffectiveRetentionDays(doc) {
 }
 function isImmune(doc) {
   if (doc.type === "probe") return false;
+  if (doc.admissionState === "candidate" || doc.admissionState === "ephemeral") return false;
   if (doc.valueCategory === "core") return true;
   const importance = getImportanceLevel(doc);
   if (importance === "critical") return true;
@@ -9162,6 +9438,7 @@ function isImmune(doc) {
 }
 function getImmunityReason(doc) {
   if (doc.type === "probe") return null;
+  if (doc.admissionState === "candidate" || doc.admissionState === "ephemeral") return null;
   if (doc.valueCategory === "core") return "core valueCategory (formation-classified)";
   const importance = getImportanceLevel(doc);
   if (importance === "critical") return "critical importance";
@@ -9294,7 +9571,9 @@ function toRetentionDocument(obs, accessMap) {
     status: obs.status ?? "active",
     source: obs.source ?? "agent",
     sourceDetail: obs.sourceDetail ?? "",
-    valueCategory: obs.valueCategory ?? ""
+    valueCategory: obs.valueCategory ?? "",
+    admissionState: obs.admissionState ?? "",
+    admissionReason: obs.admissionReason ?? ""
   };
 }
 async function archiveExpiredBatch(_projectDir, options) {
@@ -9308,7 +9587,7 @@ async function archiveExpiredBatch(_projectDir, options) {
   });
   const hasMore = page.length > limit;
   const scanned = hasMore ? page.slice(0, limit) : page;
-  const candidateIds = scanned.filter((observation) => getRetentionZone(
+  const candidateIds = scanned.filter((observation) => !options.reader || canManageObservation(observation, options.reader)).filter((observation) => getRetentionZone(
     toRetentionDocument(observation, options.accessMap),
     options.referenceTime
   ) === "archive-candidate").map((observation) => observation.id);
@@ -9321,7 +9600,7 @@ async function archiveExpiredBatch(_projectDir, options) {
   const nextCursor = hasMore && scanned.length > 0 ? scanned[scanned.length - 1].id : void 0;
   return nextCursor === void 0 ? { archived, scanned: scanned.length } : { archived, scanned: scanned.length, nextCursor };
 }
-async function archiveExpired(projectDir2, referenceTime, accessMap, projectId) {
+async function archiveExpired(projectDir2, referenceTime, accessMap, projectId, reader) {
   const store = getObservationStore();
   if (projectId) {
     let afterId;
@@ -9331,12 +9610,14 @@ async function archiveExpired(projectDir2, referenceTime, accessMap, projectId)
         projectId,
         afterId,
         referenceTime,
-        accessMap
+        accessMap,
+        reader
       });
       archived += batch.archived;
       afterId = batch.nextCursor;
     } while (afterId !== void 0);
-    const remaining = await store.countByProject(projectId, { status: "active" });
+    const remainingObservations = await store.loadByProject(projectId, { status: "active" });
+    const remaining = reader ? remainingObservations.filter((observation) => canManageObservation(observation, reader)).length : remainingObservations.length;
     return { archived, remaining };
   }
   return await store.atomic(async (tx) => {
@@ -9366,6 +9647,7 @@ var init_retention = __esm({
     "use strict";
     init_esm_shims();
     init_obs_store();
+    init_visibility();
     RETENTION_DAYS = {
       critical: 365,
       high: 180,
@@ -9401,6 +9683,49 @@ var init_retention = __esm({
   }
 });
 
+// src/memory/admission.ts
+var admission_exports = {};
+__export(admission_exports, {
+  isCandidateObservation: () => isCandidateObservation,
+  isEligibleForAutomaticDelivery: () => isEligibleForAutomaticDelivery,
+  isEligibleForKnowledgePromotion: () => isEligibleForKnowledgePromotion,
+  qualifyCandidateFromCurrentCode: () => qualifyCandidateFromCurrentCode
+});
+function isEligibleForAutomaticDelivery(observation) {
+  return observation.admissionState !== "ephemeral" && observation.admissionState !== "candidate";
+}
+function isCandidateObservation(observation) {
+  return observation.admissionState === "candidate";
+}
+function isEligibleForKnowledgePromotion(observation) {
+  return isEligibleForAutomaticDelivery(observation) && observation.valueCategory !== "ephemeral" && resolveObservationVisibility(observation) === "project";
+}
+function qualifyCandidateFromCurrentCode(input) {
+  if (!isCandidateObservation(input.observation)) return void 0;
+  if (input.observation.valueCategory === "ephemeral") return void 0;
+  if (input.currentCodeReferenceCount <= 0) return void 0;
+  const typeLabel = DURABLE_AUTOMATIC_TYPES.has(input.observation.type) ? "high-value automatic record" : "automatic record";
+  return {
+    admissionState: "qualified",
+    admissionReason: `${typeLabel} qualified against ${input.currentCodeReferenceCount} current Code Memory reference(s)`
+  };
+}
+var DURABLE_AUTOMATIC_TYPES;
+var init_admission = __esm({
+  "src/memory/admission.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_visibility();
+    DURABLE_AUTOMATIC_TYPES = /* @__PURE__ */ new Set([
+      "decision",
+      "gotcha",
+      "problem-solution",
+      "trade-off",
+      "why-it-exists"
+    ]);
+  }
+});
+
 // src/workspace/workflow-sync.ts
 import matter9 from "gray-matter";
 var WorkflowSyncer;
@@ -10801,6 +11126,7 @@ var init_isolated_maintenance = __esm({
       "retention-archive",
       "consolidation",
       "codegraph-refresh",
+      "observation-qualify",
       "claim-derive",
       "claim-requalification",
       "knowledge-compile",
@@ -11236,9 +11562,10 @@ async function loadConsolidationPage(projectId, options) {
   return hasMore && observations2.length > 0 ? { observations: observations2, nextCursor: observations2[observations2.length - 1].id } : { observations: observations2 };
 }
 function findClusters(observations2, threshold) {
-  if (observations2.length < MIN_CLUSTER_SIZE) return [];
+  const eligible = observations2.filter(isEligibleForAutomaticDelivery).filter((observation) => resolveObservationVisibility(observation) === "project");
+  if (eligible.length < MIN_CLUSTER_SIZE) return [];
   const groups = /* @__PURE__ */ new Map();
-  for (const obs of observations2) {
+  for (const obs of eligible) {
     const key = `${obs.entityName}::${obs.type}`;
     const group = groups.get(key) ?? [];
     group.push(obs);
@@ -11375,6 +11702,8 @@ var init_consolidation = __esm({
     "use strict";
     init_esm_shims();
     init_obs_store();
+    init_admission();
+    init_visibility();
     DEFAULT_SIMILARITY_THRESHOLD = 0.45;
     HIGH_VALUE_SIMILARITY_THRESHOLD = 0.85;
     HIGH_VALUE_TYPES = /* @__PURE__ */ new Set(["gotcha", "decision", "trade-off", "reasoning", "problem-solution"]);
@@ -12174,6 +12503,7 @@ __export(claims_exports, {
   buildClaimIdentity: () => buildClaimIdentity,
   deriveLowRiskClaimsFromObservation: () => deriveLowRiskClaimsFromObservation,
   requalifyClaimsForCodeState: () => requalifyClaimsForCodeState,
+  reviewClaim: () => reviewClaim,
   selectClaimsForTask: () => selectClaimsForTask,
   supersedeClaim: () => supersedeClaim,
   writeClaim: () => writeClaim
@@ -12360,6 +12690,39 @@ function writeClaim(store, input) {
     };
   });
 }
+function reviewClaim(store, input) {
+  if (input.reviewState !== "approved" && input.reviewState !== "rejected") {
+    throw new Error("A claim review must approve or reject the claim");
+  }
+  const detail = compactText(input.detail, "review detail");
+  return store.transaction(() => {
+    const claim = store.getClaim(input.claimId);
+    if (!claim) throw new Error("Claim was not found");
+    if (input.reviewState === "approved" && claim.status === "superseded") {
+      throw new Error("A superseded claim cannot be approved");
+    }
+    const now3 = (/* @__PURE__ */ new Date()).toISOString();
+    const nextStatus = input.reviewState === "rejected" ? "unknown" : claim.status === "unknown" && claim.reviewState === "rejected" ? "active" : claim.status;
+    const updated = {
+      ...claim,
+      status: nextStatus,
+      reviewState: input.reviewState,
+      updatedAt: now3
+    };
+    store.updateClaim(updated);
+    store.recordEvent({
+      projectId: claim.projectId,
+      claimId: claim.id,
+      kind: "reviewed",
+      fromStatus: claim.status,
+      toStatus: updated.status,
+      detail: "Review: " + claim.reviewState + " -> " + input.reviewState + ". " + detail,
+      createdAt: now3
+    });
+    reconcileConflicts(store, claim.projectId, claim.conflictKey, now3);
+    return store.getClaim(claim.id) ?? updated;
+  });
+}
 function supersedeClaim(store, input) {
   const evidence = validateEvidence(input.evidence);
   return store.transaction(() => {
@@ -12448,7 +12811,7 @@ function deriveLowRiskClaimsFromObservation(store, observation, codeStore) {
     scope: "project",
     confidence,
     observedAt: observation.updatedAt ?? observation.createdAt,
-    reviewState: "approved",
+    reviewState: isGit ? "approved" : "needs-review",
     origin: isGit ? "git" : "derived",
     evidence
   });
@@ -13324,81 +13687,425 @@ var init_workflow_store = __esm({
   }
 });
 
-// src/knowledge/workflows.ts
-var workflows_exports = {};
-__export(workflows_exports, {
-  WORKFLOW_ADAPTER_TARGETS: () => WORKFLOW_ADAPTER_TARGETS,
-  applyWorkflowAdapter: () => applyWorkflowAdapter,
-  importWindsurfWorkflows: () => importWindsurfWorkflows,
-  parseWorkflowMarkdown: () => parseWorkflowMarkdown,
-  previewWorkflowAdapter: () => previewWorkflowAdapter,
-  recordWorkflowRun: () => recordWorkflowRun,
-  renderWorkflowMarkdown: () => renderWorkflowMarkdown,
-  selectWorkflows: () => selectWorkflows,
-  selectWorkspaceWorkflows: () => selectWorkspaceWorkflows,
-  syncCanonicalWorkflows: () => syncCanonicalWorkflows,
-  writeCanonicalWorkflow: () => writeCanonicalWorkflow
+// src/codegraph/task-lens.ts
+var task_lens_exports = {};
+__export(task_lens_exports, {
+  containsTaskKeyword: () => containsTaskKeyword,
+  lensPathCandidates: () => lensPathCandidates,
+  lensVerificationHints: () => lensVerificationHints,
+  rankLensPaths: () => rankLensPaths,
+  rankLensSources: () => rankLensSources,
+  resolveTaskLens: () => resolveTaskLens,
+  scoreLensSource: () => scoreLensSource,
+  shouldShowLensSource: () => shouldShowLensSource
 });
-import { createHash as createHash12 } from "crypto";
-import { promises as fs14 } from "fs";
-import path17 from "path";
-import matter11 from "gray-matter";
-function hash3(value) {
-  return createHash12("sha256").update(value).digest("hex");
-}
-function now2() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function slug(value) {
-  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 72);
-  return normalized || "workflow";
+function normalizePath2(path25) {
+  return path25.replace(/\\/g, "/");
 }
-function titleFromName(name) {
-  return name.replace(/[-_]+/g, " ").split(" ").filter(Boolean).map((part) => part.slice(0, 1).toUpperCase() + part.slice(1)).join(" ") || "Imported Workflow";
+function tokenize2(text) {
+  return (text.toLowerCase().match(/[a-z0-9_./-]+|[\u4e00-\u9fff]+/g) ?? []).map((token) => token.trim()).filter((token) => token.length > 1 && !STOP_WORDS.has(token));
 }
-function requiredText(data, key) {
-  const value = data[key];
-  if (typeof value !== "string" || !value.trim()) {
-    throw new Error("workflow frontmatter requires " + key);
+function containsTaskKeyword(text, keyword) {
+  const matcher = /^[a-z0-9_-]+$/i.test(keyword) ? new RegExp(`(^|[^a-z0-9_-])${keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?=[^a-z0-9_-]|$)`, "gi") : new RegExp(keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "gi");
+  let match;
+  while ((match = matcher.exec(text)) !== null) {
+    const keywordIndex = match.index + (match[1]?.length ?? 0);
+    if (!isNegatedTaskKeyword(text, keywordIndex)) return true;
   }
-  return value.trim();
+  return false;
 }
-function optionalText4(data, key) {
-  const value = data[key];
-  if (value === void 0 || value === null || value === "") return void 0;
-  if (typeof value !== "string") throw new Error("workflow frontmatter field " + key + " must be text");
-  return value.trim() || void 0;
+function isNegatedTaskKeyword(text, keywordIndex) {
+  const boundary = Math.max(
+    text.lastIndexOf(".", keywordIndex - 1),
+    text.lastIndexOf("!", keywordIndex - 1),
+    text.lastIndexOf("?", keywordIndex - 1),
+    text.lastIndexOf(";", keywordIndex - 1),
+    text.lastIndexOf("\n", keywordIndex - 1),
+    text.lastIndexOf("\u3002", keywordIndex - 1),
+    text.lastIndexOf("\uFF01", keywordIndex - 1),
+    text.lastIndexOf("\uFF1F", keywordIndex - 1),
+    text.lastIndexOf("\uFF1B", keywordIndex - 1)
+  );
+  let prefix = text.slice(boundary + 1, keywordIndex).toLowerCase();
+  const contrast = /(?:,|\uff0c)\s*(?:but|however|instead|yet|\u4f46\u662f|\u4f46|\u800c\u662f)\s*/gi;
+  let contrastMatch;
+  let contrastEnd = -1;
+  while ((contrastMatch = contrast.exec(prefix)) !== null) contrastEnd = contrast.lastIndex;
+  if (contrastEnd >= 0) prefix = prefix.slice(contrastEnd);
+  if (/\b(?:do|does|did|should|must|can|could|will|would|may|might)\s+not\b/.test(prefix)) return true;
+  if (/\b(?:don't|dont|never|without|avoid|skip)\b/.test(prefix)) return true;
+  if (/(?:^|[\s,])no\s+(?:[a-z0-9_-]+\s*){0,4}$/i.test(prefix)) return true;
+  const chineseClauseStart = Math.max(prefix.lastIndexOf(","), prefix.lastIndexOf("\uFF0C"), prefix.lastIndexOf("\u3001"));
+  const chineseClause = prefix.slice(chineseClauseStart + 1);
+  return /(?:\u4e0d\u8981|\u4e0d\u5e94|\u4e0d\u53ef|\u4e0d\u80fd|\u4e0d\u4f1a|\u7981\u6b62|\u52ff|\u4e0d)\s*(?:\u7acb\u5373|\u76f4\u63a5|\u518d|\u73b0\u5728|\u64c5\u81ea|\u5148)?\s*$/.test(chineseClause);
 }
-function optionalStringArray(data, key) {
-  const value = data[key];
-  if (value === void 0 || value === null) return [];
-  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
-    throw new Error("workflow frontmatter field " + key + " must be a string array");
+function resolveTaskLens(task) {
+  const normalized = (task ?? "").toLowerCase();
+  if (!normalized.trim()) return LENSES.general;
+  let best = {
+    id: "general",
+    score: 0,
+    priority: Number.MAX_SAFE_INTEGER
+  };
+  for (const id of LENS_PRIORITY) {
+    const score = KEYWORDS[id].reduce((sum, keyword) => sum + (containsTaskKeyword(normalized, keyword) ? 1 : 0), 0);
+    const priority = LENS_PRIORITY.indexOf(id);
+    if (score > best.score || score === best.score && score > 0 && priority < best.priority) {
+      best = { id, score, priority };
+    }
   }
-  return [...new Set(value.map((item) => item.trim()).filter(Boolean))];
+  return best.score > 0 ? LENSES[best.id] : LENSES.general;
 }
-function optionalNumber(data, key, fallback) {
-  const value = data[key];
-  if (value === void 0 || value === null || value === "") return fallback;
-  if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
-    throw new Error("workflow frontmatter field " + key + " must be a positive integer");
+function pathKindScore(path25, lens) {
+  const normalized = normalizePath2(path25).toLowerCase();
+  const name = normalized.split("/").pop() ?? normalized;
+  const inDocs = normalized.startsWith("docs/") || name === "readme.md" || name.includes("readme");
+  const isTest = /(^|\/)(tests?|__tests__|spec|fixtures?)\//.test(normalized) || /\.(test|spec)\.[cm]?[jt]sx?$/.test(normalized) || /\.(test|spec)\.py$/.test(normalized);
+  const isSource = normalized.startsWith("src/") || normalized.includes("/src/");
+  const isPackage = name === "package.json" || name === "package-lock.json" || name === "pnpm-lock.yaml" || name === "yarn.lock";
+  const isChangelog = name === "changelog.md" || name === "changes.md";
+  const isWorkflow = normalized.startsWith(".github/workflows/");
+  switch (lens.id) {
+    case "bugfix":
+      return (isTest ? 80 : 0) + (isSource ? 50 : 0) + (normalized.includes("debug") ? 20 : 0);
+    case "test":
+      return (isTest ? 90 : 0) + (isSource ? 45 : 0);
+    case "release":
+      return (isChangelog ? 100 : 0) + (isPackage ? 90 : 0) + (isWorkflow ? 70 : 0) + (inDocs ? 35 : 0);
+    case "onboarding":
+      return (name === "readme.md" ? 100 : 0) + (inDocs ? 80 : 0) + (isPackage ? 45 : 0) + (isSource ? 20 : 0);
+    case "docs":
+      return (inDocs ? 100 : 0) + (isChangelog ? 60 : 0) + (isSource ? 25 : 0);
+    case "refactor":
+      return (isSource ? 70 : 0) + (isTest ? 65 : 0);
+    case "feature":
+      return (isSource ? 80 : 0) + (isTest ? 45 : 0) + (inDocs ? 20 : 0);
+    default:
+      if (isSource || isTest) return 60;
+      if (normalized.startsWith("packages/") && normalized.includes("/src/")) return 45;
+      if (inDocs) return 20;
+      return 0;
   }
-  return value;
 }
-function optionalStatus(data) {
-  const value = data.status;
-  if (value === void 0 || value === null || value === "") return "draft";
-  if (typeof value !== "string" || !STATUS_VALUES.includes(value)) {
-    throw new Error("workflow frontmatter field status is invalid");
-  }
-  return value;
+function tokenScore(text, tokens) {
+  if (tokens.length === 0) return 0;
+  const normalized = text.toLowerCase();
+  return tokens.reduce((sum, token) => sum + (normalized.includes(token) ? 12 : 0), 0);
 }
-function normalizeAgents(values) {
-  const unknown = values.filter((value) => !KNOWN_AGENTS.includes(value));
-  if (unknown.length > 0) {
-    throw new Error("workflow frontmatter has unsupported agent: " + unknown[0]);
-  }
-  return values;
+function sourceTaskMatchScore(source, task) {
+  const tokens = tokenize2(task ?? "");
+  if (tokens.length === 0) return 0;
+  const text = [
+    source.title,
+    source.path ?? "",
+    source.symbol ?? ""
+  ].join("\n").toLowerCase();
+  const matches = tokens.filter((token) => text.includes(token)).length;
+  if (matches >= 2) return 40;
+  if (matches === 1) return 24;
+  return 0;
+}
+function fallbackPathRank(path25) {
+  const normalized = normalizePath2(path25);
+  if (normalized.startsWith("src/")) return 0;
+  if (normalized.startsWith("tests/") || normalized.startsWith("test/")) return 1;
+  if (normalized.startsWith("packages/") && normalized.includes("/src/")) return 2;
+  if (normalized.startsWith("docs/") || normalized.toLowerCase() === "readme.md") return 3;
+  return 4;
+}
+function rankLensPaths(paths, lens, task) {
+  const tokens = tokenize2(task ?? "");
+  return [...new Set(paths.map(normalizePath2))].map((path25, index) => ({
+    path: path25,
+    index,
+    score: pathKindScore(path25, lens) + tokenScore(path25, tokens),
+    fallback: fallbackPathRank(path25)
+  })).sort((a, b) => b.score - a.score || a.fallback - b.fallback || a.index - b.index || a.path.localeCompare(b.path)).map((item) => item.path);
+}
+function lensPathCandidates(lens) {
+  switch (lens.id) {
+    case "release":
+      return ["CHANGELOG.md", "package.json", "package-lock.json", ".github/workflows/ci.yml", ".github/workflows/test.yml", "README.md"];
+    case "onboarding":
+      return ["README.md", "docs/README.md", "docs/API_REFERENCE.md", "package.json"];
+    case "docs":
+      return ["README.md", "README.zh-CN.md", "docs/README.md", "docs/API_REFERENCE.md", "CHANGELOG.md"];
+    case "test":
+    case "bugfix":
+      return ["tests", "test"];
+    default:
+      return [];
+  }
+}
+function scoreLensSource(source, lens, task) {
+  const tokens = tokenize2(task ?? "");
+  const text = [source.title, source.type, source.path ?? "", source.symbol ?? ""].join("\n");
+  return pathKindScore(source.path ?? "", lens) + tokenScore(text, tokens) + sourceTaskMatchScore(source, task);
+}
+function rankLensSources(sources, lens, task) {
+  return [...sources].map((source, index) => ({
+    source,
+    index,
+    score: scoreLensSource(source, lens, task)
+  })).sort((a, b) => b.score - a.score || a.source.observationId - b.source.observationId || a.index - b.index).map((item) => item.source);
+}
+function lensVerificationHints(lens) {
+  switch (lens.id) {
+    case "bugfix":
+      return [
+        "run the smallest failing test or repro first",
+        "inspect the changed code path before trusting old memory"
+      ];
+    case "test":
+      return [
+        "run the exact focused test file or test name first",
+        "inspect fixtures and harness setup before changing assertions"
+      ];
+    case "release":
+      return [
+        "run build, tests, package smoke, and publish dry-run where available",
+        "verify package metadata, changelog, and Git state before publishing"
+      ];
+    case "onboarding":
+      return [
+        "read the docs/start files first, then inspect only the code paths needed for the task",
+        "treat old implementation memories as leads until current code confirms them"
+      ];
+    case "refactor":
+      return [
+        "inspect call sites and tests before editing shared code",
+        "run the narrow affected test plus one regression smoke"
+      ];
+    case "docs":
+      return [
+        "check headings, links, commands, and examples against current code",
+        "run the smallest docs or package smoke available"
+      ];
+    case "feature":
+      return [
+        "inspect the closest existing implementation pattern before adding new code",
+        "run focused tests plus one user-flow smoke after changes"
+      ];
+    default:
+      return [
+        "inspect the Start here files before editing",
+        "run the smallest relevant test or smoke command after changes"
+      ];
+  }
+}
+function shouldShowLensSource(source, lens, task) {
+  if (lens.id === "general") return true;
+  const score = scoreLensSource(source, lens, task);
+  if (lens.id === "onboarding" || lens.id === "release" || lens.id === "docs") return score >= 40;
+  return score > 0;
+}
+var STOP_WORDS, LENSES, KEYWORDS, LENS_PRIORITY;
+var init_task_lens = __esm({
+  "src/codegraph/task-lens.ts"() {
+    "use strict";
+    init_esm_shims();
+    STOP_WORDS = /* @__PURE__ */ new Set([
+      "a",
+      "an",
+      "and",
+      "as",
+      "for",
+      "in",
+      "into",
+      "of",
+      "on",
+      "onto",
+      "the",
+      "this",
+      "that",
+      "to",
+      "with",
+      "work",
+      "project",
+      "continue",
+      "\u7EE7\u7EED",
+      "\u9879\u76EE"
+    ]);
+    LENSES = {
+      bugfix: {
+        id: "bugfix",
+        description: "debug the failure with current code and the smallest repro first",
+        sourceLimit: 6,
+        cautionLimit: 4,
+        hideUnrelatedCautionDetails: true,
+        hideUnrelatedReliableDetails: false
+      },
+      feature: {
+        id: "feature",
+        description: "build a scoped feature from nearby source, types, and user flow",
+        sourceLimit: 6,
+        cautionLimit: 3,
+        hideUnrelatedCautionDetails: true,
+        hideUnrelatedReliableDetails: false
+      },
+      release: {
+        id: "release",
+        description: "prepare a release using current metadata, changelog, build, and package checks",
+        sourceLimit: 4,
+        cautionLimit: 2,
+        hideUnrelatedCautionDetails: true,
+        hideUnrelatedReliableDetails: true
+      },
+      onboarding: {
+        id: "onboarding",
+        description: "understand the project shape before trusting old implementation details",
+        sourceLimit: 4,
+        cautionLimit: 2,
+        hideUnrelatedCautionDetails: true,
+        hideUnrelatedReliableDetails: true
+      },
+      refactor: {
+        id: "refactor",
+        description: "change structure carefully by reading shared code, call sites, and tests",
+        sourceLimit: 6,
+        cautionLimit: 4,
+        hideUnrelatedCautionDetails: true,
+        hideUnrelatedReliableDetails: false
+      },
+      docs: {
+        id: "docs",
+        description: "update documentation against current code and public entry points",
+        sourceLimit: 5,
+        cautionLimit: 2,
+        hideUnrelatedCautionDetails: true,
+        hideUnrelatedReliableDetails: true
+      },
+      test: {
+        id: "test",
+        description: "work from tests, fixtures, harnesses, and the related source files",
+        sourceLimit: 6,
+        cautionLimit: 3,
+        hideUnrelatedCautionDetails: true,
+        hideUnrelatedReliableDetails: false
+      },
+      general: {
+        id: "general",
+        description: "balanced project handoff with current facts, code memory, and verification hints",
+        sourceLimit: 8,
+        cautionLimit: 5,
+        hideUnrelatedCautionDetails: false,
+        hideUnrelatedReliableDetails: false
+      }
+    };
+    KEYWORDS = {
+      bugfix: [
+        "bug",
+        "crash",
+        "incident",
+        "debug",
+        "error",
+        "fail",
+        "failing",
+        "fix",
+        "issue",
+        "regression",
+        "repro",
+        "\u62A5\u9519",
+        "\u5D29\u6E83",
+        "\u6545\u969C",
+        "\u5931\u8D25",
+        "\u4FEE\u590D",
+        "\u95EE\u9898"
+      ],
+      feature: ["add", "build", "feature", "implement", "new", "support", "\u65B0\u589E", "\u5B9E\u73B0", "\u652F\u6301", "\u529F\u80FD"],
+      release: ["bump", "changelog", "npm", "pack", "publish", "release", "version", "\u53D1\u7248", "\u53D1\u5E03", "\u7248\u672C"],
+      onboarding: ["architecture", "handoff", "onboard", "overview", "understand", "\u63A5\u624B", "\u4E86\u89E3", "\u7406\u89E3", "\u67B6\u6784"],
+      refactor: ["cleanup", "migrate", "refactor", "rename", "restructure", "\u91CD\u6784", "\u8FC1\u79FB", "\u6539\u9020"],
+      docs: ["doc", "docs", "readme", "\u6587\u6863", "\u8BF4\u660E"],
+      test: ["coverage", "fixture", "smoke", "spec", "test", "tests", "testing", "vitest", "\u6D4B\u8BD5"]
+    };
+    LENS_PRIORITY = [
+      "bugfix",
+      "release",
+      "test",
+      "refactor",
+      "feature",
+      "docs",
+      "onboarding"
+    ];
+  }
+});
+
+// src/knowledge/workflows.ts
+var workflows_exports = {};
+__export(workflows_exports, {
+  WORKFLOW_ADAPTER_TARGETS: () => WORKFLOW_ADAPTER_TARGETS,
+  applyWorkflowAdapter: () => applyWorkflowAdapter,
+  importWindsurfWorkflows: () => importWindsurfWorkflows,
+  parseWorkflowMarkdown: () => parseWorkflowMarkdown,
+  previewWorkflowAdapter: () => previewWorkflowAdapter,
+  recordWorkflowRun: () => recordWorkflowRun,
+  renderWorkflowMarkdown: () => renderWorkflowMarkdown,
+  selectWorkflows: () => selectWorkflows,
+  selectWorkspaceWorkflows: () => selectWorkspaceWorkflows,
+  syncCanonicalWorkflows: () => syncCanonicalWorkflows,
+  writeCanonicalWorkflow: () => writeCanonicalWorkflow
+});
+import { createHash as createHash12 } from "crypto";
+import { promises as fs14 } from "fs";
+import path17 from "path";
+import matter11 from "gray-matter";
+function hash3(value) {
+  return createHash12("sha256").update(value).digest("hex");
+}
+function now2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function slug(value) {
+  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 72);
+  return normalized || "workflow";
+}
+function titleFromName(name) {
+  return name.replace(/[-_]+/g, " ").split(" ").filter(Boolean).map((part) => part.slice(0, 1).toUpperCase() + part.slice(1)).join(" ") || "Imported Workflow";
+}
+function requiredText(data, key) {
+  const value = data[key];
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("workflow frontmatter requires " + key);
+  }
+  return value.trim();
+}
+function optionalText4(data, key) {
+  const value = data[key];
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "string") throw new Error("workflow frontmatter field " + key + " must be text");
+  return value.trim() || void 0;
+}
+function optionalStringArray(data, key) {
+  const value = data[key];
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error("workflow frontmatter field " + key + " must be a string array");
+  }
+  return [...new Set(value.map((item) => item.trim()).filter(Boolean))];
+}
+function optionalNumber(data, key, fallback) {
+  const value = data[key];
+  if (value === void 0 || value === null || value === "") return fallback;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+    throw new Error("workflow frontmatter field " + key + " must be a positive integer");
+  }
+  return value;
+}
+function optionalStatus(data) {
+  const value = data.status;
+  if (value === void 0 || value === null || value === "") return "draft";
+  if (typeof value !== "string" || !STATUS_VALUES.includes(value)) {
+    throw new Error("workflow frontmatter field status is invalid");
+  }
+  return value;
+}
+function normalizeAgents(values) {
+  const unknown = values.filter((value) => !KNOWN_AGENTS.includes(value));
+  if (unknown.length > 0) {
+    throw new Error("workflow frontmatter has unsupported agent: " + unknown[0]);
+  }
+  return values;
 }
 function phaseFromValue(value, index) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -13646,20 +14353,27 @@ function taskScore(workflow, task) {
   const text = task.toLowerCase();
   let score = 0;
   const reasons = [];
+  const matchedLenses = /* @__PURE__ */ new Set();
+  const matchedTriggers = /* @__PURE__ */ new Set();
   for (const lens of workflow.taskLenses) {
     const terms = LENS_TERMS[lens.toLowerCase()] ?? [lens.toLowerCase()];
-    if (terms.some((term) => text.includes(term))) {
+    if (terms.some((term) => containsTaskKeyword(task, term))) {
       score += 20;
       reasons.push("matches " + lens + " workflow");
+      matchedLenses.add(lens.toLowerCase());
     }
   }
   for (const trigger of workflow.triggers) {
     const term = trigger.toLowerCase().trim();
-    if (term.length >= 2 && text.includes(term)) {
+    if (term.length >= 2 && containsTaskKeyword(task, term)) {
       score += 8;
       reasons.push('matches trigger "' + trigger + '"');
+      matchedTriggers.add(term);
     }
   }
+  const hasSpecificLens = workflow.taskLenses.some((lens) => !GENERIC_WORKFLOW_LENSES.has(lens.toLowerCase()));
+  const hasSpecificMatch = [...matchedLenses].some((lens) => !GENERIC_WORKFLOW_LENSES.has(lens)) || [...matchedTriggers].some((trigger) => !GENERIC_WORKFLOW_TERMS.has(trigger));
+  if (hasSpecificLens && !hasSpecificMatch) return { score: 0, reasons: [] };
   return { score, reasons: [...new Set(reasons)] };
 }
 function selectWorkflows(input) {
@@ -13677,9 +14391,28 @@ function selectWorkflows(input) {
   return selected.slice(0, Math.max(1, Math.min(input.limit ?? 2, 2)));
 }
 function importedWorkflowSpec(input) {
+  let sourceMatter;
+  try {
+    sourceMatter = matter11(input.raw);
+  } catch (error) {
+    throw new Error("Malformed Windsurf workflow Markdown: " + (error instanceof Error ? error.message : String(error)));
+  }
+  if (sourceMatter.data.id !== void 0) {
+    const id = requiredText(sourceMatter.data, "id");
+    const sourcePath2 = "workflows/" + slug(id) + ".md";
+    const canonical = parsedWorkflow(sourceMatter.data, sourceMatter.content, {
+      workspaceId: input.workspace.id,
+      sourcePath: sourcePath2,
+      contentHash: hash3(input.raw)
+    });
+    return materializeWorkflow({
+      ...canonical,
+      importedFrom: input.sourcePath.replace(/\\/g, "/")
+    });
+  }
   const entry = new WorkflowSyncer().parseWindsurfWorkflow(input.sourceName, input.raw);
   const content = entry.content.trim() || "## Execute\n\nFollow the imported workflow.";
-  const lenses = inferTaskLenses(entry.name + "\n" + entry.description + "\n" + content);
+  const lenses = inferTaskLenses(entry.name + "\n" + entry.description);
   const createdAt = now2();
   const sourcePath = "workflows/" + slug(entry.name) + ".md";
   const spec = {
@@ -13900,7 +14633,7 @@ async function selectWorkspaceWorkflows(input) {
     errors: synced.errors
   };
 }
-var KNOWN_AGENTS, WORKFLOW_ADAPTER_TARGETS, STATUS_VALUES, LENS_TERMS;
+var KNOWN_AGENTS, WORKFLOW_ADAPTER_TARGETS, STATUS_VALUES, LENS_TERMS, GENERIC_WORKFLOW_LENSES, GENERIC_WORKFLOW_TERMS;
 var init_workflows = __esm({
   "src/knowledge/workflows.ts"() {
     "use strict";
@@ -13909,6 +14642,7 @@ var init_workflows = __esm({
     init_workflow_sync();
     init_workspace();
     init_workflow_store();
+    init_task_lens();
     KNOWN_AGENTS = [
       "windsurf",
       "cursor",
@@ -13940,6 +14674,8 @@ var init_workflows = __esm({
       refactor: ["refactor", "cleanup", "restructure", "\u91CD\u6784", "\u6574\u7406"],
       test: ["test", "verify", "smoke", "\u6D4B\u8BD5", "\u9A8C\u8BC1"]
     };
+    GENERIC_WORKFLOW_LENSES = /* @__PURE__ */ new Set(["review", "test"]);
+    GENERIC_WORKFLOW_TERMS = /* @__PURE__ */ new Set(["review", "audit", "test", "verify", "smoke"]);
   }
 });
 
@@ -13986,6 +14722,15 @@ function claimDerivationCursor(payload) {
   const value = payload.cursor;
   return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
 }
+function observationQualificationBatchSize(payload) {
+  const value = payload.limit;
+  if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_OBSERVATION_QUALIFICATION_BATCH_SIZE;
+  return Math.min(500, Math.max(1, Math.floor(value)));
+}
+function observationQualificationCursor(payload) {
+  const value = payload.cursor;
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}
 function observationId(payload) {
   const value = payload.observationId;
   return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : void 0;
@@ -14164,6 +14909,71 @@ function createProjectMaintenanceHandler(projectId, projectDir2, projectRoot, op
         ...snapshot?.id ? { snapshotId: snapshot.id } : {},
         ...options.maintenanceQueue ? { queue: options.maintenanceQueue } : {}
       });
+      enqueueObservationQualification({
+        projectId,
+        dataDir: projectDir2,
+        source: "codegraph-refresh",
+        ...options.maintenanceQueue ? { queue: options.maintenanceQueue } : {}
+      });
+      return { action: "complete" };
+    }
+    if (job.kind === "observation-qualify") {
+      const [
+        { CodeGraphStore: CodeGraphStore2 },
+        { bindObservationToCode: bindObservationToCode2 },
+        { getObservationStore: getObservationStore2 },
+        { qualifyCandidateFromCurrentCode: qualifyCandidateFromCurrentCode2 },
+        { updateObservationAdmission: updateObservationAdmission2 }
+      ] = await Promise.all([
+        Promise.resolve().then(() => (init_store(), store_exports)),
+        Promise.resolve().then(() => (init_binder(), binder_exports)),
+        Promise.resolve().then(() => (init_obs_store(), obs_store_exports)),
+        Promise.resolve().then(() => (init_admission(), admission_exports)),
+        Promise.resolve().then(() => (init_observations(), observations_exports))
+      ]);
+      const codeStore = new CodeGraphStore2();
+      await codeStore.init(projectDir2);
+      const limit = observationQualificationBatchSize(job.payload);
+      const page = await getObservationStore2().loadByProject(projectId, {
+        status: "active",
+        afterId: observationQualificationCursor(job.payload),
+        limit: limit + 1
+      });
+      const hasMore = page.length > limit;
+      const observations2 = hasMore ? page.slice(0, limit) : page;
+      const indexedAtMs = Date.parse(codeStore.status(projectId).indexedAt ?? "");
+      for (const observation of observations2) {
+        if (observation.admissionState !== "candidate") continue;
+        if (!Number.isFinite(indexedAtMs) || indexedAtMs < Date.parse(observation.createdAt)) continue;
+        await bindObservationToCode2(codeStore, observation);
+        const currentCodeReferenceCount = codeStore.listObservationRefs(projectId, observation.id).filter((reference) => reference.status === "current").length;
+        const qualification = qualifyCandidateFromCurrentCode2({
+          observation,
+          currentCodeReferenceCount
+        });
+        if (!qualification) continue;
+        await updateObservationAdmission2({
+          observationId: observation.id,
+          projectId,
+          expectedState: "candidate",
+          // Automatic capture earns project visibility only after a current
+          // Code Memory link exists. Explicit/private records retain scope.
+          ...observation.sourceDetail === "hook" ? { visibility: "project" } : {},
+          ...qualification
+        });
+      }
+      if (hasMore && observations2.length > 0) {
+        return {
+          action: "reschedule",
+          delayMs: 0,
+          resetAttempts: true,
+          payload: {
+            ...job.payload,
+            cursor: observations2[observations2.length - 1].id,
+            limit
+          }
+        };
+      }
       return { action: "complete" };
     }
     if (job.kind === "claim-derive") {
@@ -14329,7 +15139,7 @@ function createProjectMaintenanceDispatcher(projectId, projectDir2, projectRoot,
     return isolatedRunner({ job, projectRoot, dataDir: projectDir2 });
   };
 }
-var DEFAULT_VECTOR_BATCH_SIZE, DEFAULT_RETENTION_BATCH_SIZE, DEFAULT_CONSOLIDATION_BATCH_SIZE, DEFAULT_CODEGRAPH_MAX_FILES, DEFAULT_CLAIM_DERIVATION_BATCH_SIZE, VECTOR_RETRY_DELAY_MS, DEDUP_PER_PAIR_TIMEOUT_MS;
+var DEFAULT_VECTOR_BATCH_SIZE, DEFAULT_RETENTION_BATCH_SIZE, DEFAULT_CONSOLIDATION_BATCH_SIZE, DEFAULT_CODEGRAPH_MAX_FILES, DEFAULT_CLAIM_DERIVATION_BATCH_SIZE, DEFAULT_OBSERVATION_QUALIFICATION_BATCH_SIZE, VECTOR_RETRY_DELAY_MS, DEDUP_PER_PAIR_TIMEOUT_MS;
 var init_project_maintenance = __esm({
   "src/runtime/project-maintenance.ts"() {
     "use strict";
@@ -14341,6 +15151,7 @@ var init_project_maintenance = __esm({
     DEFAULT_CONSOLIDATION_BATCH_SIZE = 200;
     DEFAULT_CODEGRAPH_MAX_FILES = 5e3;
     DEFAULT_CLAIM_DERIVATION_BATCH_SIZE = 100;
+    DEFAULT_OBSERVATION_QUALIFICATION_BATCH_SIZE = 100;
     VECTOR_RETRY_DELAY_MS = 5e3;
     DEDUP_PER_PAIR_TIMEOUT_MS = 5e3;
   }
@@ -14582,9 +15393,9 @@ async function getSessionContext(projectDir2, projectId, limit = 3) {
       return true;
     });
   })() : l2Scored).slice(0, 5).map(({ obs }) => obs);
-  const l1HookObs = projectObs.filter((obs) => classifyLayer(obs) === "L1").sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()).slice(0, 3);
+  const l1HookObs = projectObs.filter((obs) => isEligibleForAutomaticDelivery(obs) && classifyLayer(obs) === "L1").sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()).slice(0, 3);
   const l3GitCount = projectObs.filter((obs) => classifyLayer(obs) === "L3").length;
-  const totalHookCount = projectObs.filter((obs) => classifyLayer(obs) === "L1").length;
+  const totalHookCount = projectObs.filter((obs) => isEligibleForAutomaticDelivery(obs) && classifyLayer(obs) === "L1").length;
   const activeEntities = [
     ...new Set(l2Obs.map((o) => o.entityName).filter((n) => !!n && n.trim().length > 0))
   ].slice(0, 5);
@@ -14710,6 +15521,7 @@ var init_session = __esm({
   "src/memory/session.ts"() {
     "use strict";
     init_esm_shims();
+    init_admission();
     init_disclosure_policy();
     init_aliases();
     init_obs_store();
@@ -14862,27 +15674,80 @@ function workflowOutput(selection) {
     cautions: selection.cautions.map((caution) => short(caution, 22))
   };
 }
-function appendLine(lines, candidate, maxTokens, omitted, omittedKind) {
+function appendLine(lines, candidate, maxTokens, omitted, omittedKind, selected, receiptSelection) {
   const next = lines.length ? lines.join("\n") + "\n" + candidate : candidate;
   if (countTextTokens(next) <= maxTokens) {
     lines.push(candidate);
+    if (receiptSelection) selected?.push(receiptSelection);
     return true;
   }
   omitted.push(omittedKind);
   return false;
 }
+function freshnessForMemory(status) {
+  if (status === "current" || status === "suspect" || status === "stale") return status;
+  return "unknown";
+}
+function receiptOmissionKind(raw) {
+  if (raw.includes("task")) return "task";
+  if (raw.includes("fact")) return "current-fact";
+  if (raw.includes("state")) return "code-state";
+  if (raw.includes("semantic")) return "semantic-code";
+  if (raw.includes("start")) return "start-here";
+  if (raw.includes("memory")) return "memory";
+  if (raw.includes("claim")) return "claim";
+  if (raw.includes("knowledge-page")) return "knowledge-page";
+  if (raw.includes("workflow")) return "workflow";
+  if (raw.includes("verification")) return "verification";
+  if (raw.includes("caution")) return "caution";
+  return void 0;
+}
+function receiptOmissions(omitted, hiddenCautionMemoryCount) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const raw of omitted) {
+    const kind = receiptOmissionKind(raw);
+    if (!kind || raw.endsWith("-heading")) continue;
+    counts.set(kind, (counts.get(kind) ?? 0) + 1);
+  }
+  const receipt = [...counts.entries()].map(([kind, count2]) => ({
+    kind,
+    reason: "token-budget",
+    count: count2
+  }));
+  if (hiddenCautionMemoryCount > 0) {
+    receipt.push({
+      kind: "caution",
+      reason: "hidden-by-task-lens",
+      count: hiddenCautionMemoryCount
+    });
+  }
+  return receipt;
+}
+function scheduledActions(cautions) {
+  return cautions.filter((caution) => caution.kind === "codegraph-refresh-queued").map((caution) => short(caution.message, 28));
+}
 function renderTaskWorksetPrompt(input) {
   const maxTokens = input.budget?.maxTokens ?? 180;
   const omitted = [];
+  const selected = [];
   const lines = ["Memorix Autopilot Brief"];
   const task = short(input.task || "Continue the current task.", 34);
-  appendLine(lines, "Task: " + task, maxTokens, omitted, "task-detail");
+  appendLine(lines, "Task: " + task, maxTokens, omitted, "task-detail", selected, {
+    kind: "task",
+    reason: "current task supplied by the caller",
+    trust: "source-backed"
+  });
   appendLine(lines, "Task lens: " + input.lens, maxTokens, omitted, "lens");
   if (input.cautions.length > 0 || input.cautionMemory.length > 0) {
     appendLine(lines, "", maxTokens, omitted, "caution-heading");
     appendLine(lines, "Cautions", maxTokens, omitted, "caution-heading");
     for (const caution of input.cautions.slice(0, 6)) {
-      appendLine(lines, "- " + short(caution.message, 22), maxTokens, omitted, "caution");
+      appendLine(lines, "- " + short(caution.message, 22), maxTokens, omitted, "caution", selected, {
+        kind: "caution",
+        id: "caution:" + caution.kind,
+        reason: "current project caution",
+        trust: "source-backed"
+      });
     }
     for (const memory of input.cautionMemory.slice(0, 3)) {
       const location = memory.path ? memory.path + (memory.symbol ? "#" + memory.symbol : "") : "no current code location";
@@ -14892,7 +15757,15 @@ function renderTaskWorksetPrompt(input) {
         "- #" + memory.id + " " + memory.status + ": " + short(memory.title, 18) + " (" + location + reason + ")",
         maxTokens,
         omitted,
-        "caution-memory"
+        "caution-memory",
+        selected,
+        {
+          kind: "memory",
+          id: "memory:" + memory.id,
+          reason: "task-relevant memory requiring source verification",
+          freshness: freshnessForMemory(memory.status),
+          trust: "historical"
+        }
       );
     }
     if (input.hiddenCautionMemoryCount > 0) {
@@ -14903,13 +15776,22 @@ function renderTaskWorksetPrompt(input) {
     appendLine(lines, "", maxTokens, omitted, "facts-heading");
     appendLine(lines, "Current project facts", maxTokens, omitted, "facts-heading");
     for (const fact of input.currentFacts.slice(0, 4)) {
-      appendLine(lines, "- " + short(fact, 40), maxTokens, omitted, "current-fact");
+      appendLine(lines, "- " + short(fact, 40), maxTokens, omitted, "current-fact", selected, {
+        kind: "current-fact",
+        reason: "current project state",
+        trust: "source-backed"
+      });
     }
   }
   if (input.codeState) {
     appendLine(lines, "", maxTokens, omitted, "state-heading");
     appendLine(lines, "Project state", maxTokens, omitted, "state-heading");
-    appendLine(lines, input.codeState, maxTokens, omitted, "code-state");
+    appendLine(lines, input.codeState, maxTokens, omitted, "code-state", selected, {
+      kind: "code-state",
+      ...input.provenance.snapshotId ? { id: "snapshot:" + input.provenance.snapshotId } : {},
+      reason: "latest available Code State snapshot",
+      trust: "source-backed"
+    });
   }
   if (input.semanticCode && (input.semanticCode.entryPoints.length > 0 || input.semanticCode.relations.length > 0)) {
     appendLine(lines, "", maxTokens, omitted, "semantic-code-heading");
@@ -14921,7 +15803,14 @@ function renderTaskWorksetPrompt(input) {
         "- " + location + ": " + short(relation.from.name, 12) + " " + short(relation.kind, 8) + " " + short(relation.to.name, 12),
         maxTokens,
         omitted,
-        "semantic-relation"
+        "semantic-relation",
+        selected,
+        {
+          kind: "semantic-code",
+          id: "code:" + location,
+          reason: "validated optional semantic code relation",
+          trust: "derived"
+        }
       );
     }
     if (input.semanticCode.relations.length === 0) {
@@ -14932,7 +15821,14 @@ function renderTaskWorksetPrompt(input) {
           "- " + location + ": " + short(entry.name, 16) + " (" + short(entry.kind, 8) + ")",
           maxTokens,
           omitted,
-          "semantic-entry"
+          "semantic-entry",
+          selected,
+          {
+            kind: "semantic-code",
+            id: "code:" + location,
+            reason: "validated optional semantic code entry point",
+            trust: "derived"
+          }
         );
       }
     }
@@ -14941,7 +15837,12 @@ function renderTaskWorksetPrompt(input) {
     appendLine(lines, "", maxTokens, omitted, "start-heading");
     appendLine(lines, "Start here", maxTokens, omitted, "start-heading");
     for (const source of input.startHere.slice(0, 5)) {
-      appendLine(lines, "- " + source, maxTokens, omitted, "start-here");
+      appendLine(lines, "- " + source, maxTokens, omitted, "start-here", selected, {
+        kind: "start-here",
+        id: "path:" + source,
+        reason: "task-lensed starting point",
+        trust: "derived"
+      });
     }
   }
   if (input.reliableMemory.length > 0) {
@@ -14954,7 +15855,15 @@ function renderTaskWorksetPrompt(input) {
         "- #" + memory.id + " " + memory.type + ": " + short(memory.title, 18) + " (" + location + ")",
         maxTokens,
         omitted,
-        "reliable-memory"
+        "reliable-memory",
+        selected,
+        {
+          kind: "memory",
+          id: "memory:" + memory.id,
+          reason: "current code-bound memory",
+          freshness: freshnessForMemory(memory.status),
+          trust: "historical"
+        }
       );
     }
   }
@@ -14962,10 +15871,25 @@ function renderTaskWorksetPrompt(input) {
     appendLine(lines, "", maxTokens, omitted, "knowledge-heading");
     appendLine(lines, "Project knowledge", maxTokens, omitted, "knowledge-heading");
     for (const claim of input.claims.slice(0, 3)) {
-      appendLine(lines, "- " + claim.assertion + " [" + claim.id + "]", maxTokens, omitted, "claim");
+      appendLine(lines, "- " + claim.assertion + " [" + claim.id + "]", maxTokens, omitted, "claim", selected, {
+        kind: "claim",
+        id: "claim:" + claim.id,
+        reason: "source-qualified task match",
+        trust: "source-backed"
+      });
     }
     for (const page of input.pages.slice(0, 2)) {
-      appendLine(lines, "- page: " + page.relativePath, maxTokens, omitted, "knowledge-page");
+      const supportsDeliveredClaim = page.claimIds.some((claimId) => selected.some((item) => item.kind === "claim" && item.id === "claim:" + claimId));
+      if (!supportsDeliveredClaim) {
+        omitted.push("knowledge-page-dependency");
+        continue;
+      }
+      appendLine(lines, "- page: " + page.relativePath, maxTokens, omitted, "knowledge-page", selected, {
+        kind: "knowledge-page",
+        id: "page:" + page.id,
+        reason: "approved page linked to a selected claim",
+        trust: "source-backed"
+      });
     }
   }
   if (input.workflows.length > 0) {
@@ -14977,7 +15901,14 @@ function renderTaskWorksetPrompt(input) {
         "- " + workflow.title + ": " + workflow.firstPhase.title + " - " + workflow.firstPhase.instructions,
         maxTokens,
         omitted,
-        "workflow"
+        "workflow",
+        selected,
+        {
+          kind: "workflow",
+          id: "workflow:" + workflow.id,
+          reason: "task-matching project workflow",
+          trust: "source-backed"
+        }
       );
     }
   }
@@ -14985,16 +15916,23 @@ function renderTaskWorksetPrompt(input) {
     appendLine(lines, "", maxTokens, omitted, "verification-heading");
     appendLine(lines, "Verify", maxTokens, omitted, "verification-heading");
     for (const check of input.verification.slice(0, 4)) {
-      appendLine(lines, "- " + short(check, 20), maxTokens, omitted, "verification");
+      appendLine(lines, "- " + short(check, 20), maxTokens, omitted, "verification", selected, {
+        kind: "verification",
+        reason: "task-lensed verification guidance",
+        trust: "derived"
+      });
     }
   }
   return {
     prompt: lines.join("\n"),
     tokenCount: countTextTokens(lines.join("\n")),
-    omitted: unique(omitted)
+    omitted: unique(omitted),
+    omittedItems: omitted,
+    selected
   };
 }
 async function buildTaskWorkset(input) {
+  const startedAt = Date.now();
   const task = input.task?.trim() ?? "";
   const maxTokens = Math.max(96, Math.min(Math.floor(input.maxTokens ?? 180), 320));
   const cautions = [...input.runtimeCautions ?? [], ...snapshotCautions(input)];
@@ -15096,6 +16034,18 @@ async function buildTaskWorkset(input) {
     ...base,
     budget: { maxTokens }
   });
+  const receipt = {
+    version: "1.2.2",
+    target: input.deliveryTarget ?? "project-context",
+    elapsedMs: Math.max(0, Date.now() - startedAt),
+    budget: {
+      maxTokens,
+      tokenCount: rendered.tokenCount
+    },
+    selected: rendered.selected,
+    omitted: receiptOmissions(rendered.omittedItems, base.hiddenCautionMemoryCount),
+    scheduledActions: scheduledActions(normalizedCautions)
+  };
   return {
     ...base,
     budget: {
@@ -15103,6 +16053,7 @@ async function buildTaskWorkset(input) {
       tokenCount: rendered.tokenCount,
       omitted: rendered.omitted
     },
+    receipt,
     prompt: rendered.prompt
   };
 }
@@ -15124,7 +16075,8 @@ var init_workset = __esm({
 // src/codegraph/current-facts.ts
 var current_facts_exports = {};
 __export(current_facts_exports, {
-  collectCurrentProjectFacts: () => collectCurrentProjectFacts
+  collectCurrentProjectFacts: () => collectCurrentProjectFacts,
+  formatGitFact: () => formatGitFact
 });
 import { execFileSync } from "child_process";
 import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
@@ -15169,11 +16121,16 @@ function runGit2(rootPath, args) {
   }
 }
 function readGitFacts(rootPath) {
-  const branch = runGit2(rootPath, ["branch", "--show-current"]);
+  const available = runGit2(rootPath, ["rev-parse", "--is-inside-work-tree"]) === "true";
+  if (!available) {
+    return { available: false, dirty: false, detached: false };
+  }
+  const branch = runGit2(rootPath, ["symbolic-ref", "--quiet", "--short", "HEAD"]) ?? runGit2(rootPath, ["branch", "--show-current"]);
   const commit = runGit2(rootPath, ["rev-parse", "--short", "HEAD"]);
   const latestCommit = runGit2(rootPath, ["log", "-1", "--pretty=%s"]);
   const dirty = Boolean(runGit2(rootPath, ["status", "--porcelain"]));
   return {
+    available: true,
     ...branch ? { branch } : {},
     ...commit ? { commit } : {},
     ...latestCommit ? { latestCommit } : {},
@@ -15181,6 +16138,15 @@ function readGitFacts(rootPath) {
     detached: !branch
   };
 }
+function formatGitFact(git) {
+  if (!git.available) return "Git: unavailable";
+  const parts = [];
+  if (git.detached) parts.push("detached HEAD");
+  else if (git.branch) parts.push("branch " + git.branch);
+  if (git.commit) parts.push("commit " + git.commit);
+  parts.push(git.dirty ? "dirty worktree" : "clean worktree");
+  return "Git: " + parts.join(", ");
+}
 function parseProgressNote(content) {
   const lastUpdated = content.match(/Last updated\*\*:\s*(\d{4}-\d{2}-\d{2})/i) ?? content.match(/Last updated:\s*(\d{4}-\d{2}-\d{2})/i);
   const branchHint = content.match(/Branch\*\*:\s*([^\r\n]+)/i) ?? content.match(/Branch:\s*([^\r\n]+)/i);
@@ -15791,376 +16757,63 @@ function collectGraph(store, projectId, observations2, exclude) {
           status: "unbound",
           reason: "Recorded file hint; Code Memory refresh is pending."
         });
-        freshness.unbound++;
-      }
-    }
-  }
-  return {
-    files,
-    symbols,
-    refs,
-    freshness,
-    sources,
-    suggestedReads: compactSuggestedReads(suggestedReads, 8, exclude)
-  };
-}
-function overviewFromGraph(input) {
-  const status = input.store.status(input.project.id);
-  return {
-    project: input.project,
-    code: {
-      provider: status.provider,
-      files: status.files,
-      symbols: status.symbols,
-      edges: status.edges,
-      refs: status.refs,
-      ...status.indexedAt ? { indexedAt: status.indexedAt } : {},
-      languages: countLanguages(input.graph.files),
-      ...status.latestSnapshot ? { latestSnapshot: status.latestSnapshot } : {}
-    },
-    memory: {
-      total: input.observations.filter((obs) => obs.projectId === input.project.id).length,
-      active: input.active.length
-    },
-    freshness: input.graph.freshness,
-    suggestedReads: input.graph.suggestedReads
-  };
-}
-function buildProjectContextExplain(input) {
-  const active = activeObservations(input.observations, input.project.id);
-  const graph = collectGraph(input.store, input.project.id, active, input.exclude);
-  const overview = overviewFromGraph({
-    project: input.project,
-    store: input.store,
-    observations: input.observations,
-    active,
-    graph
-  });
-  return {
-    project: input.project,
-    sources: graph.sources.sort((a, b) => a.observationId - b.observationId || (a.path ?? "").localeCompare(b.path ?? "")),
-    overview
-  };
-}
-var init_project_context = __esm({
-  "src/codegraph/project-context.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_freshness2();
-    init_exclude();
-  }
-});
-
-// src/codegraph/task-lens.ts
-var task_lens_exports = {};
-__export(task_lens_exports, {
-  lensPathCandidates: () => lensPathCandidates,
-  lensVerificationHints: () => lensVerificationHints,
-  rankLensPaths: () => rankLensPaths,
-  rankLensSources: () => rankLensSources,
-  resolveTaskLens: () => resolveTaskLens,
-  scoreLensSource: () => scoreLensSource,
-  shouldShowLensSource: () => shouldShowLensSource
-});
-function normalizePath2(path25) {
-  return path25.replace(/\\/g, "/");
-}
-function tokenize2(text) {
-  return (text.toLowerCase().match(/[a-z0-9_./-]+|[\u4e00-\u9fff]+/g) ?? []).map((token) => token.trim()).filter((token) => token.length > 1 && !STOP_WORDS.has(token));
-}
-function containsKeyword(text, keyword) {
-  if (/^[a-z0-9_-]+$/i.test(keyword)) {
-    return new RegExp(`(^|[^a-z0-9_-])${keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}([^a-z0-9_-]|$)`, "i").test(text);
-  }
-  return text.includes(keyword);
-}
-function resolveTaskLens(task) {
-  const normalized = (task ?? "").toLowerCase();
-  if (!normalized.trim()) return LENSES.general;
-  let best = {
-    id: "general",
-    score: 0,
-    priority: Number.MAX_SAFE_INTEGER
-  };
-  for (const id of LENS_PRIORITY) {
-    const score = KEYWORDS[id].reduce((sum, keyword) => sum + (containsKeyword(normalized, keyword) ? 1 : 0), 0);
-    const priority = LENS_PRIORITY.indexOf(id);
-    if (score > best.score || score === best.score && score > 0 && priority < best.priority) {
-      best = { id, score, priority };
-    }
-  }
-  return best.score > 0 ? LENSES[best.id] : LENSES.general;
-}
-function pathKindScore(path25, lens) {
-  const normalized = normalizePath2(path25).toLowerCase();
-  const name = normalized.split("/").pop() ?? normalized;
-  const inDocs = normalized.startsWith("docs/") || name === "readme.md" || name.includes("readme");
-  const isTest = /(^|\/)(tests?|__tests__|spec|fixtures?)\//.test(normalized) || /\.(test|spec)\.[cm]?[jt]sx?$/.test(normalized) || /\.(test|spec)\.py$/.test(normalized);
-  const isSource = normalized.startsWith("src/") || normalized.includes("/src/");
-  const isPackage = name === "package.json" || name === "package-lock.json" || name === "pnpm-lock.yaml" || name === "yarn.lock";
-  const isChangelog = name === "changelog.md" || name === "changes.md";
-  const isWorkflow = normalized.startsWith(".github/workflows/");
-  switch (lens.id) {
-    case "bugfix":
-      return (isTest ? 80 : 0) + (isSource ? 50 : 0) + (normalized.includes("debug") ? 20 : 0);
-    case "test":
-      return (isTest ? 90 : 0) + (isSource ? 45 : 0);
-    case "release":
-      return (isChangelog ? 100 : 0) + (isPackage ? 90 : 0) + (isWorkflow ? 70 : 0) + (inDocs ? 35 : 0);
-    case "onboarding":
-      return (name === "readme.md" ? 100 : 0) + (inDocs ? 80 : 0) + (isPackage ? 45 : 0) + (isSource ? 20 : 0);
-    case "docs":
-      return (inDocs ? 100 : 0) + (isChangelog ? 60 : 0) + (isSource ? 25 : 0);
-    case "refactor":
-      return (isSource ? 70 : 0) + (isTest ? 65 : 0);
-    case "feature":
-      return (isSource ? 80 : 0) + (isTest ? 45 : 0) + (inDocs ? 20 : 0);
-    default:
-      if (isSource || isTest) return 60;
-      if (normalized.startsWith("packages/") && normalized.includes("/src/")) return 45;
-      if (inDocs) return 20;
-      return 0;
-  }
-}
-function tokenScore(text, tokens) {
-  if (tokens.length === 0) return 0;
-  const normalized = text.toLowerCase();
-  return tokens.reduce((sum, token) => sum + (normalized.includes(token) ? 12 : 0), 0);
-}
-function sourceTaskMatchScore(source, task) {
-  const tokens = tokenize2(task ?? "");
-  if (tokens.length === 0) return 0;
-  const text = [
-    source.title,
-    source.path ?? "",
-    source.symbol ?? ""
-  ].join("\n").toLowerCase();
-  const matches = tokens.filter((token) => text.includes(token)).length;
-  if (matches >= 2) return 40;
-  if (matches === 1) return 24;
-  return 0;
-}
-function fallbackPathRank(path25) {
-  const normalized = normalizePath2(path25);
-  if (normalized.startsWith("src/")) return 0;
-  if (normalized.startsWith("tests/") || normalized.startsWith("test/")) return 1;
-  if (normalized.startsWith("packages/") && normalized.includes("/src/")) return 2;
-  if (normalized.startsWith("docs/") || normalized.toLowerCase() === "readme.md") return 3;
-  return 4;
-}
-function rankLensPaths(paths, lens, task) {
-  const tokens = tokenize2(task ?? "");
-  return [...new Set(paths.map(normalizePath2))].map((path25, index) => ({
-    path: path25,
-    index,
-    score: pathKindScore(path25, lens) + tokenScore(path25, tokens),
-    fallback: fallbackPathRank(path25)
-  })).sort((a, b) => b.score - a.score || a.fallback - b.fallback || a.index - b.index || a.path.localeCompare(b.path)).map((item) => item.path);
-}
-function lensPathCandidates(lens) {
-  switch (lens.id) {
-    case "release":
-      return ["CHANGELOG.md", "package.json", "package-lock.json", ".github/workflows/ci.yml", ".github/workflows/test.yml", "README.md"];
-    case "onboarding":
-      return ["README.md", "docs/README.md", "docs/API_REFERENCE.md", "package.json"];
-    case "docs":
-      return ["README.md", "README.zh-CN.md", "docs/README.md", "docs/API_REFERENCE.md", "CHANGELOG.md"];
-    case "test":
-    case "bugfix":
-      return ["tests", "test"];
-    default:
-      return [];
-  }
-}
-function scoreLensSource(source, lens, task) {
-  const tokens = tokenize2(task ?? "");
-  const text = [source.title, source.type, source.path ?? "", source.symbol ?? ""].join("\n");
-  return pathKindScore(source.path ?? "", lens) + tokenScore(text, tokens) + sourceTaskMatchScore(source, task);
-}
-function rankLensSources(sources, lens, task) {
-  return [...sources].map((source, index) => ({
-    source,
-    index,
-    score: scoreLensSource(source, lens, task)
-  })).sort((a, b) => b.score - a.score || a.source.observationId - b.source.observationId || a.index - b.index).map((item) => item.source);
-}
-function lensVerificationHints(lens) {
-  switch (lens.id) {
-    case "bugfix":
-      return [
-        "run the smallest failing test or repro first",
-        "inspect the changed code path before trusting old memory"
-      ];
-    case "test":
-      return [
-        "run the exact focused test file or test name first",
-        "inspect fixtures and harness setup before changing assertions"
-      ];
-    case "release":
-      return [
-        "run build, tests, package smoke, and publish dry-run where available",
-        "verify package metadata, changelog, and Git state before publishing"
-      ];
-    case "onboarding":
-      return [
-        "read the docs/start files first, then inspect only the code paths needed for the task",
-        "treat old implementation memories as leads until current code confirms them"
-      ];
-    case "refactor":
-      return [
-        "inspect call sites and tests before editing shared code",
-        "run the narrow affected test plus one regression smoke"
-      ];
-    case "docs":
-      return [
-        "check headings, links, commands, and examples against current code",
-        "run the smallest docs or package smoke available"
-      ];
-    case "feature":
-      return [
-        "inspect the closest existing implementation pattern before adding new code",
-        "run focused tests plus one user-flow smoke after changes"
-      ];
-    default:
-      return [
-        "inspect the Start here files before editing",
-        "run the smallest relevant test or smoke command after changes"
-      ];
+        freshness.unbound++;
+      }
+    }
   }
+  return {
+    files,
+    symbols,
+    refs,
+    freshness,
+    sources,
+    suggestedReads: compactSuggestedReads(suggestedReads, 8, exclude)
+  };
 }
-function shouldShowLensSource(source, lens, task) {
-  if (lens.id === "general") return true;
-  const score = scoreLensSource(source, lens, task);
-  if (lens.id === "onboarding" || lens.id === "release" || lens.id === "docs") return score >= 40;
-  return score > 0;
+function overviewFromGraph(input) {
+  const status = input.store.status(input.project.id);
+  return {
+    project: input.project,
+    code: {
+      provider: status.provider,
+      files: status.files,
+      symbols: status.symbols,
+      edges: status.edges,
+      refs: status.refs,
+      ...status.indexedAt ? { indexedAt: status.indexedAt } : {},
+      languages: countLanguages(input.graph.files),
+      ...status.latestSnapshot ? { latestSnapshot: status.latestSnapshot } : {}
+    },
+    memory: {
+      total: input.observations.filter((obs) => obs.projectId === input.project.id).length,
+      active: input.active.length
+    },
+    freshness: input.graph.freshness,
+    suggestedReads: input.graph.suggestedReads
+  };
 }
-var STOP_WORDS, LENSES, KEYWORDS, LENS_PRIORITY;
-var init_task_lens = __esm({
-  "src/codegraph/task-lens.ts"() {
+function buildProjectContextExplain(input) {
+  const active = activeObservations(input.observations, input.project.id);
+  const graph = collectGraph(input.store, input.project.id, active, input.exclude);
+  const overview = overviewFromGraph({
+    project: input.project,
+    store: input.store,
+    observations: input.observations,
+    active,
+    graph
+  });
+  return {
+    project: input.project,
+    sources: graph.sources.sort((a, b) => a.observationId - b.observationId || (a.path ?? "").localeCompare(b.path ?? "")),
+    overview
+  };
+}
+var init_project_context = __esm({
+  "src/codegraph/project-context.ts"() {
     "use strict";
     init_esm_shims();
-    STOP_WORDS = /* @__PURE__ */ new Set([
-      "a",
-      "an",
-      "and",
-      "as",
-      "for",
-      "in",
-      "into",
-      "of",
-      "on",
-      "onto",
-      "the",
-      "this",
-      "that",
-      "to",
-      "with",
-      "work",
-      "project",
-      "continue",
-      "\u7EE7\u7EED",
-      "\u9879\u76EE"
-    ]);
-    LENSES = {
-      bugfix: {
-        id: "bugfix",
-        description: "debug the failure with current code and the smallest repro first",
-        sourceLimit: 6,
-        cautionLimit: 4,
-        hideUnrelatedCautionDetails: true,
-        hideUnrelatedReliableDetails: false
-      },
-      feature: {
-        id: "feature",
-        description: "build a scoped feature from nearby source, types, and user flow",
-        sourceLimit: 6,
-        cautionLimit: 3,
-        hideUnrelatedCautionDetails: true,
-        hideUnrelatedReliableDetails: false
-      },
-      release: {
-        id: "release",
-        description: "prepare a release using current metadata, changelog, build, and package checks",
-        sourceLimit: 4,
-        cautionLimit: 2,
-        hideUnrelatedCautionDetails: true,
-        hideUnrelatedReliableDetails: true
-      },
-      onboarding: {
-        id: "onboarding",
-        description: "understand the project shape before trusting old implementation details",
-        sourceLimit: 4,
-        cautionLimit: 2,
-        hideUnrelatedCautionDetails: true,
-        hideUnrelatedReliableDetails: true
-      },
-      refactor: {
-        id: "refactor",
-        description: "change structure carefully by reading shared code, call sites, and tests",
-        sourceLimit: 6,
-        cautionLimit: 4,
-        hideUnrelatedCautionDetails: true,
-        hideUnrelatedReliableDetails: false
-      },
-      docs: {
-        id: "docs",
-        description: "update documentation against current code and public entry points",
-        sourceLimit: 5,
-        cautionLimit: 2,
-        hideUnrelatedCautionDetails: true,
-        hideUnrelatedReliableDetails: true
-      },
-      test: {
-        id: "test",
-        description: "work from tests, fixtures, harnesses, and the related source files",
-        sourceLimit: 6,
-        cautionLimit: 3,
-        hideUnrelatedCautionDetails: true,
-        hideUnrelatedReliableDetails: false
-      },
-      general: {
-        id: "general",
-        description: "balanced project handoff with current facts, code memory, and verification hints",
-        sourceLimit: 8,
-        cautionLimit: 5,
-        hideUnrelatedCautionDetails: false,
-        hideUnrelatedReliableDetails: false
-      }
-    };
-    KEYWORDS = {
-      bugfix: [
-        "bug",
-        "crash",
-        "debug",
-        "error",
-        "fail",
-        "failing",
-        "fix",
-        "issue",
-        "regression",
-        "repro",
-        "\u62A5\u9519",
-        "\u5D29\u6E83",
-        "\u5931\u8D25",
-        "\u4FEE\u590D",
-        "\u95EE\u9898"
-      ],
-      feature: ["add", "build", "feature", "implement", "new", "support", "\u65B0\u589E", "\u5B9E\u73B0", "\u652F\u6301", "\u529F\u80FD"],
-      release: ["bump", "changelog", "npm", "pack", "publish", "release", "version", "\u53D1\u7248", "\u53D1\u5E03", "\u7248\u672C"],
-      onboarding: ["architecture", "handoff", "onboard", "overview", "understand", "\u63A5\u624B", "\u4E86\u89E3", "\u7406\u89E3", "\u67B6\u6784"],
-      refactor: ["cleanup", "migrate", "refactor", "rename", "restructure", "\u91CD\u6784", "\u8FC1\u79FB", "\u6539\u9020"],
-      docs: ["doc", "docs", "readme", "\u6587\u6863", "\u8BF4\u660E"],
-      test: ["coverage", "fixture", "smoke", "spec", "test", "tests", "testing", "vitest", "\u6D4B\u8BD5"]
-    };
-    LENS_PRIORITY = [
-      "bugfix",
-      "release",
-      "test",
-      "refactor",
-      "feature",
-      "docs",
-      "onboarding"
-    ];
+    init_freshness2();
+    init_exclude();
   }
 });
 
@@ -16178,6 +16831,9 @@ import path19 from "path";
 function activeProjectObservations(observations2, projectId) {
   return observations2.filter((obs) => obs.projectId === projectId && (obs.status ?? "active") === "active");
 }
+function deliveryEligibleProjectObservations(observations2, projectId) {
+  return activeProjectObservations(observations2, projectId).filter((observation) => isEligibleForAutomaticDelivery(observation));
+}
 function decideRefresh(input) {
   if (input.mode === "never") {
     return { performed: false, reason: "disabled", message: "Automatic project scan disabled." };
@@ -16252,13 +16908,27 @@ async function buildAutoProjectContext(input) {
           activeProjectObservations(input.observations, input.project.id)
         );
         try {
-          const { enqueueClaimRequalification: enqueueClaimRequalification2 } = await Promise.resolve().then(() => (init_lifecycle(), lifecycle_exports));
+          const { MaintenanceTargetStore: MaintenanceTargetStore2 } = await Promise.resolve().then(() => (init_maintenance_targets(), maintenance_targets_exports));
+          new MaintenanceTargetStore2(input.dataDir).register({
+            projectId: input.project.id,
+            projectRoot: input.project.rootPath,
+            dataDir: input.dataDir
+          });
+          const {
+            enqueueClaimRequalification: enqueueClaimRequalification2,
+            enqueueObservationQualification: enqueueObservationQualification2
+          } = await Promise.resolve().then(() => (init_lifecycle(), lifecycle_exports));
           enqueueClaimRequalification2({
             dataDir: input.dataDir,
             projectId: input.project.id,
             source: "foreground-refresh",
             snapshotId: store.latestSnapshot(input.project.id)?.id
           });
+          enqueueObservationQualification2({
+            dataDir: input.dataDir,
+            projectId: input.project.id,
+            source: "foreground-refresh"
+          });
         } catch {
         }
         refresh = { ...refresh, backfill };
@@ -16275,7 +16945,9 @@ async function buildAutoProjectContext(input) {
   const explain = buildProjectContextExplain({
     project: input.project,
     store,
-    observations: input.observations,
+    // Binding sees all active evidence, but automatic delivery sees only
+    // evidence that has passed the control-plane admission gate.
+    observations: deliveryEligibleProjectObservations(input.observations, input.project.id),
     exclude
   });
   const overview = explain.overview;
@@ -16366,7 +17038,8 @@ async function buildAutoProjectContext(input) {
       suspect: overview.freshness.suspect,
       stale: overview.freshness.stale
     },
-    runtimeCautions
+    runtimeCautions,
+    ...input.deliveryTarget ? { deliveryTarget: input.deliveryTarget } : {}
   });
   return {
     project: input.project,
@@ -16459,15 +17132,7 @@ function formatCurrentFactsLines(facts) {
   if (facts.latestChangelog) {
     lines.push(`- Latest changelog: ${facts.latestChangelog.version}${facts.latestChangelog.date ? ` (${facts.latestChangelog.date})` : ""}`);
   }
-  const gitParts = [];
-  if (facts.git.detached) {
-    gitParts.push("detached HEAD");
-  } else if (facts.git.branch) {
-    gitParts.push(`branch ${facts.git.branch}`);
-  }
-  if (facts.git.commit) gitParts.push(`commit ${facts.git.commit}`);
-  gitParts.push(facts.git.dirty ? "dirty worktree" : "clean worktree");
-  lines.push(`- Git: ${gitParts.join(", ")}`);
+  lines.push("- " + formatGitFact(facts.git));
   if (facts.git.latestCommit) lines.push(`- Latest commit: ${facts.git.latestCommit}`);
   lines.push("- Current facts above outrank progress/dev-log files when they conflict.");
   if (facts.staleNotes.length > 0) {
@@ -16489,11 +17154,7 @@ function worksetFactLines(facts) {
   if (facts.latestChangelog) {
     lines.push("Latest changelog: " + facts.latestChangelog.version + (facts.latestChangelog.date ? " (" + facts.latestChangelog.date + ")" : ""));
   }
-  const gitParts = [];
-  if (facts.git.branch) gitParts.push("branch " + facts.git.branch);
-  if (facts.git.commit) gitParts.push("commit " + facts.git.commit);
-  gitParts.push(facts.git.dirty ? "dirty worktree" : "clean worktree");
-  lines.push("Git: " + gitParts.join(", "));
+  lines.push(formatGitFact(facts.git));
   for (const note of facts.staleNotes.slice(0, 1)) {
     lines.push(
       "Historical note: " + note.path + (note.branchHint ? " (branch hint " + note.branchHint + "; " + note.reason + ")" : " (" + note.reason + ")")
@@ -16612,6 +17273,7 @@ var init_auto_context = __esm({
     init_external_provider();
     init_project_context();
     init_store();
+    init_admission();
     init_task_lens();
     DEFAULT_MAX_AGE_MS = 10 * 60 * 1e3;
   }
@@ -16804,7 +17466,8 @@ async function attachTaskWorkset(input) {
       suspect: input.pack.warnings.filter((warning) => warning.status === "suspect").length,
       stale: input.pack.warnings.filter((warning) => warning.status === "stale").length
     },
-    runtimeCautions: input.runtimeCautions
+    runtimeCautions: input.runtimeCautions,
+    deliveryTarget: "context-pack"
   });
   return { ...input.pack, workset };
 }
@@ -18216,11 +18879,14 @@ __export(export_import_exports, {
   exportAsMarkdown: () => exportAsMarkdown,
   importFromJson: () => importFromJson
 });
-async function exportAsJson(projectDir2, projectId) {
+async function exportAsJson(projectDir2, projectId, reader) {
   const store = getObservationStore();
   const allObs = await store.loadAll();
   const allSessions = await getSessionStore().loadAll();
-  const projectObs = allObs.filter((o) => o.projectId === projectId);
+  const projectObs = filterReadableObservations(
+    allObs.filter((o) => o.projectId === projectId),
+    reader
+  );
   const projectSessions = allSessions.filter((s) => s.projectId === projectId);
   const typeBreakdown = {};
   for (const obs of projectObs) {
@@ -18239,8 +18905,8 @@ async function exportAsJson(projectDir2, projectId) {
     }
   };
 }
-async function exportAsMarkdown(projectDir2, projectId) {
-  const data = await exportAsJson(projectDir2, projectId);
+async function exportAsMarkdown(projectDir2, projectId, reader) {
+  const data = await exportAsJson(projectDir2, projectId, reader);
   const lines = [];
   lines.push(`# Memorix Export: ${projectId}`);
   lines.push(`Exported: ${data.exportedAt}`);
@@ -18342,6 +19008,7 @@ var init_export_import = __esm({
   "src/memory/export-import.ts"() {
     "use strict";
     init_esm_shims();
+    init_visibility();
     init_obs_store();
     init_session_store();
     OBSERVATION_ICONS2 = {
@@ -18518,6 +19185,7 @@ function isEligible(o, projectId) {
   if (isCommandLog2(o)) return false;
   if (isInactive(o)) return false;
   if (isOtherProject(o, projectId)) return false;
+  if (!isEligibleForKnowledgePromotion(o)) return false;
   if (o.valueCategory === "ephemeral") return false;
   if (!contextualHasSubstance(o)) return false;
   return true;
@@ -18666,6 +19334,7 @@ var init_generator = __esm({
   "src/wiki/generator.ts"() {
     "use strict";
     init_esm_shims();
+    init_admission();
     COMMAND_LOG_TITLE4 = /^(Ran:|Command:|Executed:)\s/i;
     SECTION_DEFS = [
       {
@@ -18952,6 +19621,9 @@ function sendError(res, message, status = 500) {
 function filterByProject(items, projectId) {
   return items.filter((item) => item.projectId === projectId);
 }
+function filterDashboardObservations(observations2, projectId) {
+  return filterReadableObservations(observations2, { projectId });
+}
 function isActiveStatus(status) {
   return (status ?? "active") === "active";
 }
@@ -18975,13 +19647,8 @@ function prepareDashboardConfig(projectRoot) {
   }
 }
 function computeProjectGraphCounts(allEntities, allRelations, projectObs) {
-  const entityNames = new Set(
-    projectObs.filter((o) => (o.status ?? "active") === "active" && o.entityName).map((o) => o.entityName)
-  );
-  const entities = allEntities.filter((e) => entityNames.has(e.name));
-  const entityNameSet = new Set(entities.map((e) => e.name));
-  const relations = allRelations.filter((r) => entityNameSet.has(r.from) && entityNameSet.has(r.to));
-  return { entities: entities.length, relations: relations.length, entityNames };
+  const scoped = scopeKnowledgeGraphToProject({ entities: allEntities, relations: allRelations }, projectObs);
+  return { entities: scoped.entities.length, relations: scoped.relations.length, entityNames: scoped.entityNames };
 }
 async function handleApi(req, res, dataDir, projectId, projectName, baseDir, projectRoot, projectResolved, mode = "standalone", port = 3210) {
   const url = new URL(req.url || "/", `http://${req.headers.host}`);
@@ -19004,7 +19671,10 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
     switch (apiPath) {
       case "/projects": {
         try {
-          const allObs = await getObservationStore().loadAll();
+          const allObs = filterReadableObservations(
+            await getObservationStore().loadAll(),
+            {}
+          );
           const projectSet = /* @__PURE__ */ new Map();
           for (const obs of allObs) {
             if (!isActiveStatus(obs.status)) continue;
@@ -19053,18 +19723,19 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
         await initGraphStore(effectiveDataDir);
         const gStore = getGraphStore();
         const graph = { entities: gStore.loadEntities(), relations: gStore.loadRelations() };
-        const graphObs = await getObservationStore().loadByProject(effectiveProjectId, { status: "active" });
-        const projectEntityNames = new Set(
-          graphObs.filter((o) => o.entityName).map((o) => o.entityName)
+        const graphObs = filterDashboardObservations(
+          await getObservationStore().loadByProject(effectiveProjectId, { status: "active" }),
+          effectiveProjectId
         );
-        const entities = graph.entities.filter((e) => projectEntityNames.has(e.name));
-        const entityNameSet = new Set(entities.map((e) => e.name));
-        const relations = graph.relations.filter((r) => entityNameSet.has(r.from) && entityNameSet.has(r.to));
-        sendJson(res, { entities, relations });
+        const scoped = scopeKnowledgeGraphToProject(graph, graphObs);
+        sendJson(res, { entities: scoped.entities, relations: scoped.relations });
         break;
       }
       case "/observations": {
-        const observations2 = await getObservationStore().loadByProject(effectiveProjectId, { status: "active" });
+        const observations2 = filterDashboardObservations(
+          await getObservationStore().loadByProject(effectiveProjectId, { status: "active" }),
+          effectiveProjectId
+        );
         sendJson(res, observations2);
         break;
       }
@@ -19077,7 +19748,10 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
       case "/stats": {
         await initGraphStore(effectiveDataDir);
         const graph = { entities: getGraphStore().loadEntities(), relations: getGraphStore().loadRelations() };
-        const observations2 = await getObservationStore().loadByProject(effectiveProjectId, { status: "active" });
+        const observations2 = filterDashboardObservations(
+          await getObservationStore().loadByProject(effectiveProjectId, { status: "active" }),
+          effectiveProjectId
+        );
         const nextId2 = await getObservationStore().loadIdCounter();
         const projectGraphCounts = computeProjectGraphCounts(graph.entities, graph.relations, observations2);
         const typeCounts = {};
@@ -19195,7 +19869,10 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
         break;
       }
       case "/retention": {
-        const observations2 = await getObservationStore().loadByProject(effectiveProjectId, { status: "active" });
+        const observations2 = filterDashboardObservations(
+          await getObservationStore().loadByProject(effectiveProjectId, { status: "active" }),
+          effectiveProjectId
+        );
         const now3 = Date.now();
         const scored = observations2.filter((obs) => obs.type !== "probe").map((obs) => {
           const age = now3 - new Date(obs.createdAt || now3).getTime();
@@ -19233,7 +19910,10 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
         const { generateKnowledgeBase: generateKnowledgeBase2 } = await Promise.resolve().then(() => (init_generator(), generator_exports));
         const { initMiniSkillStore: initMiniSkillStore2, getMiniSkillStore: getMiniSkillStore2 } = await Promise.resolve().then(() => (init_mini_skill_store(), mini_skill_store_exports));
         await initMiniSkillStore2(effectiveDataDir);
-        const allObs = await getObservationStore().loadByProject(effectiveProjectId, { status: "active" });
+        const allObs = filterDashboardObservations(
+          await getObservationStore().loadByProject(effectiveProjectId, { status: "active" }),
+          effectiveProjectId
+        );
         const skills = await getMiniSkillStore2().loadByProject(effectiveProjectId);
         const overview = generateKnowledgeBase2({
           projectId: effectiveProjectId,
@@ -19249,22 +19929,19 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
         const { initGraphStore: initGraphStore2, getGraphStore: getGraphStore2 } = await Promise.resolve().then(() => (init_graph_store(), graph_store_exports));
         await initMiniSkillStore2(effectiveDataDir);
         await initGraphStore2(effectiveDataDir);
-        const allObs = await getObservationStore().loadByProject(effectiveProjectId, { status: "active" });
+        const allObs = filterDashboardObservations(
+          await getObservationStore().loadByProject(effectiveProjectId, { status: "active" }),
+          effectiveProjectId
+        );
         const skills = await getMiniSkillStore2().loadByProject(effectiveProjectId);
         const fullGraph = { entities: getGraphStore2().loadEntities(), relations: getGraphStore2().loadRelations() };
-        const graphObs = await getObservationStore().loadByProject(effectiveProjectId, { status: "active" });
-        const projectEntityNames = new Set(
-          graphObs.filter((o) => o.entityName).map((o) => o.entityName)
-        );
-        const scopedEntities = fullGraph.entities.filter((e) => projectEntityNames.has(e.name));
-        const scopedEntityNameSet = new Set(scopedEntities.map((e) => e.name));
-        const scopedRelations = fullGraph.relations.filter((r) => scopedEntityNameSet.has(r.from) && scopedEntityNameSet.has(r.to));
+        const scoped = scopeKnowledgeGraphToProject(fullGraph, allObs);
         const graph = generateKnowledgeGraph2({
           projectId: effectiveProjectId,
           observations: allObs,
           miniSkills: skills,
-          graphEntities: scopedEntities,
-          graphRelations: scopedRelations
+          graphEntities: scoped.entities,
+          graphRelations: scoped.relations
         });
         sendJson(res, graph);
         break;
@@ -19378,7 +20055,7 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
         break;
       }
       case "/identity": {
-        const allObs = await getObservationStore().loadAll();
+        const allObs = filterReadableObservations(await getObservationStore().loadAll(), {});
         const allProjectIds = [...new Set(allObs.map((o) => o.projectId).filter(Boolean))];
         let classifyProjectId2 = () => "real";
         let isDirtyProjectId2 = () => false;
@@ -19463,6 +20140,8 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
             sendError(res, "Observation not found", 404);
           } else if (matchObs.projectId !== effectiveProjectId) {
             sendError(res, `Observation #${obsId} belongs to project "${matchObs.projectId}", not "${effectiveProjectId}"`, 403);
+          } else if (!canManageObservation(matchObs, { projectId: effectiveProjectId })) {
+            sendError(res, `Observation #${obsId} is not manageable from the unbound dashboard.`, 403);
           } else {
             await obsStore.remove(obsId);
             try {
@@ -19484,18 +20163,16 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
         if (apiPath === "/export") {
           await initGraphStore(effectiveDataDir);
           const fullGraph = { entities: getGraphStore().loadEntities(), relations: getGraphStore().loadRelations() };
-          const observations2 = await getObservationStore().loadByProject(effectiveProjectId, { status: "active" });
-          const nextId2 = await getObservationStore().loadIdCounter();
-          const exportEntityNames = new Set(
-            observations2.filter((o) => (o.status ?? "active") === "active" && o.entityName).map((o) => o.entityName)
+          const observations2 = filterDashboardObservations(
+            await getObservationStore().loadByProject(effectiveProjectId, { status: "active" }),
+            effectiveProjectId
           );
-          const exportEntities = fullGraph.entities.filter((e) => exportEntityNames.has(e.name));
-          const exportEntitySet = new Set(exportEntities.map((e) => e.name));
-          const exportRelations = fullGraph.relations.filter((r) => exportEntitySet.has(r.from) && exportEntitySet.has(r.to));
+          const nextId2 = await getObservationStore().loadIdCounter();
+          const scoped = scopeKnowledgeGraphToProject(fullGraph, observations2);
           const exportData = {
             project: { id: effectiveProjectId, name: effectiveProjectName },
             exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            graph: { entities: exportEntities, relations: exportRelations },
+            graph: { entities: scoped.entities, relations: scoped.relations },
             observations: observations2,
             nextId: nextId2
           };
@@ -19812,6 +20489,8 @@ var init_server = __esm({
     init_dotenv_loader();
     init_yaml_loader();
     init_yaml_loader();
+    init_graph_scope();
+    init_visibility();
     MIME_TYPES = {
       ".html": "text/html; charset=utf-8",
       ".css": "text/css; charset=utf-8",
@@ -20589,6 +21268,11 @@ async function createHandoffArtifact(input, storeObservation2, teamStore) {
     sourceDetail: "explicit",
     valueCategory: "core",
     // immune to retention archival
+    // A direct handoff is not a project-wide memo. The sender retains access
+    // and the explicit recipient receives a read grant. Broadcast handoffs
+    // are deliberately visible only to active team members.
+    visibility: input.toAgentId ? "personal" : "team",
+    ...input.toAgentId ? { sharedWithAgentIds: [input.toAgentId] } : {},
     createdByAgentId: input.fromAgentId
   });
   try {
@@ -22528,6 +23212,24 @@ async function createAutoRelations(obs, extracted, graphManager) {
   const relationType = inferRelationType(obs);
   const relations = [];
   const selfName = obs.entityName.toLowerCase();
+  const explicitRelated = [...new Set((obs.relatedEntities ?? []).map((name) => name.trim()).filter((name) => name && name.toLowerCase() !== selfName))];
+  if (explicitRelated.length > 0) {
+    await graphManager.createEntities(explicitRelated.map((name) => ({
+      name,
+      entityType: "related",
+      observations: []
+    })));
+    for (const name of explicitRelated) {
+      const matchedEntity = graphManager.findEntityByName(name);
+      if (matchedEntity) {
+        relations.push({
+          from: obs.entityName,
+          to: matchedEntity.name,
+          relationType: "related_entity"
+        });
+      }
+    }
+  }
   const candidates = [
     ...extracted.identifiers,
     ...extracted.files.map((f) => f.split("/").pop()?.replace(/\.\w+$/, "") ?? ""),
@@ -22569,6 +23271,8 @@ async function createAutoRelations(obs, extracted, graphManager) {
 
 // src/server.ts
 init_entity_extractor();
+init_graph_scope();
+init_visibility();
 
 // src/compact/engine.ts
 init_esm_shims();
@@ -22694,7 +23398,15 @@ function formatTimeline(timeline) {
 function formatObservationDetail(doc) {
   const icon = getTypeIcon(doc.type);
   const lines = [];
-  const header = buildProvenanceHeader(doc.sourceDetail, doc.valueCategory, doc.source, doc.commitHash, doc.relatedCommits);
+  const header = buildProvenanceHeader(
+    doc.sourceDetail,
+    doc.valueCategory,
+    doc.admissionState,
+    doc.admissionReason,
+    doc.source,
+    doc.commitHash,
+    doc.relatedCommits
+  );
   if (header) {
     lines.push(header);
     lines.push("");
@@ -22729,7 +23441,7 @@ function formatObservationDetail(doc) {
   }
   return lines.join("\n");
 }
-function buildProvenanceHeader(sourceDetail, valueCategory, source, commitHash, relatedCommits) {
+function buildProvenanceHeader(sourceDetail, valueCategory, admissionState, admissionReason, source, commitHash, relatedCommits) {
   const sd = resolveSourceDetail(sourceDetail, source);
   if (!sd) return "";
   const label = sourceKindLabel(sd);
@@ -22740,11 +23452,21 @@ function buildProvenanceHeader(sourceDetail, valueCategory, source, commitHash,
   if (verificationLine) {
     lines.push(verificationLine);
   }
-  if (valueCategory === "core") {
+  if (valueCategory === "core" && admissionState !== "candidate" && admissionState !== "ephemeral") {
     lines.push("[CORE] Core \u2014 immune to decay");
+  } else if (valueCategory === "core") {
+    lines.push("[CORE] Core candidate \u2014 not durable until qualification completes");
   } else if (valueCategory === "ephemeral") {
     lines.push("[WARN] Ephemeral \u2014 short-lived signal");
   }
+  if (admissionState === "candidate") {
+    lines.push("[PENDING] Candidate \u2014 excluded from automatic context until current Code Memory qualifies it");
+  } else if (admissionState === "ephemeral") {
+    lines.push("[TRACE] Ephemeral capture \u2014 excluded from automatic context");
+  } else if (admissionState === "qualified") {
+    lines.push("[QUALIFIED] Automatic evidence passed current Code Memory qualification");
+  }
+  if (admissionReason) lines.push(`Admission: ${redactCredentials(admissionReason)}`);
   return lines.join("\n");
 }
 function sourceKindLabel(sd) {
@@ -22825,6 +23547,7 @@ init_obs_store();
 init_mini_skill_store();
 init_mini_skills();
 init_secret_filter();
+init_visibility();
 function normalizeMemoryBrowseQuery(query) {
   const trimmed = query.trim();
   if (!trimmed) return "";
@@ -22867,11 +23590,13 @@ async function compactSearch(options) {
   );
   let formatted = formatIndexTable(entries, searchOptions.query, !options.projectId);
   if (entries.length === 0 && options.projectId) {
-    const allObservations = getAllObservations();
+    const allObservations = filterReadableObservations(getAllObservations(), options.reader);
     const projectAliases = new Set(await resolveAliases(options.projectId).catch(() => [options.projectId]));
     const projectHasStoredMemory = allObservations.some((obs) => obs.projectId && projectAliases.has(obs.projectId));
     if (!projectHasStoredMemory) {
-      formatted = `This project does not have any Memorix memories yet.
+      formatted = options.reader ? `No Memorix memories are available to this session yet.
+
+The tool call worked, but this session has no project-visible memory to retrieve.` : `This project does not have any Memorix memories yet.
 
 It looks like a fresh project: the tool call worked, but there is nothing stored to retrieve yet.
 
@@ -22885,8 +23610,8 @@ This project does have stored Memorix memories, but none matched the current que
   const totalTokens = countTextTokens(formatted);
   return { entries, formatted, totalTokens };
 }
-async function compactTimeline(anchorId, projectId, depthBefore = 3, depthAfter = 3) {
-  const result = await getTimeline(anchorId, projectId, depthBefore, depthAfter);
+async function compactTimeline(anchorId, projectId, depthBefore = 3, depthAfter = 3, reader) {
+  const result = await getTimeline(anchorId, projectId, depthBefore, depthAfter, reader);
   const timeline = {
     anchorId,
     anchorEntry: result.anchor,
@@ -22897,7 +23622,7 @@ async function compactTimeline(anchorId, projectId, depthBefore = 3, depthAfter
   const totalTokens = countTextTokens(formatted);
   return { timeline, formatted, totalTokens };
 }
-async function compactDetail(idsOrRefs) {
+async function compactDetail(idsOrRefs, options = {}) {
   const invalidRefs = [];
   const parsedRefs = [];
   for (let i = 0; i < idsOrRefs.length; i++) {
@@ -22954,7 +23679,7 @@ async function compactDetail(idsOrRefs) {
   const missingRefs = [];
   for (const ref of refs) {
     const obs = getObservation(ref.id, ref.projectId);
-    if (obs && (ref.projectId ? obs.projectId === ref.projectId : true)) {
+    if (obs && (ref.projectId ? obs.projectId === ref.projectId : true) && canReadObservation(obs, options.reader)) {
       documentMap.set(toRefKey(ref), {
         id: makeOramaObservationId(obs.projectId, obs.id),
         observationId: obs.id,
@@ -22973,7 +23698,12 @@ async function compactDetail(idsOrRefs) {
         status: obs.status ?? "active",
         source: obs.source ?? "agent",
         sourceDetail: obs.sourceDetail ?? "",
-        valueCategory: obs.valueCategory ?? ""
+        valueCategory: obs.valueCategory ?? "",
+        admissionState: obs.admissionState ?? "",
+        admissionReason: obs.admissionReason ?? "",
+        visibility: obs.visibility ?? "project",
+        createdByAgentId: obs.createdByAgentId ?? "",
+        sharedWithAgentIds: JSON.stringify(obs.sharedWithAgentIds ?? [])
       });
     } else {
       missingRefs.push(ref);
@@ -22983,17 +23713,17 @@ async function compactDetail(idsOrRefs) {
     for (const ref of missingRefs) {
       const fallbackDocs = await getObservationsByIds([ref.id], ref.projectId);
       const doc = fallbackDocs[0];
-      if (doc) {
+      if (doc && canReadObservation(doc, options.reader)) {
         documentMap.set(toRefKey(ref), doc);
         continue;
       }
       const stored = await getPersistedObservation(ref);
-      if (stored) {
+      if (stored && canReadObservation(stored, options.reader)) {
         documentMap.set(toRefKey(ref), observationToDocument(stored));
       }
     }
   }
-  const allObs = getAllObservations();
+  const allObs = filterReadableObservations(getAllObservations(), options.reader);
   const crossRefMap = /* @__PURE__ */ new Map();
   for (const ref of refs) {
     const obs = getObservation(ref.id, ref.projectId);
@@ -23107,7 +23837,12 @@ function observationToDocument(obs) {
     status: obs.status ?? "active",
     source: obs.source ?? "agent",
     sourceDetail: obs.sourceDetail ?? "",
-    valueCategory: obs.valueCategory ?? ""
+    valueCategory: obs.valueCategory ?? "",
+    admissionState: obs.admissionState ?? "",
+    admissionReason: obs.admissionReason ?? "",
+    visibility: obs.visibility ?? "project",
+    createdByAgentId: obs.createdByAgentId ?? "",
+    sharedWithAgentIds: JSON.stringify(obs.sharedWithAgentIds ?? [])
   };
 }
 function formatMiniSkillDetail(skill2, provenanceStatus) {
@@ -23226,7 +23961,9 @@ function auditMemoryQuality(observations2, options) {
     status: obs.status ?? "active",
     source: obs.source ?? "agent",
     sourceDetail: obs.sourceDetail ?? "",
-    valueCategory: obs.valueCategory ?? ""
+    valueCategory: obs.valueCategory ?? "",
+    admissionState: obs.admissionState ?? "",
+    admissionReason: obs.admissionReason ?? ""
   }, options.referenceTime) !== "active").map((obs) => makeEntry(obs, "Outside active retention zone"));
   const summary = {
     total: scoped.length,
@@ -23268,6 +24005,7 @@ function auditMemoryQuality(observations2, options) {
 
 // src/memory/graph-context.ts
 init_retention();
+init_admission();
 function formatGraphContextPrompt(packet) {
   const lines = [
     "## Memory Context Packet",
@@ -23425,7 +24163,9 @@ function scoreForPacket(obs, queryTokens, referenceTime, broadMemoryQuery) {
     status: obs.status ?? "active",
     source: obs.source ?? "agent",
     sourceDetail: obs.sourceDetail ?? "",
-    valueCategory: obs.valueCategory ?? ""
+    valueCategory: obs.valueCategory ?? "",
+    admissionState: obs.admissionState ?? "",
+    admissionReason: obs.admissionReason ?? ""
   }, referenceTime) !== "active") {
     score -= 2;
   }
@@ -23519,8 +24259,11 @@ function buildGraphContextPacket(observations2, options) {
     ...audit.issues.orphans.map((entry) => entry.id),
     ...audit.issues.retentionCandidates.map((entry) => entry.id)
   ]);
-  const filteredObservations = observations2.filter((obs) => obs.projectId === options.projectId && !riskIds.has(obs.id));
-  const baseObservations = filteredObservations.length > 0 ? filteredObservations : observations2;
+  const deliveryEligible = observations2.filter(
+    (obs) => obs.projectId === options.projectId && isEligibleForAutomaticDelivery(obs)
+  );
+  const filteredObservations = deliveryEligible.filter((obs) => !riskIds.has(obs.id));
+  const baseObservations = filteredObservations.length > 0 ? filteredObservations : deliveryEligible;
   const memories = pickMemories(baseObservations, options.projectId, options.query, options.limit ?? 5, referenceTime);
   const entities = buildEntities(memories);
   const entityNames = new Set(entities.map((entity) => entity.name));
@@ -26007,6 +26750,8 @@ async function createMemorixServer(cwd, existingServer, sharedTeam, options = {}
   let projectResolutionError = null;
   let explicitProjectBound = false;
   let currentAgentId;
+  let teamStore;
+  let initTeamStoreForProject;
   if (detectedProject) {
     rawProject = detectedProject;
   } else {
@@ -26254,7 +26999,7 @@ The path should point to a directory containing a .git folder.`
   };
   const server = existingServer ?? new McpServer({
     name: "memorix",
-    version: true ? "1.2.0" : "1.0.1"
+    version: true ? "1.2.2" : "1.0.1"
   });
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {
@@ -26274,11 +27019,26 @@ The path should point to a directory containing a .git folder.`
     }
     return originalRegisterTool(name, ...args);
   });
+  const getObservationReader = (scope = "project") => {
+    let isTeamMember = false;
+    if (teamFeaturesEnabled && currentAgentId) {
+      try {
+        const agent = teamStore.getAgent(currentAgentId);
+        isTeamMember = agent?.project_id === project.id && agent.status === "active";
+      } catch {
+      }
+    }
+    return {
+      ...scope === "project" ? { projectId: project.id } : {},
+      ...currentAgentId ? { agentId: currentAgentId } : {},
+      isTeamMember
+    };
+  };
   server.registerTool(
     "memorix_store",
     {
       title: "Store Memory",
-      description: "Store a new observation/memory. Automatically indexed for search. Use type to classify: gotcha ([GOTCHA] critical pitfall), decision ([DECISION] architecture choice), problem-solution ([FIX] bug fix), how-it-works ([INFO] explanation), what-changed ([CHANGE] change), discovery ([DISCOVERY] insight), why-it-exists ([WHY] rationale), trade-off ([TRADEOFF] compromise), session-request ([SESSION] original goal). Stored memories persist across sessions and are shared with other IDEs and agents (Cursor, Windsurf, Claude Code, Codex, Copilot, Gemini CLI, OpenCode, OpenClaw, Hermes Agent, Oh-my-Pi, Kiro, Antigravity, Trae) via the same local data directory.",
+      description: "Store a new observation/memory. Automatically indexed for search. Use type to classify: gotcha ([GOTCHA] critical pitfall), decision ([DECISION] architecture choice), problem-solution ([FIX] bug fix), how-it-works ([INFO] explanation), what-changed ([CHANGE] change), discovery ([DISCOVERY] insight), why-it-exists ([WHY] rationale), trade-off ([TRADEOFF] compromise), session-request ([SESSION] original goal). Project visibility is the default. Personal or team visibility requires an explicitly joined coordination identity.",
       inputSchema: {
         entityName: z2.string().describe('The entity this observation belongs to (e.g., "auth-module", "port-config")'),
         type: z2.enum(OBSERVATION_TYPES).describe("Observation type for classification"),
@@ -26296,361 +27056,214 @@ The path should point to a directory containing a .git folder.`
           completion: z2.number().optional().describe("Completion percentage 0-100")
         }).optional().describe("Progress tracking for task/feature observations"),
         relatedCommits: z2.array(z2.string()).optional().describe("Git commit hashes this memory relates to (links ground truth \u2194 reasoning)"),
-        relatedEntities: z2.array(z2.string()).optional().describe("Other entity names this memory cross-references")
+        relatedEntities: z2.array(z2.string()).optional().describe("Other entity names this memory cross-references"),
+        visibility: z2.enum(["personal", "project", "team"]).optional().describe(
+          "Retrieval scope. Project is the normal shared default; personal/team require memorix_session_start with joinTeam=true."
+        )
       }
     },
-    async ({ entityName: rawEntityName, type: rawType, title: rawTitle, narrative, facts, filesModified, concepts, topicKey, progress, relatedCommits, relatedEntities }) => {
+    async ({ entityName: rawEntityName, type: rawType, title: rawTitle, narrative, facts, filesModified, concepts, topicKey, progress, relatedCommits, relatedEntities, visibility }) => {
       const unresolved = requireResolvedProject("store memory in the current project");
       if (unresolved) return unresolved;
-      return withFreshIndex(async () => {
-        let entityName = rawEntityName;
-        let type = rawType;
-        let title = rawTitle;
-        let safeFacts = facts ? coerceStringArray(facts) : void 0;
-        const safeFiles = filesModified ? coerceStringArray(filesModified) : void 0;
-        const safeConcepts = concepts ? coerceStringArray(concepts) : void 0;
-        let formationMode = "active";
-        if (process.env.MEMORIX_FORMATION_MODE) {
-          formationMode = process.env.MEMORIX_FORMATION_MODE;
-        } else {
-          try {
-            const { getBehaviorConfig: getBehaviorConfig2 } = await Promise.resolve().then(() => (init_behavior(), behavior_exports));
-            formationMode = getBehaviorConfig2({ projectRoot: project.rootPath }).formationMode;
-          } catch {
-          }
-        }
-        const useFormation = formationMode === "active";
-        let formationResult = null;
-        let formationNote = "";
-        if (useFormation && !topicKey && !progress) {
-          let currentFormationStage = "setup";
-          const completedFormationStages = {};
-          const formationStartTime = Date.now();
-          const onFormationStageEvent = (event) => {
-            if (event.status === "start") {
-              currentFormationStage = event.stage;
-              return;
-            }
-            currentFormationStage = event.stage;
-            if (event.stageDurationMs !== void 0) {
-              completedFormationStages[event.stage] = event.stageDurationMs;
-            }
-          };
-          try {
-            const formationConfig = {
-              mode: "active",
-              useLLM: isLLMEnabled(),
-              minValueScore: 0.3,
-              searchMemories: async (q, limit, pid) => {
-                const result = await compactSearch({ query: q, limit, projectId: pid, status: "active" });
-                if (result.entries.length === 0) return [];
-                const details = await compactDetail(result.entries.map((e) => e.id));
-                return details.documents.map((d, i) => ({
-                  id: Number(d.id.replace("obs-", "")),
-                  observationId: d.observationId,
-                  title: d.title,
-                  narrative: d.narrative,
-                  facts: d.facts,
-                  entityName: d.entityName,
-                  type: d.type,
-                  score: result.entries[i]?.score ?? 0
-                }));
-              },
-              getObservation: (id) => {
-                const o = getObservation(id);
-                if (!o) return null;
-                return {
-                  id: o.id,
-                  entityName: o.entityName,
-                  type: o.type,
-                  title: o.title,
-                  narrative: o.narrative,
-                  facts: o.facts,
-                  topicKey: o.topicKey
-                };
-              },
-              getEntityNames: () => graphManager.getEntityNames(),
-              onStageEvent: onFormationStageEvent
-            };
-            formationResult = await withTimeout2(
-              runFormation({
-                entityName,
-                type,
-                title,
-                narrative,
-                facts: safeFacts,
-                projectId: project.id,
-                source: "explicit"
-              }, formationConfig),
-              FORMATION_TIMEOUT_MS,
-              "Formation pipeline"
-            );
-            const modeIcon = "[FAST]";
-            formationNote = `
-${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formationResult.evaluation.score.toFixed(2)}) | ${formationResult.resolution.action} | ${formationResult.pipeline.durationMs}ms`;
-            if (formationResult.extraction.extractedFacts.length > 0) {
-              formationNote += ` | +${formationResult.extraction.extractedFacts.length} facts`;
-            }
-            if (formationResult.extraction.titleImproved) formationNote += " | title\u2191";
-            if (formationResult.extraction.entityResolved) formationNote += ` | entity\u2192${formationResult.entityName}`;
-            if (formationResult.extraction.typeCorrected) formationNote += ` | type\u2192${formationResult.type}`;
-          } catch (formationErr) {
-            const isTimeout = formationErr instanceof Error && formationErr.message.includes("timed out");
-            const elapsedMs = Date.now() - formationStartTime;
-            const stageSummary = formatFormationStageDurations(completedFormationStages);
-            console.error(
-              `[memorix] Formation ${isTimeout ? "timed out" : "failed"} in memorix_store after ${elapsedMs}ms/${FORMATION_TIMEOUT_MS}ms at stage ${currentFormationStage}${stageSummary ? ` | completed: ${stageSummary}` : ""}`
-            );
-            if (!isTimeout && formationErr instanceof Error) {
-              console.error(`[memorix] Formation error: ${formationErr.message}`);
+      const requestedVisibility = visibility ?? "project";
+      const reader = getObservationReader();
+      if (requestedVisibility !== "project" && !currentAgentId) {
+        return {
+          content: [{ type: "text", text: "Personal or team memory requires memorix_session_start with joinTeam=true so Memorix can bind an owner." }],
+          isError: true
+        };
+      }
+      if (requestedVisibility === "team" && !reader.isTeamMember) {
+        return {
+          content: [{ type: "text", text: "Team memory requires an active coordination membership in the current project." }],
+          isError: true
+        };
+      }
+      try {
+        return await withFreshIndex(async () => {
+          let entityName = rawEntityName;
+          let type = rawType;
+          let title = rawTitle;
+          let safeFacts = facts ? coerceStringArray(facts) : void 0;
+          const safeFiles = filesModified ? coerceStringArray(filesModified) : void 0;
+          const safeConcepts = concepts ? coerceStringArray(concepts) : void 0;
+          let formationMode = "active";
+          if (process.env.MEMORIX_FORMATION_MODE) {
+            formationMode = process.env.MEMORIX_FORMATION_MODE;
+          } else {
+            try {
+              const { getBehaviorConfig: getBehaviorConfig2 } = await Promise.resolve().then(() => (init_behavior(), behavior_exports));
+              formationMode = getBehaviorConfig2({ projectRoot: project.rootPath }).formationMode;
+            } catch {
             }
-            formationNote = `
-[WARN] Formation ${isTimeout ? "timed out" : "failed"} \u2014 storing base observation without enrichment`;
           }
-        }
-        if (useFormation && formationResult && formationResult.resolution.action !== "new") {
-          const { action: action2, targetId, reason } = formationResult.resolution;
-          if (action2 === "merge" && targetId) {
-            const targetObs = getObservation(targetId);
-            if (targetObs) {
-              await storeObservation({
-                entityName: targetObs.entityName,
-                type: targetObs.type,
-                title: formationResult.title,
-                narrative: formationResult.narrative,
-                facts: formationResult.facts,
-                filesModified: safeFiles,
-                concepts: safeConcepts,
-                projectId: project.id,
-                topicKey: targetObs.topicKey,
-                progress,
-                sourceDetail: "explicit",
-                createdByAgentId: currentAgentId
-              });
-              return {
-                content: [{
-                  type: "text",
-                  text: `[UPDATED] Formation MERGE: merged into #${targetId} (${reason})${formationNote}`
-                }]
-              };
-            }
-          } else if (action2 === "evolve" && targetId) {
-            const targetObs = getObservation(targetId);
-            if (targetObs) {
-              await storeObservation({
-                entityName: targetObs.entityName,
-                type: targetObs.type,
-                title: formationResult.title,
-                narrative: formationResult.narrative,
-                facts: formationResult.facts,
-                filesModified: safeFiles,
-                concepts: safeConcepts,
-                projectId: project.id,
-                topicKey: targetObs.topicKey,
-                progress,
-                sourceDetail: "explicit",
-                createdByAgentId: currentAgentId
-              });
-              return {
-                content: [{
-                  type: "text",
-                  text: `[UPDATED] Formation EVOLVE: evolved #${targetId} (${reason})${formationNote}`
-                }]
-              };
-            }
-          } else if (action2 === "discard") {
-            return {
-              content: [{
-                type: "text",
-                text: `[SKIP] Formation DISCARD: ${reason}${formationNote}`
-              }]
+          const useFormation = formationMode === "active";
+          let formationResult = null;
+          let formationNote = "";
+          if (useFormation && !topicKey && !progress) {
+            let currentFormationStage = "setup";
+            const completedFormationStages = {};
+            const formationStartTime = Date.now();
+            const onFormationStageEvent = (event) => {
+              if (event.status === "start") {
+                currentFormationStage = event.stage;
+                return;
+              }
+              currentFormationStage = event.stage;
+              if (event.stageDurationMs !== void 0) {
+                completedFormationStages[event.stage] = event.stageDurationMs;
+              }
             };
-          }
-        }
-        let compactAction = "";
-        let compactMerged = false;
-        if (!useFormation && !topicKey && !progress) {
-          try {
-            const searchResult = await compactSearch({
-              query: `${title} ${narrative.substring(0, 200)}`,
-              limit: 5,
-              projectId: project.id,
-              status: "active"
-            });
-            const similarEntries = searchResult.entries.map((e) => e);
-            if (similarEntries.length > 0) {
-              const similarIds = similarEntries.map((e) => e.id);
-              const details = await compactDetail(similarIds);
-              const existingMemories = details.documents.map((d, i) => ({
-                id: d.observationId,
-                title: d.title,
-                narrative: d.narrative,
-                facts: d.facts,
-                score: similarEntries[i]?.score ?? 0
-              }));
-              const decision = await withTimeout2(
-                compactOnWrite(
-                  { title, narrative, facts: safeFacts ?? [] },
-                  existingMemories
-                ),
-                COMPACT_ON_WRITE_TIMEOUT_MS,
-                "Compact-on-write"
-              );
-              if (decision.action === "UPDATE" && decision.targetId) {
-                const targetObs = getObservation(decision.targetId);
-                if (targetObs) {
-                  await storeObservation({
-                    entityName: targetObs.entityName,
-                    type: targetObs.type,
-                    title: decision.mergedNarrative ? title : targetObs.title,
-                    narrative: decision.mergedNarrative ?? narrative,
-                    facts: decision.mergedFacts ?? safeFacts,
-                    filesModified: safeFiles,
-                    concepts: safeConcepts,
-                    projectId: project.id,
-                    topicKey: targetObs.topicKey,
-                    progress,
-                    sourceDetail: "explicit",
-                    createdByAgentId: currentAgentId
-                  });
-                  compactAction = `[UPDATED] Compact UPDATE: merged into #${decision.targetId} (${decision.reason})`;
-                  compactMerged = true;
+            try {
+              const formationConfig = {
+                mode: "active",
+                useLLM: isLLMEnabled(),
+                minValueScore: 0.3,
+                searchMemories: async (q, limit, pid) => {
+                  const result = await compactSearch({ query: q, limit, projectId: pid, status: "active", reader });
+                  if (result.entries.length === 0) return [];
+                  const details = await compactDetail(result.entries.map((e) => e.id), { reader });
+                  return details.documents.map((d, i) => ({
+                    id: Number(d.id.replace("obs-", "")),
+                    observationId: d.observationId,
+                    title: d.title,
+                    narrative: d.narrative,
+                    facts: d.facts,
+                    entityName: d.entityName,
+                    type: d.type,
+                    score: result.entries[i]?.score ?? 0
+                  }));
+                },
+                getObservation: (id) => {
+                  const o = getObservation(id);
+                  if (!o || o.projectId !== project.id || !canReadObservation(o, reader)) return null;
                   return {
-                    content: [{
-                      type: "text",
-                      text: `${compactAction}
-Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
-                    }]
+                    id: o.id,
+                    entityName: o.entityName,
+                    type: o.type,
+                    title: o.title,
+                    narrative: o.narrative,
+                    facts: o.facts,
+                    topicKey: o.topicKey
                   };
-                }
-              } else if (decision.action === "NONE") {
+                },
+                getEntityNames: () => graphManager.getEntityNames(),
+                onStageEvent: onFormationStageEvent
+              };
+              formationResult = await withTimeout2(
+                runFormation({
+                  entityName,
+                  type,
+                  title,
+                  narrative,
+                  facts: safeFacts,
+                  projectId: project.id,
+                  source: "explicit"
+                }, formationConfig),
+                FORMATION_TIMEOUT_MS,
+                "Formation pipeline"
+              );
+              const modeIcon = "[FAST]";
+              formationNote = `
+${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formationResult.evaluation.score.toFixed(2)}) | ${formationResult.resolution.action} | ${formationResult.pipeline.durationMs}ms`;
+              if (formationResult.extraction.extractedFacts.length > 0) {
+                formationNote += ` | +${formationResult.extraction.extractedFacts.length} facts`;
+              }
+              if (formationResult.extraction.titleImproved) formationNote += " | title\u2191";
+              if (formationResult.extraction.entityResolved) formationNote += ` | entity\u2192${formationResult.entityName}`;
+              if (formationResult.extraction.typeCorrected) formationNote += ` | type\u2192${formationResult.type}`;
+            } catch (formationErr) {
+              const isTimeout = formationErr instanceof Error && formationErr.message.includes("timed out");
+              const elapsedMs = Date.now() - formationStartTime;
+              const stageSummary = formatFormationStageDurations(completedFormationStages);
+              console.error(
+                `[memorix] Formation ${isTimeout ? "timed out" : "failed"} in memorix_store after ${elapsedMs}ms/${FORMATION_TIMEOUT_MS}ms at stage ${currentFormationStage}${stageSummary ? ` | completed: ${stageSummary}` : ""}`
+              );
+              if (!isTimeout && formationErr instanceof Error) {
+                console.error(`[memorix] Formation error: ${formationErr.message}`);
+              }
+              formationNote = `
+[WARN] Formation ${isTimeout ? "timed out" : "failed"} \u2014 storing base observation without enrichment`;
+            }
+          }
+          if (useFormation && formationResult && formationResult.resolution.action !== "new") {
+            const { action: action2, targetId, reason } = formationResult.resolution;
+            if (action2 === "merge" && targetId) {
+              const targetObs = getObservation(targetId);
+              if (targetObs && targetObs.projectId === project.id && canReadObservation(targetObs, reader)) {
+                await storeObservation({
+                  entityName: targetObs.entityName,
+                  type: targetObs.type,
+                  title: formationResult.title,
+                  narrative: formationResult.narrative,
+                  facts: formationResult.facts,
+                  filesModified: safeFiles,
+                  concepts: safeConcepts,
+                  projectId: project.id,
+                  topicKey: targetObs.topicKey,
+                  progress,
+                  sourceDetail: "explicit",
+                  createdByAgentId: currentAgentId,
+                  visibility,
+                  visibilityReader: reader
+                });
                 return {
                   content: [{
                     type: "text",
-                    text: `[SKIP] Compact SKIP: ${decision.reason}
-Existing memory #${decision.targetId} already covers this.
-Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
+                    text: `[UPDATED] Formation MERGE: merged into #${targetId} (${reason})${formationNote}`
                   }]
                 };
-              } else if (decision.action === "DELETE" && decision.targetId) {
-                const { resolveObservations: resolveObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
-                await resolveObservations2([decision.targetId], "resolved");
-                compactAction = ` | Compact: resolved outdated #${decision.targetId}`;
               }
-              if (decision.enrichedFacts && decision.enrichedFacts.length > 0) {
-                const currentFacts = safeFacts ?? [];
-                const newFacts = decision.enrichedFacts.filter((f) => !currentFacts.includes(f));
-                if (newFacts.length > 0) {
-                  compactAction += ` | +${newFacts.length} LLM-extracted facts`;
-                }
+            } else if (action2 === "evolve" && targetId) {
+              const targetObs = getObservation(targetId);
+              if (targetObs && targetObs.projectId === project.id && canReadObservation(targetObs, reader)) {
+                await storeObservation({
+                  entityName: targetObs.entityName,
+                  type: targetObs.type,
+                  title: formationResult.title,
+                  narrative: formationResult.narrative,
+                  facts: formationResult.facts,
+                  filesModified: safeFiles,
+                  concepts: safeConcepts,
+                  projectId: project.id,
+                  topicKey: targetObs.topicKey,
+                  progress,
+                  sourceDetail: "explicit",
+                  createdByAgentId: currentAgentId,
+                  visibility,
+                  visibilityReader: reader
+                });
+                return {
+                  content: [{
+                    type: "text",
+                    text: `[UPDATED] Formation EVOLVE: evolved #${targetId} (${reason})${formationNote}`
+                  }]
+                };
               }
+            } else if (action2 === "discard") {
+              return {
+                content: [{
+                  type: "text",
+                  text: `[SKIP] Formation DISCARD: ${reason}${formationNote}`
+                }]
+              };
             }
-          } catch {
-          }
-        }
-        if (formationResult && formationResult.resolution.action === "new") {
-          const llmFacts = formationResult.extraction.extractedFacts;
-          if (llmFacts.length > 0) {
-            const currentFacts = safeFacts ?? [];
-            const currentLower = new Set(currentFacts.map((f) => f.toLowerCase().trim()));
-            const newFacts = llmFacts.filter((f) => !currentLower.has(f.toLowerCase().trim()));
-            if (newFacts.length > 0) {
-              safeFacts = [...currentFacts, ...newFacts];
-            }
-          }
-          if (formationResult.extraction.titleImproved && formationResult.title) {
-            title = formationResult.title;
-          }
-          if (formationResult.extraction.typeCorrected && formationResult.type) {
-            type = formationResult.type;
-          }
-          if (formationResult.extraction.entityResolved && formationResult.entityName) {
-            entityName = formationResult.entityName;
-          }
-        }
-        await graphManager.createEntities([
-          { name: entityName, entityType: "auto", observations: [] }
-        ]);
-        let sessionId;
-        try {
-          const { getActiveSession: getActiveSession2 } = await Promise.resolve().then(() => (init_session(), session_exports));
-          const active = await getActiveSession2(projectDir2, project.id);
-          if (active) sessionId = active.id;
-        } catch {
-        }
-        let finalNarrative = narrative;
-        let compressionNote = "";
-        try {
-          const { compressNarrative: compressNarrative2 } = await Promise.resolve().then(() => (init_quality(), quality_exports));
-          const { compressed, saved, usedLLM } = await withTimeout2(
-            compressNarrative2(narrative, safeFacts, type),
-            COMPRESSION_TIMEOUT_MS,
-            "Narrative compression"
-          );
-          if (usedLLM && saved > 0) {
-            finalNarrative = compressed;
-            compressionNote = ` | compressed -${saved} tokens`;
-          }
-        } catch {
-        }
-        let attributionWarning = "";
-        try {
-          const attrCheck = await checkProjectAttribution(entityName, project.id, getAllObservations());
-          if (attrCheck.suspicious) {
-            attributionWarning = `
-[WARN] Attribution notice: entity "${entityName}" has 0 observations in "${project.id}" but ${attrCheck.count} in "${attrCheck.knownIn}" (confidence: ${attrCheck.confidence}). Verify the correct project is bound before storing.`;
           }
-        } catch {
-        }
-        const { observation: obs, upserted } = await storeObservation({
-          entityName,
-          type,
-          title,
-          narrative: finalNarrative,
-          facts: safeFacts,
-          filesModified: safeFiles,
-          concepts: safeConcepts,
-          projectId: project.id,
-          topicKey,
-          sessionId,
-          progress,
-          relatedCommits,
-          relatedEntities,
-          sourceDetail: "explicit",
-          valueCategory: formationResult?.evaluation.category,
-          createdByAgentId: currentAgentId
-        });
-        await graphManager.addObservations([
-          { entityName, contents: [`[#${obs.id}] ${title}`] }
-        ]);
-        const extracted = extractEntities([title, narrative, ...safeFacts ?? []].join(" "));
-        const autoRelCount = await createAutoRelations(obs, extracted, graphManager);
-        const enrichmentParts = [];
-        const autoFiles = obs.filesModified.filter((f) => !(safeFiles ?? []).includes(f));
-        const autoConcepts = obs.concepts.filter((c) => !(safeConcepts ?? []).includes(c));
-        if (autoFiles.length > 0) enrichmentParts.push(`+${autoFiles.length} files extracted`);
-        if (autoConcepts.length > 0) enrichmentParts.push(`+${autoConcepts.length} concepts enriched`);
-        if (autoRelCount > 0) enrichmentParts.push(`+${autoRelCount} relations auto-created`);
-        if (obs.hasCausalLanguage) enrichmentParts.push("causal language detected");
-        if (upserted) enrichmentParts.push(`topic upserted (rev ${obs.revisionCount ?? 1})`);
-        const enrichment = enrichmentParts.length > 0 ? `
-Auto-enriched: ${enrichmentParts.join(", ")}` : "";
-        const action = upserted ? "[UPDATED] Updated" : "[OK] Stored";
-        if (!useFormation && !topicKey && !progress) {
-          const shadowFormation = async () => {
-            let oldCompactDecision = null;
+          let compactAction = "";
+          let compactMerged = false;
+          if (!useFormation && !topicKey && !progress) {
             try {
-              const compactStart = Date.now();
               const searchResult = await compactSearch({
                 query: `${title} ${narrative.substring(0, 200)}`,
                 limit: 5,
                 projectId: project.id,
-                status: "active"
+                status: "active",
+                reader
               });
               const similarEntries = searchResult.entries.map((e) => e);
               if (similarEntries.length > 0) {
                 const similarIds = similarEntries.map((e) => e.id);
-                const details = await compactDetail(similarIds);
+                const details = await compactDetail(similarIds, { reader });
                 const existingMemories = details.documents.map((d, i) => ({
                   id: d.observationId,
                   title: d.title,
@@ -26658,78 +27271,266 @@ Auto-enriched: ${enrichmentParts.join(", ")}` : "";
                   facts: d.facts,
                   score: similarEntries[i]?.score ?? 0
                 }));
-                const decision = await compactOnWrite(
-                  { title, narrative, facts: safeFacts ?? [] },
-                  existingMemories
+                const decision = await withTimeout2(
+                  compactOnWrite(
+                    { title, narrative, facts: safeFacts ?? [] },
+                    existingMemories
+                  ),
+                  COMPACT_ON_WRITE_TIMEOUT_MS,
+                  "Compact-on-write"
                 );
-                oldCompactDecision = {
-                  action: decision.action,
-                  targetId: decision.targetId,
-                  reason: decision.reason,
-                  durationMs: Date.now() - compactStart
-                };
+                if (decision.action === "UPDATE" && decision.targetId) {
+                  const targetObs = getObservation(decision.targetId);
+                  if (targetObs && targetObs.projectId === project.id && canReadObservation(targetObs, reader)) {
+                    await storeObservation({
+                      entityName: targetObs.entityName,
+                      type: targetObs.type,
+                      title: decision.mergedNarrative ? title : targetObs.title,
+                      narrative: decision.mergedNarrative ?? narrative,
+                      facts: decision.mergedFacts ?? safeFacts,
+                      filesModified: safeFiles,
+                      concepts: safeConcepts,
+                      projectId: project.id,
+                      topicKey: targetObs.topicKey,
+                      progress,
+                      sourceDetail: "explicit",
+                      createdByAgentId: currentAgentId,
+                      visibility,
+                      visibilityReader: reader
+                    });
+                    compactAction = `[UPDATED] Compact UPDATE: merged into #${decision.targetId} (${decision.reason})`;
+                    compactMerged = true;
+                    return {
+                      content: [{
+                        type: "text",
+                        text: `${compactAction}
+Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
+                      }]
+                    };
+                  }
+                } else if (decision.action === "NONE") {
+                  return {
+                    content: [{
+                      type: "text",
+                      text: `[SKIP] Compact SKIP: ${decision.reason}
+Existing memory #${decision.targetId} already covers this.
+Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
+                    }]
+                  };
+                } else if (decision.action === "DELETE" && decision.targetId) {
+                  const { resolveObservations: resolveObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
+                  await resolveObservations2([decision.targetId], "resolved");
+                  compactAction = ` | Compact: resolved outdated #${decision.targetId}`;
+                }
+                if (decision.enrichedFacts && decision.enrichedFacts.length > 0) {
+                  const currentFacts = safeFacts ?? [];
+                  const newFacts = decision.enrichedFacts.filter((f) => !currentFacts.includes(f));
+                  if (newFacts.length > 0) {
+                    compactAction += ` | +${newFacts.length} LLM-extracted facts`;
+                  }
+                }
               }
             } catch {
             }
-            const formationConfig = {
-              mode: formationMode,
-              useLLM: isLLMEnabled(),
-              minValueScore: 0.3,
-              searchMemories: async (q, limit, pid) => {
-                const result = await compactSearch({ query: q, limit, projectId: pid, status: "active" });
-                if (result.entries.length === 0) return [];
-                const details = await compactDetail(result.entries.map((e) => e.id));
-                return details.documents.map((d, i) => ({
-                  id: Number(d.id.replace("obs-", "")),
-                  observationId: d.observationId,
-                  title: d.title,
-                  narrative: d.narrative,
-                  facts: d.facts,
-                  entityName: d.entityName,
-                  type: d.type,
-                  score: result.entries[i]?.score ?? 0
-                }));
-              },
-              getObservation: (id) => {
-                const o = getObservation(id);
-                if (!o) return null;
-                return { id: o.id, entityName: o.entityName, type: o.type, title: o.title, narrative: o.narrative, facts: o.facts, topicKey: o.topicKey };
-              },
-              getEntityNames: () => graphManager.getEntityNames()
-            };
-            const formed = await withTimeout2(
-              runFormation({ entityName, type, title, narrative, facts: safeFacts, projectId: project.id, source: "explicit", topicKey }, formationConfig),
-              FORMATION_TIMEOUT_MS,
-              "Shadow formation"
+          }
+          if (formationResult && formationResult.resolution.action === "new") {
+            const llmFacts = formationResult.extraction.extractedFacts;
+            if (llmFacts.length > 0) {
+              const currentFacts = safeFacts ?? [];
+              const currentLower = new Set(currentFacts.map((f) => f.toLowerCase().trim()));
+              const newFacts = llmFacts.filter((f) => !currentLower.has(f.toLowerCase().trim()));
+              if (newFacts.length > 0) {
+                safeFacts = [...currentFacts, ...newFacts];
+              }
+            }
+            if (formationResult.extraction.titleImproved && formationResult.title) {
+              title = formationResult.title;
+            }
+            if (formationResult.extraction.typeCorrected && formationResult.type) {
+              type = formationResult.type;
+            }
+            if (formationResult.extraction.entityResolved && formationResult.entityName) {
+              entityName = formationResult.entityName;
+            }
+          }
+          await graphManager.createEntities([
+            { name: entityName, entityType: "auto", observations: [] }
+          ]);
+          let sessionId;
+          try {
+            const { getActiveSession: getActiveSession2 } = await Promise.resolve().then(() => (init_session(), session_exports));
+            const active = await getActiveSession2(projectDir2, project.id);
+            if (active) sessionId = active.id;
+          } catch {
+          }
+          let finalNarrative = narrative;
+          let compressionNote = "";
+          try {
+            const { compressNarrative: compressNarrative2 } = await Promise.resolve().then(() => (init_quality(), quality_exports));
+            const { compressed, saved, usedLLM } = await withTimeout2(
+              compressNarrative2(narrative, safeFacts, type),
+              COMPRESSION_TIMEOUT_MS,
+              "Narrative compression"
             );
-            const { recordBeforeAfterMetrics: recordBeforeAfterMetrics2 } = await Promise.resolve().then(() => (init_formation(), formation_exports));
-            if (oldCompactDecision) {
-              recordBeforeAfterMetrics2({
-                formationAction: formed.resolution.action,
-                formationTargetId: formed.resolution.targetId,
-                oldCompactAction: oldCompactDecision.action,
-                oldCompactTargetId: oldCompactDecision.targetId,
-                oldCompactReason: oldCompactDecision.reason,
-                formationValueScore: formed.evaluation.score,
-                formationValueCategory: formed.evaluation.category,
-                formationDurationMs: formed.pipeline.durationMs,
-                compactDurationMs: oldCompactDecision.durationMs
-              });
+            if (usedLLM && saved > 0) {
+              finalNarrative = compressed;
+              compressionNote = ` | compressed -${saved} tokens`;
             }
-          };
-          shadowFormation().catch(() => {
+          } catch {
+          }
+          let attributionWarning = "";
+          try {
+            const attrCheck = await checkProjectAttribution(
+              entityName,
+              project.id,
+              filterReadableObservations(getAllObservations(), reader)
+            );
+            if (attrCheck.suspicious) {
+              attributionWarning = `
+[WARN] Attribution notice: entity "${entityName}" has 0 observations in "${project.id}" but ${attrCheck.count} in "${attrCheck.knownIn}" (confidence: ${attrCheck.confidence}). Verify the correct project is bound before storing.`;
+            }
+          } catch {
+          }
+          const { observation: obs, upserted } = await storeObservation({
+            entityName,
+            type,
+            title,
+            narrative: finalNarrative,
+            facts: safeFacts,
+            filesModified: safeFiles,
+            concepts: safeConcepts,
+            projectId: project.id,
+            topicKey,
+            sessionId,
+            progress,
+            relatedCommits,
+            relatedEntities,
+            sourceDetail: "explicit",
+            valueCategory: formationResult?.evaluation.category,
+            createdByAgentId: currentAgentId,
+            visibility,
+            visibilityReader: reader
           });
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: `${action} observation #${obs.id} "${title}" (~${obs.tokens} tokens)
+          await graphManager.addObservations([
+            { entityName, contents: [`[#${obs.id}] ${title}`] }
+          ]);
+          const extracted = extractEntities([title, narrative, ...safeFacts ?? []].join(" "));
+          const autoRelCount = await createAutoRelations(obs, extracted, graphManager);
+          const enrichmentParts = [];
+          const autoFiles = obs.filesModified.filter((f) => !(safeFiles ?? []).includes(f));
+          const autoConcepts = obs.concepts.filter((c) => !(safeConcepts ?? []).includes(c));
+          if (autoFiles.length > 0) enrichmentParts.push(`+${autoFiles.length} files extracted`);
+          if (autoConcepts.length > 0) enrichmentParts.push(`+${autoConcepts.length} concepts enriched`);
+          if (autoRelCount > 0) enrichmentParts.push(`+${autoRelCount} relations auto-created`);
+          if (obs.hasCausalLanguage) enrichmentParts.push("causal language detected");
+          if (upserted) enrichmentParts.push(`topic upserted (rev ${obs.revisionCount ?? 1})`);
+          const enrichment = enrichmentParts.length > 0 ? `
+Auto-enriched: ${enrichmentParts.join(", ")}` : "";
+          const action = upserted ? "[UPDATED] Updated" : "[OK] Stored";
+          if (!useFormation && !topicKey && !progress) {
+            const shadowFormation = async () => {
+              let oldCompactDecision = null;
+              try {
+                const compactStart = Date.now();
+                const searchResult = await compactSearch({
+                  query: `${title} ${narrative.substring(0, 200)}`,
+                  limit: 5,
+                  projectId: project.id,
+                  status: "active",
+                  reader
+                });
+                const similarEntries = searchResult.entries.map((e) => e);
+                if (similarEntries.length > 0) {
+                  const similarIds = similarEntries.map((e) => e.id);
+                  const details = await compactDetail(similarIds, { reader });
+                  const existingMemories = details.documents.map((d, i) => ({
+                    id: d.observationId,
+                    title: d.title,
+                    narrative: d.narrative,
+                    facts: d.facts,
+                    score: similarEntries[i]?.score ?? 0
+                  }));
+                  const decision = await compactOnWrite(
+                    { title, narrative, facts: safeFacts ?? [] },
+                    existingMemories
+                  );
+                  oldCompactDecision = {
+                    action: decision.action,
+                    targetId: decision.targetId,
+                    reason: decision.reason,
+                    durationMs: Date.now() - compactStart
+                  };
+                }
+              } catch {
+              }
+              const formationConfig = {
+                mode: formationMode,
+                useLLM: isLLMEnabled(),
+                minValueScore: 0.3,
+                searchMemories: async (q, limit, pid) => {
+                  const result = await compactSearch({ query: q, limit, projectId: pid, status: "active", reader });
+                  if (result.entries.length === 0) return [];
+                  const details = await compactDetail(result.entries.map((e) => e.id), { reader });
+                  return details.documents.map((d, i) => ({
+                    id: Number(d.id.replace("obs-", "")),
+                    observationId: d.observationId,
+                    title: d.title,
+                    narrative: d.narrative,
+                    facts: d.facts,
+                    entityName: d.entityName,
+                    type: d.type,
+                    score: result.entries[i]?.score ?? 0
+                  }));
+                },
+                getObservation: (id) => {
+                  const o = getObservation(id);
+                  if (!o || o.projectId !== project.id || !canReadObservation(o, reader)) return null;
+                  return { id: o.id, entityName: o.entityName, type: o.type, title: o.title, narrative: o.narrative, facts: o.facts, topicKey: o.topicKey };
+                },
+                getEntityNames: () => graphManager.getEntityNames()
+              };
+              const formed = await withTimeout2(
+                runFormation({ entityName, type, title, narrative, facts: safeFacts, projectId: project.id, source: "explicit", topicKey }, formationConfig),
+                FORMATION_TIMEOUT_MS,
+                "Shadow formation"
+              );
+              const { recordBeforeAfterMetrics: recordBeforeAfterMetrics2 } = await Promise.resolve().then(() => (init_formation(), formation_exports));
+              if (oldCompactDecision) {
+                recordBeforeAfterMetrics2({
+                  formationAction: formed.resolution.action,
+                  formationTargetId: formed.resolution.targetId,
+                  oldCompactAction: oldCompactDecision.action,
+                  oldCompactTargetId: oldCompactDecision.targetId,
+                  oldCompactReason: oldCompactDecision.reason,
+                  formationValueScore: formed.evaluation.score,
+                  formationValueCategory: formed.evaluation.category,
+                  formationDurationMs: formed.pipeline.durationMs,
+                  compactDurationMs: oldCompactDecision.durationMs
+                });
+              }
+            };
+            shadowFormation().catch(() => {
+            });
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: `${action} observation #${obs.id} "${title}" (~${obs.tokens} tokens)
 Entity: ${entityName} | Type: ${type} | Project: ${project.id}${obs.topicKey ? ` | Topic: ${obs.topicKey}` : ""}${compactAction}${compressionNote}${enrichment}${formationNote}${attributionWarning}`
-            }
-          ]
+              }
+            ]
+          };
+        });
+      } catch (error) {
+        return {
+          content: [{
+            type: "text",
+            text: error instanceof Error ? error.message : "Failed to store memory."
+          }],
+          isError: true
         };
-      });
+      }
     }
   );
   server.registerTool(
@@ -26801,7 +27602,8 @@ Use this as the \`topicKey\` parameter in \`memorix_store\` to enable upsert beh
           // Use scope: 'global' to explicitly search all projects.
           projectId: scope === "global" ? void 0 : project.id,
           status: status ?? "active",
-          source
+          source,
+          reader: getObservationReader(scope === "global" ? "global" : "project")
         });
         const timeoutPromise = new Promise(
           (_, reject) => setTimeout(() => reject(new Error(`Search timeout after ${TIMEOUT_MS}ms`)), TIMEOUT_MS)
@@ -26859,7 +27661,10 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
       const unresolved = requireResolvedProject("build graph context for the current project");
       if (unresolved) return unresolved;
       const { getObservationStore: getObservationStore2 } = await Promise.resolve().then(() => (init_obs_store(), obs_store_exports));
-      const observations2 = await getObservationStore2().loadByProject(project.id);
+      const observations2 = filterReadableObservations(
+        await getObservationStore2().loadByProject(project.id),
+        getObservationReader()
+      );
       const packet = buildGraphContextPacket(observations2, {
         projectId: project.id,
         query,
@@ -26911,7 +27716,10 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
         Promise.resolve().then(() => (init_maintenance_jobs(), maintenance_jobs_exports)),
         Promise.resolve().then(() => (init_lifecycle(), lifecycle_exports))
       ]);
-      const observations2 = await getObservationStore2().loadByProject(project.id, { status: "active" });
+      const observations2 = filterReadableObservations(
+        await getObservationStore2().loadByProject(project.id, { status: "active" }),
+        getObservationReader()
+      );
       const context = await buildAutoProjectContext2({
         project,
         dataDir: projectDir2,
@@ -26986,7 +27794,7 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
         { getResolvedConfig: getResolvedConfig2 },
         { getExternalCodeGraphContext: getExternalCodeGraphContext2 },
         { getObservationStore: getObservationStore2 },
-        { collectCurrentProjectFacts: collectCurrentProjectFacts2 },
+        { collectCurrentProjectFacts: collectCurrentProjectFacts2, formatGitFact: formatGitFact2 },
         { resolveTaskLens: resolveTaskLens2 }
       ] = await Promise.all([
         Promise.resolve().then(() => (init_store(), store_exports)),
@@ -27001,7 +27809,10 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
       await store.init(projectDir2);
       const codegraphConfig = getResolvedConfig2({ projectRoot: project.rootPath }).codegraph;
       const exclude = codegraphConfig.excludePatterns;
-      const observations2 = await getObservationStore2().loadByProject(project.id, { status: "active" });
+      const observations2 = filterReadableObservations(
+        await getObservationStore2().loadByProject(project.id, { status: "active" }),
+        getObservationReader()
+      );
       observations2.reverse();
       const basePack = assembleContextPackForTask2({
         store,
@@ -27027,7 +27838,7 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
       if (currentFacts.latestChangelog) {
         worksetFacts.push("Latest changelog: " + currentFacts.latestChangelog.version + (currentFacts.latestChangelog.date ? " (" + currentFacts.latestChangelog.date + ")" : ""));
       }
-      worksetFacts.push("Git: " + (currentFacts.git.branch ? "branch " + currentFacts.git.branch + ", " : "") + (currentFacts.git.dirty ? "dirty worktree" : "clean worktree"));
+      worksetFacts.push(formatGitFact2(currentFacts.git));
       const codeState = snapshot ? "- Code state: " + (snapshot.baseRevision ? snapshot.baseRevision.slice(0, 12) : "Git unavailable") + ", " + snapshot.worktreeState + " worktree, epoch " + snapshot.sourceEpoch : "- Code state: no completed snapshot yet";
       const pack = await attachTaskWorkset2({
         pack: basePack,
@@ -27059,11 +27870,13 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
     "memorix_knowledge",
     {
       title: "Knowledge Workspace",
-      description: "Manage the reviewable project Knowledge Workspace. Use it only for deliberate knowledge operations: initialize a local or versioned workspace, inspect status, compile source-backed proposals, lint, apply a reviewed proposal, or manage canonical workflows. It is intentionally absent from the default micro/lite profiles.",
+      description: "Manage the reviewable project Knowledge Workspace. Use it only for deliberate knowledge operations: initialize a local or versioned workspace, review source-backed claims, compile proposals, lint, apply a reviewed proposal, or manage canonical workflows. It is intentionally absent from the default micro/lite profiles.",
       inputSchema: {
         action: z2.enum([
           "workspace_init",
           "status",
+          "claim_list",
+          "claim_review",
           "compile",
           "lint",
           "proposal_apply",
@@ -27078,6 +27891,9 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
         path: z2.string().optional().describe("Explicit versioned workspace path, used only by workspace_init"),
         proposalId: z2.string().optional().describe("Pending proposal id for proposal_apply"),
         allowManualOverwrite: z2.boolean().optional().default(false).describe("Explicitly allow proposal_apply to replace a manually edited page"),
+        claimId: z2.string().optional().describe("Source-backed claim id for claim_review"),
+        claimReviewState: z2.enum(["approved", "rejected"]).optional().describe("Deliberate review verdict for claim_review"),
+        reviewDetail: z2.string().max(2e3).optional().describe("Evidence check performed before approving or rejecting a claim"),
         workflowId: z2.string().optional().describe("Canonical workflow id for workflow preview, apply, or run"),
         agent: z2.string().optional().describe("Target agent for a workflow adapter"),
         task: z2.string().optional().describe("Task text for workflow selection or a workflow run"),
@@ -27094,6 +27910,9 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
       path: workspacePath,
       proposalId,
       allowManualOverwrite,
+      claimId,
+      claimReviewState,
+      reviewDetail,
       workflowId,
       agent,
       task,
@@ -27116,6 +27935,7 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
       };
       const [
         { ClaimStore: ClaimStore2 },
+        { reviewClaim: reviewClaim2 },
         { CodeGraphStore: CodeGraphStore2 },
         { initializeKnowledgeWorkspace: initializeKnowledgeWorkspace2, loadKnowledgeWorkspace: loadKnowledgeWorkspace2 },
         { KnowledgeWorkspaceStore: KnowledgeWorkspaceStore2 },
@@ -27131,6 +27951,7 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
         }
       ] = await Promise.all([
         Promise.resolve().then(() => (init_claim_store(), claim_store_exports)),
+        Promise.resolve().then(() => (init_claims(), claims_exports)),
         Promise.resolve().then(() => (init_store(), store_exports)),
         Promise.resolve().then(() => (init_workspace(), workspace_exports)),
         Promise.resolve().then(() => (init_workspace_store(), workspace_store_exports)),
@@ -27180,10 +28001,52 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
               targetPath: proposal.targetPath,
               reason: proposal.reason,
               createdAt: proposal.createdAt
-            }))
+            })),
+            reviewableClaims: claims.listClaims(project.id, { limit: 100 }).filter((claim) => claim.reviewState === "needs-review").map((claim) => ({ id: claim.id, subject: claim.subject, predicate: claim.predicate, objectValue: claim.objectValue }))
           }
         });
       }
+      if (action === "claim_list") {
+        return text({
+          claims: claims.listClaims(project.id, { limit: 100 }).map((claim) => ({
+            id: claim.id,
+            subject: claim.subject,
+            predicate: claim.predicate,
+            objectValue: claim.objectValue,
+            status: claim.status,
+            reviewState: claim.reviewState,
+            origin: claim.origin,
+            confidence: claim.confidence,
+            evidenceCount: claims.listEvidence(claim.id).length
+          })),
+          next: "Approve only after checking the linked evidence. Rejected claims stay out of retrieval and publication."
+        });
+      }
+      if (action === "claim_review") {
+        const requestedClaimId = requireText(claimId, "claimId");
+        const detail = requireText(reviewDetail, "reviewDetail");
+        if (!requestedClaimId || !claimReviewState || !detail) {
+          return text({ error: "claimId, claimReviewState, and reviewDetail are required for claim_review." }, true);
+        }
+        const existing = claims.getClaim(requestedClaimId);
+        if (!existing || existing.projectId !== project.id) {
+          return text({ error: "Claim was not found for the current project." }, true);
+        }
+        const claim = reviewClaim2(claims, {
+          claimId: requestedClaimId,
+          reviewState: claimReviewState,
+          detail
+        });
+        return text({
+          claim: {
+            id: claim.id,
+            status: claim.status,
+            reviewState: claim.reviewState,
+            updatedAt: claim.updatedAt
+          },
+          next: claim.reviewState === "approved" ? "This approved source-backed claim can now be considered by knowledge compilation." : "This rejected claim is excluded from retrieval and knowledge compilation."
+        });
+      }
       if (action === "compile") {
         const result = await compileKnowledgeWorkspace2({ workspace, claims });
         return text({
@@ -27222,7 +28085,13 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
       if (action === "workflow_import") {
         const result = await importWindsurfWorkflows2({ workspace, projectRoot });
         return text({
-          imported: result.imported.map((workflow2) => ({ id: workflow2.id, title: workflow2.title, sourcePath: workflow2.sourcePath })),
+          imported: result.imported.map((workflow2) => ({
+            id: workflow2.id,
+            title: workflow2.title,
+            sourcePath: workflow2.sourcePath,
+            importedFrom: workflow2.importedFrom,
+            verificationGates: workflow2.verificationGates
+          })),
           skipped: result.skipped
         });
       }
@@ -27234,7 +28103,9 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
             title: workflow2.title,
             status: workflow2.status,
             taskLenses: workflow2.taskLenses,
-            sourcePath: workflow2.sourcePath
+            sourcePath: workflow2.sourcePath,
+            importedFrom: workflow2.importedFrom,
+            verificationGates: workflow2.verificationGates
           })),
           parseErrors: synced.errors
         });
@@ -27313,9 +28184,15 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
       }
     },
     async ({ ids, status }) => {
-      const { resolveObservations: resolveObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
+      const { resolveObservations: resolveObservations2, getObservation: getObservation2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
       const safeIds = (Array.isArray(ids) ? ids : [ids]).map((id) => coerceNumber(id, 0)).filter((id) => id > 0);
-      const result = await resolveObservations2(safeIds, status ?? "resolved");
+      const reader = getObservationReader();
+      const authorizedIds = safeIds.filter((id) => {
+        const observation = getObservation2(id, project.id);
+        return observation ? canManageObservation(observation, reader) : false;
+      });
+      const result = await resolveObservations2(authorizedIds, status ?? "resolved");
+      const deniedCount = safeIds.length - authorizedIds.length;
       const parts = [];
       if (result.resolved.length > 0) {
         parts.push(`[OK] Resolved ${result.resolved.length} observation(s): #${result.resolved.join(", #")}`);
@@ -27323,6 +28200,9 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
       if (result.notFound.length > 0) {
         parts.push(`[WARN] Not found: #${result.notFound.join(", #")}`);
       }
+      if (deniedCount > 0) {
+        parts.push(`[WARN] Skipped ${deniedCount} observation(s) outside this session's write scope.`);
+      }
       parts.push('\nResolved memories are hidden from default search. Use status="all" to include them.');
       parts.push('[STATS] Run `memorix_retention` with `action: "report"` to check remaining cleanup status.');
       return {
@@ -27352,6 +28232,7 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
     async ({ entityName, decision, alternatives, rationale, constraints, expectedOutcome, risks, concepts, filesModified, relatedCommits, relatedEntities }) => {
       const unresolved = requireResolvedProject("store reasoning in the current project");
       if (unresolved) return unresolved;
+      const reader = getObservationReader();
       return withFreshIndex(async () => {
         const narrativeParts = [rationale];
         if (alternatives && alternatives.length > 0) {
@@ -27374,7 +28255,11 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
         ]);
         let reasoningAttributionWarning = "";
         try {
-          const attrCheck = await checkProjectAttribution(entityName, project.id, getAllObservations());
+          const attrCheck = await checkProjectAttribution(
+            entityName,
+            project.id,
+            filterReadableObservations(getAllObservations(), reader)
+          );
           if (attrCheck.suspicious) {
             reasoningAttributionWarning = `
 [WARN] Attribution notice: entity "${entityName}" has 0 observations in "${project.id}" but ${attrCheck.count} in "${attrCheck.knownIn}" (confidence: ${attrCheck.confidence}). Verify the correct project is bound before storing.`;
@@ -27394,7 +28279,8 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
           relatedCommits,
           relatedEntities,
           sourceDetail: "explicit",
-          createdByAgentId: currentAgentId
+          createdByAgentId: currentAgentId,
+          visibility: "project"
         });
         await graphManager.addObservations([
           { entityName, contents: [`[#${obs.id}] [REASONING] ${decision}`] }
@@ -27426,7 +28312,11 @@ Entity: ${entityName} | ${facts.length} facts | ${obs.tokens} tokens${reasoningA
       const minCount = threshold ?? 2;
       let entries;
       try {
-        entries = await auditProjectObservations(project.id, await withFreshIndex(() => getAllObservations()), minCount);
+        entries = await auditProjectObservations(
+          project.id,
+          await withFreshIndex(() => filterReadableObservations(getAllObservations(), getObservationReader())),
+          minCount
+        );
       } catch (err) {
         return {
           content: [{
@@ -27491,7 +28381,8 @@ Entity: ${entityName} | ${facts.length} facts | ${obs.tokens} tokens${reasoningA
         limit: safeLimit,
         type: "reasoning",
         projectId: scope === "global" ? void 0 : project.id,
-        status: "active"
+        status: "active",
+        reader: getObservationReader(scope === "global" ? "global" : "project")
       }));
       if (result.entries.length === 0) {
         return {
@@ -27516,7 +28407,11 @@ ${result.formatted}` }]
     },
     async ({ query, dryRun }) => {
       const { getAllObservations: getAllObservations2, resolveObservations: resolveObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
-      const allObs = await withFreshIndex(() => getAllObservations2().filter((o) => (o.status ?? "active") === "active" && o.projectId === project.id));
+      const reader = getObservationReader();
+      const allObs = await withFreshIndex(() => filterReadableObservations(
+        getAllObservations2().filter((o) => (o.status ?? "active") === "active" && o.projectId === project.id),
+        reader
+      ).filter((observation) => canManageObservation(observation, reader)));
       if (allObs.length < 2) {
         return { content: [{ type: "text", text: "Not enough active memories to deduplicate." }] };
       }
@@ -27530,7 +28425,7 @@ ${result.formatted}` }]
       }
       let candidates;
       if (query) {
-        const searchResult = await compactSearch({ query, limit: 20, projectId: project.id, status: "active" });
+        const searchResult = await compactSearch({ query, limit: 20, projectId: project.id, status: "active", reader });
         const idSet = new Set(searchResult.entries.map((e) => e.id));
         candidates = allObs.filter((o) => idSet.has(o.id));
       } else {
@@ -27620,7 +28515,8 @@ ${actions.join("\n")}`
         safeAnchor,
         project.id,
         safeBefore,
-        safeAfter
+        safeAfter,
+        getObservationReader()
       );
       return {
         content: [
@@ -27654,12 +28550,14 @@ ${actions.join("\n")}`
       const safeTypedRefs = coerceStringArray(typedRefs);
       let result;
       try {
+        const hasCrossProjectRef = safeRefs.some((ref) => ref.projectId && ref.projectId !== project.id) || safeTypedRefs.some((ref) => ref.includes("@") && !ref.endsWith(`@${project.id}`));
+        const reader = getObservationReader(hasCrossProjectRef ? "global" : "project");
         if (safeTypedRefs.length > 0) {
-          result = await compactDetail(safeTypedRefs);
+          result = await compactDetail(safeTypedRefs, { reader });
         } else if (safeRefs.length > 0) {
-          result = await compactDetail(safeRefs);
+          result = await compactDetail(safeRefs, { reader });
         } else {
-          result = await compactDetail(safeIds.map((id) => ({ id, projectId: project.id })));
+          result = await compactDetail(safeIds.map((id) => ({ id, projectId: project.id })), { reader });
         }
       } catch (err) {
         return { content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }], isError: true };
@@ -27685,11 +28583,15 @@ ${actions.join("\n")}`
     },
     async (args) => {
       const action = args.action ?? "report";
-      const { getRetentionSummary: getRetentionSummary2, getArchiveCandidates: getArchiveCandidates2, rankByRelevance: rankByRelevance2, archiveExpired: archiveExpired2, getRetentionZone: getRetentionZone2, explainRetention: explainRetention2 } = await Promise.resolve().then(() => (init_retention(), retention_exports));
+      const { getRetentionSummary: getRetentionSummary2, getArchiveCandidates: getArchiveCandidates2, rankByRelevance: rankByRelevance2, getRetentionZone: getRetentionZone2, explainRetention: explainRetention2 } = await Promise.resolve().then(() => (init_retention(), retention_exports));
       const { getDb: getDb2 } = await Promise.resolve().then(() => (init_orama_store(), orama_store_exports));
       const { search: search2 } = await import("@orama/orama");
-      const { getAllObservations: getAllObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
-      const allObs = await withFreshIndex(() => getAllObservations2());
+      const { getAllObservations: getAllObservations2, resolveObservations: resolveObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
+      const reader = getObservationReader();
+      const allObs = await withFreshIndex(() => filterReadableObservations(
+        getAllObservations2().filter((observation) => observation.projectId === project.id),
+        reader
+      ));
       const accessMap = /* @__PURE__ */ new Map();
       try {
         const database = await getDb2();
@@ -27706,20 +28608,6 @@ ${actions.join("\n")}`
         }
       } catch {
       }
-      if (action === "archive") {
-        const result = await archiveExpired2(projectDir2, void 0, accessMap, project.id);
-        if (result.archived === 0) {
-          return {
-            content: [{ type: "text", text: "[OK] No expired observations to archive. All memories are within their retention period." }]
-          };
-        }
-        return {
-          content: [{ type: "text", text: `[ARCHIVED] Archived ${result.archived} expired observations (status set to 'archived' in-place)
-${result.remaining} active observations remaining.
-
-Archived memories are hidden from default search but can be found with status: "all".` }]
-        };
-      }
       const docs = allObs.map((obs) => ({
         id: `obs-${obs.id}`,
         observationId: obs.id,
@@ -27738,13 +28626,34 @@ Archived memories are hidden from default search but can be found with status: "
         status: obs.status ?? "active",
         source: obs.source ?? "agent",
         sourceDetail: obs.sourceDetail ?? "",
-        valueCategory: obs.valueCategory ?? ""
+        valueCategory: obs.valueCategory ?? "",
+        admissionState: obs.admissionState ?? "",
+        admissionReason: obs.admissionReason ?? "",
+        visibility: obs.visibility ?? "project",
+        createdByAgentId: obs.createdByAgentId ?? "",
+        sharedWithAgentIds: JSON.stringify(obs.sharedWithAgentIds ?? [])
       }));
       if (docs.length === 0) {
         return {
           content: [{ type: "text", text: "No observations found for this project." }]
         };
       }
+      if (action === "archive") {
+        const managedIds = new Set(
+          allObs.filter((observation) => canManageObservation(observation, reader)).map((observation) => observation.id)
+        );
+        const candidates2 = getArchiveCandidates2(docs).filter((document) => managedIds.has(document.observationId));
+        if (candidates2.length === 0) {
+          return {
+            content: [{ type: "text", text: "[OK] No expired memories in this session's write scope to archive." }]
+          };
+        }
+        const result = await resolveObservations2(candidates2.map((document) => document.observationId), "archived");
+        return {
+          content: [{ type: "text", text: `[ARCHIVED] Archived ${result.resolved.length} expired observation(s) in this session's write scope.
+${Math.max(0, managedIds.size - result.resolved.length)} visible writable observations remaining.` }]
+        };
+      }
       if (action === "stale") {
         const staleDocs = docs.filter((d) => getRetentionZone2(d) === "stale");
         if (staleDocs.length === 0) {
@@ -28063,13 +28972,14 @@ Archived memories are hidden from default search but can be found with status: "
     async function scopeGraphToProject(graph) {
       const { getAllObservations: getAllObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
       const allObs = await withFreshIndex(() => getAllObservations2());
-      const projectEntityNames = new Set(
-        allObs.filter((o) => o.projectId === project.id && (o.status ?? "active") === "active" && o.entityName).map((o) => o.entityName)
+      const scoped = scopeKnowledgeGraphToProject(
+        graph,
+        filterReadableObservations(
+          allObs.filter((observation) => observation.projectId === project.id),
+          getObservationReader()
+        )
       );
-      const entities = graph.entities.filter((e) => projectEntityNames.has(e.name));
-      const entityNameSet = new Set(entities.map((e) => e.name));
-      const relations = graph.relations.filter((r) => entityNameSet.has(r.from) && entityNameSet.has(r.to));
-      return { entities, relations };
+      return { entities: scoped.entities, relations: scoped.relations };
     }
     server.registerTool(
       "read_graph",
@@ -28342,7 +29252,10 @@ ${skill2.content}` }]
         };
       }
       const { getObservationStore: getStore } = await Promise.resolve().then(() => (init_obs_store(), obs_store_exports));
-      const allObs = await getStore().loadAll();
+      const allObs = filterReadableObservations(
+        (await getStore().loadAll()).filter((observation) => observation.projectId === project.id),
+        getObservationReader()
+      );
       const obsData = allObs.map((o) => ({
         id: o.id || 0,
         entityName: o.entityName || "unknown",
@@ -28441,7 +29354,11 @@ ${skill2.content}` }]
       }
       const { getAllObservations: getAllObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
       const allObs = await withFreshIndex(() => getAllObservations2());
-      const matched = allObs.filter((o) => observationIds.includes(o.id));
+      const reader = getObservationReader();
+      const matched = filterReadableObservations(
+        allObs.filter((observation) => observation.projectId === project.id && observationIds.includes(observation.id)),
+        reader
+      );
       if (matched.length === 0) {
         return { content: [{ type: "text", text: `No observations found for IDs: [${observationIds.join(", ")}]. Use \`memorix_search\` to find valid IDs.` }], isError: true };
       }
@@ -28449,6 +29366,13 @@ ${skill2.content}` }]
       if (nonActive.length > 0) {
         return { content: [{ type: "text", text: `Cannot promote: ${nonActive.length} observation(s) are not active: ${nonActive.map((o) => `#${o.id} (${o.status})`).join(", ")}. Only active observations can be promoted to permanent knowledge.` }], isError: true };
       }
+      const nonProjectShared = matched.filter((observation) => resolveObservationVisibility(observation) !== "project");
+      if (nonProjectShared.length > 0) {
+        return {
+          content: [{ type: "text", text: `Cannot promote private or team-scoped observations: ${nonProjectShared.map((observation) => `#${observation.id}`).join(", ")}. Promote only deliberate project-shared knowledge.` }],
+          isError: true
+        };
+      }
       const skill2 = await promoteToMiniSkill2(projectDir2, project.id, matched, { trigger, instruction, tags });
       const lines = [
         `[OK] Created mini-skill #${skill2.id}`,
@@ -28607,8 +29531,11 @@ Ensure the path points to a directory containing a .git folder (or a subdirector
           const lastSeen = registeredAgent.last_seen_obs_generation;
           const store = getObservationStore();
           const currentGen = store.getGeneration();
-          const projectObs = await withFreshIndex(() => getAllObservations().filter(
-            (o) => o.projectId === project.id && (o.writeGeneration ?? 0) > lastSeen
+          const projectObs = await withFreshIndex(() => filterReadableObservations(
+            getAllObservations().filter(
+              (o) => o.projectId === project.id && (o.writeGeneration ?? 0) > lastSeen
+            ),
+            getObservationReader()
           ));
           const wm = computeWatermark2(lastSeen, currentGen, projectObs.length);
           if (wm.newObservationCount > 0) {
@@ -28777,7 +29704,7 @@ ${summary ? "Summary saved for next session context injection." : "No summary pr
     "memorix_transfer",
     {
       title: "Transfer Memories",
-      description: 'Export or import project memories. Action "export": export observations and sessions (JSON or Markdown). Action "import": import from a JSON export (re-assigns IDs, skips duplicate topicKeys).',
+      description: 'Export or import project memories. Action "export": export observations visible to the current agent and project sessions (JSON or Markdown). Action "import": import from a JSON export (re-assigns IDs, skips duplicate topicKeys).',
       inputSchema: {
         action: z2.enum(["export", "import"]).describe("Operation: export or import"),
         format: z2.enum(["json", "markdown"]).optional().describe("Export format (for export, default: json)"),
@@ -28788,10 +29715,10 @@ ${summary ? "Summary saved for next session context injection." : "No summary pr
       if (action === "export") {
         const { exportAsJson: exportAsJson2, exportAsMarkdown: exportAsMarkdown2 } = await Promise.resolve().then(() => (init_export_import(), export_import_exports));
         if (format === "markdown") {
-          const md = await exportAsMarkdown2(projectDir2, project.id);
+          const md = await exportAsMarkdown2(projectDir2, project.id, getObservationReader());
           return { content: [{ type: "text", text: md }] };
         }
-        const data = await exportAsJson2(projectDir2, project.id);
+        const data = await exportAsJson2(projectDir2, project.id, getObservationReader());
         const json = JSON.stringify(data, null, 2);
         return {
           content: [{
@@ -28988,8 +29915,6 @@ ${json}
       }
     }
   );
-  let teamStore;
-  let initTeamStoreForProject;
   if (teamFeaturesEnabled) {
     const { initTeamStore: initTeamStore2 } = await Promise.resolve().then(() => (init_team_store(), team_store_exports));
     initTeamStoreForProject = initTeamStore2;
@@ -29262,7 +30187,7 @@ ${lines.join("\n")}` }] };
       description: `Send, broadcast, or read messages between agents. Durable: messages survive restarts and reach inactive recipients. Action "send": direct message to one agent. Action "broadcast": message all agents. Action "inbox": read this agent's inbox.`,
       inputSchema: {
         action: z2.enum(["send", "broadcast", "inbox"]).describe("Operation to perform"),
-        from: z2.string().optional().describe("Sender agent ID (for send/broadcast)"),
+        from: z2.string().optional().describe("Your sender agent ID. Omit it to use this session identity."),
         to: z2.string().optional().describe("Receiver agent ID (for send)"),
         type: z2.enum(["request", "response", "info", "announcement", "contract", "error", "handoff"]).optional().describe("Message type (for send/broadcast)"),
         content: z2.string().optional().describe("Message content (for send/broadcast)"),
@@ -29273,13 +30198,20 @@ ${lines.join("\n")}` }] };
       }
     },
     async ({ action, from, to, type: msgType, content, agentId, markRead, toRole, handoffStatus }) => {
+      const requireCurrentTeamAgent = () => {
+        if (!currentAgentId) return null;
+        const agent = teamStore.getAgent(currentAgentId);
+        return agent?.project_id === project.id && agent.status === "active" ? agent : null;
+      };
       if (action === "send") {
-        if (!from || !msgType || !content) return { content: [{ type: "text", text: "[ERROR] from, type, and content required for send" }], isError: true };
+        const sender = requireCurrentTeamAgent();
+        if (!sender || !msgType || !content) return { content: [{ type: "text", text: "[ERROR] active session identity, type, and content required for send" }], isError: true };
+        if (from && from !== currentAgentId) return { content: [{ type: "text", text: "[ERROR] from must match the current session identity" }], isError: true };
         if (!to && !toRole) return { content: [{ type: "text", text: "[ERROR] either to (agent ID) or toRole is required for send" }], isError: true };
         if (content.length > 1e4) return { content: [{ type: "text", text: "[ERROR] Message too large (max 10KB)" }], isError: true };
         const msg = teamStore.sendMessage({
           projectId: project.id,
-          senderAgentId: from,
+          senderAgentId: currentAgentId,
           recipientAgentId: to ?? null,
           type: msgType,
           content,
@@ -29291,11 +30223,13 @@ ${lines.join("\n")}` }] };
         return { content: [{ type: "text", text: `Message sent (${msgType}) to ${target} | ID: ${msg.id.slice(0, 8)}\u2026${toRole ? ` [role: ${toRole}]` : ""}` }] };
       }
       if (action === "broadcast") {
-        if (!from || !msgType || !content) return { content: [{ type: "text", text: "[ERROR] from, type, and content required for broadcast" }], isError: true };
+        const sender = requireCurrentTeamAgent();
+        if (!sender || !msgType || !content) return { content: [{ type: "text", text: "[ERROR] active session identity, type, and content required for broadcast" }], isError: true };
+        if (from && from !== currentAgentId) return { content: [{ type: "text", text: "[ERROR] from must match the current session identity" }], isError: true };
         if (content.length > 1e4) return { content: [{ type: "text", text: "[ERROR] Message too large (max 10KB)" }], isError: true };
         const msg = teamStore.sendMessage({
           projectId: project.id,
-          senderAgentId: from,
+          senderAgentId: currentAgentId,
           recipientAgentId: null,
           type: msgType,
           content
@@ -29303,8 +30237,12 @@ ${lines.join("\n")}` }] };
         if ("error" in msg) return { content: [{ type: "text", text: `[ERROR] ${msg.error}` }], isError: true };
         return { content: [{ type: "text", text: `Broadcast (${msgType}) | ID: ${msg.id.slice(0, 8)}\u2026` }] };
       }
-      const inboxId = agentId || from || "";
-      if (!inboxId) return { content: [{ type: "text", text: "[ERROR] agentId required for inbox" }], isError: true };
+      const inboxAgent = requireCurrentTeamAgent();
+      if (!inboxAgent) return { content: [{ type: "text", text: "[ERROR] active session identity required for inbox" }], isError: true };
+      if (agentId && agentId !== currentAgentId || from && from !== currentAgentId) {
+        return { content: [{ type: "text", text: "[ERROR] inbox access is limited to the current session identity" }], isError: true };
+      }
+      const inboxId = currentAgentId;
       const inbox = teamStore.getInbox(project.id, inboxId);
       const unread = teamStore.getUnreadCount(project.id, inboxId);
       if (inbox.length === 0) return { content: [{ type: "text", text: "Inbox empty" }] };
@@ -29332,24 +30270,34 @@ ${lines.join("\n")}` }] };
     },
     async ({ agentId, markInboxRead }) => {
       const { computeWatermark: computeWatermark2, computePoll: computePoll2 } = await Promise.resolve().then(() => (init_poll(), poll_exports));
+      if (agentId && agentId !== currentAgentId) {
+        return {
+          content: [{ type: "text", text: "[ERROR] agentId must match the current session identity." }],
+          isError: true
+        };
+      }
+      const effectiveAgentId = currentAgentId;
       let watermark = computeWatermark2(0, 0, 0);
-      if (agentId) {
-        const agent = teamStore.getAgent(agentId);
+      if (effectiveAgentId) {
+        const agent = teamStore.getAgent(effectiveAgentId);
         if (agent) {
           const lastSeen = agent.last_seen_obs_generation;
           const store = getObservationStore();
           const currentGen = store.getGeneration();
-          const projectObs = await withFreshIndex(() => getAllObservations().filter(
-            (o) => o.projectId === project.id && (o.writeGeneration ?? 0) > lastSeen
+          const projectObs = await withFreshIndex(() => filterReadableObservations(
+            getAllObservations().filter(
+              (o) => o.projectId === project.id && (o.writeGeneration ?? 0) > lastSeen
+            ),
+            getObservationReader()
           ));
           watermark = computeWatermark2(lastSeen, currentGen, projectObs.length);
-          teamStore.updateWatermark(agentId, currentGen);
-          teamStore.heartbeat(agentId);
+          teamStore.updateWatermark(effectiveAgentId, currentGen);
+          teamStore.heartbeat(effectiveAgentId);
         }
       }
-      const poll = computePoll2(teamStore, project.id, agentId ?? null, watermark);
-      if (markInboxRead && agentId) {
-        teamStore.markAllRead(project.id, agentId);
+      const poll = computePoll2(teamStore, project.id, effectiveAgentId ?? null, watermark);
+      if (markInboxRead && effectiveAgentId) {
+        teamStore.markAllRead(project.id, effectiveAgentId);
       }
       const lines = [];
       if (poll.agent) {
@@ -29409,7 +30357,7 @@ ${lines.join("\n")}` }] };
     "memorix_handoff",
     {
       title: "Team Handoff \u2014 Agent Context Transfer",
-      description: "Create a structured handoff artifact when passing work to another agent. The handoff is stored as a durable observation (searchable, immune to archival) and a notification message is sent to the recipient. Use this when completing a task and another agent should continue, or when you want to leave context for whoever works on this next.",
+      description: "Create a structured handoff artifact when passing work to another agent. A targeted handoff is visible only to its sender and recipient; a broadcast handoff is team-visible. The handoff is stored as a durable observation (immune to archival) and a notification message is sent to the recipient. Use this when completing a task and another agent should continue, or when you want to leave context for whoever works on this next.",
       inputSchema: {
         fromAgentId: z2.string().describe("Your agent ID (from team_manage join or session_start with joinTeam=true)"),
         summary: z2.string().describe("Human-readable summary of what you did and what needs to happen next"),
@@ -29422,6 +30370,34 @@ ${lines.join("\n")}` }] };
     },
     async ({ fromAgentId, summary, context, toAgentId, taskId, filesModified, concepts }) => {
       const { createHandoffArtifact: createHandoffArtifact2 } = await Promise.resolve().then(() => (init_handoff(), handoff_exports));
+      if (!currentAgentId) {
+        return {
+          content: [{ type: "text", text: "Create a coordination identity first: call memorix_session_start with joinTeam=true." }],
+          isError: true
+        };
+      }
+      if (fromAgentId !== currentAgentId) {
+        return {
+          content: [{ type: "text", text: "fromAgentId must match the identity returned for this session. Memorix will not create a handoff on behalf of another agent." }],
+          isError: true
+        };
+      }
+      const sender = teamStore.getAgent(currentAgentId);
+      if (!sender || sender.project_id !== project.id || sender.status !== "active") {
+        return {
+          content: [{ type: "text", text: "The current coordination identity is not an active member of this project." }],
+          isError: true
+        };
+      }
+      if (toAgentId) {
+        const recipient = teamStore.getAgent(toAgentId);
+        if (!recipient || recipient.project_id !== project.id) {
+          return {
+            content: [{ type: "text", text: "The handoff recipient must be an agent registered in the current project." }],
+            isError: true
+          };
+        }
+      }
       const result = await createHandoffArtifact2(
         {
           projectId: project.id,