memorix 1.2.1 → 1.2.3

package/src/cli/tui/chat-service.ts

@@ -3,11 +3,11 @@ import { loadDotenv } from '../../config/dotenv-loader.js';
 import { initLLM, isLLMEnabled, getLLMConfig, callLLMWithTools } from '../../llm/provider.js';
 import type { ChatMessage, ToolDefinition, ToolCall } from '../../llm/provider.js';
 import { initObservations, prepareSearchIndex, storeObservation, resolveObservations, getObservation, getAllObservations } from '../../memory/observations.js';
-import type { ObservationType } from '../../types.js';
-import { detectProject } from '../../project/detector.js';
+import { canManageObservation, filterReadableObservations } from '../../memory/visibility.js';
+import type { ObservationReader, ObservationType } from '../../types.js';
 import { getLastSearchMode } from '../../store/orama-store.js';
-import { getProjectDataDir } from '../../store/persistence.js';
 import type { MemorixDocument } from '../../types.js';
+import { getTuiOperatorContext } from './operator-context.js';
 
 export interface ChatHistoryTurn {
   role: 'user' | 'assistant';
@@ -208,19 +208,29 @@ async function prepareProjectSearch(projectId: string, dataDir: string): Promise
 
 interface ToolExecutionContext {
   projectId: string;
+  reader: ObservationReader;
+  writerAgentId?: string;
   collectedSources: ChatSource[];
 }
 
+async function resolveTuiContext() {
+  try {
+    return await getTuiOperatorContext();
+  } catch {
+    return null;
+  }
+}
+
 function executeSearchMemories(args: { query: string; limit?: number }, ctx: ToolExecutionContext): Promise<string> {
   const limit = Math.min(args.limit ?? SEARCH_LIMIT, 10);
-  return compactSearch({ query: args.query, limit, projectId: ctx.projectId, status: 'active' })
+  return compactSearch({ query: args.query, limit, projectId: ctx.projectId, status: 'active', reader: ctx.reader })
     .then((result) => {
       const entries = result.entries.slice(0, DETAIL_LIMIT);
       if (entries.length === 0) return 'No memories found for that query.';
 
       // Collect sources for citation tracking
       const refs = entries.map((e) => ({ id: e.id, projectId: ctx.projectId }));
-      return compactDetail(refs).then((detail) => {
+      return compactDetail(refs, { reader: ctx.reader }).then((detail) => {
         for (let i = 0; i < detail.documents.length; i++) {
           const doc = detail.documents[i];
           const score = entries[i]?.score ?? 0;
@@ -235,7 +245,7 @@ function executeSearchMemories(args: { query: string; limit?: number }, ctx: Too
 }
 
 function executeGetMemoryDetail(args: { id: number }, ctx: ToolExecutionContext): Promise<string> {
-  return compactDetail([{ id: args.id, projectId: ctx.projectId }])
+  return compactDetail([{ id: args.id, projectId: ctx.projectId }], { reader: ctx.reader })
     .then((detail) => {
       if (detail.documents.length === 0) return `Observation ${args.id} not found.`;
       const doc = detail.documents[0];
@@ -295,6 +305,8 @@ function executeStoreMemory(
     facts: args.facts,
     projectId: ctx.projectId,
     source: 'agent',
+    visibilityReader: ctx.reader,
+    ...(ctx.writerAgentId ? { createdByAgentId: ctx.writerAgentId } : {}),
   }).then((result) => {
     const obs = result.observation;
     ctx.collectedSources.push({
@@ -314,7 +326,7 @@ function executeUpdateMemory(
   ctx: ToolExecutionContext,
 ): string {
   const obs = getObservation(args.id, ctx.projectId);
-  if (!obs) return `Observation ${args.id} not found.`;
+  if (!obs || !canManageObservation(obs, ctx.reader)) return `Observation ${args.id} not found.`;
 
   const shouldAppend = args.append !== false; // default true
   const newNarrative = shouldAppend
@@ -334,6 +346,7 @@ function executeUpdateMemory(
     projectId: ctx.projectId,
     topicKey: obs.topicKey,
     source: 'agent',
+    visibilityReader: ctx.reader,
   }).catch(() => {/* non-blocking */});
 
   return `Updated observation [obs:${args.id}] — ${shouldAppend ? 'appended to' : 'replaced'} narrative${args.facts?.length ? ` and added ${args.facts.length} facts` : ''}. Changes will be persisted asynchronously.`;
@@ -344,7 +357,7 @@ function executeDeleteMemory(
   ctx: ToolExecutionContext,
 ): Promise<string> {
   const obs = getObservation(args.id, ctx.projectId);
-  if (!obs) return Promise.resolve(`Observation ${args.id} not found.`);
+  if (!obs || !canManageObservation(obs, ctx.reader)) return Promise.resolve(`Observation ${args.id} not found.`);
 
   return resolveObservations([args.id], 'resolved')
     .then((result) => {
@@ -361,8 +374,10 @@ function executeListRecentMemories(
   ctx: ToolExecutionContext,
 ): string {
   const limit = Math.min(args.limit ?? 10, 20);
-  let allObs = getAllObservations()
-    .filter(o => o.projectId === ctx.projectId && o.status !== 'archived' && o.status !== 'resolved');
+  let allObs = filterReadableObservations(
+    getAllObservations().filter(o => o.projectId === ctx.projectId && o.status !== 'archived' && o.status !== 'resolved'),
+    ctx.reader,
+  );
 
   if (args.type) {
     allObs = allObs.filter(o => o.type === args.type);
@@ -399,10 +414,10 @@ export async function askMemoryQuestion(
     };
   }
 
-  const project = detectProject(process.cwd());
+  const operatorContext = await resolveTuiContext();
 
   // No project + no LLM → dead end
-  if (!project) {
+  if (!operatorContext) {
     loadDotenv(process.cwd());
     initLLM({ scope: 'agent' });
     if (!isLLMEnabled()) {
@@ -438,10 +453,11 @@ export async function askMemoryQuestion(
     };
   }
 
+  const { project, dataDir, reader, identity } = operatorContext;
+
   loadDotenv(project.rootPath);
   initLLM({ scope: 'agent' });
 
-  const dataDir = await getProjectDataDir(project.id);
   await prepareProjectSearch(project.id, dataDir);
 
   const searchMode = normalizeSearchMode(getLastSearchMode(project.id) || 'fulltext');
@@ -453,11 +469,12 @@ export async function askMemoryQuestion(
       limit: SEARCH_LIMIT,
       projectId: project.id,
       status: 'active',
+      reader,
     });
     const topEntries = searchResult.entries.slice(0, DETAIL_LIMIT);
     const detailRefs = topEntries.map((entry) => ({ id: entry.id, projectId: project.id }));
     const detailResult = detailRefs.length > 0
-      ? await compactDetail(detailRefs)
+      ? await compactDetail(detailRefs, { reader })
       : { documents: [], formatted: '', totalTokens: 0 };
     const sources = detailResult.documents.map((doc, index) => toSource(doc, topEntries[index]?.score ?? 0));
 
@@ -488,6 +505,8 @@ export async function askMemoryQuestion(
 
   const ctx: ToolExecutionContext = {
     projectId: project.id,
+    reader,
+    ...(identity ? { writerAgentId: identity.agentId } : {}),
     collectedSources: [],
   };
 
@@ -584,10 +603,10 @@ export async function askMemoryQuestionStream(
     };
   }
 
-  const project = detectProject(process.cwd());
+  const operatorContext = await resolveTuiContext();
 
   // No project + no LLM → dead end
-  if (!project) {
+  if (!operatorContext) {
     loadDotenv(process.cwd());
     initLLM({ scope: 'agent' });
     if (!isLLMEnabled()) {
@@ -626,10 +645,11 @@ export async function askMemoryQuestionStream(
     };
   }
 
+  const { project, dataDir, reader, identity } = operatorContext;
+
   loadDotenv(project.rootPath);
   initLLM({ scope: 'agent' });
 
-  const dataDir = await getProjectDataDir(project.id);
   await prepareProjectSearch(project.id, dataDir);
 
   const searchMode = normalizeSearchMode(getLastSearchMode(project.id) || 'fulltext');
@@ -641,11 +661,12 @@ export async function askMemoryQuestionStream(
       limit: SEARCH_LIMIT,
       projectId: project.id,
       status: 'active',
+      reader,
     });
     const topEntries = searchResult.entries.slice(0, DETAIL_LIMIT);
     const detailRefs = topEntries.map((entry) => ({ id: entry.id, projectId: project.id }));
     const detailResult = detailRefs.length > 0
-      ? await compactDetail(detailRefs)
+      ? await compactDetail(detailRefs, { reader })
       : { documents: [], formatted: '', totalTokens: 0 };
     const sources = detailResult.documents.map((doc, index) => toSource(doc, topEntries[index]?.score ?? 0));
 
@@ -672,6 +693,8 @@ export async function askMemoryQuestionStream(
 
   const ctx: ToolExecutionContext = {
     projectId: project.id,
+    reader,
+    ...(identity ? { writerAgentId: identity.agentId } : {}),
     collectedSources: [],
   };
 

package/src/cli/tui/data.ts

@@ -6,6 +6,7 @@
  */
 
 import * as fs from 'node:fs';
+import { getTuiOperatorContext } from './operator-context.js';
 
 export interface ProjectInfo {
   name: string;
@@ -98,9 +99,7 @@ function truncate(text: string, max = 60): string {
 
 export async function getProjectInfo(): Promise<ProjectInfo | null> {
   try {
-    const { detectProject } = await import('../../project/detector.js');
-    const proj = detectProject(process.cwd());
-    if (!proj) return null;
+    const { project: proj } = await getTuiOperatorContext();
     return {
       name: proj.name,
       id: proj.id,
@@ -127,12 +126,8 @@ export async function getHealthInfo(projectId?: string): Promise<HealthInfo> {
   };
 
   try {
-    const { detectProject } = await import('../../project/detector.js');
-    const { getProjectDataDir } = await import('../../store/persistence.js');
     const { initObservationStore: initStore, getObservationStore: getStore } = await import('../../store/obs-store.js');
-
-    const proj = detectProject(process.cwd());
-    if (!proj) return defaults;
+    const { project: proj, dataDir, reader } = await getTuiOperatorContext();
 
     // Load .env BEFORE any process.env reads or provider initialization (#46)
     try {
@@ -141,11 +136,11 @@ export async function getHealthInfo(projectId?: string): Promise<HealthInfo> {
     } catch { /* best-effort */ }
 
     const effectiveProjectId = projectId || proj.id;
-    const dataDir = await getProjectDataDir(effectiveProjectId);
+    if (effectiveProjectId !== proj.id) return defaults;
     await initStore(dataDir);
     const allObs = (await getStore().loadAll()) as any[];
-    // Filter by project — flat storage shares one observations.json across projects
-    const obs = allObs.filter((o: any) => o.projectId === effectiveProjectId);
+    const { filterReadableObservations } = await import('../../memory/visibility.js');
+    const obs = filterReadableObservations(allObs, reader);
     const active = obs.filter((o: any) => (o.status ?? 'active') === 'active');
 
     defaults.totalMemories = obs.length;
@@ -219,19 +214,15 @@ export async function getHealthInfo(projectId?: string): Promise<HealthInfo> {
 
 export async function getRecentMemories(limit = 8, projectId?: string): Promise<MemoryItem[]> {
   try {
-    const { detectProject } = await import('../../project/detector.js');
-    const { getProjectDataDir } = await import('../../store/persistence.js');
     const { initObservationStore: initStore, getObservationStore: getStore } = await import('../../store/obs-store.js');
-
-    const proj = detectProject(process.cwd());
-    if (!proj) return [];
+    const { project: proj, dataDir, reader } = await getTuiOperatorContext();
 
     const effectiveProjectId = projectId || proj.id;
-    const dataDir = await getProjectDataDir(effectiveProjectId);
+    if (effectiveProjectId !== proj.id) return [];
     await initStore(dataDir);
     const allObs = (await getStore().loadAll()) as any[];
-    // Filter by project — flat storage shares one observations.json
-    const projectObs = allObs.filter((o: any) => o.projectId === effectiveProjectId);
+    const { filterReadableObservations } = await import('../../memory/visibility.js');
+    const projectObs = filterReadableObservations(allObs, reader);
     const active = projectObs.filter((o: any) => (o.status ?? 'active') === 'active');
     const filtered = active.filter((o: any) => !/^(Ran:|Command:|Executed:)\s/i.test(o.title || ''));
 
@@ -251,18 +242,13 @@ export async function getRecentMemories(limit = 8, projectId?: string): Promise<
 export async function searchMemories(query: string, limit = 10): Promise<SearchResult[]> {
   try {
     const { searchObservations } = await import('../../store/orama-store.js');
-    const { getProjectDataDir } = await import('../../store/persistence.js');
-    const { detectProject } = await import('../../project/detector.js');
     const { initObservations, prepareSearchIndex } = await import('../../memory/observations.js');
+    const { project: proj, dataDir, reader } = await getTuiOperatorContext();
 
-    const proj = detectProject(process.cwd());
-    if (!proj) return [];
-
-    const dataDir = await getProjectDataDir(proj.id);
     await initObservations(dataDir);
     await prepareSearchIndex();
 
-    const results = await searchObservations({ query, limit, projectId: proj.id });
+    const results = await searchObservations({ query, limit, projectId: proj.id, reader });
 
     const typeIcons: Record<string, string> = {
       gotcha: '!',
@@ -290,15 +276,10 @@ export async function searchMemories(query: string, limit = 10): Promise<SearchR
 
 export async function storeQuickMemory(text: string): Promise<{ id: number; title: string } | null> {
   try {
-    const { detectProject } = await import('../../project/detector.js');
-    const { getProjectDataDir } = await import('../../store/persistence.js');
     const { initObservations, storeObservation } = await import('../../memory/observations.js');
     const { initObservationStore } = await import('../../store/obs-store.js');
+    const { project: proj, dataDir, reader, identity } = await getTuiOperatorContext();
 
-    const proj = detectProject(process.cwd());
-    if (!proj) return null;
-
-    const dataDir = await getProjectDataDir(proj.id);
     await initObservationStore(dataDir);
     await initObservations(dataDir);
 
@@ -310,6 +291,8 @@ export async function storeQuickMemory(text: string): Promise<{ id: number; titl
       facts: [],
       projectId: proj.id,
       sourceDetail: 'explicit',
+      visibilityReader: reader,
+      ...(identity ? { createdByAgentId: identity.agentId } : {}),
     });
 
     return { id: result.observation.id, title: text.slice(0, 100) };
@@ -484,23 +467,21 @@ export async function getKnowledgeGraph(
   projectId?: string,
 ): Promise<import('../../wiki/types.js').ProjectKnowledgeGraph | null> {
   try {
-    const { detectProject } = await import('../../project/detector.js');
-    const { getProjectDataDir } = await import('../../store/persistence.js');
     const { initObservationStore } = await import('../../store/obs-store.js');
     const { initObservations, getAllObservations } = await import('../../memory/observations.js');
+    const { filterReadableObservations } = await import('../../memory/visibility.js');
     const { initMiniSkillStore, getMiniSkillStore } = await import('../../store/mini-skill-store.js');
     const { generateKnowledgeGraph } = await import('../../wiki/knowledge-graph.js');
 
-    const proj = detectProject(process.cwd());
-    if (!proj) return null;
+    const { project: proj, dataDir, reader } = await getTuiOperatorContext();
 
     const effectiveProjectId = projectId || proj.id;
-    const dataDir = await getProjectDataDir(effectiveProjectId);
+    if (effectiveProjectId !== proj.id) return null;
     await initObservationStore(dataDir);
     await initObservations(dataDir);
     await initMiniSkillStore(dataDir);
 
-    const observations = getAllObservations();
+    const observations = filterReadableObservations(getAllObservations(), reader);
     const skills = await getMiniSkillStore().loadByProject(effectiveProjectId);
 
     return generateKnowledgeGraph({
@@ -515,23 +496,21 @@ export async function getKnowledgeGraph(
 
 export async function getKnowledgeBase(projectId?: string): Promise<import('../../wiki/types.js').ProjectKnowledgeOverview | null> {
   try {
-    const { detectProject } = await import('../../project/detector.js');
-    const { getProjectDataDir } = await import('../../store/persistence.js');
     const { initObservationStore } = await import('../../store/obs-store.js');
     const { initObservations, getAllObservations } = await import('../../memory/observations.js');
+    const { filterReadableObservations } = await import('../../memory/visibility.js');
     const { initMiniSkillStore, getMiniSkillStore } = await import('../../store/mini-skill-store.js');
     const { generateKnowledgeBase } = await import('../../wiki/generator.js');
 
-    const proj = detectProject(process.cwd());
-    if (!proj) return null;
+    const { project: proj, dataDir, reader } = await getTuiOperatorContext();
 
     const effectiveProjectId = projectId || proj.id;
-    const dataDir = await getProjectDataDir(effectiveProjectId);
+    if (effectiveProjectId !== proj.id) return null;
     await initObservationStore(dataDir);
     await initObservations(dataDir);
     await initMiniSkillStore(dataDir);
 
-    const observations = getAllObservations();
+    const observations = filterReadableObservations(getAllObservations(), reader);
     const skills = await getMiniSkillStore().loadByProject(effectiveProjectId);
 
     return generateKnowledgeBase({

package/src/cli/tui/operator-context.ts

@@ -0,0 +1,60 @@
+import { initTeamStore } from '../../team/team-store.js';
+import { loadCliIdentity, resolveCliIdentity } from '../identity.js';
+import { getCliInvocation } from '../invocation.js';
+import type { CliProjectContext } from '../commands/operator-shared.js';
+
+export type TuiOperatorContext = Omit<CliProjectContext, 'teamStore'>;
+
+/**
+ * The Ink workbench is another CLI entry point, not an alternate security
+ * model. It uses the same identity resolver, but avoids opening coordination
+ * state until an actor was explicitly selected.
+ */
+export async function getTuiOperatorContext(): Promise<TuiOperatorContext> {
+  const invocation = getCliInvocation();
+  const { detectProject } = await import('../../project/detector.js');
+  const project = detectProject(
+    invocation.projectRoot
+      ?? process.env.MEMORIX_PROJECT_ROOT
+      ?? process.cwd(),
+  );
+  if (!project) throw new Error('No git repository found in the current directory.');
+
+  const { getProjectDataDir } = await import('../../store/persistence.js');
+  const dataDir = await getProjectDataDir(project.id);
+  try {
+    const { MaintenanceTargetStore } = await import('../../runtime/maintenance-targets.js');
+    new MaintenanceTargetStore(dataDir).register({
+      projectId: project.id,
+      projectRoot: project.rootPath,
+      dataDir,
+    });
+  } catch {
+    // Workbench reads remain available when optional maintenance metadata fails.
+  }
+
+  const savedIdentity = await loadCliIdentity(dataDir, project.id);
+  if (!invocation.actorId && !savedIdentity) {
+    return {
+      project,
+      dataDir,
+      reader: { projectId: project.id },
+      identity: null,
+    };
+  }
+
+  const teamStore = await initTeamStore(dataDir);
+  const resolved = await resolveCliIdentity({
+    project,
+    dataDir,
+    teamStore,
+    explicitActorId: invocation.actorId,
+  });
+  return {
+    project,
+    dataDir,
+    reader: resolved.reader,
+    identity: resolved.identity,
+    ...(resolved.warning ? { identityWarning: resolved.warning } : {}),
+  };
+}

package/src/cli/tui/session-service.ts

@@ -53,12 +53,13 @@ export async function getSessionState(projectId?: string): Promise<SessionState>
 
 export async function bindSession(): Promise<SessionState> {
   try {
-    const proj = await resolveProject();
-    if (!proj) return { status: 'error', error: 'No project detected' };
+    const { getTuiOperatorContext } = await import('./operator-context.js');
+    const { project: proj, reader } = await getTuiOperatorContext();
 
     const { startSession } = await import('../../memory/session.js');
     const { session, previousContext } = await startSession(proj.rootPath, proj.id, {
       agent: 'memorix-tui',
+      reader,
     });
 
     return {

package/src/cli/tui/views/MemoryView.tsx

@@ -65,21 +65,23 @@ export function MemoryView({ projectId, focusRefId, selectedIdx, onNavigateKnowl
     (async () => {
       try {
         setLoading(true);
-        const { getObservation, initObservations, getAllObservations } = await import('../../../memory/observations.js');
-        const { getProjectDataDir } = await import('../../../store/persistence.js');
+        const { initObservations, getAllObservations } = await import('../../../memory/observations.js');
+        const { filterReadableObservations } = await import('../../../memory/visibility.js');
         const { initObservationStore } = await import('../../../store/obs-store.js');
-        const { detectProject } = await import('../../../project/detector.js');
+        const { getTuiOperatorContext } = await import('../operator-context.js');
 
-        const proj = detectProject(process.cwd());
-        if (!proj) return;
+        const { project: proj, dataDir, reader } = await getTuiOperatorContext();
 
-        const dataDir = await getProjectDataDir(projectId || proj.id);
+        const effectiveProjectId = projectId || proj.id;
+        if (effectiveProjectId !== proj.id) return;
         await initObservationStore(dataDir);
         await initObservations(dataDir);
 
         const obsId = parseInt(idMatch[1], 10);
-        const allObs = getAllObservations();
-        const obs = allObs.find((o: any) => o.id === obsId);
+        const obs = filterReadableObservations(
+          getAllObservations().filter((observation) => observation.projectId === effectiveProjectId),
+          reader,
+        ).find((observation) => observation.id === obsId);
         if (obs) {
           setDetailItem({
             id: obs.id,

package/src/codegraph/auto-context.ts

@@ -2,6 +2,7 @@ import { existsSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { getResolvedConfig } from '../config/resolved-config.js';
 import { buildTaskWorkset, type TaskWorkset, type WorksetCaution } from '../knowledge/workset.js';
+import type { ContextDeliveryTarget } from '../knowledge/context-assembly.js';
 import type { ProjectInfo } from '../types.js';
 import { backfillMissingObservationCodeRefs, type CodeRefBackfillResult } from './binder.js';
 import { collectCurrentProjectFacts, formatGitFact, type CurrentProjectFacts } from './current-facts.js';
@@ -19,6 +20,7 @@ import {
   type ProjectContextOverview,
 } from './project-context.js';
 import { CodeGraphStore } from './store.js';
+import { isEligibleForAutomaticDelivery } from '../memory/admission.js';
 import {
   lensPathCandidates,
   lensVerificationHints,
@@ -71,6 +73,14 @@ function activeProjectObservations(
   return observations.filter(obs => obs.projectId === projectId && (obs.status ?? 'active') === 'active');
 }
 
+function deliveryEligibleProjectObservations(
+  observations: ProjectContextObservation[],
+  projectId: string,
+): ProjectContextObservation[] {
+  return activeProjectObservations(observations, projectId)
+    .filter((observation) => isEligibleForAutomaticDelivery(observation));
+}
+
 function decideRefresh(input: {
   mode: AutoContextRefreshMode;
   status: ReturnType<CodeGraphStore['status']>;
@@ -118,6 +128,8 @@ export async function buildAutoProjectContext(input: {
    * request. MCP and hook callers use this to keep their response path fast.
    */
   enqueueRefresh?: () => void | Promise<void>;
+  /** The caller surface is recorded in the Workset receipt, not its prompt. */
+  deliveryTarget?: ContextDeliveryTarget;
 }): Promise<AutoProjectContext> {
   const refreshMode = input.refresh ?? 'auto';
   const now = input.now ?? new Date();
@@ -173,13 +185,27 @@ export async function buildAutoProjectContext(input: {
           activeProjectObservations(input.observations, input.project.id) as any,
         );
         try {
-          const { enqueueClaimRequalification } = await import('../runtime/lifecycle.js');
+          const { MaintenanceTargetStore } = await import('../runtime/maintenance-targets.js');
+          new MaintenanceTargetStore(input.dataDir).register({
+            projectId: input.project.id,
+            projectRoot: input.project.rootPath,
+            dataDir: input.dataDir,
+          });
+          const {
+            enqueueClaimRequalification,
+            enqueueObservationQualification,
+          } = await import('../runtime/lifecycle.js');
           enqueueClaimRequalification({
             dataDir: input.dataDir,
             projectId: input.project.id,
             source: 'foreground-refresh',
             snapshotId: store.latestSnapshot(input.project.id)?.id,
           });
+          enqueueObservationQualification({
+            dataDir: input.dataDir,
+            projectId: input.project.id,
+            source: 'foreground-refresh',
+          });
         } catch {
           // The completed scan remains useful even if its later maintenance cannot queue.
         }
@@ -198,7 +224,9 @@ export 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;
@@ -300,6 +328,7 @@ export async function buildAutoProjectContext(input: {
       stale: overview.freshness.stale,
     },
     runtimeCautions,
+    ...(input.deliveryTarget ? { deliveryTarget: input.deliveryTarget } : {}),
   });
 
   return {

package/src/codegraph/context-pack.ts

@@ -316,6 +316,7 @@ export async function attachTaskWorkset(input: {
       stale: input.pack.warnings.filter(warning => warning.status === 'stale').length,
     },
     runtimeCautions: input.runtimeCautions,
+    deliveryTarget: 'context-pack',
   });
   return { ...input.pack, workset };
 }

package/src/codegraph/project-context.ts

@@ -16,6 +16,8 @@ export interface ProjectContextObservation {
   title: string;
   type: string;
   status?: string;
+  /** Automatic capture must be qualified before it can source a project brief. */
+  admissionState?: 'ephemeral' | 'candidate' | 'qualified';
   createdAt?: string;
   updatedAt?: string;
   /** Explicit file paths recorded with a memory, used only before Code Memory exists. */