memorix 1.2.0 → 1.2.2

package/src/codegraph/task-lens.ts

@@ -115,6 +115,7 @@ const KEYWORDS: Record<Exclude<TaskLensId, 'general'>, string[]> = {
   bugfix: [
     'bug',
     'crash',
+    'incident',
     'debug',
     'error',
     'fail',
@@ -125,6 +126,7 @@ const KEYWORDS: Record<Exclude<TaskLensId, 'general'>, string[]> = {
     'repro',
     '报错',
     '崩溃',
+    '故障',
     '失败',
     '修复',
     '问题',
@@ -157,11 +159,53 @@ function tokenize(text: string): string[] {
     .filter(token => token.length > 1 && !STOP_WORDS.has(token));
 }
 
-function containsKeyword(text: string, keyword: string): boolean {
-  if (/^[a-z0-9_-]+$/i.test(keyword)) {
-    return new RegExp(`(^|[^a-z0-9_-])${keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}([^a-z0-9_-]|$)`, 'i').test(text);
+/**
+ * Match a task keyword only when the task states it as an action or intent,
+ * rather than prohibiting that action. Workflow selection shares this rule so
+ * a safety constraint cannot reintroduce an intent rejected by task routing.
+ */
+export function containsTaskKeyword(text: string, keyword: string): boolean {
+  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: RegExpExecArray | null;
+  while ((match = matcher.exec(text)) !== null) {
+    const keywordIndex = match.index + (match[1]?.length ?? 0);
+    if (!isNegatedTaskKeyword(text, keywordIndex)) return true;
   }
-  return text.includes(keyword);
+  return false;
+}
+
+/**
+ * Task text often carries safety constraints such as "do not publish". Those
+ * constraints must not route a debugging task into the release workflow.
+ * Keep this deliberately small and local: it only suppresses a keyword inside
+ * the same sentence when the sentence explicitly negates an action.
+ */
+function isNegatedTaskKeyword(text: string, keywordIndex: number): boolean {
+  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: RegExpExecArray | null;
+  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);
 }
 
 export function resolveTaskLens(task?: string): TaskLens {
@@ -175,7 +219,7 @@ export function resolveTaskLens(task?: string): TaskLens {
   };
 
   for (const id of LENS_PRIORITY) {
-    const score = KEYWORDS[id].reduce((sum, keyword) => sum + (containsKeyword(normalized, keyword) ? 1 : 0), 0);
+    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 };

package/src/compact/engine.ts

@@ -9,7 +9,7 @@
  * Layer 3 (detail)   → Full observation content (~500-1000 tokens/result)
  */
 
-import type { SearchOptions, IndexEntry, TimelineContext, MemorixDocument, ObservationRef, MemoryRef, MiniSkill, SourceSnapshot } from '../types.js';
+import type { SearchOptions, IndexEntry, TimelineContext, MemorixDocument, ObservationRef, MemoryRef, MiniSkill, SourceSnapshot, ObservationReader } from '../types.js';
 import { searchObservations, getTimeline, getObservationsByIds, makeOramaObservationId } from '../store/orama-store.js';
 import { getObservation, getAllObservations } from '../memory/observations.js';
 import { ensureFreshIndex } from '../memory/freshness.js';
@@ -21,6 +21,7 @@ import { getObservationStore } from '../store/obs-store.js';
 import { getMiniSkillStore } from '../store/mini-skill-store.js';
 import { miniSkillToDocument, resolveProvenanceStatus, type ProvenanceStatus } from '../skills/mini-skills.js';
 import { redactCredentials } from '../memory/secret-filter.js';
+import { canReadObservation, filterReadableObservations } from '../memory/visibility.js';
 
 export function normalizeMemoryBrowseQuery(query: string): string {
   const trimmed = query.trim();
@@ -76,14 +77,17 @@ export async function compactSearch(options: SearchOptions): Promise<{
   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.\n\n` +
-        `It looks like a fresh project: the tool call worked, but there is nothing stored to retrieve yet.\n\n` +
-        `Memories will start appearing after observations, session summaries, hook captures, or git-memory are written.`;
+        options.reader
+          ? `No Memorix memories are available to this session yet.\n\n` +
+            `The tool call worked, but this session has no project-visible memory to retrieve.`
+          : `This project does not have any Memorix memories yet.\n\n` +
+            `It looks like a fresh project: the tool call worked, but there is nothing stored to retrieve yet.\n\n` +
+            `Memories will start appearing after observations, session summaries, hook captures, or git-memory are written.`;
     } else {
       formatted =
         `No memories found matching "${options.query}".\n\n` +
@@ -106,12 +110,13 @@ export async function compactTimeline(
   projectId?: string,
   depthBefore = 3,
   depthAfter = 3,
+  reader?: ObservationReader,
 ): Promise<{
   timeline: TimelineContext;
   formatted: string;
   totalTokens: number;
 }> {
-  const result = await getTimeline(anchorId, projectId, depthBefore, depthAfter);
+  const result = await getTimeline(anchorId, projectId, depthBefore, depthAfter, reader);
 
   const timeline: TimelineContext = {
     anchorId,
@@ -135,6 +140,7 @@ export async function compactTimeline(
  */
 export async function compactDetail(
   idsOrRefs: number[] | ObservationRef[] | string[],
+  options: { reader?: ObservationReader } = {},
 ): Promise<{
   documents: MemorixDocument[];
   formatted: string;
@@ -212,7 +218,7 @@ export async function compactDetail(
   const missingRefs: ObservationRef[] = [];
   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,
@@ -232,6 +238,11 @@ export async function compactDetail(
         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 ?? []),
       });
     } else {
       missingRefs.push(ref);
@@ -242,19 +253,19 @@ export async function compactDetail(
     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));
       }
     }
   }
 
   // Build cross-reference map for all requested observations
-  const allObs = getAllObservations();
+  const allObs = filterReadableObservations(getAllObservations(), options.reader);
   const crossRefMap = new Map<string, string[]>();
   for (const ref of refs) {
     const obs = getObservation(ref.id, ref.projectId);
@@ -401,6 +412,11 @@ function observationToDocument(obs: ReturnType<typeof getAllObservations>[number
     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 ?? []),
   };
 }
 

package/src/compact/index-format.ts

@@ -179,6 +179,8 @@ export function formatObservationDetail(doc: {
   entityName: string;
   sourceDetail?: string;
   valueCategory?: string;
+  admissionState?: string;
+  admissionReason?: string;
   source?: string;
   commitHash?: string;
   relatedCommits?: string[];
@@ -187,7 +189,15 @@ export function formatObservationDetail(doc: {
   const lines: string[] = [];
 
   // Provenance header — shown before #ID when sourceDetail (or legacy source='git') is set
-  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('');
@@ -236,6 +246,8 @@ export function formatObservationDetail(doc: {
 function buildProvenanceHeader(
   sourceDetail?: string,
   valueCategory?: string,
+  admissionState?: string,
+  admissionReason?: string,
   source?: string,
   commitHash?: string,
   relatedCommits?: string[],
@@ -257,12 +269,23 @@ function buildProvenanceHeader(
     lines.push(verificationLine);
   }
 
-  if (valueCategory === 'core') {
+  if (valueCategory === 'core' && admissionState !== 'candidate' && admissionState !== 'ephemeral') {
     lines.push('[CORE] Core — immune to decay');
+  } else if (valueCategory === 'core') {
+    lines.push('[CORE] Core candidate — not durable until qualification completes');
   } else if (valueCategory === 'ephemeral') {
     lines.push('[WARN] Ephemeral — short-lived signal');
   }
 
+  if (admissionState === 'candidate') {
+    lines.push('[PENDING] Candidate — excluded from automatic context until current Code Memory qualifies it');
+  } else if (admissionState === 'ephemeral') {
+    lines.push('[TRACE] Ephemeral capture — 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');
 }
 

package/src/compact/token-budget.ts

@@ -1,74 +1,74 @@
-/**
- * Token Budget Manager
- *
- * Provides token counting and budget management for Progressive Disclosure.
- * Source: gpt-tokenizer (737 stars, JS port of OpenAI's tiktoken)
- *
- * Used by the Compact Engine to determine which layer of detail
- * fits within the caller's token budget.
- */
-
-import { countTokens, isWithinTokenLimit } from 'gpt-tokenizer';
-
-/**
- * Count tokens in a string.
- */
-export function countTextTokens(text: string): number {
-  return countTokens(text);
-}
-
-/**
- * Check if text fits within a token limit.
- * Returns the token count if within limit, false otherwise.
- */
-export function fitsInBudget(text: string, limit: number): number | false {
-  return isWithinTokenLimit(text, limit);
-}
-
-/**
- * Truncate text to fit within a token budget.
- * Truncates at sentence boundaries when possible.
- */
-export function truncateToTokenBudget(text: string, budget: number): string {
-  if (fitsInBudget(text, budget) !== false) {
-    return text;
-  }
-
-  // Binary search for the right length
-  const sentences = text.split(/(?<=[.!?])\s+/);
-  let result = '';
-
-  for (const sentence of sentences) {
-    const candidate = result ? `${result} ${sentence}` : sentence;
-    if (fitsInBudget(candidate, budget) === false) {
-      break;
-    }
-    result = candidate;
-  }
-
-  // If no complete sentence fits, truncate by characters
-  if (!result) {
-    // Rough estimate: 1 token ≈ 4 chars for English, ≈ 1.5 chars for Chinese
-    const estimatedChars = budget * 2;
-    result = text.slice(0, estimatedChars);
-    // Refine
-    while (fitsInBudget(result, budget) === false && result.length > 0) {
-      result = result.slice(0, Math.floor(result.length * 0.9));
-    }
-    if (result.length < text.length) {
-      result += '...';
-    }
-  }
-
-  return result;
-}
-
-/**
- * Estimate the token cost of an IndexEntry line.
- * Used to predict compact index size.
- */
-export function estimateIndexEntryTokens(title: string): number {
-  // Format: "| #ID | Time | Icon | Title | ~Tokens |"
-  // Overhead is roughly 15 tokens for formatting
-  return countTextTokens(title) + 15;
-}
+/**
+ * Token Budget Manager
+ *
+ * Provides token counting and budget management for Progressive Disclosure.
+ * Source: gpt-tokenizer (737 stars, JS port of OpenAI's tiktoken)
+ *
+ * Used by the Compact Engine to determine which layer of detail
+ * fits within the caller's token budget.
+ */
+
+import { countTokens, isWithinTokenLimit } from 'gpt-tokenizer';
+
+/**
+ * Count tokens in a string.
+ */
+export function countTextTokens(text: string): number {
+  return countTokens(text);
+}
+
+/**
+ * Check if text fits within a token limit.
+ * Returns the token count if within limit, false otherwise.
+ */
+export function fitsInBudget(text: string, limit: number): number | false {
+  return isWithinTokenLimit(text, limit);
+}
+
+/**
+ * Truncate text to fit within a token budget.
+ * Truncates at sentence boundaries when possible.
+ */
+export function truncateToTokenBudget(text: string, budget: number): string {
+  if (fitsInBudget(text, budget) !== false) {
+    return text;
+  }
+
+  // Binary search for the right length
+  const sentences = text.split(/(?<=[.!?])\s+/);
+  let result = '';
+
+  for (const sentence of sentences) {
+    const candidate = result ? `${result} ${sentence}` : sentence;
+    if (fitsInBudget(candidate, budget) === false) {
+      break;
+    }
+    result = candidate;
+  }
+
+  // If no complete sentence fits, truncate by characters
+  if (!result) {
+    // Rough estimate: 1 token ≈ 4 chars for English, ≈ 1.5 chars for Chinese
+    const estimatedChars = budget * 2;
+    result = text.slice(0, estimatedChars);
+    // Refine
+    while (fitsInBudget(result, budget) === false && result.length > 0) {
+      result = result.slice(0, Math.floor(result.length * 0.9));
+    }
+    if (result.length < text.length) {
+      result += '...';
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Estimate the token cost of an IndexEntry line.
+ * Used to predict compact index size.
+ */
+export function estimateIndexEntryTokens(title: string): number {
+  // Format: "| #ID | Time | Icon | Title | ~Tokens |"
+  // Overhead is roughly 15 tokens for formatting
+  return countTextTokens(title) + 15;
+}

package/src/dashboard/project-classification.ts

@@ -1,64 +1,64 @@
-/**
- * Project classification helpers — shared by /api/projects and /api/identity.
- *
- * Three kinds:
- *   - 'real':        genuine user projects (e.g. AVIDS2/memorix, github.com/org/repo)
- *   - 'temporary':   test/demo/smoke/e2e scratch projects (local/task-*, local/smoke-*, etc.)
- *   - 'placeholder': unresolved / obviously broken IDs (placeholder/*, __unresolved__, System32)
- *
- * A 'dirty' project is one with a clearly broken canonical ID (System32 etc.).
- * 'dirty' and 'temporary' are orthogonal axes:
- *   - local/task-abc        → temporary, NOT dirty
- *   - placeholder/xxx       → placeholder, dirty
- *   - System32\something    → real-looking location but dirty (broken ID)
- */
-
-export type ProjectKind = 'real' | 'temporary' | 'placeholder';
-
-/** Regex list — anything matching is temporary (scratch projects) */
-const TEMPORARY_PATTERNS: RegExp[] = [
-  /^local\/task-/i,
-  /^local\/smoke-/i,
-  /^local\/release-smoke-/i,
-  /^local\/memorix-e2e-/i,
-  /^local\/orchestrate-/i,
-  /^local\/scratch-/i,
-  /^local\/tmp-/i,
-];
-
-/** Regex list — anything matching is placeholder/unresolved */
-const PLACEHOLDER_PATTERNS: RegExp[] = [
-  /^__unresolved__$/,
-  /^placeholder\//i,
-];
-
-/** Regex list — IDs that indicate a broken canonical ID (dirty). */
-const DIRTY_PATTERNS: RegExp[] = [
-  /^placeholder\//i,
-  /System32/i,
-  /Microsoft VS Code/i,
-  /node_modules/i,
-  /\.vscode/i,
-  /^local\/[A-Z]:\\/i,
-];
-
-export function classifyProjectId(id: string): ProjectKind {
-  if (!id) return 'placeholder';
-  if (PLACEHOLDER_PATTERNS.some(p => p.test(id))) return 'placeholder';
-  if (TEMPORARY_PATTERNS.some(p => p.test(id))) return 'temporary';
-  return 'real';
-}
-
-export function isDirtyProjectId(id: string): boolean {
-  if (!id) return false;
-  return DIRTY_PATTERNS.some(p => p.test(id));
-}
-
-/** Friendly label for UI badges */
-export function projectKindLabel(kind: ProjectKind): string {
-  switch (kind) {
-    case 'real': return 'real';
-    case 'temporary': return 'temporary';
-    case 'placeholder': return 'placeholder';
-  }
-}
+/**
+ * Project classification helpers — shared by /api/projects and /api/identity.
+ *
+ * Three kinds:
+ *   - 'real':        genuine user projects (e.g. AVIDS2/memorix, github.com/org/repo)
+ *   - 'temporary':   test/demo/smoke/e2e scratch projects (local/task-*, local/smoke-*, etc.)
+ *   - 'placeholder': unresolved / obviously broken IDs (placeholder/*, __unresolved__, System32)
+ *
+ * A 'dirty' project is one with a clearly broken canonical ID (System32 etc.).
+ * 'dirty' and 'temporary' are orthogonal axes:
+ *   - local/task-abc        → temporary, NOT dirty
+ *   - placeholder/xxx       → placeholder, dirty
+ *   - System32\something    → real-looking location but dirty (broken ID)
+ */
+
+export type ProjectKind = 'real' | 'temporary' | 'placeholder';
+
+/** Regex list — anything matching is temporary (scratch projects) */
+const TEMPORARY_PATTERNS: RegExp[] = [
+  /^local\/task-/i,
+  /^local\/smoke-/i,
+  /^local\/release-smoke-/i,
+  /^local\/memorix-e2e-/i,
+  /^local\/orchestrate-/i,
+  /^local\/scratch-/i,
+  /^local\/tmp-/i,
+];
+
+/** Regex list — anything matching is placeholder/unresolved */
+const PLACEHOLDER_PATTERNS: RegExp[] = [
+  /^__unresolved__$/,
+  /^placeholder\//i,
+];
+
+/** Regex list — IDs that indicate a broken canonical ID (dirty). */
+const DIRTY_PATTERNS: RegExp[] = [
+  /^placeholder\//i,
+  /System32/i,
+  /Microsoft VS Code/i,
+  /node_modules/i,
+  /\.vscode/i,
+  /^local\/[A-Z]:\\/i,
+];
+
+export function classifyProjectId(id: string): ProjectKind {
+  if (!id) return 'placeholder';
+  if (PLACEHOLDER_PATTERNS.some(p => p.test(id))) return 'placeholder';
+  if (TEMPORARY_PATTERNS.some(p => p.test(id))) return 'temporary';
+  return 'real';
+}
+
+export function isDirtyProjectId(id: string): boolean {
+  if (!id) return false;
+  return DIRTY_PATTERNS.some(p => p.test(id));
+}
+
+/** Friendly label for UI badges */
+export function projectKindLabel(kind: ProjectKind): string {
+  switch (kind) {
+    case 'real': return 'real';
+    case 'temporary': return 'temporary';
+    case 'placeholder': return 'placeholder';
+  }
+}