memorix 1.1.13 → 1.2.0

package/src/dashboard/server.ts

@@ -322,9 +322,15 @@ async function handleApi(
                 };
 
                 let maintenance = { total: 0, pending: 0, running: 0, retrying: 0, completed: 0, failed: 0 };
+                let lifecycle: unknown;
                 try {
                     const { MaintenanceJobStore } = await import('../runtime/maintenance-jobs.js');
                     maintenance = new MaintenanceJobStore(effectiveDataDir).summary(effectiveProjectId);
+                    const { collectLifecycleDiagnostics } = await import('../runtime/lifecycle-status.js');
+                    lifecycle = await collectLifecycleDiagnostics({
+                        dataDir: effectiveDataDir,
+                        projectId: effectiveProjectId,
+                    });
                 } catch { /* optional maintenance diagnostics */ }
 
                 sendJson(res, {
@@ -338,6 +344,7 @@ async function handleApi(
                     embedding: embeddingStatus,
                     storage: storageInfo,
                     maintenance,
+                    ...(lifecycle ? { lifecycle } : {}),
                     gitSummary: {
                         total: gitMemories.length,
                         recentWeek: recentGitCount,
@@ -349,7 +356,10 @@ async function handleApi(
             }
 
             case '/maintenance': {
-                const { MaintenanceJobStore } = await import('../runtime/maintenance-jobs.js');
+                const [{ MaintenanceJobStore }, { collectLifecycleDiagnostics }] = await Promise.all([
+                    import('../runtime/maintenance-jobs.js'),
+                    import('../runtime/lifecycle-status.js'),
+                ]);
                 const jobs = new MaintenanceJobStore(effectiveDataDir).list({
                     projectId: effectiveProjectId,
                     limit: 50,
@@ -357,6 +367,10 @@ async function handleApi(
                 sendJson(res, {
                     summary: new MaintenanceJobStore(effectiveDataDir).summary(effectiveProjectId),
                     jobs,
+                    lifecycle: await collectLifecycleDiagnostics({
+                        dataDir: effectiveDataDir,
+                        projectId: effectiveProjectId,
+                    }),
                 });
                 break;
             }

package/src/evaluation/workset-evaluation.ts

@@ -0,0 +1,120 @@
+import { countTextTokens } from '../compact/token-budget.js';
+
+export const WORKSET_VARIANTS = [
+  'memory-only',
+  'current-context',
+  'candidate-workset',
+] as const;
+
+export type WorksetVariant = typeof WORKSET_VARIANTS[number];
+
+/**
+ * A normalized result shape for evaluating a task context. The production
+ * Workset builder will populate this shape in Phase 5; Phase 0 uses it to
+ * establish deterministic baseline fixtures without an LLM dependency.
+ */
+export interface EvaluatedWorkset {
+  variant: WorksetVariant;
+  prompt: string;
+  startHere: string[];
+  evidenceIds: string[];
+  cautions: string[];
+}
+
+export interface WorksetExpectation {
+  requiredStartHere?: string[];
+  requiredEvidenceIds?: string[];
+  requiredCautions?: string[];
+  maxTokens: number;
+  maxTokensByVariant?: Partial<Record<WorksetVariant, number>>;
+}
+
+export interface WorksetEvaluationFixture {
+  id: string;
+  title: string;
+  task: string;
+  expectation: WorksetExpectation;
+}
+
+export interface WorksetEvaluationResult {
+  fixtureId: string;
+  variant: WorksetVariant;
+  tokenCount: number;
+  tokenBudget: number;
+  withinBudget: boolean;
+  missingStartHere: string[];
+  missingEvidenceIds: string[];
+  missingCautions: string[];
+  passed: boolean;
+}
+
+export interface WorksetComparison {
+  fixtureId: string;
+  results: WorksetEvaluationResult[];
+  byVariant: Partial<Record<WorksetVariant, WorksetEvaluationResult>>;
+}
+
+function unique(values: string[]): string[] {
+  return [...new Set(values)];
+}
+
+function missing(required: string[] | undefined, actual: string[]): string[] {
+  const available = new Set(actual);
+  return unique(required ?? []).filter(value => !available.has(value));
+}
+
+function tokenBudgetFor(
+  expectation: WorksetExpectation,
+  variant: WorksetVariant,
+): number {
+  return expectation.maxTokensByVariant?.[variant] ?? expectation.maxTokens;
+}
+
+/**
+ * Evaluate one context against source-backed fixture requirements. This is
+ * deliberately mechanical: it reports evidence, safety, and token gaps
+ * instead of asking a model to grade another model's answer.
+ */
+export function evaluateWorkset(
+  fixture: WorksetEvaluationFixture,
+  workset: EvaluatedWorkset,
+): WorksetEvaluationResult {
+  const tokenCount = countTextTokens(workset.prompt);
+  const missingStartHere = missing(fixture.expectation.requiredStartHere, workset.startHere);
+  const missingEvidenceIds = missing(fixture.expectation.requiredEvidenceIds, workset.evidenceIds);
+  const missingCautions = missing(fixture.expectation.requiredCautions, workset.cautions);
+  const tokenBudget = tokenBudgetFor(fixture.expectation, workset.variant);
+  const withinBudget = tokenCount <= tokenBudget;
+
+  return {
+    fixtureId: fixture.id,
+    variant: workset.variant,
+    tokenCount,
+    tokenBudget,
+    withinBudget,
+    missingStartHere,
+    missingEvidenceIds,
+    missingCautions,
+    passed: withinBudget
+      && missingStartHere.length === 0
+      && missingEvidenceIds.length === 0
+      && missingCautions.length === 0,
+  };
+}
+
+/**
+ * Compare memory-only, current-context, and candidate Worksets against the
+ * same task requirements. Missing variants are intentionally allowed so a
+ * new retrieval implementation can be introduced incrementally.
+ */
+export function compareWorksets(
+  fixture: WorksetEvaluationFixture,
+  worksets: EvaluatedWorkset[],
+): WorksetComparison {
+  const results = worksets.map(workset => evaluateWorkset(fixture, workset));
+  const byVariant: Partial<Record<WorksetVariant, WorksetEvaluationResult>> = {};
+  for (const result of results) {
+    byVariant[result.variant] = result;
+  }
+  return { fixtureId: fixture.id, results, byVariant };
+}

package/src/hooks/handler.ts

@@ -298,12 +298,12 @@ async function handleSessionStart(input: NormalizedHookInput): Promise<{
         dataDir,
         observations: activeObservations,
         refresh: 'auto',
-        enqueueRefresh: () => import('../runtime/maintenance-jobs.js').then(({ MaintenanceJobStore }) => {
-            new MaintenanceJobStore(dataDir).enqueue({
+        enqueueRefresh: () => import('../runtime/lifecycle.js').then(({ enqueueCodegraphRefresh }) => {
+            enqueueCodegraphRefresh({
+              dataDir,
               projectId: canonicalId,
-              kind: 'codegraph-refresh',
-              dedupeKey: 'hook-codegraph-refresh',
-              payload: { maxFiles: 5_000 },
+              source: 'hook-session-start',
+              maxFiles: 5_000,
             });
           }),
       });
@@ -337,7 +337,7 @@ async function handleSessionStart(input: NormalizedHookInput): Promise<{
  * Pipeline: Classify → Policy check → Store → Respond
  * Pattern detection is used for classification only, not storage gating.
  */
-export async function handleHookEvent(input: NormalizedHookInput): Promise<{
+async function handleHookEventCore(input: NormalizedHookInput): Promise<{
   observation: ReturnType<typeof buildObservation> | null;
   output: HookOutput;
 }> {
@@ -431,6 +431,48 @@ export async function handleHookEvent(input: NormalizedHookInput): Promise<{
   };
 }
 
+/** Queue a later scan after an actual file mutation without scanning in the hook. */
+async function queueCodegraphRefreshForMutation(input: NormalizedHookInput): Promise<void> {
+  if (classifyTool(input) !== 'file_modify') return;
+  try {
+    const [
+      { detectProject },
+      { getProjectDataDir },
+      { initAliasRegistry, registerAlias },
+      { enqueueCodegraphRefresh },
+    ] = await Promise.all([
+      import('../project/detector.js'),
+      import('../store/persistence.js'),
+      import('../project/aliases.js'),
+      import('../runtime/lifecycle.js'),
+    ]);
+    const project = detectProject(input.cwd || process.cwd());
+    if (!project) return;
+    const dataDir = await getProjectDataDir(project.id);
+    initAliasRegistry(dataDir);
+    const projectId = await registerAlias(project);
+    enqueueCodegraphRefresh({
+      dataDir,
+      projectId,
+      source: 'hook-file-mutation',
+      maxFiles: 5_000,
+    });
+  } catch {
+    // Hooks remain capture-first even if optional Code Memory scheduling fails.
+  }
+}
+
+export async function handleHookEvent(input: NormalizedHookInput): Promise<{
+  observation: ReturnType<typeof buildObservation> | null;
+  output: HookOutput;
+}> {
+  try {
+    return await handleHookEventCore(input);
+  } finally {
+    await queueCodegraphRefreshForMutation(input);
+  }
+}
+
 /**
  * Convert Memorix's neutral hook response into the host-specific response
  * schema expected by each supported agent.

package/src/knowledge/claim-store.ts

@@ -0,0 +1,267 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { sanitizeCredentials } from '../memory/secret-filter.js';
+import { getDatabase } from '../store/sqlite-db.js';
+import type {
+  ClaimConflict,
+  ClaimEvent,
+  ClaimEvidenceRef,
+  KnowledgeClaim,
+  KnowledgeClaimStatus,
+} from './types.js';
+
+function optionalText(value: unknown): string | undefined {
+  return typeof value === 'string' && value ? value : undefined;
+}
+
+function rowToClaim(row: any): KnowledgeClaim {
+  return {
+    id: row.id,
+    projectId: row.projectId,
+    subject: row.subject,
+    predicate: row.predicate,
+    objectValue: row.objectValue,
+    scope: row.scope,
+    claimKey: row.claimKey,
+    conflictKey: row.conflictKey,
+    status: row.status,
+    confidence: Number(row.confidence),
+    observedAt: row.observedAt,
+    ...(optionalText(row.validFrom) ? { validFrom: row.validFrom } : {}),
+    ...(optionalText(row.validTo) ? { validTo: row.validTo } : {}),
+    ...(optionalText(row.supersededBy) ? { supersededBy: row.supersededBy } : {}),
+    reviewState: row.reviewState,
+    origin: row.origin,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}
+
+function rowToEvidence(row: any): ClaimEvidenceRef {
+  return {
+    id: row.id,
+    claimId: row.claimId,
+    evidenceKind: row.evidenceKind,
+    evidenceId: row.evidenceId,
+    relation: row.relation,
+    ...(optionalText(row.snapshotId) ? { snapshotId: row.snapshotId } : {}),
+    ...(optionalText(row.locator) ? { locator: row.locator } : {}),
+    ...(optionalText(row.capturedHash) ? { capturedHash: row.capturedHash } : {}),
+    createdAt: row.createdAt,
+  };
+}
+
+function rowToEvent(row: any): ClaimEvent {
+  return {
+    id: row.id,
+    projectId: row.projectId,
+    claimId: row.claimId,
+    kind: row.kind,
+    ...(optionalText(row.fromStatus) ? { fromStatus: row.fromStatus } : {}),
+    ...(optionalText(row.toStatus) ? { toStatus: row.toStatus } : {}),
+    ...(optionalText(row.relatedClaimId) ? { relatedClaimId: row.relatedClaimId } : {}),
+    ...(optionalText(row.detail) ? { detail: row.detail } : {}),
+    createdAt: row.createdAt,
+  };
+}
+
+function evidenceKey(input: Omit<ClaimEvidenceRef, 'id' | 'claimId' | 'createdAt'>): string {
+  return createHash('sha256').update(JSON.stringify([
+    input.evidenceKind,
+    input.evidenceId,
+    input.relation,
+    input.snapshotId ?? '',
+    input.locator ?? '',
+    input.capturedHash ?? '',
+  ])).digest('hex');
+}
+
+/**
+ * SQLite access for the claim ledger. Domain policy belongs in claims.ts; this
+ * class only preserves records and their audit trail atomically.
+ */
+export class ClaimStore {
+  private db: any = null;
+
+  async init(dataDir: string): Promise<void> {
+    this.db = getDatabase(dataDir);
+  }
+
+  transaction<T>(fn: () => T): T {
+    return this.db.transaction(fn)();
+  }
+
+  getClaim(id: string): KnowledgeClaim | undefined {
+    const row = this.db.prepare('SELECT * FROM knowledge_claims WHERE id = ?').get(id);
+    return row ? rowToClaim(row) : undefined;
+  }
+
+  listClaims(
+    projectId: string,
+    options: { statuses?: readonly KnowledgeClaimStatus[]; limit?: number } = {},
+  ): KnowledgeClaim[] {
+    const limit = Math.max(1, Math.min(1_000, Math.floor(options.limit ?? 500)));
+    if (options.statuses && options.statuses.length > 0) {
+      return this.db.prepare(`
+        SELECT * FROM knowledge_claims
+        WHERE projectId = ? AND status IN (SELECT value FROM json_each(?))
+        ORDER BY updatedAt DESC, id
+        LIMIT ?
+      `).all(projectId, JSON.stringify([...new Set(options.statuses)]), limit).map(rowToClaim);
+    }
+    return this.db.prepare(`
+      SELECT * FROM knowledge_claims
+      WHERE projectId = ?
+      ORDER BY updatedAt DESC, id
+      LIMIT ?
+    `).all(projectId, limit).map(rowToClaim);
+  }
+
+  findReusableClaim(projectId: string, claimKey: string): KnowledgeClaim | undefined {
+    const row = this.db.prepare(`
+      SELECT * FROM knowledge_claims
+      WHERE projectId = ? AND claimKey = ? AND status IN ('active', 'disputed')
+      ORDER BY updatedAt DESC
+      LIMIT 1
+    `).get(projectId, claimKey);
+    return row ? rowToClaim(row) : undefined;
+  }
+
+  listClaimsByConflictKey(projectId: string, conflictKey: string): KnowledgeClaim[] {
+    return this.db.prepare(`
+      SELECT * FROM knowledge_claims
+      WHERE projectId = ? AND conflictKey = ?
+      ORDER BY createdAt ASC, id
+    `).all(projectId, conflictKey).map(rowToClaim);
+  }
+
+  listConflicts(projectId: string): ClaimConflict[] {
+    const rows = this.db.prepare(`
+      SELECT conflictKey
+      FROM knowledge_claims
+      WHERE projectId = ? AND status IN ('active', 'disputed') AND reviewState = 'approved'
+      GROUP BY conflictKey
+      HAVING COUNT(DISTINCT claimKey) > 1
+      ORDER BY conflictKey
+    `).all(projectId) as Array<{ conflictKey: string }>;
+    return rows.map(({ conflictKey }) => ({
+      conflictKey,
+      claims: this.listClaimsByConflictKey(projectId, conflictKey)
+        .filter(claim => claim.status === 'active' || claim.status === 'disputed'),
+    }));
+  }
+
+  insertClaim(claim: KnowledgeClaim): void {
+    this.db.prepare(`
+      INSERT INTO knowledge_claims (
+        id, projectId, subject, predicate, objectValue, scope, claimKey, conflictKey,
+        status, confidence, observedAt, validFrom, validTo, supersededBy,
+        reviewState, origin, createdAt, updatedAt
+      ) VALUES (
+        @id, @projectId, @subject, @predicate, @objectValue, @scope, @claimKey, @conflictKey,
+        @status, @confidence, @observedAt, @validFrom, @validTo, @supersededBy,
+        @reviewState, @origin, @createdAt, @updatedAt
+      )
+    `).run({
+      ...claim,
+      validFrom: claim.validFrom ?? null,
+      validTo: claim.validTo ?? null,
+      supersededBy: claim.supersededBy ?? null,
+    });
+  }
+
+  updateClaim(claim: KnowledgeClaim): void {
+    this.db.prepare(`
+      UPDATE knowledge_claims SET
+        subject = @subject,
+        predicate = @predicate,
+        objectValue = @objectValue,
+        scope = @scope,
+        claimKey = @claimKey,
+        conflictKey = @conflictKey,
+        status = @status,
+        confidence = @confidence,
+        observedAt = @observedAt,
+        validFrom = @validFrom,
+        validTo = @validTo,
+        supersededBy = @supersededBy,
+        reviewState = @reviewState,
+        origin = @origin,
+        updatedAt = @updatedAt
+      WHERE id = @id
+    `).run({
+      ...claim,
+      validFrom: claim.validFrom ?? null,
+      validTo: claim.validTo ?? null,
+      supersededBy: claim.supersededBy ?? null,
+    });
+  }
+
+  touchClaim(id: string, updatedAt: string): void {
+    this.db.prepare('UPDATE knowledge_claims SET updatedAt = ? WHERE id = ?').run(updatedAt, id);
+  }
+
+  insertEvidence(input: Omit<ClaimEvidenceRef, 'id' | 'createdAt'> & { createdAt?: string }): boolean {
+    const createdAt = input.createdAt ?? new Date().toISOString();
+    const key = evidenceKey(input);
+    const result = this.db.prepare(`
+      INSERT OR IGNORE INTO knowledge_claim_evidence (
+        id, claimId, evidenceKind, evidenceId, relation, snapshotId,
+        locator, capturedHash, evidenceKey, createdAt
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      randomUUID(),
+      input.claimId,
+      input.evidenceKind,
+      input.evidenceId,
+      input.relation,
+      input.snapshotId ?? null,
+      input.locator ? sanitizeCredentials(input.locator) : null,
+      input.capturedHash ?? null,
+      key,
+      createdAt,
+    );
+    return Number(result.changes ?? 0) > 0;
+  }
+
+  listEvidence(claimId: string): ClaimEvidenceRef[] {
+    return this.db.prepare(`
+      SELECT * FROM knowledge_claim_evidence
+      WHERE claimId = ?
+      ORDER BY createdAt ASC, id
+    `).all(claimId).map(rowToEvidence);
+  }
+
+  recordEvent(input: Omit<ClaimEvent, 'id' | 'createdAt'> & { createdAt?: string }): ClaimEvent {
+    const event: ClaimEvent = {
+      id: randomUUID(),
+      ...input,
+      ...(input.detail ? { detail: sanitizeCredentials(input.detail) } : {}),
+      createdAt: input.createdAt ?? new Date().toISOString(),
+    };
+    this.db.prepare(`
+      INSERT INTO knowledge_claim_events (
+        id, projectId, claimId, kind, fromStatus, toStatus,
+        relatedClaimId, detail, createdAt
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      event.id,
+      event.projectId,
+      event.claimId,
+      event.kind,
+      event.fromStatus ?? null,
+      event.toStatus ?? null,
+      event.relatedClaimId ?? null,
+      event.detail ?? null,
+      event.createdAt,
+    );
+    return event;
+  }
+
+  listEvents(claimId: string): ClaimEvent[] {
+    return this.db.prepare(`
+      SELECT * FROM knowledge_claim_events
+      WHERE claimId = ?
+      ORDER BY createdAt ASC, id
+    `).all(claimId).map(rowToEvent);
+  }
+}