memorix 1.2.2 → 1.2.4

package/src/memory/refs.ts

@@ -1,94 +1,94 @@
-/**
- * Typed Memory Reference Protocol (Phase 3a)
- *
- * Provides a formal, unambiguous way to reference memory objects
- * (observations and mini-skills) across internal code and the MCP API.
- *
- * String format:
- *   obs:42          — observation #42
- *   skill:3         — mini-skill #3
- *   obs:42@org/proj — observation #42 in project org/proj
- *
- * Legacy support:
- *   42   (bare number)  → obs:42
- *   "42" (bare string)  → obs:42
- *
- * Display short forms (presentation only):
- *   #42  — observation
- *   S3   — mini-skill
- */
-
-import type { MemoryRef } from '../types.js';
-
-// ── Parsing ──────────────────────────────────────────────────────
-
-const TYPED_REF_RE = /^(obs|skill):(\d+)(?:@(.+))?$/;
-
-/**
- * Parse a typed memory reference from a string or number.
- *
- * Accepts:
- *   - "obs:42", "skill:3", "obs:42@org/proj"
- *   - 42 (bare number → obs:42)
- *   - "42" (bare numeric string → obs:42)
- *
- * Throws on invalid input.
- */
-export function parseMemoryRef(input: string | number): MemoryRef {
-  // Bare number → legacy observation ref
-  if (typeof input === 'number') {
-    if (!Number.isInteger(input) || input < 0) {
-      throw new Error(`Invalid memory ref: ${input} (must be a non-negative integer)`);
-    }
-    return { kind: 'obs', id: input };
-  }
-
-  const trimmed = input.trim();
-
-  // Bare numeric string → legacy observation ref
-  if (/^\d+$/.test(trimmed)) {
-    return { kind: 'obs', id: parseInt(trimmed, 10) };
-  }
-
-  // Typed ref: obs:42 or skill:3 or obs:42@org/proj
-  const match = trimmed.match(TYPED_REF_RE);
-  if (!match) {
-    throw new Error(
-      `Invalid memory ref: "${input}". Expected format: obs:<id>, skill:<id>, obs:<id>@<projectId>, or a bare number.`,
-    );
-  }
-
-  const kind = match[1] as 'obs' | 'skill';
-  const id = parseInt(match[2], 10);
-  const projectId = match[3] || undefined;
-
-  return { kind, id, projectId };
-}
-
-// ── Serialization ────────────────────────────────────────────────
-
-/**
- * Serialize a MemoryRef to its canonical string form.
- *
- * Examples:
- *   { kind: 'obs', id: 42 }                    → "obs:42"
- *   { kind: 'skill', id: 3 }                   → "skill:3"
- *   { kind: 'obs', id: 42, projectId: 'o/p' }  → "obs:42@o/p"
- */
-export function serializeMemoryRef(ref: MemoryRef): string {
-  const base = `${ref.kind}:${ref.id}`;
-  return ref.projectId ? `${base}@${ref.projectId}` : base;
-}
-
-// ── Display ──────────────────────────────────────────────────────
-
-/**
- * Format a MemoryRef for human-readable display.
- *
- * Short forms:
- *   obs:42  → "#42"
- *   skill:3 → "S3"
- */
-export function displayRef(ref: MemoryRef): string {
-  return ref.kind === 'obs' ? `#${ref.id}` : `S${ref.id}`;
-}
+/**
+ * Typed Memory Reference Protocol (Phase 3a)
+ *
+ * Provides a formal, unambiguous way to reference memory objects
+ * (observations and mini-skills) across internal code and the MCP API.
+ *
+ * String format:
+ *   obs:42          — observation #42
+ *   skill:3         — mini-skill #3
+ *   obs:42@org/proj — observation #42 in project org/proj
+ *
+ * Legacy support:
+ *   42   (bare number)  → obs:42
+ *   "42" (bare string)  → obs:42
+ *
+ * Display short forms (presentation only):
+ *   #42  — observation
+ *   S3   — mini-skill
+ */
+
+import type { MemoryRef } from '../types.js';
+
+// ── Parsing ──────────────────────────────────────────────────────
+
+const TYPED_REF_RE = /^(obs|skill):(\d+)(?:@(.+))?$/;
+
+/**
+ * Parse a typed memory reference from a string or number.
+ *
+ * Accepts:
+ *   - "obs:42", "skill:3", "obs:42@org/proj"
+ *   - 42 (bare number → obs:42)
+ *   - "42" (bare numeric string → obs:42)
+ *
+ * Throws on invalid input.
+ */
+export function parseMemoryRef(input: string | number): MemoryRef {
+  // Bare number → legacy observation ref
+  if (typeof input === 'number') {
+    if (!Number.isInteger(input) || input < 0) {
+      throw new Error(`Invalid memory ref: ${input} (must be a non-negative integer)`);
+    }
+    return { kind: 'obs', id: input };
+  }
+
+  const trimmed = input.trim();
+
+  // Bare numeric string → legacy observation ref
+  if (/^\d+$/.test(trimmed)) {
+    return { kind: 'obs', id: parseInt(trimmed, 10) };
+  }
+
+  // Typed ref: obs:42 or skill:3 or obs:42@org/proj
+  const match = trimmed.match(TYPED_REF_RE);
+  if (!match) {
+    throw new Error(
+      `Invalid memory ref: "${input}". Expected format: obs:<id>, skill:<id>, obs:<id>@<projectId>, or a bare number.`,
+    );
+  }
+
+  const kind = match[1] as 'obs' | 'skill';
+  const id = parseInt(match[2], 10);
+  const projectId = match[3] || undefined;
+
+  return { kind, id, projectId };
+}
+
+// ── Serialization ────────────────────────────────────────────────
+
+/**
+ * Serialize a MemoryRef to its canonical string form.
+ *
+ * Examples:
+ *   { kind: 'obs', id: 42 }                    → "obs:42"
+ *   { kind: 'skill', id: 3 }                   → "skill:3"
+ *   { kind: 'obs', id: 42, projectId: 'o/p' }  → "obs:42@o/p"
+ */
+export function serializeMemoryRef(ref: MemoryRef): string {
+  const base = `${ref.kind}:${ref.id}`;
+  return ref.projectId ? `${base}@${ref.projectId}` : base;
+}
+
+// ── Display ──────────────────────────────────────────────────────
+
+/**
+ * Format a MemoryRef for human-readable display.
+ *
+ * Short forms:
+ *   obs:42  → "#42"
+ *   skill:3 → "S3"
+ */
+export function displayRef(ref: MemoryRef): string {
+  return ref.kind === 'obs' ? `#${ref.id}` : `S${ref.id}`;
+}

package/src/memory/secret-filter.ts

@@ -1,79 +1,79 @@
-/**
- * Secret Filter
- *
- * Conservative credential detection and redaction for Memorix memory content.
- * Designed for low false-positive risk: only matches explicit credential
- * assignments (key=value / key: value), not generic discussion of auth concepts.
- *
- *   sanitizeCredentials()  — store-time: called inside storeObservation() before write
- *   redactCredentials()    — retrieval-time: called in format/output paths for legacy safety
- *   containsCredential()   — predicate used for testing and optional logging
- *
- * Both sanitize and redact share the same pattern logic. They are kept as
- * separate named exports so call-site semantics remain clear.
- */
-
-/**
- * Replaces the VALUE portion of matched credential patterns with [REDACTED].
- * The credential key name is preserved so context is not lost.
- *
- * Pattern categories:
- *   1. key=value / key: value forms — password, token, api_key, secret, etc.
- *      Requires a real value (6+ non-whitespace chars) to avoid matching
- *      discussion text like "password must be 8 chars".
- *   2. Bearer authorization header tokens (20+ chars)
- *   3. Structured token prefixes: GitHub (ghp_/ghs_/gho_), OpenAI (sk-), JWT (eyJ)
- */
-function applyRedaction(text: string): string {
-  if (!text) return text;
-  let out = text;
-
-  // key=value / key: "value" / key='value' — preserve key, redact value
-  out = out.replace(
-    /((?:password|passwd|pwd|secret|token|api[_-]?key|auth[_-]?key|access[_-]?key|private[_-]?key|client[_-]?secret)\s*[:=]\s*["']?)([^\s"',;\n]{6,})/gi,
-    '$1[REDACTED]',
-  );
-
-  // Bearer <token> — preserve "Bearer ", redact token
-  out = out.replace(
-    /(Bearer\s+)([A-Za-z0-9._\-/+]{20,})/g,
-    '$1[REDACTED]',
-  );
-
-  // GitHub tokens (ghp_, ghs_, gho_, github_pat_)
-  out = out.replace(/\b(?:ghp|ghs|gho|github_pat)_[A-Za-z0-9]{36,}\b/g, '[REDACTED]');
-
-  // OpenAI / similar keys (sk-...)
-  out = out.replace(/\bsk-[A-Za-z0-9T-]{20,}\b/g, '[REDACTED]');
-
-  // JWT tokens (base64url header eyJ...)
-  out = out.replace(/\beyJ[A-Za-z0-9._-]{40,}\b/g, '[REDACTED]');
-
-  return out;
-}
-
-/**
- * Store-time sanitization: strips credential values before any durable write.
- * Called inside storeObservation() / upsertObservation() so that every write
- * path (hooks, git-ingest, CLI, reasoning, compact-on-write) is covered.
- */
-export function sanitizeCredentials(text: string): string {
-  return applyRedaction(text);
-}
-
-/**
- * Retrieval-time redaction: masks credential values in display output.
- * Applied in all output formatters (detail, index table, timeline, session context)
- * as a safety net for legacy observations stored before sanitization was in place.
- */
-export function redactCredentials(text: string): string {
-  return applyRedaction(text);
-}
-
-/**
- * Returns true if the text contains an obvious credential pattern.
- * Used for testing and optional diagnostic logging.
- */
-export function containsCredential(text: string): boolean {
-  return applyRedaction(text) !== text;
-}
+/**
+ * Secret Filter
+ *
+ * Conservative credential detection and redaction for Memorix memory content.
+ * Designed for low false-positive risk: only matches explicit credential
+ * assignments (key=value / key: value), not generic discussion of auth concepts.
+ *
+ *   sanitizeCredentials()  — store-time: called inside storeObservation() before write
+ *   redactCredentials()    — retrieval-time: called in format/output paths for legacy safety
+ *   containsCredential()   — predicate used for testing and optional logging
+ *
+ * Both sanitize and redact share the same pattern logic. They are kept as
+ * separate named exports so call-site semantics remain clear.
+ */
+
+/**
+ * Replaces the VALUE portion of matched credential patterns with [REDACTED].
+ * The credential key name is preserved so context is not lost.
+ *
+ * Pattern categories:
+ *   1. key=value / key: value forms — password, token, api_key, secret, etc.
+ *      Requires a real value (6+ non-whitespace chars) to avoid matching
+ *      discussion text like "password must be 8 chars".
+ *   2. Bearer authorization header tokens (20+ chars)
+ *   3. Structured token prefixes: GitHub (ghp_/ghs_/gho_), OpenAI (sk-), JWT (eyJ)
+ */
+function applyRedaction(text: string): string {
+  if (!text) return text;
+  let out = text;
+
+  // key=value / key: "value" / key='value' — preserve key, redact value
+  out = out.replace(
+    /((?:password|passwd|pwd|secret|token|api[_-]?key|auth[_-]?key|access[_-]?key|private[_-]?key|client[_-]?secret)\s*[:=]\s*["']?)([^\s"',;\n]{6,})/gi,
+    '$1[REDACTED]',
+  );
+
+  // Bearer <token> — preserve "Bearer ", redact token
+  out = out.replace(
+    /(Bearer\s+)([A-Za-z0-9._\-/+]{20,})/g,
+    '$1[REDACTED]',
+  );
+
+  // GitHub tokens (ghp_, ghs_, gho_, github_pat_)
+  out = out.replace(/\b(?:ghp|ghs|gho|github_pat)_[A-Za-z0-9]{36,}\b/g, '[REDACTED]');
+
+  // OpenAI / similar keys (sk-...)
+  out = out.replace(/\bsk-[A-Za-z0-9T-]{20,}\b/g, '[REDACTED]');
+
+  // JWT tokens (base64url header eyJ...)
+  out = out.replace(/\beyJ[A-Za-z0-9._-]{40,}\b/g, '[REDACTED]');
+
+  return out;
+}
+
+/**
+ * Store-time sanitization: strips credential values before any durable write.
+ * Called inside storeObservation() / upsertObservation() so that every write
+ * path (hooks, git-ingest, CLI, reasoning, compact-on-write) is covered.
+ */
+export function sanitizeCredentials(text: string): string {
+  return applyRedaction(text);
+}
+
+/**
+ * Retrieval-time redaction: masks credential values in display output.
+ * Applied in all output formatters (detail, index table, timeline, session context)
+ * as a safety net for legacy observations stored before sanitization was in place.
+ */
+export function redactCredentials(text: string): string {
+  return applyRedaction(text);
+}
+
+/**
+ * Returns true if the text contains an obvious credential pattern.
+ * Used for testing and optional diagnostic logging.
+ */
+export function containsCredential(text: string): boolean {
+  return applyRedaction(text) !== text;
+}

package/src/memory/session.ts

@@ -11,7 +11,7 @@
  * - Cross-agent session awareness (all agents share session data)
  */
 
-import type { Observation, Session } from '../types.js';
+import type { Observation, ObservationReader, Session } from '../types.js';
 import { isEligibleForAutomaticDelivery } from './admission.js';
 import { classifyLayer } from './disclosure-policy.js';
 import { resolveAliases } from '../project/aliases.js';
@@ -19,8 +19,20 @@ import { getObservationStore } from '../store/obs-store.js';
 import { getSessionStore } from '../store/session-store.js';
 import { KnowledgeGraphManager } from './graph.js';
 import { redactCredentials, sanitizeCredentials } from './secret-filter.js';
+import { canReadObservation } from './visibility.js';
 
 const PRIORITY_TYPES = new Set(['gotcha', 'decision', 'problem-solution', 'trade-off', 'discovery']);
+const RESUME_TYPES = new Set([
+  'gotcha',
+  'decision',
+  'problem-solution',
+  'trade-off',
+  'discovery',
+  'how-it-works',
+  'what-changed',
+  'reasoning',
+  'session-request',
+]);
 const TYPE_EMOJI: Record<string, string> = {
   'gotcha': '[DISCOVERY]',
   'decision': '[WHY]',
@@ -177,6 +189,138 @@ function isSystemSelfObservation(obs: Observation): boolean {
   return SYSTEM_SELF_PATTERNS.some((pattern) => pattern.test(text));
 }
 
+export interface SessionResumeMemory {
+  id: number;
+  title: string;
+  type: string;
+  detail?: string;
+}
+
+/** A compact, source-aware view of prior work for a task continuation. */
+export interface SessionResumeBrief {
+  previousSession?: {
+    id: string;
+    agent?: string;
+    endedAt?: string;
+    summary: string;
+  };
+  memories: SessionResumeMemory[];
+}
+
+function readerForAlias(
+  reader: ObservationReader | undefined,
+  aliases: Set<string>,
+  observation: Observation,
+): ObservationReader | undefined {
+  if (!reader) return undefined;
+  return reader.projectId && aliases.has(observation.projectId)
+    ? { ...reader, projectId: observation.projectId }
+    : reader;
+}
+
+function readableAliasObservations(
+  observations: Observation[],
+  aliases: Set<string>,
+  reader?: ObservationReader,
+): Observation[] {
+  return reader
+    ? observations.filter((observation) => canReadObservation(
+      observation,
+      readerForAlias(reader, aliases, observation),
+    ))
+    : observations;
+}
+
+function isUsefulSessionSummary(summary: string | undefined): summary is string {
+  return Boolean(summary)
+    && !NOISE_PATTERNS.some((pattern) => pattern.test(summary!))
+    && !SYSTEM_SELF_PATTERNS.some((pattern) => pattern.test(summary!));
+}
+
+function continuationTaskTokens(task?: string): string[] {
+  return [...new Set(
+    (task?.toLowerCase().match(/[a-z0-9_./-]+|[\u4e00-\u9fff]+/g) ?? [])
+      .map((token) => token.trim())
+      .filter((token) => token.length > 1 && !['continue', 'resume', '继续', '接手', '恢复'].includes(token)),
+  )].slice(0, 8);
+}
+
+function continuationScore(observation: Observation, projectTokens: string[], task?: string): number {
+  let score = scoreObservationForSessionContext(observation, projectTokens);
+  if (observation.type === 'session-request' || observation.type === 'what-changed') score += 1;
+  const text = stringifyObservation(observation);
+  const matches = continuationTaskTokens(task).filter((token) => text.includes(token)).length;
+  score += Math.min(matches, 2) * 2;
+  return score;
+}
+
+/**
+ * Return only the latest meaningful session summary and a few durable memory
+ * anchors. It is deliberately separate from the verbose session-context view:
+ * this is a delivery projection for one bounded Task Workset, not another
+ * storage model or an automatic transcript dump.
+ */
+export async function getSessionResumeBrief(
+  projectId: string,
+  task?: string,
+  reader?: ObservationReader,
+): Promise<SessionResumeBrief> {
+  const aliasSet = await resolveProjectIds(projectId);
+  const [sessions, allObs] = await Promise.all([
+    loadAliasSessions(aliasSet),
+    loadAliasActiveObservations(aliasSet),
+  ]);
+  const readableObs = readableAliasObservations(allObs, aliasSet, reader);
+  const previous = sessions
+    .filter((session) => session.status === 'completed')
+    .sort((a, b) => new Date(b.endedAt || b.startedAt).getTime() - new Date(a.endedAt || a.startedAt).getTime())
+    .find((session) => (
+      session.summary
+      && session.summary !== '(session ended implicitly by new session start)'
+      && isUsefulSessionSummary(session.summary)
+    ));
+
+  const projectTokens = tokenizeProjectId(projectId);
+  const memories = readableObs
+    .filter((observation) => RESUME_TYPES.has(observation.type))
+    .filter((observation) => classifyLayer(observation) === 'L2')
+    .filter((observation) => !isNoiseObservation(observation) && !isSystemSelfObservation(observation))
+    .map((observation) => ({
+      observation,
+      score: continuationScore(observation, projectTokens, task),
+    }))
+    .sort((a, b) => (
+      b.score - a.score
+      || new Date(b.observation.createdAt).getTime() - new Date(a.observation.createdAt).getTime()
+      || a.observation.id - b.observation.id
+    ))
+    .slice(0, 3)
+    .map(({ observation }) => ({
+      id: observation.id,
+      title: sanitizeCredentials(observation.title),
+      type: observation.type,
+      ...(observation.facts?.[0]
+        ? { detail: sanitizeCredentials(observation.facts[0]) }
+        : observation.narrative
+          ? { detail: sanitizeCredentials(observation.narrative) }
+          : {}),
+    }));
+
+  return {
+    ...(previous?.summary
+      ? {
+        previousSession: {
+          id: previous.id,
+          ...(previous.agent ? { agent: previous.agent } : {}),
+          ...(previous.endedAt ? { endedAt: previous.endedAt } : {}),
+          summary: sanitizeCredentials(previous.summary),
+        },
+      }
+      : {}),
+    memories,
+  };
+}
+
 export function scoreObservationForSessionContext(obs: Observation, projectTokens: string[], now = Date.now()): number {
   let score = TYPE_WEIGHTS[obs.type] ?? 1;
   const text = stringifyObservation(obs);
@@ -242,7 +386,7 @@ export function scoreObservationForSessionContext(obs: Observation, projectToken
 export async function startSession(
   projectDir: string,
   projectId: string,
-  opts?: { sessionId?: string; agent?: string },
+  opts?: { sessionId?: string; agent?: string; reader?: ObservationReader },
 ): Promise<{ session: Session; previousContext: string }> {
   const sessionId = opts?.sessionId || generateSessionId();
   const now = new Date().toISOString();
@@ -256,7 +400,7 @@ export async function startSession(
   };
 
   // Load previous context before creating new session
-  const previousContext = await getSessionContext(projectDir, projectId);
+  const previousContext = await getSessionContext(projectDir, projectId, 3, opts?.reader);
 
   // Atomic rollover: complete all active sessions for this project's aliases
   // and insert the new session in a single SQLite transaction.
@@ -306,17 +450,22 @@ export async function endSession(
  *   Key Memories   — durable explicit working context (L2)
  *   Session History— orientation log
  *   L3 Evidence    — pointers to git-memory and hook traces (on-demand)
+ *
+ * When a reader is supplied, automatic observation delivery follows that
+ * identity's visibility boundary. Omit it only for trusted maintenance paths.
  */
 export async function getSessionContext(
   projectDir: string,
   projectId: string,
   limit: number = 3,
+  reader?: ObservationReader,
 ): Promise<string> {
   const aliasSet = await resolveProjectIds(projectId);
   const [sessions, allObs] = await Promise.all([
     loadAliasSessions(aliasSet),
     loadAliasActiveObservations(aliasSet),
   ]);
+  const readableObs = readableAliasObservations(allObs, aliasSet, reader);
   /** Check if a session summary contains noise/system-self content */
   const isNoisySummary = (summary: string | undefined): boolean => {
     if (!summary) return false;
@@ -329,7 +478,7 @@ export async function getSessionContext(
     .sort((a, b) => new Date(b.endedAt || b.startedAt).getTime() - new Date(a.endedAt || a.startedAt).getTime())
     .slice(0, limit);
 
-  if (projectSessions.length === 0 && allObs.length === 0) {
+  if (projectSessions.length === 0 && readableObs.length === 0) {
     return '';
   }
 
@@ -337,7 +486,7 @@ export async function getSessionContext(
   const projectTokens = tokenizeProjectId(projectId);
 
   // ── Partition project observations by disclosure layer ─────────────
-  const projectObs = allObs
+  const projectObs = readableObs
     .filter((obs) => !isNoiseObservation(obs) && !isSystemSelfObservation(obs));
 
   // L2: durable working context (explicit/undefined/core), priority types only
@@ -392,11 +541,11 @@ export async function getSessionContext(
   // Active entities enrich the section when it is shown but do not open it alone.
   const hasL1Content = l1HookObs.length > 0 || l3GitCount > 0;
   if (hasL1Content) {
-    // Graph neighbor routing hint: 1-hop neighbors of activeEntities from the
-    // knowledge graph. Routing only — no query expansion, no rerank, no 2-hop
-    // traversal. Silently skipped if graph is absent, empty, or throws.
+    // Graph relations do not yet carry observation visibility metadata, so an
+    // agent-facing reader must not use them as an indirect disclosure channel.
+    // Trusted maintenance paths retain the existing routing hint.
     let graphNeighbors: string[] = [];
-    if (activeEntities.length > 0) {
+    if (!reader && activeEntities.length > 0) {
       try {
         const graphMgr = new KnowledgeGraphManager(projectDir);
         await graphMgr.init();