@redaksjon/protokoll 1.0.13 → 1.0.14-dev.20260216152331.67acb08

package/dist/configDiscovery.js

@@ -1,8 +1,8 @@
-import { resolve, isAbsolute, relative, extname, join, dirname, basename } from 'node:path';
+import { resolve, relative, isAbsolute, extname, join, dirname, basename } from 'node:path';
 import * as Metadata from '@redaksjon/protokoll-engine';
 import { Transcript, Media, Util, Pipeline, findIgnoredResilient, findCompanyResilient, findTermResilient, findPersonResilient, findProjectResilient, Reasoning, VALID_STATUSES, isValidStatus } from '@redaksjon/protokoll-engine';
 import * as yaml from 'js-yaml';
-import { stat, readdir, mkdir } from 'node:fs/promises';
+import { stat, readdir, mkdir, unlink } from 'node:fs/promises';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { create as create$1, parseEntityUri as parseEntityUri$1, createRelationship, createDocumentContent, createCodeContent, createMarkdownContent, createTextContent, createUrlContent } from '@redaksjon/context';
@@ -277,7 +277,7 @@ const resourceTemplates = [
   }
 ];
 
-const VERSION = "1.0.13 (HEAD/8ec1dcf T:v1.0.13 2026-02-15 13:08:35 -0800) linux arm64 v24.13.1";
+const VERSION = "1.0.14-dev.20260216152331.67acb08 (working/67acb08  2026-02-16 07:22:44 -0800) linux arm64 v24.13.1";
 const PROGRAM_NAME = "protokoll";
 const DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS = "YYYY-M-D-HHmmss";
 const DEFAULT_AUDIO_EXTENSIONS = ["mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm", "qta"];
@@ -668,7 +668,7 @@ const ensurePklExtension$1 = Transcript.ensurePklExtension;
 function isUuidInput(input) {
   return /^[a-f0-9]{8}/.test(input);
 }
-async function findTranscriptByUuid(uuid, searchDirectories) {
+async function findTranscriptByUuid$1(uuid, searchDirectories) {
   return Transcript.findTranscriptByUuid(uuid, searchDirectories);
 }
 const logger = getLogger();
@@ -821,7 +821,7 @@ async function resolveTranscriptPath$1(uriOrPathOrUuid, contextDirectory) {
   }
   const outputDirectory = await getConfiguredDirectory("outputDirectory");
   if (isUuidInput(uriOrPathOrUuid)) {
-    const foundPath = await findTranscriptByUuid(uriOrPathOrUuid, [outputDirectory]);
+    const foundPath = await findTranscriptByUuid$1(uriOrPathOrUuid, [outputDirectory]);
     if (!foundPath) {
       throw new Error(`Transcript not found for UUID: ${uriOrPathOrUuid}`);
     }
@@ -858,6 +858,25 @@ async function resolveTranscriptPath$1(uriOrPathOrUuid, contextDirectory) {
   return existsResult.path;
 }
 
+const shared = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    fileExists,
+    formatEntity,
+    getAudioMetadata,
+    getConfiguredDirectory,
+    getContextDirectories,
+    logger,
+    media,
+    mergeArray,
+    resolveTranscriptPath: resolveTranscriptPath$1,
+    sanitizePath,
+    slugify,
+    storage,
+    validateNotRemoteMode,
+    validatePathWithinDirectory,
+    validatePathWithinOutputDirectory
+}, Symbol.toStringTag, { value: 'Module' }));
+
 const { listTranscripts, resolveTranscriptPath, readTranscriptContent, stripTranscriptExtension } = Transcript;
 async function readTranscriptResource(transcriptPath) {
   if (!transcriptPath || typeof transcriptPath !== "string") {
@@ -2023,6 +2042,8 @@ async function handleProcessAudio(args) {
   const outputFilenameOptions = contextConfig.outputFilenameOptions || DEFAULT_OUTPUT_FILENAME_OPTIONS;
   const processedDirectory = config.processedDirectory ?? void 0;
   const { creationTime, hash } = await getAudioMetadata(audioFile);
+  const { getWeightModelService, updateTranscriptInWeightModel } = await import('./weightModel.js');
+  const weightModelService = getWeightModelService();
   const pipeline = await Pipeline.create({
     model: args.model || DEFAULT_MODEL,
     transcriptionModel: args.transcriptionModel || DEFAULT_TRANSCRIPTION_MODEL,
@@ -2041,7 +2062,11 @@ async function handleProcessAudio(args) {
     outputFilenameOptions,
     processedDirectory: processedDirectory || void 0,
     maxAudioSize: DEFAULT_MAX_AUDIO_SIZE,
-    tempDirectory: DEFAULT_TEMP_DIRECTORY
+    tempDirectory: DEFAULT_TEMP_DIRECTORY,
+    weightModelProvider: weightModelService?.provider,
+    onTranscriptEntitiesUpdated: (uuid, entityIds, projectId) => {
+      updateTranscriptInWeightModel(uuid, entityIds, projectId);
+    }
   });
   const result = await pipeline.process({
     audioFile,
@@ -2133,6 +2158,18 @@ const listProjectsTool = {
       includeInactive: {
         type: "boolean",
         description: "Include inactive projects (default: false)"
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of results to return (default: 50)"
+      },
+      offset: {
+        type: "number",
+        description: "Number of results to skip for pagination (default: 0)"
+      },
+      search: {
+        type: "string",
+        description: "Filter by name/ID substring match (case-insensitive)"
       }
     },
     required: []
@@ -2147,6 +2184,18 @@ const listPeopleTool = {
       contextDirectory: {
         type: "string",
         description: "Path to the .protokoll context directory"
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of results to return (default: 50)"
+      },
+      offset: {
+        type: "number",
+        description: "Number of results to skip for pagination (default: 0)"
+      },
+      search: {
+        type: "string",
+        description: "Filter by name/ID substring match (case-insensitive)"
       }
     },
     required: []
@@ -2161,6 +2210,18 @@ const listTermsTool = {
       contextDirectory: {
         type: "string",
         description: "Path to the .protokoll context directory"
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of results to return (default: 50)"
+      },
+      offset: {
+        type: "number",
+        description: "Number of results to skip for pagination (default: 0)"
+      },
+      search: {
+        type: "string",
+        description: "Filter by name/ID substring match (case-insensitive)"
       }
     },
     required: []
@@ -2175,6 +2236,18 @@ const listCompaniesTool = {
       contextDirectory: {
         type: "string",
         description: "Path to the .protokoll context directory"
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of results to return (default: 50)"
+      },
+      offset: {
+        type: "number",
+        description: "Number of results to skip for pagination (default: 0)"
+      },
+      search: {
+        type: "string",
+        description: "Filter by name/ID substring match (case-insensitive)"
       }
     },
     required: []
@@ -2193,6 +2266,14 @@ const searchContextTool = {
       contextDirectory: {
         type: "string",
         description: "Path to the .protokoll context directory"
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of results to return (default: 50)"
+      },
+      offset: {
+        type: "number",
+        description: "Number of results to skip for pagination (default: 0)"
       }
     },
     required: ["query"]
@@ -2221,6 +2302,35 @@ const getEntityTool = {
     required: ["entityType", "entityId"]
   }
 };
+const predictEntitiesTool = {
+  name: "protokoll_predict_entities",
+  description: "Predict likely entities based on transcript context using weight model. Returns ranked entity suggestions based on co-occurrence patterns and project affinity. Useful for intelligent entity correction suggestions.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      transcriptPath: {
+        type: "string",
+        description: "Path to the transcript file"
+      },
+      maxPredictions: {
+        type: "number",
+        description: "Maximum number of predictions to return (default: 10)",
+        minimum: 1,
+        maximum: 50
+      },
+      minScore: {
+        type: "number",
+        description: "Minimum prediction score (default: 1)",
+        minimum: 0
+      },
+      contextDirectory: {
+        type: "string",
+        description: "Path to the .protokoll context directory"
+      }
+    },
+    required: ["transcriptPath"]
+  }
+};
 async function handleContextStatus(args) {
   const context = await getContextInstance(args.contextDirectory);
   const dirs = context.getDiscoveredDirs();
@@ -2252,9 +2362,22 @@ async function handleListProjects(args) {
   if (!args.includeInactive) {
     projects = projects.filter((p) => p.active !== false);
   }
+  if (args.search) {
+    const searchLower = args.search.toLowerCase();
+    projects = projects.filter(
+      (p) => p.name.toLowerCase().includes(searchLower) || p.id.toLowerCase().includes(searchLower)
+    );
+  }
+  const total = projects.length;
+  const limit = args.limit ?? 50;
+  const offset = args.offset ?? 0;
+  const paginatedProjects = projects.slice(offset, offset + limit);
   return {
-    count: projects.length,
-    projects: projects.map((p) => ({
+    total,
+    limit,
+    offset,
+    count: paginatedProjects.length,
+    projects: paginatedProjects.map((p) => ({
       id: p.id,
       name: p.name,
       active: p.active !== false,
@@ -2267,10 +2390,23 @@ async function handleListProjects(args) {
 }
 async function handleListPeople(args) {
   const context = await getContextInstance(args.contextDirectory);
-  const people = context.getAllPeople();
+  let people = context.getAllPeople();
+  if (args.search) {
+    const searchLower = args.search.toLowerCase();
+    people = people.filter(
+      (p) => p.name.toLowerCase().includes(searchLower) || p.id.toLowerCase().includes(searchLower) || p.sounds_like?.some((s) => s.toLowerCase().includes(searchLower))
+    );
+  }
+  const total = people.length;
+  const limit = args.limit ?? 50;
+  const offset = args.offset ?? 0;
+  const paginatedPeople = people.slice(offset, offset + limit);
   return {
-    count: people.length,
-    people: people.map((p) => ({
+    total,
+    limit,
+    offset,
+    count: paginatedPeople.length,
+    people: paginatedPeople.map((p) => ({
       id: p.id,
       name: p.name,
       company: p.company,
@@ -2281,10 +2417,23 @@ async function handleListPeople(args) {
 }
 async function handleListTerms(args) {
   const context = await getContextInstance(args.contextDirectory);
-  const terms = context.getAllTerms();
+  let terms = context.getAllTerms();
+  if (args.search) {
+    const searchLower = args.search.toLowerCase();
+    terms = terms.filter(
+      (t) => t.name.toLowerCase().includes(searchLower) || t.id.toLowerCase().includes(searchLower) || t.sounds_like?.some((s) => s.toLowerCase().includes(searchLower))
+    );
+  }
+  const total = terms.length;
+  const limit = args.limit ?? 50;
+  const offset = args.offset ?? 0;
+  const paginatedTerms = terms.slice(offset, offset + limit);
   return {
-    count: terms.length,
-    terms: terms.map((t) => ({
+    total,
+    limit,
+    offset,
+    count: paginatedTerms.length,
+    terms: paginatedTerms.map((t) => ({
       id: t.id,
       name: t.name,
       expansion: t.expansion,
@@ -2295,10 +2444,23 @@ async function handleListTerms(args) {
 }
 async function handleListCompanies(args) {
   const context = await getContextInstance(args.contextDirectory);
-  const companies = context.getAllCompanies();
+  let companies = context.getAllCompanies();
+  if (args.search) {
+    const searchLower = args.search.toLowerCase();
+    companies = companies.filter(
+      (c) => c.name.toLowerCase().includes(searchLower) || c.id.toLowerCase().includes(searchLower) || c.sounds_like?.some((s) => s.toLowerCase().includes(searchLower))
+    );
+  }
+  const total = companies.length;
+  const limit = args.limit ?? 50;
+  const offset = args.offset ?? 0;
+  const paginatedCompanies = companies.slice(offset, offset + limit);
   return {
-    count: companies.length,
-    companies: companies.map((c) => ({
+    total,
+    limit,
+    offset,
+    count: paginatedCompanies.length,
+    companies: paginatedCompanies.map((c) => ({
       id: c.id,
       name: c.name,
       fullName: c.fullName,
@@ -2310,10 +2472,17 @@ async function handleListCompanies(args) {
 async function handleSearchContext(args) {
   const context = await getContextInstance(args.contextDirectory);
   const results = context.search(args.query);
+  const total = results.length;
+  const limit = args.limit ?? 50;
+  const offset = args.offset ?? 0;
+  const paginatedResults = results.slice(offset, offset + limit);
   return {
     query: args.query,
-    count: results.length,
-    results: results.map(formatEntity)
+    total,
+    limit,
+    offset,
+    count: paginatedResults.length,
+    results: paginatedResults.map(formatEntity)
   };
 }
 async function handleGetEntity(args) {
@@ -2344,6 +2513,36 @@ async function handleGetEntity(args) {
     filePath
   };
 }
+async function handlePredictEntities(args) {
+  const { resolveTranscriptPath } = await Promise.resolve().then(() => shared);
+  const { Transcript: TranscriptUtils } = await import('@redaksjon/protokoll-engine');
+  const { ensurePklExtension } = TranscriptUtils;
+  const { PklTranscript } = await import('@redaksjon/protokoll-format');
+  const absolutePath = await resolveTranscriptPath(args.transcriptPath, args.contextDirectory);
+  const pklPath = ensurePklExtension(absolutePath);
+  const transcript = PklTranscript.open(pklPath, { readOnly: true });
+  const projectId = transcript.metadata.project;
+  const entities = transcript.metadata.entities || {};
+  const knownEntityIds = [
+    ...(entities.people || []).map((e) => e.id),
+    ...(entities.projects || []).map((e) => e.id),
+    ...(entities.terms || []).map((e) => e.id),
+    ...(entities.companies || []).map((e) => e.id)
+  ];
+  transcript.close();
+  const { getWeightModelService } = await import('./weightModel.js');
+  const service = getWeightModelService();
+  if (!service?.isReady || !service.provider) {
+    return { success: true, predictions: [] };
+  }
+  const predictions = service.provider.predictLikelyEntities({
+    knownEntityIds,
+    projectId,
+    maxPredictions: args.maxPredictions || 10,
+    minScore: args.minScore ?? 1
+  });
+  return { success: true, predictions };
+}
 
 const addPersonTool = {
   name: "protokoll_add_person",
@@ -2898,6 +3097,51 @@ const addCompanyTool = {
     required: ["name"]
   }
 };
+const editCompanyTool = {
+  name: "protokoll_edit_company",
+  description: "Edit an existing company with manual modifications. Can update company details and manage sounds_like variants.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      id: {
+        type: "string",
+        description: "Company ID to edit"
+      },
+      name: {
+        type: "string",
+        description: "Update company name"
+      },
+      fullName: {
+        type: "string",
+        description: "Set full legal name"
+      },
+      industry: {
+        type: "string",
+        description: "Set industry"
+      },
+      sounds_like: {
+        type: "array",
+        items: { type: "string" },
+        description: "Replace entire sounds_like array"
+      },
+      add_sounds_like: {
+        type: "array",
+        items: { type: "string" },
+        description: "Add sounds_like variants"
+      },
+      remove_sounds_like: {
+        type: "array",
+        items: { type: "string" },
+        description: "Remove sounds_like variants"
+      },
+      contextDirectory: {
+        type: "string",
+        description: "Path to the .protokoll context directory"
+      }
+    },
+    required: ["id"]
+  }
+};
 const deleteEntityTool = {
   name: "protokoll_delete_entity",
   description: "Delete an entity from the context. Removes the entity's YAML file from the context directory.",
@@ -3426,6 +3670,47 @@ async function handleAddCompany(args) {
     entity: formatEntity(company)
   };
 }
+async function handleEditCompany(args) {
+  const context = await create({
+    startingDir: args.contextDirectory || process.cwd()
+  });
+  if (!context.hasContext()) {
+    throw new Error("No .protokoll directory found. Initialize context first.");
+  }
+  const existingCompany = findCompanyResilient(context, args.id);
+  const updatedSoundsLike = mergeArray(
+    existingCompany.sounds_like,
+    args.sounds_like,
+    args.add_sounds_like,
+    args.remove_sounds_like
+  );
+  const updatedCompany = {
+    ...existingCompany,
+    ...args.name !== void 0 && { name: args.name },
+    ...args.fullName !== void 0 && { fullName: args.fullName },
+    ...args.industry !== void 0 && { industry: args.industry },
+    updatedAt: /* @__PURE__ */ new Date()
+  };
+  if (updatedSoundsLike !== void 0) {
+    updatedCompany.sounds_like = updatedSoundsLike;
+  } else if (existingCompany.sounds_like && (args.sounds_like !== void 0 || args.remove_sounds_like)) {
+    delete updatedCompany.sounds_like;
+  }
+  await context.saveEntity(updatedCompany, true);
+  const changes = [];
+  if (args.name !== void 0) changes.push(`name: "${args.name}"`);
+  if (args.fullName !== void 0) changes.push(`fullName: "${args.fullName}"`);
+  if (args.industry !== void 0) changes.push(`industry: "${args.industry}"`);
+  if (args.sounds_like !== void 0) changes.push(`sounds_like replaced with ${args.sounds_like.length} items`);
+  if (args.add_sounds_like?.length) changes.push(`added ${args.add_sounds_like.length} sounds_like variants`);
+  if (args.remove_sounds_like?.length) changes.push(`removed ${args.remove_sounds_like.length} sounds_like variants`);
+  return {
+    success: true,
+    message: `Updated company "${existingCompany.name}"`,
+    changes,
+    company: formatEntity(updatedCompany)
+  };
+}
 async function handleDeleteEntity(args) {
   const context = await create({
     startingDir: args.contextDirectory || process.cwd()
@@ -3460,6 +3745,34 @@ async function handleDeleteEntity(args) {
   };
 }
 
+const entityTools = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    addCompanyTool,
+    addPersonTool,
+    addProjectTool,
+    addTermTool,
+    deleteEntityTool,
+    editCompanyTool,
+    editPersonTool,
+    editProjectTool,
+    editTermTool,
+    handleAddCompany,
+    handleAddPerson,
+    handleAddProject,
+    handleAddTerm,
+    handleDeleteEntity,
+    handleEditCompany,
+    handleEditPerson,
+    handleEditProject,
+    handleEditTerm,
+    handleMergeTerms,
+    handleUpdateProject,
+    handleUpdateTerm,
+    mergeTermsTool,
+    updateProjectTool,
+    updateTermTool
+}, Symbol.toStringTag, { value: 'Module' }));
+
 const suggestProjectMetadataTool = {
   name: "protokoll_suggest_project_metadata",
   description: "Generate project metadata suggestions without creating the project. Returns sounds_like (phonetic variants for transcription), explicit_phrases (content-matching trigger phrases), topics and description from source content. Useful for interactive workflows where AI assistant presents suggestions for user review before creating the project.",
@@ -3585,6 +3898,15 @@ const listTranscriptsTool = {
         type: "string",
         description: "Search for transcripts containing this text (searches filename and content)"
       },
+      entityId: {
+        type: "string",
+        description: "Filter to transcripts that reference this entity ID"
+      },
+      entityType: {
+        type: "string",
+        enum: ["person", "project", "term", "company"],
+        description: "Entity type to filter by (used with entityId to narrow search)"
+      },
       contextDirectory: {
         type: "string",
         description: "Optional: Path to the .protokoll context directory"
@@ -3835,6 +4157,72 @@ const createNoteTool = {
     required: ["title"]
   }
 };
+const getEnhancementLogTool = {
+  name: "protokoll_get_enhancement_log",
+  description: "Get the enhancement log for a transcript. Returns a timestamped audit trail of enhancement pipeline steps (transcribe, enhance, simple-replace phases). Shows what happened during processing: entities found, corrections applied, tools called, etc.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      transcriptPath: {
+        type: "string",
+        description: 'Transcript URI (preferred) or relative path from output directory. URI format: "protokoll://transcript/2026/2/12-1606-meeting" (no file extension). Path format: "2026/2/12-1606-meeting" or "2026/2/12-1606-meeting.pkl"'
+      },
+      phase: {
+        type: "string",
+        enum: ["transcribe", "enhance", "simple-replace"],
+        description: "Optional: Filter to a specific phase"
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of entries to return (default: 100)"
+      },
+      offset: {
+        type: "number",
+        description: "Number of entries to skip for pagination (default: 0)"
+      },
+      contextDirectory: {
+        type: "string",
+        description: "Optional: Path to the .protokoll context directory"
+      }
+    },
+    required: ["transcriptPath"]
+  }
+};
+const correctToEntityTool = {
+  name: "protokoll_correct_to_entity",
+  description: "Correct misheard text in transcript by mapping to existing or new entity. Atomically updates transcript content, adds misspelling to entity sounds_like array, updates entity references, and logs the correction to enhancement_log. This is the primary mechanism for training the transcription system.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      transcriptPath: {
+        type: "string",
+        description: "Path to transcript file"
+      },
+      selectedText: {
+        type: "string",
+        description: "The misheard text to correct"
+      },
+      entityType: {
+        type: "string",
+        enum: ["person", "project", "term", "company"],
+        description: "Type of entity"
+      },
+      entityId: {
+        type: "string",
+        description: "ID of existing entity (for map-to-existing flow)"
+      },
+      entityName: {
+        type: "string",
+        description: "Name of new entity to create (for create-new flow)"
+      },
+      contextDirectory: {
+        type: "string",
+        description: "Path to .protokoll context directory"
+      }
+    },
+    required: ["transcriptPath", "selectedText", "entityType"]
+  }
+};
 async function handleReadTranscript(args) {
   const absolutePath = await resolveTranscriptPath$1(args.transcriptPath, args.contextDirectory);
   const transcriptData = await readTranscript(absolutePath);
@@ -3875,6 +4263,8 @@ async function handleListTranscripts(args) {
     startDate: args.startDate,
     endDate: args.endDate,
     search: args.search
+    // entityId: args.entityId,
+    // entityType: args.entityType,
   });
   const outputDirectory = await getConfiguredDirectory("outputDirectory", args.contextDirectory);
   const relativeTranscripts = await Promise.all(
@@ -3904,7 +4294,9 @@ async function handleListTranscripts(args) {
       sortBy: args.sortBy ?? "date",
       startDate: args.startDate,
       endDate: args.endDate,
-      search: args.search
+      search: args.search,
+      entityId: args.entityId,
+      entityType: args.entityType
     }
   };
 }
@@ -4155,11 +4547,16 @@ async function handleUpdateTranscriptEntityReferences(args) {
   };
   const pklPath = ensurePklExtension(absolutePath);
   const transcript = PklTranscript.open(pklPath, { readOnly: false });
+  const transcriptUuid = transcript.metadata.id;
+  const projectId = transcript.metadata.project;
   try {
     transcript.updateMetadata({ entities });
   } finally {
     transcript.close();
   }
+  const { updateTranscriptInWeightModel } = await import('./weightModel.js');
+  const allEntityIds = entityReferences.map((e) => e.id);
+  updateTranscriptInWeightModel(transcriptUuid, allEntityIds, projectId);
   const outputDirectory = await getConfiguredDirectory("outputDirectory", args.contextDirectory);
   const relativePath = await sanitizePath(pklPath, outputDirectory);
   return {
@@ -4291,6 +4688,206 @@ async function handleCreateNote(args) {
     message: `Note "${args.title}" created successfully`
   };
 }
+async function handleGetEnhancementLog(args) {
+  const absolutePath = await resolveTranscriptPath$1(args.transcriptPath, args.contextDirectory);
+  const transcript = PklTranscript.open(absolutePath, { readOnly: true });
+  try {
+    const allEntries = [];
+    const limit = args.limit ?? 100;
+    const offset = args.offset ?? 0;
+    const total = allEntries.length;
+    const entries = allEntries.slice(offset, offset + limit);
+    const serializedEntries = entries.map((entry) => ({
+      id: entry.id,
+      timestamp: entry.timestamp.toISOString(),
+      phase: entry.phase,
+      action: entry.action,
+      details: entry.details,
+      entities: entry.entities
+    }));
+    return {
+      entries: serializedEntries,
+      total,
+      limit,
+      offset,
+      hasMore: offset + limit < total
+    };
+  } finally {
+    transcript.close();
+  }
+}
+function applyCorrections(transcriptText, corrections) {
+  let correctedText = transcriptText;
+  for (const [original, corrected] of corrections) {
+    if (original !== corrected && corrected.trim() !== "") {
+      const regex = new RegExp(original.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "gi");
+      correctedText = correctedText.replace(regex, corrected);
+    }
+  }
+  return correctedText;
+}
+async function handleCorrectToEntity(args) {
+  const context = await create({ startingDir: args.contextDirectory || process.cwd() });
+  const absolutePath = await resolveTranscriptPath$1(args.transcriptPath, args.contextDirectory);
+  const pklPath = ensurePklExtension(absolutePath);
+  let finalEntityId;
+  let finalEntityName;
+  let isNewEntity = false;
+  if (args.entityName) {
+    const EntityTools2 = await Promise.resolve().then(() => entityTools);
+    const createArgs = { name: args.entityName, contextDirectory: args.contextDirectory };
+    try {
+      let result;
+      switch (args.entityType) {
+        case "person":
+          result = await EntityTools2.handleAddPerson(createArgs);
+          break;
+        case "project":
+          result = await EntityTools2.handleAddProject(createArgs);
+          break;
+        case "term":
+          result = await EntityTools2.handleAddTerm({ term: args.entityName, contextDirectory: args.contextDirectory });
+          break;
+        case "company":
+          result = await EntityTools2.handleAddCompany(createArgs);
+          break;
+      }
+      finalEntityId = result.entity.id;
+      finalEntityName = result.entity.name;
+      isNewEntity = true;
+    } catch (error) {
+      const match = error.message?.match(/ID\s+["']([^"']+)["']\s+already exists/i);
+      if (match) {
+        finalEntityId = match[1];
+        const { findPersonResilient, findProjectResilient, findTermResilient, findCompanyResilient } = await import('@redaksjon/protokoll-engine');
+        let entity;
+        switch (args.entityType) {
+          case "person":
+            entity = findPersonResilient(context, finalEntityId);
+            break;
+          case "project":
+            entity = findProjectResilient(context, finalEntityId);
+            break;
+          case "term":
+            entity = findTermResilient(context, finalEntityId);
+            break;
+          case "company":
+            entity = findCompanyResilient(context, finalEntityId);
+            break;
+        }
+        finalEntityName = entity.name;
+      } else {
+        throw error;
+      }
+    }
+  } else if (args.entityId) {
+    finalEntityId = args.entityId;
+    const { findPersonResilient, findProjectResilient, findTermResilient, findCompanyResilient } = await import('@redaksjon/protokoll-engine');
+    let entity;
+    switch (args.entityType) {
+      case "person":
+        entity = findPersonResilient(context, finalEntityId);
+        break;
+      case "project":
+        entity = findProjectResilient(context, finalEntityId);
+        break;
+      case "term":
+        entity = findTermResilient(context, finalEntityId);
+        break;
+      case "company":
+        entity = findCompanyResilient(context, finalEntityId);
+        break;
+    }
+    finalEntityName = entity.name;
+  } else {
+    throw new Error("Either entityId or entityName must be provided");
+  }
+  const transcript = PklTranscript.open(pklPath, { readOnly: false });
+  const originalContent = transcript.content;
+  const corrections = /* @__PURE__ */ new Map([[args.selectedText, finalEntityName]]);
+  const correctedContent = applyCorrections(originalContent, corrections);
+  transcript.updateContent(correctedContent);
+  const EntityTools = await Promise.resolve().then(() => entityTools);
+  const editArgs = {
+    id: finalEntityId,
+    add_sounds_like: [args.selectedText],
+    contextDirectory: args.contextDirectory
+  };
+  switch (args.entityType) {
+    case "person":
+      await EntityTools.handleEditPerson(editArgs);
+      break;
+    case "project":
+      await EntityTools.handleEditProject(editArgs);
+      break;
+    case "term":
+      await EntityTools.handleEditTerm(editArgs);
+      break;
+    case "company":
+      await EntityTools.handleEditCompany(editArgs);
+      break;
+  }
+  const entities = transcript.metadata.entities || { people: [], projects: [], terms: [], companies: [] };
+  const entityRef = { id: finalEntityId, name: finalEntityName, type: args.entityType };
+  let entityArray;
+  switch (args.entityType) {
+    case "person":
+      entityArray = entities.people || [];
+      if (!entityArray.some((e) => e.id === finalEntityId)) {
+        entities.people = [...entityArray, entityRef];
+      }
+      break;
+    case "project":
+      entityArray = entities.projects || [];
+      if (!entityArray.some((e) => e.id === finalEntityId)) {
+        entities.projects = [...entityArray, entityRef];
+      }
+      break;
+    case "term":
+      entityArray = entities.terms || [];
+      if (!entityArray.some((e) => e.id === finalEntityId)) {
+        entities.terms = [...entityArray, entityRef];
+      }
+      break;
+    case "company":
+      entityArray = entities.companies || [];
+      if (!entityArray.some((e) => e.id === finalEntityId)) {
+        entities.companies = [...entityArray, entityRef];
+      }
+      break;
+  }
+  transcript.updateMetadata({ entities });
+  transcript.enhancementLog.logStep(
+    /* @__PURE__ */ new Date(),
+    "user-correction",
+    // Type will be correct after protokoll-format link
+    "correction_applied",
+    {
+      original: args.selectedText,
+      replacement: finalEntityName,
+      entityId: finalEntityId,
+      entityType: args.entityType,
+      isNewEntity
+    },
+    [{ id: finalEntityId, name: finalEntityName, type: args.entityType }]
+  );
+  transcript.close();
+  const allEntityIds = [
+    ...(entities.people || []).map((e) => e.id),
+    ...(entities.projects || []).map((e) => e.id),
+    ...(entities.terms || []).map((e) => e.id),
+    ...(entities.companies || []).map((e) => e.id)
+  ];
+  const { updateTranscriptInWeightModel } = await import('./weightModel.js');
+  updateTranscriptInWeightModel(transcript.metadata.id, allEntityIds, transcript.metadata.project);
+  return {
+    success: true,
+    message: `Corrected "${args.selectedText}" to "${finalEntityName}"`,
+    correction: { original: args.selectedText, replacement: finalEntityName },
+    entity: { id: finalEntityId, name: finalEntityName, type: args.entityType },
+    isNewEntity
+  };
+}
 
 const getVersionTool = {
   name: "protokoll_get_version",
@@ -5127,6 +5724,307 @@ async function handleDeleteTask(args) {
   }
 }
 
+const {
+  findUploadedTranscripts,
+  findTranscribingTranscripts,
+  resetTranscriptToUploaded,
+  findTranscriptByUuid
+} = Transcript;
+let workerInstance = null;
+function setWorkerInstance(worker) {
+  workerInstance = worker;
+}
+const queueStatusTool = {
+  name: "protokoll_queue_status",
+  description: "Get current upload queue status - pending transcriptions, processing, and recent completions. Shows what audio files are waiting to be transcribed and which are currently being processed.",
+  inputSchema: {
+    type: "object",
+    properties: {}
+  }
+};
+const getTranscriptByUuidTool = {
+  name: "protokoll_get_transcript_by_uuid",
+  description: "Get transcript metadata and status by UUID. Accepts either full UUID or 8-character prefix. Useful for checking upload status after receiving UUID from upload endpoint.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      uuid: {
+        type: "string",
+        description: "UUID or 8-character UUID prefix"
+      },
+      includeContent: {
+        type: "boolean",
+        description: "Include transcript content (default: false). Only works for transcripts in initial/enhanced/reviewed status."
+      }
+    },
+    required: ["uuid"]
+  }
+};
+const retryTranscriptionTool = {
+  name: "protokoll_retry_transcription",
+  description: "Retry a failed transcription by resetting status from error to uploaded. The transcript will be re-queued for processing.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      uuid: {
+        type: "string",
+        description: "UUID of transcript to retry"
+      }
+    },
+    required: ["uuid"]
+  }
+};
+const cancelTranscriptionTool = {
+  name: "protokoll_cancel_transcription",
+  description: "Cancel a pending or processing transcription. Optionally delete the PKL file.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      uuid: {
+        type: "string",
+        description: "UUID of transcript to cancel"
+      },
+      deleteFile: {
+        type: "boolean",
+        description: "Also delete the PKL file (default: false)"
+      }
+    },
+    required: ["uuid"]
+  }
+};
+const workerStatusTool = {
+  name: "protokoll_worker_status",
+  description: "Get background transcription worker status and statistics. Shows if worker is running, current task, total processed, and uptime.",
+  inputSchema: {
+    type: "object",
+    properties: {}
+  }
+};
+const restartWorkerTool = {
+  name: "protokoll_restart_worker",
+  description: "Restart the background transcription worker. Useful if worker is stuck or needs to reload configuration.",
+  inputSchema: {
+    type: "object",
+    properties: {}
+  }
+};
+function getTranscribingStartTime(metadata) {
+  if (!metadata.history || metadata.history.length === 0) {
+    return metadata.date?.toISOString() || "";
+  }
+  const transcribingTransition = metadata.history.filter((h) => h.to === "transcribing").sort((a, b) => b.at.getTime() - a.at.getTime())[0];
+  return transcribingTransition?.at.toISOString() || metadata.date?.toISOString() || "";
+}
+function getCompletionTime(metadata) {
+  if (!metadata.history || metadata.history.length === 0) {
+    return "";
+  }
+  const lastTransition = metadata.history.sort((a, b) => b.at.getTime() - a.at.getTime())[0];
+  return lastTransition?.at.toISOString() || "";
+}
+async function findRecentTranscripts(searchDirectories, limit) {
+  const results = [];
+  const oneDayAgo = new Date(Date.now() - 24 * 60 * 60 * 1e3);
+  const { glob } = await import('glob');
+  for (const dir of searchDirectories) {
+    const files = await glob("????????-*.pkl", { cwd: dir, absolute: true });
+    for (const file of files) {
+      try {
+        const transcript = PklTranscript.open(file, { readOnly: true });
+        const metadata = transcript.metadata;
+        const recentlyCompleted = metadata.history?.some(
+          (h) => h.at >= oneDayAgo && ["initial", "enhanced", "reviewed", "error"].includes(h.to)
+        );
+        if (recentlyCompleted) {
+          results.push({
+            uuid: metadata.id,
+            filePath: file,
+            metadata
+          });
+        }
+        await transcript.close();
+      } catch (error) {
+        console.warn(`Failed to open transcript ${file}:`, error);
+      }
+    }
+  }
+  results.sort((a, b) => {
+    const aTime = a.metadata.history?.[a.metadata.history.length - 1]?.at.getTime() || 0;
+    const bTime = b.metadata.history?.[b.metadata.history.length - 1]?.at.getTime() || 0;
+    return bTime - aTime;
+  });
+  return results.slice(0, limit);
+}
+async function handleQueueStatus() {
+  const outputDir = getOutputDirectory();
+  const uploaded = await findUploadedTranscripts([outputDir]);
+  const transcribing = await findTranscribingTranscripts([outputDir]);
+  const recent = await findRecentTranscripts([outputDir], 10);
+  return {
+    pending: uploaded.map((t) => ({
+      uuid: t.uuid,
+      filename: t.metadata.audioFile || "unknown",
+      uploadedAt: t.metadata.date?.toISOString() || ""
+    })),
+    processing: transcribing.map((t) => ({
+      uuid: t.uuid,
+      filename: t.metadata.audioFile || "unknown",
+      startedAt: getTranscribingStartTime(t.metadata)
+    })),
+    recent: recent.map((t) => ({
+      uuid: t.uuid,
+      filename: t.metadata.audioFile || t.metadata.title || "unknown",
+      completedAt: getCompletionTime(t.metadata),
+      status: t.metadata.status || "unknown"
+    })),
+    totalPending: uploaded.length
+  };
+}
+async function handleGetTranscriptByUuid(args) {
+  try {
+    const outputDir = getOutputDirectory();
+    const filePath = await findTranscriptByUuid(args.uuid, [outputDir]);
+    if (!filePath) {
+      return { found: false, error: `No transcript found for UUID: ${args.uuid}` };
+    }
+    const transcript = PklTranscript.open(filePath, { readOnly: true });
+    const metadata = transcript.metadata;
+    const result = {
+      found: true,
+      uuid: metadata.id,
+      filePath: await sanitizePath(filePath, outputDir),
+      metadata
+    };
+    if (args.includeContent && ["initial", "enhanced", "reviewed"].includes(metadata.status || "")) {
+      result.content = transcript.content || "";
+    }
+    await transcript.close();
+    return result;
+  } catch (error) {
+    return { found: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function handleRetryTranscription(args) {
+  try {
+    const outputDir = getOutputDirectory();
+    const filePath = await findTranscriptByUuid(args.uuid, [outputDir]);
+    if (!filePath) {
+      return {
+        success: false,
+        message: "",
+        error: `No transcript found for UUID: ${args.uuid}`
+      };
+    }
+    const transcript = PklTranscript.open(filePath, { readOnly: true });
+    const metadata = transcript.metadata;
+    await transcript.close();
+    if (metadata.status !== "error") {
+      return {
+        success: false,
+        message: "",
+        error: `Transcript is not in error status (current: ${metadata.status})`
+      };
+    }
+    await resetTranscriptToUploaded(filePath);
+    return {
+      success: true,
+      message: `Transcript ${args.uuid} reset to uploaded status and re-queued`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: "",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function handleCancelTranscription(args) {
+  try {
+    const outputDir = getOutputDirectory();
+    const filePath = await findTranscriptByUuid(args.uuid, [outputDir]);
+    if (!filePath) {
+      return {
+        success: false,
+        message: "",
+        error: `No transcript found for UUID: ${args.uuid}`
+      };
+    }
+    const transcript = PklTranscript.open(filePath, { readOnly: true });
+    const metadata = transcript.metadata;
+    await transcript.close();
+    if (!["uploaded", "transcribing"].includes(metadata.status || "")) {
+      return {
+        success: false,
+        message: "",
+        error: `Cannot cancel transcript in ${metadata.status} status. Only uploaded/transcribing can be cancelled.`
+      };
+    }
+    if (args.deleteFile) {
+      await unlink(filePath);
+      return {
+        success: true,
+        message: `Transcript ${args.uuid} cancelled and file deleted`
+      };
+    } else {
+      const transcriptToUpdate = PklTranscript.open(filePath);
+      transcriptToUpdate.updateMetadata({
+        status: "error",
+        errorDetails: "Cancelled by user"
+      });
+      await transcriptToUpdate.close();
+      return {
+        success: true,
+        message: `Transcript ${args.uuid} cancelled (marked as error)`
+      };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      message: "",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function handleWorkerStatus() {
+  if (!workerInstance) {
+    return {
+      isRunning: false,
+      totalProcessed: 0,
+      uptime: 0
+    };
+  }
+  return {
+    isRunning: workerInstance.isActive(),
+    currentTask: workerInstance.getCurrentTask(),
+    totalProcessed: workerInstance.getProcessedCount(),
+    lastProcessed: workerInstance.getLastProcessedTime(),
+    uptime: workerInstance.getUptime()
+  };
+}
+async function handleRestartWorker() {
+  if (!workerInstance) {
+    return {
+      success: false,
+      message: "",
+      error: "Worker not initialized"
+    };
+  }
+  try {
+    await workerInstance.stop();
+    await workerInstance.start();
+    return {
+      success: true,
+      message: "Worker restarted successfully"
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: "",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
 const tools = [
   // System Information
   getVersionTool,
@@ -5145,6 +6043,7 @@ const tools = [
   listCompaniesTool,
   searchContextTool,
   getEntityTool,
+  predictEntitiesTool,
   // Entity CRUD
   addPersonTool,
   editPersonTool,
@@ -5156,6 +6055,7 @@ const tools = [
   updateTermTool,
   mergeTermsTool,
   addCompanyTool,
+  editCompanyTool,
   deleteEntityTool,
   // Relationship Management
   addRelationshipTool,
@@ -5180,11 +6080,20 @@ const tools = [
   updateTranscriptContentTool,
   updateTranscriptEntityReferencesTool,
   createNoteTool,
+  getEnhancementLogTool,
+  correctToEntityTool,
   // Lifecycle Status & Tasks
   setStatusTool,
   createTaskTool,
   completeTaskTool,
-  deleteTaskTool
+  deleteTaskTool,
+  // Queue Management
+  queueStatusTool,
+  getTranscriptByUuidTool,
+  retryTranscriptionTool,
+  cancelTranscriptionTool,
+  workerStatusTool,
+  restartWorkerTool
 ];
 async function handleToolCall(name, args) {
   switch (name) {
@@ -5218,6 +6127,8 @@ async function handleToolCall(name, args) {
       return handleSearchContext(args);
     case "protokoll_get_entity":
       return handleGetEntity(args);
+    case "protokoll_predict_entities":
+      return handlePredictEntities(args);
     // Entity CRUD
     case "protokoll_add_person":
       return handleAddPerson(args);
@@ -5239,6 +6150,8 @@ async function handleToolCall(name, args) {
       return handleMergeTerms(args);
     case "protokoll_add_company":
       return handleAddCompany(args);
+    case "protokoll_edit_company":
+      return handleEditCompany(args);
     case "protokoll_delete_entity":
       return handleDeleteEntity(args);
     // Smart Assistance
@@ -5283,6 +6196,10 @@ async function handleToolCall(name, args) {
       return handleUpdateTranscriptEntityReferences(args);
     case "protokoll_create_note":
       return handleCreateNote(args);
+    case "protokoll_get_enhancement_log":
+      return handleGetEnhancementLog(args);
+    case "protokoll_correct_to_entity":
+      return handleCorrectToEntity(args);
     // Lifecycle Status & Tasks
     case "protokoll_set_status":
       return handleSetStatus(args);
@@ -5292,6 +6209,19 @@ async function handleToolCall(name, args) {
       return handleCompleteTask(args);
     case "protokoll_delete_task":
       return handleDeleteTask(args);
+    // Queue Management
+    case "protokoll_queue_status":
+      return handleQueueStatus();
+    case "protokoll_get_transcript_by_uuid":
+      return handleGetTranscriptByUuid(args);
+    case "protokoll_retry_transcription":
+      return handleRetryTranscription(args);
+    case "protokoll_cancel_transcription":
+      return handleCancelTranscription(args);
+    case "protokoll_worker_status":
+      return handleWorkerStatus();
+    case "protokoll_restart_worker":
+      return handleRestartWorker();
     default:
       throw new Error(`Unknown tool: ${name}`);
   }
@@ -5391,5 +6321,5 @@ async function initializeWorkingDirectoryFromArgsAndConfig() {
   }
 }
 
-export { DEFAULT_CONFIG_FILE as D, handleListResources as a, handleReadResource as b, getPrompt as c, initializeServerConfig as d, getCachedRoots as e, getServerConfig as f, getPrompts as g, handleToolCall as h, initializeWorkingDirectoryFromArgsAndConfig as i, getContext as j, serverConfig$1 as k, loadCardigantimeConfig as l, setRoots as s, tools as t, uri as u };
+export { DEFAULT_CONFIG_FILE as D, handleListResources as a, handleReadResource as b, getPrompt as c, initializeServerConfig as d, getCachedRoots as e, getServerConfig as f, getPrompts as g, handleToolCall as h, initializeWorkingDirectoryFromArgsAndConfig as i, getContext as j, getOutputDirectory as k, loadCardigantimeConfig as l, setWorkerInstance as m, serverConfig$1 as n, setRoots as s, tools as t, uri as u };
 //# sourceMappingURL=configDiscovery.js.map