@piecemaker-legal/piecemaker 1.0.6 → 1.0.8

package/server/piecemaker/company-search.ts

@@ -0,0 +1,183 @@
+import express, { type Request, type Response } from 'express';
+
+const REGISTRE_PUBLIC_MCP_URL = 'https://registre-public.com/api/mcp';
+const MCP_PROTOCOL_VERSION = '2025-03-26';
+const MCP_TIMEOUT_MS = 20_000;
+
+type JsonRpcPayload = {
+  result?: {
+    content?: Array<{ type?: string; text?: string }>;
+    isError?: boolean;
+  };
+  error?: { message?: string };
+};
+
+export type CompanyDirector = { name: string; role: string };
+
+export type CompanySearchFields = {
+  legalName: string;
+  legalForm: string;
+  status: string;
+  siren: string;
+  siret: string;
+  vat: string;
+  legalFormCode: string;
+  naf: string;
+  creationDate: string;
+  category: string;
+  address: string;
+  directors: CompanyDirector[];
+  finances: string[];
+  source: string;
+};
+
+export type CompanySearchResult = {
+  name: string;
+  siren: string;
+  summary: string;
+  url: string;
+  details: string;
+  fields: CompanySearchFields;
+};
+
+function parseMcpPayload(body: string): JsonRpcPayload {
+  const trimmed = body.trim();
+  if (trimmed.startsWith('{')) return JSON.parse(trimmed) as JsonRpcPayload;
+  const payloads = trimmed
+    .split(/\r?\n/)
+    .filter((line) => line.startsWith('data:'))
+    .map((line) => line.slice(5).trim())
+    .filter(Boolean)
+    .map((line) => JSON.parse(line) as JsonRpcPayload);
+  const payload = payloads.at(-1);
+  if (!payload) throw new Error('Réponse PERS_MORALE_1 invalide.');
+  return payload;
+}
+
+async function mcpRequest(id: number, method: string, params: Record<string, unknown>, sessionId?: string): Promise<{ payload: JsonRpcPayload; sessionId?: string }> {
+  const response = await fetch(REGISTRE_PUBLIC_MCP_URL, {
+    method: 'POST',
+    headers: {
+      Accept: 'application/json, text/event-stream',
+      'Content-Type': 'application/json',
+      ...(sessionId ? { 'Mcp-Session-Id': sessionId } : {}),
+    },
+    body: JSON.stringify({ jsonrpc: '2.0', id, method, params }),
+    signal: AbortSignal.timeout(MCP_TIMEOUT_MS),
+  });
+  const body = await response.text();
+  if (!response.ok) throw new Error(`Registre Public a répondu ${response.status}.`);
+  const payload = parseMcpPayload(body);
+  if (payload.error?.message) throw new Error(payload.error.message);
+  return { payload, sessionId: response.headers.get('mcp-session-id') || sessionId };
+}
+
+async function mcpNotification(method: string, params: Record<string, unknown>, sessionId?: string): Promise<void> {
+  const response = await fetch(REGISTRE_PUBLIC_MCP_URL, {
+    method: 'POST',
+    headers: {
+      Accept: 'application/json, text/event-stream',
+      'Content-Type': 'application/json',
+      ...(sessionId ? { 'Mcp-Session-Id': sessionId } : {}),
+    },
+    body: JSON.stringify({ jsonrpc: '2.0', method, params }),
+    signal: AbortSignal.timeout(MCP_TIMEOUT_MS),
+  });
+  if (!response.ok) throw new Error(`Registre Public a répondu ${response.status}.`);
+}
+
+function resultText(payload: JsonRpcPayload): string {
+  const text = payload.result?.content?.filter((entry) => entry.type === 'text' && typeof entry.text === 'string').map((entry) => entry.text).join('\n').trim();
+  if (!text || payload.result?.isError) throw new Error('Registre Public n’a renvoyé aucun résultat exploitable.');
+  return text;
+}
+
+function lineValue(text: string, label: string): string {
+  const line = text.split('\n').find((entry) => entry.startsWith(label));
+  return line ? line.slice(label.length).trim() : '';
+}
+
+export function parseSearchLine(line: string): { name: string; siren: string; summary: string } | null {
+  const match = /^-\s+(.+?)(?:\s+\(([^)]+)\))?\s+\|\s+SIREN\s+(\d{9})\s+\|\s+(.+?)\s+\|\s+NAF\s+([^|]+)\s+\|\s+(.+)$/.exec(line.trim());
+  if (!match) return null;
+  return { name: match[1].trim(), siren: match[3], summary: [match[2]?.trim(), match[4].trim(), `NAF ${match[5].trim()}`, match[6].trim()].filter(Boolean).join(' · ') };
+}
+
+function parseDirectors(text: string): CompanyDirector[] {
+  const start = text.indexOf('Dirigeants:');
+  if (start < 0) return [];
+  const block = text.slice(start + 'Dirigeants:'.length).split(/\n(?=Finances\b|$)/)[0];
+  return block.split('\n').map((line) => /^-\s+(.+?)\s+\(([^)]+)\)$/.exec(line.trim())).filter((match): match is RegExpExecArray => Boolean(match)).map((match) => ({ name: match[1].trim(), role: match[2].trim() }));
+}
+
+function parseCompanyDetails(text: string, fallback: { name: string; siren: string }): CompanySearchFields {
+  const heading = /^#\s+(.+?)\s+\(([^)]+)\)\s+\(([^)]+)\)/m.exec(text);
+  const formAndActivity = lineValue(text, 'Forme juridique (code) :');
+  const [legalFormCode, nafPart] = formAndActivity.split('|').map((value) => value.trim());
+  const creation = lineValue(text, 'Création :');
+  const [creationDate, categoryPart] = creation.split('|').map((value) => value.trim());
+  return {
+    legalName: heading?.[1]?.trim() || fallback.name,
+    legalForm: '',
+    status: heading?.[3]?.trim() || '',
+    siren: lineValue(text, 'SIREN :').split('|')[0].trim() || fallback.siren,
+    siret: (lineValue(text, 'SIREN :').match(/SIRET siège\s*:\s*([^|]+)/)?.[1] || '').trim(),
+    vat: lineValue(text, 'N° TVA intracommunautaire :'),
+    legalFormCode: legalFormCode || '',
+    naf: nafPart?.replace(/^NAF\s*:\s*/, '') || '',
+    creationDate: creationDate || '',
+    category: categoryPart?.replace(/^Catégorie\s*:\s*/, '') || '',
+    address: lineValue(text, 'Adresse du siège :'),
+    directors: parseDirectors(text),
+    finances: text.split('\n').filter((line) => line.startsWith('Finances ')).map((line) => line.trim()),
+    source: lineValue(text, 'Fiche web :'),
+  };
+}
+
+async function callTool(tool: string, args: Record<string, unknown>): Promise<string> {
+  let sessionId: string | undefined;
+  const initialized = await mcpRequest(1, 'initialize', {
+    protocolVersion: MCP_PROTOCOL_VERSION,
+    capabilities: {},
+    clientInfo: { name: 'piecemaker-dossier', version: '0.1.0' },
+  });
+  sessionId = initialized.sessionId;
+  await mcpNotification('notifications/initialized', {}, sessionId);
+  const result = await mcpRequest(2, 'tools/call', { name: tool, arguments: args }, sessionId);
+  return resultText(result.payload);
+}
+
+async function searchCompanies(query: string): Promise<CompanySearchResult[]> {
+  const searchText = await callTool('rechercher_entreprise', { query });
+  const candidates = searchText.split('\n').map(parseSearchLine).filter((entry): entry is { name: string; siren: string; summary: string } => Boolean(entry));
+  const results = await Promise.all(candidates.map(async (candidate) => {
+    const details = await callTool('fiche_entreprise', { siren: candidate.siren });
+    const fields = parseCompanyDetails(details, candidate);
+    return {
+      name: fields.legalName || candidate.name,
+      siren: fields.siren || candidate.siren,
+      summary: candidate.summary,
+      url: fields.source,
+      details,
+      fields,
+    };
+  }));
+  return results;
+}
+
+export function createCompanySearchRouter() {
+  const router = express.Router();
+  router.post('/company-search', async (request: Request, response: Response) => {
+    const query = typeof request.body?.query === 'string' ? request.body.query.trim().slice(0, 200) : '';
+    if (!query) {
+      response.status(400).json({ error: 'Un nom ou un SIREN est requis.' });
+      return;
+    }
+    try {
+      response.json({ query, results: await searchCompanies(query) });
+    } catch (error) {
+      response.status(502).json({ error: error instanceof Error ? error.message : 'Recherche Registre Public impossible.' });
+    }
+  });
+  return router;
+}

package/server/piecemaker/index.ts

@@ -6,6 +6,7 @@ import type { Router } from 'express';
 import { providerRuntimeService, sessionsService } from '@/modules/providers/index.js';
 import { findApplicationRoot, getModuleDirectory } from '@/shared/utils.js';
 
+
 import { startRequiredAnonymizer } from './anonymizer/lifecycle.js';
 import { createCitationStore } from './harness/citation-store.js';
 import { installChatCitationHarness } from './harness/chat-harness.js';
@@ -13,6 +14,8 @@ import { createCitationsRouter } from './harness/citations.routes.js';
 import { startLibraryBackend, installLibraryRuntime } from './library/index.js';
 import { createKnowledgeBackend } from './knowledge/index.js';
 import { createTimesheetBackend } from './timesheet/index.js';
+import { createCompanySearchRouter } from './company-search.js';
+import { createBodaccSearchRouter } from './bodacc-search.js';
 
 /**
  * Point d'entrée PieceMaker. Les modules de `server/piecemaker/vendor/` sont du
@@ -35,11 +38,12 @@ type PieceMakerRuntimeStatus = {
 type PieceMakerVendorModule = {
   createPieceMakerRouter(options?: { getRuntimeStatus?: () => PieceMakerRuntimeStatus; anonymizer?: unknown }): Router;
   piecemakerHome(): string;
+  stopOriginalsJobs(): Promise<void>;
 };
 
 const vendor = createRequire(import.meta.url)(routerPath) as PieceMakerVendorModule;
 
-export const { piecemakerHome } = vendor;
+export const { piecemakerHome, stopOriginalsJobs } = vendor;
 const { createAnonymizerService } = createRequire(import.meta.url)(path.join(applicationRoot, 'server/piecemaker/anonymizer/service.cjs'));
 const anonymizer = createAnonymizerService({ homeDir: piecemakerHome(), required: true });
 const ensureProxy = await startRequiredAnonymizer(anonymizer);
@@ -56,7 +60,9 @@ export function createPieceMakerRouter(options: { getRuntimeStatus?: () => Piece
     try { sessionsService.getSessionDetailsById(id); return true; } catch { return false; }
   }));
   router.use(timesheet);
-  router.use(knowledge);
+  router.use(knowledge.router);
+  router.use(createCompanySearchRouter());
+  router.use(createBodaccSearchRouter());
   return router;
 }
 export type { PieceMakerRuntimeStatus };

package/server/piecemaker/knowledge/index.ts

@@ -3,6 +3,7 @@ import express from 'express';
 import { getConnection, projectsDb } from '@/modules/database/index.js';
 
 import { KnowledgeStore } from '../../../plugins/piecemaker-dossier/src/knowledge.js';
+
 import { createKnowledgePipeline } from './pipeline.js';
 import { createKnowledgeRouter } from './routes.js';
 import { createKnowledgeService } from './service.js';
@@ -10,13 +11,17 @@ import { createKnowledgeService } from './service.js';
 export function createKnowledgeBackend(applicationRoot: string) {
   const router = express.Router();
   let knowledgeRouter: express.Router | null = null;
+  let store: KnowledgeStore | null = null;
+  const getStore = () => {
+    if (!store) store = new KnowledgeStore(getConnection());
+    return store;
+  };
   router.use((request, response, next) => {
     if (!knowledgeRouter) {
-      const store = new KnowledgeStore(getConnection());
-      const pipeline = createKnowledgePipeline({ applicationRoot, projects: projectsDb, store });
-      knowledgeRouter = createKnowledgeRouter(createKnowledgeService(store, projectsDb, pipeline));
+      const pipeline = createKnowledgePipeline({ applicationRoot, projects: projectsDb, store: getStore() });
+      knowledgeRouter = createKnowledgeRouter(createKnowledgeService(getStore(), projectsDb, pipeline));
     }
     knowledgeRouter(request, response, next);
   });
-  return router;
+  return { router };
 }

package/server/piecemaker/knowledge/pipeline.ts

@@ -1,12 +1,14 @@
+import { createRequire } from 'node:module';
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { spawn } from 'node:child_process';
 
 import type { KnowledgeStore } from '../../../plugins/piecemaker-dossier/src/knowledge.js';
-import type { GlinerDocument, GlinerMappingDocument, JsonData } from '../../../plugins/piecemaker-dossier/src/types.js';
 import { persistScanResult, scanResultOperations } from '../../../plugins/piecemaker-dossier/src/scan-result.js';
+import type { GlinerDocument, GlinerMappingDocument, JsonData } from '../../../plugins/piecemaker-dossier/src/types.js';
+
+import type { KnowledgeScanProgress } from './scan-jobs.js';
 
 type ProjectLookup = {
   getProjectById(projectId: string): { project_id: string; project_path: string } | null;
@@ -19,6 +21,29 @@ type PipelineOptions = {
   pythonPath?: string;
 };
 
+type OriginalFile = { path: string; resource?: boolean };
+
+type OriginalsPipeline = {
+  caseMappingFile(caseRoot: string): string;
+  listOriginals(caseRoot: string): Promise<OriginalFile[]>;
+  runManagedPythonJob(options: {
+    action: 'convert' | 'anonymize';
+    script: string;
+    args: string[];
+    onProgress?: (progress: KnowledgeScanProgress) => void;
+    signal?: AbortSignal;
+  }): Promise<unknown>;
+  writeCaseMapping(caseRoot: string, document: GlinerMappingDocument): unknown;
+};
+
+const require = createRequire(import.meta.url);
+const {
+  caseMappingFile,
+  listOriginals,
+  runManagedPythonJob,
+  writeCaseMapping,
+} = require('../vendor/websocket-server/originals-pipeline.cjs') as OriginalsPipeline;
+
 const SUPPORTED_EXTENSIONS = new Set(['.pdf', '.docx', '.doc', '.odt', '.rtf', '.txt', '.md', '.png', '.jpg', '.jpeg', '.tif', '.tiff', '.bmp']);
 
 function relativeKey(projectPath: string, filePath: string): string {
@@ -26,15 +51,18 @@ function relativeKey(projectPath: string, filePath: string): string {
   return crypto.createHash('sha256').update(relative).digest('hex');
 }
 
-function listedFiles(projectPath: string): string[] {
-  return fs.readdirSync(projectPath, { withFileTypes: true })
-    .filter((entry) => entry.isFile() && SUPPORTED_EXTENSIONS.has(path.extname(entry.name).toLowerCase()))
-    .map((entry) => path.join(projectPath, entry.name));
+/** Pièces scannées par défaut : même liste que l'administration, récursive, hors Markdown généré. */
+export async function defaultScanFiles(projectPath: string): Promise<string[]> {
+  const root = fs.realpathSync(projectPath);
+  const originals = await listOriginals(root);
+  return originals
+    .filter((file) => !file.resource)
+    .map((file) => path.resolve(root, file.path));
 }
 
-function safeFiles(projectPath: string, requested: unknown): string[] {
+async function safeFiles(projectPath: string, requested: unknown): Promise<string[]> {
   const root = fs.realpathSync(projectPath);
-  const candidates = Array.isArray(requested) && requested.length ? requested : listedFiles(root);
+  const candidates = Array.isArray(requested) && requested.length ? requested : await defaultScanFiles(root);
   return [...new Set(candidates.map((candidate) => {
     const raw = String(candidate || '');
     const resolved = path.resolve(root, raw);
@@ -45,29 +73,18 @@ function safeFiles(projectPath: string, requested: unknown): string[] {
   }))];
 }
 
-function runProcess(executable: string, args: string[], cwd: string): Promise<{ stdout: string; stderr: string }> {
-  return new Promise((resolve, reject) => {
-    const child = spawn(executable, args, { cwd, env: process.env, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] });
-    let stdout = '';
-    let stderr = '';
-    child.stdout.setEncoding('utf8');
-    child.stderr.setEncoding('utf8');
-    child.stdout.on('data', (chunk) => { stdout += chunk; });
-    child.stderr.on('data', (chunk) => { stderr += chunk; });
-    child.once('error', reject);
-    child.once('close', (code) => {
-      if (code === 0) resolve({ stdout, stderr });
-      else reject(new Error(stderr.trim() || stdout.trim() || `Pipeline failed with code ${code ?? 1}.`));
-    });
-  });
-}
-
 function parseObject(filePath: string): JsonData {
-  const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8').replace(/^/, '')) as unknown;
+  const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8').replace(/^\uFEFF/, '')) as unknown;
   if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error('Invalid pipeline output.');
   return parsed as JsonData;
 }
 
+function readDocumentIndex(projectPath: string): JsonData {
+  const indexPath = path.join(projectPath, '.piecemaker', 'document-index.json');
+  if (!fs.existsSync(indexPath)) return { documents: {} };
+  return parseObject(indexPath);
+}
+
 function documentsFromIndex(projectPath: string, files: string[], documentIndex: JsonData): GlinerDocument[] {
   const entries = documentIndex.documents && typeof documentIndex.documents === 'object' && !Array.isArray(documentIndex.documents)
     ? documentIndex.documents as Record<string, JsonData>
@@ -128,46 +145,61 @@ function textValue(value: unknown): string {
   return typeof value === 'string' ? value.trim() : '';
 }
 
+async function withPythonPath<T>(pythonPath: string, run: () => Promise<T>): Promise<T> {
+  const previous = process.env.PYTHON_PATH;
+  process.env.PYTHON_PATH = pythonPath;
+  try {
+    return await run();
+  } finally {
+    if (previous === undefined) delete process.env.PYTHON_PATH;
+    else process.env.PYTHON_PATH = previous;
+  }
+}
+
 export function createKnowledgePipeline(options: PipelineOptions) {
   const script = path.join(options.applicationRoot, 'server', 'piecemaker', 'vendor', 'websocket-server', 'scripts', 'convert_and_scan_pipeline.py');
   return {
-    async scan(projectId: string, requestedFiles?: unknown) {
+    async scan(projectId: string, requestedFiles?: unknown, onProgress?: (progress: KnowledgeScanProgress) => void, signal?: AbortSignal) {
       const project = options.projects.getProjectById(projectId);
       if (!project) throw new Error('Project not found.');
       const projectPath = fs.realpathSync(project.project_path);
-      const files = safeFiles(projectPath, requestedFiles);
+      const explicitFiles = Array.isArray(requestedFiles) && requestedFiles.length > 0;
+      const files = await safeFiles(projectPath, requestedFiles);
       if (!files.length) throw new Error('No supported file to scan.');
-      const temporaryRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'piecemaker-knowledge-'));
-      const mappingFile = path.join(temporaryRoot, 'mapping.json');
-      const stateFile = path.join(temporaryRoot, 'state.json');
+      const mappingFile = caseMappingFile(projectPath);
+      const stateFile = path.join(projectPath, '.piecemaker', 'anonymization-state.json');
       const outputDirectory = path.join(projectPath, 'Fichiers convertis PieceMaker');
+      fs.mkdirSync(path.dirname(mappingFile), { recursive: true });
+      fs.mkdirSync(path.dirname(stateFile), { recursive: true });
       fs.mkdirSync(outputDirectory, { recursive: true });
-      try {
-        fs.writeFileSync(mappingFile, JSON.stringify(mappingSeed(projectId, projectPath, options.store)), { mode: 0o600 });
-        const args = [
-          script,
-          ...files,
-          '-o',
-          outputDirectory,
-          '--mapping-file',
-          mappingFile,
-          '--case-root',
-          projectPath,
-          '--state-file',
-          stateFile,
-        ];
-        const processResult = await runProcess(pythonExecutable(options.pythonPath), args, projectPath);
-        const mapping = parseObject(mappingFile) as GlinerMappingDocument;
-        const documentIndex = parseObject(path.join(temporaryRoot, 'document-index.json'));
-        const documents = documentsFromIndex(projectPath, files, documentIndex);
-        const scanResult = { projectId, mapping, documents };
-        const result = Array.isArray(requestedFiles) && requestedFiles.length
-          ? options.store.update({ projectId, operations: scanResultOperations(scanResult) })
-          : persistScanResult(scanResult, options.store);
-        return { ...result, documents: documents.length, stdout: processResult.stdout.trim(), stderr: processResult.stderr.trim() };
-      } finally {
-        fs.rmSync(temporaryRoot, { recursive: true, force: true });
-      }
+      fs.writeFileSync(mappingFile, JSON.stringify(mappingSeed(projectId, projectPath, options.store)), { mode: 0o600 });
+      const args = [
+        ...files,
+        '-o',
+        outputDirectory,
+        '--mapping-file',
+        mappingFile,
+        '--case-root',
+        projectPath,
+        '--state-file',
+        stateFile,
+      ];
+      if (!explicitFiles) args.push('--skip-existing');
+      await withPythonPath(pythonExecutable(options.pythonPath), () => runManagedPythonJob({
+        action: 'anonymize',
+        script,
+        args,
+        onProgress,
+        signal,
+      }));
+      const mapping = parseObject(mappingFile) as GlinerMappingDocument;
+      writeCaseMapping(projectPath, mapping);
+      const documents = documentsFromIndex(projectPath, files, readDocumentIndex(projectPath));
+      const scanResult = { projectId, mapping, documents };
+      const result = explicitFiles
+        ? options.store.update({ projectId, operations: scanResultOperations(scanResult) })
+        : persistScanResult(scanResult, options.store);
+      return { ...result, documents: documents.length };
     },
   };
 }

package/server/piecemaker/knowledge/routes.ts

@@ -17,13 +17,11 @@ export function createKnowledgeRouter(service: KnowledgeService) {
       response.status(statusFor(error)).json({ error: error instanceof Error ? error.message : 'Knowledge operation failed.' });
     });
   };
-  router.get('/knowledge/overview', (request, response) => respond(() => service.overview(request.query.projectId), response));
-  router.get('/knowledge/mapping', (request, response) => respond(() => service.mapping(request.query.projectId), response));
-  router.get('/knowledge/chronology', (request, response) => respond(() => service.chronology(request.query.projectId), response));
   router.get('/knowledge/graph', (request, response) => respond(() => service.graph(request.query.projectId), response));
-  router.get('/knowledge/agents', (request, response) => respond(() => service.agents(request.query.projectId), response));
   router.post('/knowledge/query', (request, response) => respond(() => service.query(request.body), response));
   router.post('/knowledge/update', (request, response) => respond(() => service.update(request.body), response));
   router.post('/knowledge/scan', (request, response) => respond(() => service.scan(request.body?.projectId, request.body?.files), response));
+  router.get('/knowledge/scan/job', (request, response) => respond(() => service.scanJob(request.query.id, request.query.projectId), response));
+  router.post('/knowledge/scan/cancel', (request, response) => respond(() => service.cancelScan(request.body?.id, request.body?.projectId), response));
   return router;
 }

package/server/piecemaker/knowledge/scan-jobs.ts

@@ -0,0 +1,111 @@
+import crypto from 'node:crypto';
+
+export type KnowledgeScanPhase = 'convert' | 'scan' | 'commit';
+
+export type KnowledgeScanProgress = {
+  phase: KnowledgeScanPhase;
+  percent: number;
+  processed: number;
+  total: number;
+};
+
+export type KnowledgeScanJob = {
+  id: string;
+  projectId: string;
+  source: 'knowledge';
+  action: 'anonymize';
+  state: 'running' | 'done' | 'error' | 'cancelled';
+  phase: KnowledgeScanPhase;
+  percent: number;
+  processed: number;
+  total: number;
+  error: string | null;
+  startedAt: string;
+  finishedAt: string | null;
+};
+
+const COMPLETED_RETENTION_MS = 5 * 60_000;
+
+function isPending(job: KnowledgeScanJob): boolean {
+  return job.state === 'running';
+}
+
+export function createKnowledgeScanJobs() {
+  const jobs = new Map<string, KnowledgeScanJob>();
+  const controllers = new Map<string, AbortController>();
+
+  const prune = () => {
+    const deadline = Date.now() - COMPLETED_RETENTION_MS;
+    for (const [id, job] of jobs) {
+      if (isPending(job)) continue;
+      if (Date.parse(job.finishedAt || job.startedAt) < deadline) jobs.delete(id);
+    }
+  };
+
+  const runningForProject = (projectId: string): KnowledgeScanJob | null => {
+    for (const job of jobs.values()) if (job.projectId === projectId && isPending(job)) return job;
+    return null;
+  };
+
+  return {
+    start(projectId: string, run: (report: (progress: KnowledgeScanProgress) => void, signal: AbortSignal) => Promise<unknown>): KnowledgeScanJob {
+      prune();
+      const running = runningForProject(projectId);
+      if (running) return running;
+      const job: KnowledgeScanJob = {
+        id: crypto.randomUUID(),
+        projectId,
+        source: 'knowledge',
+        action: 'anonymize',
+        state: 'running',
+        phase: 'convert',
+        percent: 0,
+        processed: 0,
+        total: 0,
+        error: null,
+        startedAt: new Date().toISOString(),
+        finishedAt: null,
+      };
+      jobs.set(job.id, job);
+      const report = (progress: KnowledgeScanProgress) => {
+        if (job.state !== 'running') return;
+        job.phase = progress.phase;
+        job.percent = Math.max(job.percent, Math.min(100, progress.percent));
+        job.processed = progress.processed;
+        job.total = progress.total || job.total;
+      };
+      const controller = new AbortController();
+      controllers.set(job.id, controller);
+      run(report, controller.signal).then(() => {
+        if (job.state !== 'running') return;
+        job.state = 'done';
+        job.phase = 'commit';
+        job.percent = 100;
+      }, (error: unknown) => {
+        if (job.state !== 'running') return;
+        job.state = 'error';
+        job.error = error instanceof Error ? error.message : String(error);
+      }).finally(() => {
+        controllers.delete(job.id);
+        job.finishedAt = job.finishedAt || new Date().toISOString();
+      });
+      return job;
+    },
+    get(id: unknown): KnowledgeScanJob | null {
+      prune();
+      return typeof id === 'string' ? jobs.get(id) || null : null;
+    },
+    runningForProject(projectId: string): KnowledgeScanJob | null {
+      prune();
+      return runningForProject(projectId);
+    },
+    cancel(job: KnowledgeScanJob | null): KnowledgeScanJob | null {
+      if (!job || job.state !== 'running') return job;
+      job.state = 'cancelled';
+      job.finishedAt = new Date().toISOString();
+      controllers.get(job.id)?.abort();
+      controllers.delete(job.id);
+      return job;
+    },
+  };
+}

package/server/piecemaker/knowledge/service.ts

@@ -1,11 +1,10 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
 import type { KnowledgeStore } from '../../../plugins/piecemaker-dossier/src/knowledge.js';
 import { exclusionNodeOperation } from '../../../plugins/piecemaker-dossier/src/scan-result.js';
 import type { KnowledgeQueryInput, KnowledgeUpdateInput } from '../../../plugins/piecemaker-dossier/src/types.js';
+
 import { legacyExclusions } from './pipeline.js';
 import type { createKnowledgePipeline } from './pipeline.js';
+import { createKnowledgeScanJobs } from './scan-jobs.js';
 
 type ProjectLookup = {
   getProjectById(projectId: string): { project_id: string; project_path: string } | null;
@@ -17,6 +16,7 @@ function projectId(value: unknown): string {
 }
 
 export function createKnowledgeService(store: KnowledgeStore, projects: ProjectLookup, pipeline: ReturnType<typeof createKnowledgePipeline>) {
+  const scanJobs = createKnowledgeScanJobs();
   const ensureProject = (value: unknown): string => {
     const id = projectId(value);
     if (!projects.getProjectById(id)) throw new Error('Project not found.');
@@ -39,42 +39,27 @@ export function createKnowledgeService(store: KnowledgeStore, projects: ProjectL
     update(input: KnowledgeUpdateInput) {
       return store.update({ ...input, projectId: ensureProject(input.projectId) });
     },
-    overview(value: unknown) {
-      const id = ensureProject(value);
-      const nodes = snapshot(id).nodes;
-      const counts = nodes.reduce<Record<string, number>>((result, node) => {
-        result[node.kind] = (result[node.kind] || 0) + 1;
-        return result;
-      }, {});
-      return { projectId: id, counts, total: nodes.length };
-    },
-    mapping(value: unknown) {
-      const id = ensureProject(value);
-      const current = snapshot(id);
-      return { projectId: id, nodes: current.nodes.filter((node) => node.kind !== 'document'), mappings: current.mappings, exclusions: current.exclusions || [] };
-    },
-    chronology(value: unknown) {
-      const id = ensureProject(value);
-      const current = snapshot(id);
-      return { projectId: id, documents: current.nodes.filter((node) => node.kind === 'document'), links: current.links.filter((link) => link.relation === 'mentions') };
-    },
     graph(value: unknown) {
       const id = ensureProject(value);
       return snapshot(id);
     },
-    agents(value: unknown) {
+    scan(value: unknown, files?: unknown) {
       const id = ensureProject(value);
-      const project = projects.getProjectById(id);
-      if (!project) throw new Error('Project not found.');
-      const root = fs.realpathSync(project.project_path);
-      const candidate = path.join(root, 'AGENTS.md');
-      if (!fs.existsSync(candidate)) return { projectId: id, content: '', exists: false };
-      const real = fs.realpathSync(candidate);
-      if (real !== root && !real.startsWith(`${root}${path.sep}`)) throw new Error('Invalid AGENTS.md path.');
-      return { projectId: id, content: fs.readFileSync(real, 'utf8').slice(0, 2_000_000), exists: true };
+      return {
+        job: scanJobs.start(id, async (report, signal) => {
+          const result = await pipeline.scan(id, files, report, signal);
+          store.markAnonymizationComplete(id);
+          return result;
+        }),
+      };
     },
-    scan(value: unknown, files?: unknown) {
-      return pipeline.scan(ensureProject(value), files);
+    scanJob(jobId: unknown, value?: unknown) {
+      const job = scanJobs.get(jobId) || (value ? scanJobs.runningForProject(ensureProject(value)) : null);
+      return { job };
+    },
+    cancelScan(jobId: unknown, value?: unknown) {
+      const job = scanJobs.get(jobId) || (value ? scanJobs.runningForProject(ensureProject(value)) : null);
+      return { job: scanJobs.cancel(job) };
     },
   };
 }