memorix 1.2.0 → 1.2.1

package/src/dashboard/server.ts

@@ -22,6 +22,7 @@ import { loadDotenv } from '../config/dotenv-loader.js';
 import { resetDotenv } from '../config/dotenv-loader.js';
 import { initProjectRoot } from '../config/yaml-loader.js';
 import { clearProjectRoot } from '../config/yaml-loader.js';
+import { scopeKnowledgeGraphToProject } from '../memory/graph-scope.js';
 
 // MIME types for static file serving
 const MIME_TYPES: Record<string, string> = {
@@ -92,22 +93,15 @@ export function prepareDashboardConfig(projectRoot: string | null): void {
 
 /**
  * Compute project-scoped graph counts from observations.
- * Only entities referenced by this project's active observations are counted.
+ * Active observation entities and their explicit cross-references are counted.
  */
 function computeProjectGraphCounts(
     allEntities: Array<{ name: string }>,
     allRelations: Array<{ from: string; to: string }>,
-    projectObs: Array<{ entityName?: string; status?: string }>,
+    projectObs: Array<{ entityName?: string; relatedEntities?: string[]; status?: string }>,
 ): { entities: number; relations: number; entityNames: Set<string> } {
-    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 };
 }
 
 /**
@@ -210,17 +204,9 @@ async function handleApi(
                 await initGraphStore(effectiveDataDir);
                 const gStore = getGraphStore();
                 const graph = { entities: gStore.loadEntities(), relations: gStore.loadRelations() };
-                // Project-scope the graph: only include entities that have observations in this project
-                const graphObs = await getObservationStore().loadByProject(effectiveProjectId, { status: 'active' }) as Array<{ entityName?: string }>;
-                const projectEntityNames = new Set(
-                    graphObs
-                        .filter(o => o.entityName)
-                        .map(o => o.entityName!),
-                );
-                const entities = graph.entities.filter((e: any) => projectEntityNames.has(e.name));
-                const entityNameSet = new Set(entities.map((e: any) => e.name));
-                const relations = graph.relations.filter((r: any) => entityNameSet.has(r.from) && entityNameSet.has(r.to));
-                sendJson(res, { entities, relations });
+                const graphObs = await getObservationStore().loadByProject(effectiveProjectId, { status: 'active' });
+                const scoped = scopeKnowledgeGraphToProject(graph, graphObs);
+                sendJson(res, { entities: scoped.entities, relations: scoped.relations });
                 break;
             }
 
@@ -240,11 +226,11 @@ async function handleApi(
             case '/stats': {
                 await initGraphStore(effectiveDataDir);
                 const graph = { entities: getGraphStore().loadEntities(), relations: getGraphStore().loadRelations() };
-                const observations = await getObservationStore().loadByProject(effectiveProjectId, { status: 'active' }) as Array<{ type?: string; id?: number; createdAt?: string; title?: string; entityName?: string; status?: string }>;
+                const observations = await getObservationStore().loadByProject(effectiveProjectId, { status: 'active' }) as Array<{ type?: string; id?: number; createdAt?: string; title?: string; entityName?: string; relatedEntities?: string[]; status?: string }>;
                 const nextId = await getObservationStore().loadIdCounter();
 
                 // Project-scoped graph counts (must match /api/graph and /api/export)
-                const projectGraphCounts = computeProjectGraphCounts(graph.entities, graph.relations, observations as Array<{ entityName?: string; status?: string }>);
+                const projectGraphCounts = computeProjectGraphCounts(graph.entities, graph.relations, observations);
 
                 // Type counts (exclude probe -- operational heartbeats, not durable knowledge)
                 const typeCounts: Record<string, number> = {};
@@ -461,24 +447,15 @@ async function handleApi(
                 const allObs = await getObservationStore().loadByProject(effectiveProjectId, { status: 'active' });
                 const skills = await getMiniSkillStore().loadByProject(effectiveProjectId);
 
-                // Project-scope graph store (same logic as /api/graph)
                 const fullGraph = { entities: getGraphStore().loadEntities(), relations: getGraphStore().loadRelations() };
-                const graphObs = await getObservationStore().loadByProject(effectiveProjectId, { status: 'active' }) as Array<{ entityName?: string }>;
-                const projectEntityNames = new Set(
-                    graphObs
-                        .filter(o => o.entityName)
-                        .map(o => o.entityName!),
-                );
-                const scopedEntities = fullGraph.entities.filter((e: any) => projectEntityNames.has(e.name));
-                const scopedEntityNameSet = new Set(scopedEntities.map((e: any) => e.name));
-                const scopedRelations = fullGraph.relations.filter((r: any) => scopedEntityNameSet.has(r.from) && scopedEntityNameSet.has(r.to));
+                const scoped = scopeKnowledgeGraphToProject(fullGraph, allObs);
 
                 const graph = generateKnowledgeGraph({
                     projectId: effectiveProjectId,
                     observations: allObs,
                     miniSkills: skills,
-                    graphEntities: scopedEntities,
-                    graphRelations: scopedRelations,
+                    graphEntities: scoped.entities,
+                    graphRelations: scoped.relations,
                 });
 
                 sendJson(res, graph);
@@ -747,19 +724,11 @@ async function handleApi(
                     const fullGraph = { entities: getGraphStore().loadEntities(), relations: getGraphStore().loadRelations() };
                     const observations = await getObservationStore().loadByProject(effectiveProjectId, { status: 'active' });
                     const nextId = await getObservationStore().loadIdCounter();
-                    // Project-scope the graph: only entities referenced by this project's observations
-                    const exportEntityNames = new Set(
-                        observations
-                            .filter(o => (o.status ?? 'active') === 'active' && o.entityName)
-                            .map(o => o.entityName!),
-                    );
-                    const exportEntities = fullGraph.entities.filter((e: any) => exportEntityNames.has(e.name));
-                    const exportEntitySet = new Set(exportEntities.map((e: any) => e.name));
-                    const exportRelations = fullGraph.relations.filter((r: any) => exportEntitySet.has(r.from) && exportEntitySet.has(r.to));
+                    const scoped = scopeKnowledgeGraphToProject(fullGraph, observations);
                     const exportData = {
                         project: { id: effectiveProjectId, name: effectiveProjectName },
                         exportedAt: new Date().toISOString(),
-                        graph: { entities: exportEntities, relations: exportRelations },
+                        graph: { entities: scoped.entities, relations: scoped.relations },
                         observations,
                         nextId,
                     };

package/src/knowledge/claims.ts

@@ -242,6 +242,56 @@ export function writeClaim(store: ClaimStore, input: KnowledgeClaimInput): Claim
   });
 }
 
+/**
+ * Deliberately approve or reject a source-backed claim after its evidence has
+ * been checked. Derived agent observations never cross this boundary by
+ * themselves.
+ */
+export function reviewClaim(
+  store: ClaimStore,
+  input: {
+    claimId: string;
+    reviewState: Extract<KnowledgeClaimReviewState, 'approved' | 'rejected'>;
+    detail: string;
+  },
+): KnowledgeClaim {
+  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 now = new Date().toISOString();
+    const nextStatus: KnowledgeClaimStatus = input.reviewState === 'rejected'
+      ? 'unknown'
+      : claim.status === 'unknown' && claim.reviewState === 'rejected'
+        ? 'active'
+        : claim.status;
+    const updated: KnowledgeClaim = {
+      ...claim,
+      status: nextStatus,
+      reviewState: input.reviewState,
+      updatedAt: now,
+    };
+    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: now,
+    });
+    reconcileConflicts(store, claim.projectId, claim.conflictKey, now);
+    return store.getClaim(claim.id) ?? updated;
+  });
+}
+
 export function supersedeClaim(
   store: ClaimStore,
   input: {
@@ -353,7 +403,7 @@ export function deriveLowRiskClaimsFromObservation(
     scope: 'project',
     confidence,
     observedAt: observation.updatedAt ?? observation.createdAt,
-    reviewState: 'approved',
+    reviewState: isGit ? 'approved' : 'needs-review',
     origin: isGit ? 'git' : 'derived',
     evidence,
   });

package/src/knowledge/types.ts

@@ -59,6 +59,7 @@ export type KnowledgeClaimOrigin = 'explicit' | 'git' | 'derived' | 'model';
 export const CLAIM_EVENT_KINDS = [
   'created',
   'evidence-added',
+  'reviewed',
   'conflicted',
   'superseded',
   'requalified',

package/src/knowledge/workflows.ts

@@ -7,6 +7,7 @@ import { atomicWriteFile, withFileLock } from '../store/file-lock.js';
 import { WorkflowSyncer } from '../workspace/workflow-sync.js';
 import { getKnowledgeWorkspacePaths, resolveKnowledgeWorkspaceFile } from './workspace.js';
 import { WorkflowStore } from './workflow-store.js';
+import { containsTaskKeyword } from '../codegraph/task-lens.js';
 import type {
   WorkflowAdapterPreview,
   WorkflowAdapterTarget,
@@ -414,6 +415,9 @@ const LENS_TERMS: Record<string, string[]> = {
   test: ['test', 'verify', 'smoke', '测试', '验证'],
 };
 
+const GENERIC_WORKFLOW_LENSES = new Set(['review', 'test']);
+const GENERIC_WORKFLOW_TERMS = new Set(['review', 'audit', 'test', 'verify', 'smoke']);
+
 function inferTaskLenses(value: string): string[] {
   const text = value.toLowerCase();
   return Object.entries(LENS_TERMS)
@@ -425,20 +429,28 @@ function taskScore(workflow: WorkflowSpec, task: string): { score: number; reaso
   const text = task.toLowerCase();
   let score = 0;
   const reasons: string[] = [];
+  const matchedLenses = new Set<string>();
+  const matchedTriggers = new Set<string>();
   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)] };
 }
 
@@ -475,9 +487,28 @@ function importedWorkflowSpec(input: {
   sourcePath: string;
   raw: string;
 }): WorkflowSpec {
+  let sourceMatter: matter.GrayMatterFile<string>;
+  try {
+    sourceMatter = matter(input.raw);
+  } catch (error) {
+    throw new Error('Malformed Windsurf workflow Markdown: ' + (error instanceof Error ? error.message : String(error)));
+  }
+  if (sourceMatter.data.id !== undefined) {
+    const id = requiredText(sourceMatter.data as Record<string, unknown>, 'id');
+    const sourcePath = 'workflows/' + slug(id) + '.md';
+    const canonical = parsedWorkflow(sourceMatter.data as Record<string, unknown>, sourceMatter.content, {
+      workspaceId: input.workspace.id,
+      sourcePath,
+      contentHash: hash(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 = now();
   const sourcePath = 'workflows/' + slug(entry.name) + '.md';
   const spec: WorkflowSpec = {

package/src/memory/auto-relations.ts

@@ -56,6 +56,27 @@ export async function createAutoRelations(
   // Skip self-references
   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',
+        });
+      }
+    }
+  }
+
   // Check extracted identifiers against existing entities (O(1) lookups via index)
   const candidates = [
     ...extracted.identifiers,

package/src/memory/graph-scope.ts

@@ -0,0 +1,46 @@
+export interface GraphScopeObservation {
+  entityName?: string;
+  relatedEntities?: string[];
+  status?: string;
+}
+
+export interface ScopedKnowledgeGraph<Entity extends { name: string }, Relation extends { from: string; to: string }> {
+  entities: Entity[];
+  relations: Relation[];
+  entityNames: Set<string>;
+}
+
+/** Return the active project entities, including explicit cross-references. */
+export function projectGraphEntityNames(observations: readonly GraphScopeObservation[]): Set<string> {
+  const entityNames = new Set<string>();
+  for (const observation of observations) {
+    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;
+}
+
+/**
+ * Give every graph surface the same project projection: active entities plus
+ * explicit related entities, with only edges whose endpoints remain visible.
+ */
+export function scopeKnowledgeGraphToProject<
+  Entity extends { name: string },
+  Relation extends { from: string; to: string },
+>(
+  graph: { entities: readonly Entity[]; relations: readonly Relation[] },
+  observations: readonly GraphScopeObservation[],
+): ScopedKnowledgeGraph<Entity, Relation> {
+  const entityNames = projectGraphEntityNames(observations);
+  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 };
+}

package/src/orchestrate/verify-gate.ts

@@ -9,7 +9,7 @@
  * is skipped and the task completes as before (backward compatible).
  */
 
-import { spawn, execSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
 
 // ── Types ──────────────────────────────────────────────────────────
 
@@ -63,6 +63,15 @@ export function runGate(
   return new Promise<GateResult>((resolve) => {
     const chunks: Buffer[] = [];
     let totalBytes = 0;
+    let settled = false;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+
+    const finish = (result: GateResult) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      resolve(result);
+    };
 
     const proc = spawn(command, {
       cwd,
@@ -86,9 +95,14 @@ export function runGate(
     let killed = false;
     const killTree = () => {
       try {
-        if (process.platform === 'win32') {
-          // Windows: kill entire process tree via taskkill
-          execSync(`taskkill /F /T /PID ${proc.pid}`, { stdio: 'ignore' });
+        if (process.platform === 'win32' && proc.pid) {
+          // `shell: true` gives Windows a cmd.exe parent. Kill its whole tree
+          // without making the timeout path wait for a stubborn descendant.
+          const killer = spawn('taskkill.exe', ['/F', '/T', '/PID', String(proc.pid)], {
+            stdio: 'ignore',
+            windowsHide: true,
+          });
+          killer.unref();
         } else {
           // Unix: kill process group
           process.kill(-proc.pid!, 'SIGKILL');
@@ -97,20 +111,30 @@ export function runGate(
         // Fallback: kill the process directly
         try { proc.kill('SIGKILL'); } catch { /* already dead */ }
       }
+      try { proc.stdout?.destroy(); } catch { /* already closed */ }
+      try { proc.stderr?.destroy(); } catch { /* already closed */ }
+      proc.unref();
     };
 
-    const timer = setTimeout(() => {
+    timer = setTimeout(() => {
       killed = true;
       killTree();
+      const output = Buffer.concat(chunks).toString('utf-8');
+      finish({
+        gate,
+        passed: false,
+        output: output + `\n[TIMEOUT] Gate "${gate}" killed after ${timeoutMs}ms`,
+        durationMs: Date.now() - start,
+        command,
+      });
     }, timeoutMs);
 
     proc.on('close', (code) => {
-      clearTimeout(timer);
       const output = Buffer.concat(chunks).toString('utf-8');
       const durationMs = Date.now() - start;
 
       if (killed) {
-        resolve({
+        finish({
           gate,
           passed: false,
           output: output + `\n[TIMEOUT] Gate "${gate}" killed after ${timeoutMs}ms`,
@@ -120,7 +144,7 @@ export function runGate(
         return;
       }
 
-      resolve({
+      finish({
         gate,
         passed: code === 0,
         output,
@@ -130,8 +154,7 @@ export function runGate(
     });
 
     proc.on('error', (err) => {
-      clearTimeout(timer);
-      resolve({
+      finish({
         gate,
         passed: false,
         output: `[ERROR] Failed to spawn gate command: ${err.message}`,

package/src/server.ts

@@ -28,6 +28,7 @@ import { initSessionStore } from './store/session-store.js';
 import { checkProjectAttribution, auditProjectObservations } from './memory/attribution-guard.js';
 import { createAutoRelations } from './memory/auto-relations.js';
 import { extractEntities } from './memory/entity-extractor.js';
+import { scopeKnowledgeGraphToProject } from './memory/graph-scope.js';
 import { compactSearch, compactTimeline, compactDetail } from './compact/engine.js';
 import { buildGraphContextPacket, formatGraphContextPrompt } from './memory/graph-context.js';
 import { detectProject } from './project/detector.js';
@@ -1425,7 +1426,7 @@ export async function createMemorixServer(
         { getResolvedConfig },
         { getExternalCodeGraphContext },
         { getObservationStore },
-        { collectCurrentProjectFacts },
+        { collectCurrentProjectFacts, formatGitFact },
         { resolveTaskLens },
       ] = await Promise.all([
         import('./codegraph/store.js'),
@@ -1467,8 +1468,7 @@ export async function createMemorixServer(
         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(formatGitFact(currentFacts.git));
       const codeState = snapshot
         ? '- Code state: ' + (snapshot.baseRevision ? snapshot.baseRevision.slice(0, 12) : 'Git unavailable')
           + ', ' + snapshot.worktreeState + ' worktree'
@@ -1513,11 +1513,13 @@ export async function createMemorixServer(
     {
       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.',
+        '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: z.enum([
           'workspace_init',
           'status',
+          'claim_list',
+          'claim_review',
           'compile',
           'lint',
           'proposal_apply',
@@ -1532,6 +1534,9 @@ export async function createMemorixServer(
         path: z.string().optional().describe('Explicit versioned workspace path, used only by workspace_init'),
         proposalId: z.string().optional().describe('Pending proposal id for proposal_apply'),
         allowManualOverwrite: z.boolean().optional().default(false).describe('Explicitly allow proposal_apply to replace a manually edited page'),
+        claimId: z.string().optional().describe('Source-backed claim id for claim_review'),
+        claimReviewState: z.enum(['approved', 'rejected']).optional().describe('Deliberate review verdict for claim_review'),
+        reviewDetail: z.string().max(2_000).optional().describe('Evidence check performed before approving or rejecting a claim'),
         workflowId: z.string().optional().describe('Canonical workflow id for workflow preview, apply, or run'),
         agent: z.string().optional().describe('Target agent for a workflow adapter'),
         task: z.string().optional().describe('Task text for workflow selection or a workflow run'),
@@ -1548,6 +1553,9 @@ export async function createMemorixServer(
       path: workspacePath,
       proposalId,
       allowManualOverwrite,
+      claimId,
+      claimReviewState,
+      reviewDetail,
       workflowId,
       agent,
       task,
@@ -1572,6 +1580,7 @@ export async function createMemorixServer(
 
       const [
         { ClaimStore },
+        { reviewClaim },
         { CodeGraphStore },
         { initializeKnowledgeWorkspace, loadKnowledgeWorkspace },
         { KnowledgeWorkspaceStore },
@@ -1587,6 +1596,7 @@ export async function createMemorixServer(
         },
       ] = await Promise.all([
         import('./knowledge/claim-store.js'),
+        import('./knowledge/claims.js'),
         import('./codegraph/store.js'),
         import('./knowledge/workspace.js'),
         import('./knowledge/workspace-store.js'),
@@ -1642,10 +1652,58 @@ export async function createMemorixServer(
               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 = reviewClaim(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 compileKnowledgeWorkspace({ workspace, claims });
         return text({
@@ -1688,7 +1746,13 @@ export async function createMemorixServer(
       if (action === 'workflow_import') {
         const result = await importWindsurfWorkflows({ workspace, projectRoot });
         return text({
-          imported: result.imported.map(workflow => ({ id: workflow.id, title: workflow.title, sourcePath: workflow.sourcePath })),
+          imported: result.imported.map(workflow => ({
+            id: workflow.id,
+            title: workflow.title,
+            sourcePath: workflow.sourcePath,
+            importedFrom: workflow.importedFrom,
+            verificationGates: workflow.verificationGates,
+          })),
           skipped: result.skipped,
         });
       }
@@ -1702,6 +1766,8 @@ export async function createMemorixServer(
             status: workflow.status,
             taskLenses: workflow.taskLenses,
             sourcePath: workflow.sourcePath,
+            importedFrom: workflow.importedFrom,
+            verificationGates: workflow.verificationGates,
           })),
           parseErrors: synced.errors,
         });
@@ -2739,15 +2805,11 @@ export async function createMemorixServer(
   async function scopeGraphToProject(graph: { entities: any[]; relations: any[] }) {
     const { getAllObservations } = await import('./memory/observations.js');
     const allObs = await withFreshIndex(() => getAllObservations());
-    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,
+      allObs.filter(observation => observation.projectId === project.id),
     );
-    const entities = graph.entities.filter((e: any) => projectEntityNames.has(e.name));
-    const entityNameSet = new Set(entities.map((e: any) => e.name));
-    const relations = graph.relations.filter((r: any) => entityNameSet.has(r.from) && entityNameSet.has(r.to));
-    return { entities, relations };
+    return { entities: scoped.entities, relations: scoped.relations };
   }
 
   /** read_graph — MCP Official compatible */