@redaksjon/protokoll 1.0.2 → 1.0.8

package/dist/mcp/server.js

@@ -2,11 +2,11 @@
 import 'dotenv/config';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { ListRootsRequestSchema, ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { fileURLToPath } from 'node:url';
-import { resolve, dirname } from 'node:path';
-import { readFile, stat, mkdir, writeFile, unlink } from 'node:fs/promises';
-import { q as create, B as listTranscripts, d as create$1, c as create$2, g as getLogger, i as DEFAULT_OUTPUT_DIRECTORY, l as DEFAULT_OUTPUT_STRUCTURE, k as DEFAULT_OUTPUT_FILENAME_OPTIONS, p as create$3, w as DEFAULT_TRANSCRIPTION_MODEL, v as DEFAULT_MODEL, C as DEFAULT_TEMP_DIRECTORY, b as DEFAULT_MAX_AUDIO_SIZE, e as DEFAULT_INTERMEDIATE_DIRECTORY, D as DEFAULT_REASONING_LEVEL, r as create$4, E as create$6, F as create$8, G as processFeedback, H as applyChanges, I as combineTranscripts, J as editTranscript, K as parseTranscript, P as PROGRAM_NAME, V as VERSION } from '../transcript.js';
+import { resolve, extname, join, dirname, basename } from 'node:path';
+import { q as create, B as listTranscripts, m as DEFAULT_AUDIO_EXTENSIONS, d as create$1, c as create$2, g as getLogger, l as DEFAULT_OUTPUT_STRUCTURE, k as DEFAULT_OUTPUT_FILENAME_OPTIONS, p as create$3, w as DEFAULT_TRANSCRIPTION_MODEL, v as DEFAULT_MODEL, C as DEFAULT_TEMP_DIRECTORY, b as DEFAULT_MAX_AUDIO_SIZE, e as DEFAULT_INTERMEDIATE_DIRECTORY, D as DEFAULT_REASONING_LEVEL, r as create$4, E as create$6, F as create$8, G as processFeedback, H as applyChanges, I as combineTranscripts, J as editTranscript, K as parseTranscript, P as PROGRAM_NAME, V as VERSION } from '../transcript.js';
+import { readFile, readdir, stat, mkdir, writeFile, unlink } from 'node:fs/promises';
 import * as yaml from 'js-yaml';
 import { readFileSync } from 'node:fs';
 import { glob } from 'glob';
@@ -18,12 +18,12 @@ import 'fs/promises';
 import 'openai';
 import 'fluent-ffmpeg';
 import 'node:os';
-import '@riotprompt/riotprompt';
+import '@kjerneverk/riotprompt';
 import 'zod';
 import 'node:crypto';
 import 'html-to-text';
 import 'commander';
-import '@theunwalked/overcontext';
+import '@utilarium/overcontext';
 import '@redaksjon/context';
 import 'winston';
 
@@ -53,6 +53,8 @@ function parseUri(uri) {
     case "entities":
     case "entities-list":
       return parseEntitiesListUri(uri, segments, params);
+    case "audio":
+      return parseAudioUri(uri, segments, params);
     default:
       throw new Error(`Unknown resource type: ${firstSegment}`);
   }
@@ -135,6 +137,27 @@ function parseEntitiesListUri(uri, segments, params) {
     entityType
   };
 }
+function parseAudioUri(uri, segments, params) {
+  const audioType = segments[1];
+  if (audioType === "inbound") {
+    return {
+      scheme: SCHEME,
+      resourceType: "audio-inbound",
+      path: "audio/inbound",
+      params,
+      directory: params.directory
+    };
+  } else if (audioType === "processed") {
+    return {
+      scheme: SCHEME,
+      resourceType: "audio-processed",
+      path: "audio/processed",
+      params,
+      directory: params.directory
+    };
+  }
+  throw new Error(`Invalid audio URI: ${uri}. Expected protokoll://audio/inbound or protokoll://audio/processed`);
+}
 function buildTranscriptUri(transcriptPath) {
   const encoded = encodeURIComponent(transcriptPath).replace(/%2F/g, "/");
   return `${SCHEME}://transcript/${encoded}`;
@@ -160,6 +183,18 @@ function buildTranscriptsListUri(options) {
 function buildEntitiesListUri(entityType) {
   return `${SCHEME}://entities/${entityType}`;
 }
+function buildAudioInboundUri(directory) {
+  if (directory) {
+    return `${SCHEME}://audio/inbound?directory=${encodeURIComponent(directory)}`;
+  }
+  return `${SCHEME}://audio/inbound`;
+}
+function buildAudioProcessedUri(directory) {
+  if (directory) {
+    return `${SCHEME}://audio/processed?directory=${encodeURIComponent(directory)}`;
+  }
+  return `${SCHEME}://audio/processed`;
+}
 
 const directResources = [
   // Will be populated dynamically based on context
@@ -194,15 +229,21 @@ const resourceTemplates = [
     name: "Entities List",
     description: "List of entities of a given type",
     mimeType: "application/json"
+  },
+  {
+    uriTemplate: "protokoll://audio/inbound?directory={directory}",
+    name: "Inbound Audio Files",
+    description: "List of audio files waiting to be processed",
+    mimeType: "application/json"
+  },
+  {
+    uriTemplate: "protokoll://audio/processed?directory={directory}",
+    name: "Processed Audio Files",
+    description: "List of audio files that have been processed",
+    mimeType: "application/json"
   }
 ];
-async function handleListResources(contextDirectory) {
-  const dynamicResources = await getDynamicResources(contextDirectory);
-  return {
-    resources: [...directResources, ...dynamicResources],
-    resourceTemplates
-  };
-}
+
 async function getDynamicResources(contextDirectory) {
   const resources = [];
   try {
@@ -212,6 +253,7 @@ async function getDynamicResources(contextDirectory) {
     if (!context.hasContext()) {
       return resources;
     }
+    const config = context.getConfig();
     const dirs = context.getDiscoveredDirs();
     const configPath = dirs[0]?.path;
     if (configPath) {
@@ -222,37 +264,72 @@ async function getDynamicResources(contextDirectory) {
         mimeType: "application/json"
       });
     }
-  } catch {
-  }
-  return resources;
-}
-async function handleReadResource(uri) {
-  const parsed = parseUri(uri);
-  switch (parsed.resourceType) {
-    case "transcript":
-      return readTranscriptResource(parsed.transcriptPath);
-    case "entity": {
-      const entityUri = parsed;
-      return readEntityResource(entityUri.entityType, entityUri.entityId);
+    const inputDirectory = config.inputDirectory || "./recordings";
+    resources.push({
+      uri: buildAudioInboundUri(inputDirectory),
+      name: "Inbound Audio Files",
+      description: `Audio files waiting to be processed in ${inputDirectory}`,
+      mimeType: "application/json"
+    });
+    const processedDirectory = config.processedDirectory;
+    if (processedDirectory) {
+      resources.push({
+        uri: buildAudioProcessedUri(processedDirectory),
+        name: "Processed Audio Files",
+        description: `Audio files that have been processed in ${processedDirectory}`,
+        mimeType: "application/json"
+      });
     }
-    case "config":
-      return readConfigResource(parsed.configPath);
-    case "transcripts-list": {
-      const listUri = parsed;
-      return readTranscriptsListResource({
-        directory: listUri.directory,
-        startDate: listUri.startDate,
-        endDate: listUri.endDate,
-        limit: listUri.limit,
-        offset: listUri.offset
+    const entityCounts = {
+      projects: context.getAllProjects().length,
+      people: context.getAllPeople().length,
+      terms: context.getAllTerms().length,
+      companies: context.getAllCompanies().length
+    };
+    if (entityCounts.projects > 0) {
+      resources.push({
+        uri: buildEntitiesListUri("project"),
+        name: "All Projects",
+        description: `${entityCounts.projects} project(s) in context`,
+        mimeType: "application/json"
       });
     }
-    case "entities-list":
-      return readEntitiesListResource(parsed.entityType);
-    default:
-      throw new Error(`Unknown resource type: ${parsed.resourceType}`);
+    if (entityCounts.people > 0) {
+      resources.push({
+        uri: buildEntitiesListUri("person"),
+        name: "All People",
+        description: `${entityCounts.people} person/people in context`,
+        mimeType: "application/json"
+      });
+    }
+    if (entityCounts.terms > 0) {
+      resources.push({
+        uri: buildEntitiesListUri("term"),
+        name: "All Terms",
+        description: `${entityCounts.terms} term(s) in context`,
+        mimeType: "application/json"
+      });
+    }
+    if (entityCounts.companies > 0) {
+      resources.push({
+        uri: buildEntitiesListUri("company"),
+        name: "All Companies",
+        description: `${entityCounts.companies} company/companies in context`,
+        mimeType: "application/json"
+      });
+    }
+    const outputDirectory = config.outputDirectory || "~/notes";
+    resources.push({
+      uri: buildTranscriptsListUri({ directory: outputDirectory, limit: 10 }),
+      name: "Recent Transcripts",
+      description: `10 most recent transcripts in ${outputDirectory}`,
+      mimeType: "application/json"
+    });
+  } catch {
   }
+  return resources;
 }
+
 async function readTranscriptResource(transcriptPath) {
   const fullPath = transcriptPath.startsWith("/") ? transcriptPath : resolve(process.cwd(), transcriptPath);
   try {
@@ -269,84 +346,6 @@ async function readTranscriptResource(transcriptPath) {
     throw error;
   }
 }
-async function readEntityResource(entityType, entityId, contextDirectory) {
-  const context = await create({
-    startingDir: process.cwd()
-  });
-  let entity;
-  switch (entityType) {
-    case "person":
-      entity = context.getPerson(entityId);
-      break;
-    case "project":
-      entity = context.getProject(entityId);
-      break;
-    case "term":
-      entity = context.getTerm(entityId);
-      break;
-    case "company":
-      entity = context.getCompany(entityId);
-      break;
-    case "ignored":
-      entity = context.getIgnored(entityId);
-      break;
-    default:
-      throw new Error(`Unknown entity type: ${entityType}`);
-  }
-  if (!entity) {
-    throw new Error(`${entityType} "${entityId}" not found`);
-  }
-  const yamlContent = yaml.dump(entity);
-  return {
-    uri: buildEntityUri(entityType, entityId),
-    mimeType: "application/yaml",
-    text: yamlContent
-  };
-}
-async function readConfigResource(configPath) {
-  const startDir = configPath || process.cwd();
-  const context = await create({
-    startingDir: startDir
-  });
-  if (!context.hasContext()) {
-    throw new Error(`No Protokoll context found at or above: ${startDir}`);
-  }
-  const dirs = context.getDiscoveredDirs();
-  const config = context.getConfig();
-  const configData = {
-    hasContext: true,
-    discoveredDirectories: dirs.map((d) => ({
-      path: d.path,
-      level: d.level,
-      isPrimary: d.level === 0
-    })),
-    entityCounts: {
-      projects: context.getAllProjects().length,
-      people: context.getAllPeople().length,
-      terms: context.getAllTerms().length,
-      companies: context.getAllCompanies().length,
-      ignored: context.getAllIgnored().length
-    },
-    config: {
-      outputDirectory: config.outputDirectory,
-      outputStructure: config.outputStructure,
-      model: config.model,
-      smartAssistance: context.getSmartAssistanceConfig()
-    },
-    // Include URIs for easy navigation
-    resourceUris: {
-      projects: buildEntitiesListUri("project"),
-      people: buildEntitiesListUri("person"),
-      terms: buildEntitiesListUri("term"),
-      companies: buildEntitiesListUri("company")
-    }
-  };
-  return {
-    uri: buildConfigUri(configPath),
-    mimeType: "application/json",
-    text: JSON.stringify(configData, null, 2)
-  };
-}
 async function readTranscriptsListResource(options) {
   const { directory, startDate, endDate, limit = 50, offset = 0 } = options;
   if (!directory) {
@@ -388,6 +387,41 @@ async function readTranscriptsListResource(options) {
     text: JSON.stringify(responseData, null, 2)
   };
 }
+
+async function readEntityResource(entityType, entityId, contextDirectory) {
+  const context = await create({
+    startingDir: process.cwd()
+  });
+  let entity;
+  switch (entityType) {
+    case "person":
+      entity = context.getPerson(entityId);
+      break;
+    case "project":
+      entity = context.getProject(entityId);
+      break;
+    case "term":
+      entity = context.getTerm(entityId);
+      break;
+    case "company":
+      entity = context.getCompany(entityId);
+      break;
+    case "ignored":
+      entity = context.getIgnored(entityId);
+      break;
+    default:
+      throw new Error(`Unknown entity type: ${entityType}`);
+  }
+  if (!entity) {
+    throw new Error(`${entityType} "${entityId}" not found`);
+  }
+  const yamlContent = yaml.dump(entity);
+  return {
+    uri: buildEntityUri(entityType, entityId),
+    mimeType: "application/yaml",
+    text: yamlContent
+  };
+}
 async function readEntitiesListResource(entityType, contextDirectory) {
   const context = await create({
     startingDir: process.cwd()
@@ -456,6 +490,190 @@ async function readEntitiesListResource(entityType, contextDirectory) {
   };
 }
 
+async function listAudioFiles(directory) {
+  const dirPath = resolve(directory);
+  try {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    const audioFiles = [];
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        const ext = extname(entry.name).toLowerCase().substring(1);
+        if (DEFAULT_AUDIO_EXTENSIONS.includes(ext)) {
+          const filePath = join(dirPath, entry.name);
+          const stats = await stat(filePath);
+          audioFiles.push({
+            filename: entry.name,
+            path: filePath,
+            size: stats.size,
+            modified: stats.mtime.toISOString(),
+            extension: ext
+          });
+        }
+      }
+    }
+    audioFiles.sort(
+      (a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime()
+    );
+    return audioFiles;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+}
+async function readAudioInboundResource(directory) {
+  const context = await create({
+    startingDir: directory || process.cwd()
+  });
+  if (!context.hasContext()) {
+    throw new Error("No Protokoll context found");
+  }
+  const config = context.getConfig();
+  const inputDirectory = directory || config.inputDirectory || "./recordings";
+  const audioFiles = await listAudioFiles(inputDirectory);
+  const responseData = {
+    directory: resolve(inputDirectory),
+    count: audioFiles.length,
+    totalSize: audioFiles.reduce((sum, f) => sum + f.size, 0),
+    files: audioFiles.map((f) => ({
+      filename: f.filename,
+      path: f.path,
+      size: f.size,
+      sizeHuman: formatBytes(f.size),
+      modified: f.modified,
+      extension: f.extension
+    })),
+    supportedExtensions: DEFAULT_AUDIO_EXTENSIONS
+  };
+  return {
+    uri: buildAudioInboundUri(inputDirectory),
+    mimeType: "application/json",
+    text: JSON.stringify(responseData, null, 2)
+  };
+}
+async function readAudioProcessedResource(directory) {
+  const context = await create({
+    startingDir: directory || process.cwd()
+  });
+  if (!context.hasContext()) {
+    throw new Error("No Protokoll context found");
+  }
+  const config = context.getConfig();
+  const processedDirectory = directory || config.processedDirectory || "./processed";
+  const audioFiles = await listAudioFiles(processedDirectory);
+  const responseData = {
+    directory: resolve(processedDirectory),
+    count: audioFiles.length,
+    totalSize: audioFiles.reduce((sum, f) => sum + f.size, 0),
+    files: audioFiles.map((f) => ({
+      filename: f.filename,
+      path: f.path,
+      size: f.size,
+      sizeHuman: formatBytes(f.size),
+      modified: f.modified,
+      extension: f.extension
+    })),
+    supportedExtensions: DEFAULT_AUDIO_EXTENSIONS
+  };
+  return {
+    uri: buildAudioProcessedUri(processedDirectory),
+    mimeType: "application/json",
+    text: JSON.stringify(responseData, null, 2)
+  };
+}
+
+async function readConfigResource(configPath) {
+  const startDir = configPath || process.cwd();
+  const context = await create({
+    startingDir: startDir
+  });
+  if (!context.hasContext()) {
+    throw new Error(`No Protokoll context found at or above: ${startDir}`);
+  }
+  const dirs = context.getDiscoveredDirs();
+  const config = context.getConfig();
+  const configData = {
+    hasContext: true,
+    discoveredDirectories: dirs.map((d) => ({
+      path: d.path,
+      level: d.level,
+      isPrimary: d.level === 0
+    })),
+    entityCounts: {
+      projects: context.getAllProjects().length,
+      people: context.getAllPeople().length,
+      terms: context.getAllTerms().length,
+      companies: context.getAllCompanies().length,
+      ignored: context.getAllIgnored().length
+    },
+    config: {
+      outputDirectory: config.outputDirectory,
+      outputStructure: config.outputStructure,
+      model: config.model,
+      smartAssistance: context.getSmartAssistanceConfig()
+    },
+    // Include URIs for easy navigation
+    resourceUris: {
+      projects: buildEntitiesListUri("project"),
+      people: buildEntitiesListUri("person"),
+      terms: buildEntitiesListUri("term"),
+      companies: buildEntitiesListUri("company")
+    }
+  };
+  return {
+    uri: buildConfigUri(configPath),
+    mimeType: "application/json",
+    text: JSON.stringify(configData, null, 2)
+  };
+}
+
+async function handleListResources(contextDirectory) {
+  const dynamicResources = await getDynamicResources(contextDirectory);
+  return {
+    resources: [...directResources, ...dynamicResources],
+    resourceTemplates
+  };
+}
+async function handleReadResource(uri) {
+  const parsed = parseUri(uri);
+  switch (parsed.resourceType) {
+    case "transcript":
+      return readTranscriptResource(parsed.transcriptPath);
+    case "entity": {
+      const entityUri = parsed;
+      return readEntityResource(entityUri.entityType, entityUri.entityId);
+    }
+    case "config":
+      return readConfigResource(parsed.configPath);
+    case "transcripts-list": {
+      const listUri = parsed;
+      return readTranscriptsListResource({
+        directory: listUri.directory,
+        startDate: listUri.startDate,
+        endDate: listUri.endDate,
+        limit: listUri.limit,
+        offset: listUri.offset
+      });
+    }
+    case "entities-list":
+      return readEntitiesListResource(parsed.entityType);
+    case "audio-inbound":
+      return readAudioInboundResource(parsed.directory);
+    case "audio-processed":
+      return readAudioProcessedResource(parsed.directory);
+    default:
+      throw new Error(`Unknown resource type: ${parsed.resourceType}`);
+  }
+}
+
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = dirname(__filename$1);
 function getPromptsDir() {
@@ -898,6 +1116,17 @@ async function fileExists(path) {
     return false;
   }
 }
+async function getConfiguredDirectory(key, _contextDirectory) {
+  const ServerConfig = await Promise.resolve().then(() => serverConfig$1);
+  switch (key) {
+    case "inputDirectory":
+      return ServerConfig.getInputDirectory();
+    case "outputDirectory":
+      return ServerConfig.getOutputDirectory();
+    case "processedDirectory":
+      return ServerConfig.getProcessedDirectory() || resolve(process.cwd(), "./processed");
+  }
+}
 function slugify(text) {
   return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/--+/g, "-").replace(/^-|-$/g, "");
 }
@@ -1151,19 +1380,46 @@ async function handleSuggestProject(args) {
   };
 }
 
+async function findAudioFile(filenameOrPath) {
+  if (filenameOrPath.startsWith("/") && await fileExists(filenameOrPath)) {
+    return filenameOrPath;
+  }
+  const inputDirectory = await getConfiguredDirectory("inputDirectory");
+  const entries = await readdir(inputDirectory, { withFileTypes: true });
+  const matches = [];
+  for (const entry of entries) {
+    if (entry.isFile()) {
+      const filename = entry.name;
+      const ext = filename.split(".").pop()?.toLowerCase();
+      if (ext && DEFAULT_AUDIO_EXTENSIONS.includes(ext)) {
+        if (filename === filenameOrPath || filename.includes(filenameOrPath) || basename(filename, `.${ext}`) === filenameOrPath) {
+          matches.push(join(inputDirectory, filename));
+        }
+      }
+    }
+  }
+  if (matches.length === 0) {
+    throw new Error(
+      `No audio file found matching "${filenameOrPath}" in ${inputDirectory}. Try using the protokoll://audio/inbound resource to see available audio files.`
+    );
+  }
+  if (matches.length === 1) {
+    return matches[0];
+  }
+  const matchNames = matches.map((m) => basename(m)).join(", ");
+  throw new Error(
+    `Multiple audio files match "${filenameOrPath}": ${matchNames}. Please be more specific.`
+  );
+}
 const processAudioTool = {
   name: "protokoll_process_audio",
-  description: "Process an audio file through Protokoll's intelligent transcription pipeline. IMPORTANT: Before calling this, use protokoll_discover_config or protokoll_suggest_project to understand which configuration/project should be used. This tool transcribes audio using Whisper, then enhances it with context-aware processing that corrects names, terms, and routes the output to the appropriate project folder. If no contextDirectory is specified, the tool walks up from the audio file to find .protokoll. Returns the enhanced transcript text and output file path.",
+  description: "Process an audio file through Protokoll's intelligent transcription pipeline. You can provide either an absolute path OR just a filename/partial filename. If you provide a filename, it will search in the workspace's configured input directory. This tool uses workspace-level configuration automatically - no need to specify directories. Transcribes audio using Whisper, then enhances it with context-aware processing that corrects names, terms, and routes the output to the appropriate project folder. Returns the enhanced transcript text and output file path.",
   inputSchema: {
     type: "object",
     properties: {
       audioFile: {
         type: "string",
-        description: "Absolute path to the audio file to process (m4a, mp3, wav, webm, etc.)"
-      },
-      contextDirectory: {
-        type: "string",
-        description: "Path to the .protokoll context directory. If not specified, walks up from the audio file location to find one."
+        description: 'Filename, partial filename, or absolute path to the audio file. Examples: "recording.m4a", "2026-01-29", "/full/path/to/audio.m4a"'
       },
       projectId: {
         type: "string",
@@ -1171,7 +1427,7 @@ const processAudioTool = {
       },
       outputDirectory: {
         type: "string",
-        description: "Override the default output directory"
+        description: "Override the workspace output directory"
       },
       model: {
         type: "string",
@@ -1187,44 +1443,40 @@ const processAudioTool = {
 };
 const batchProcessTool = {
   name: "protokoll_batch_process",
-  description: "Process multiple audio files in a directory. Finds all audio files matching the configured extensions and processes them sequentially. Returns a summary of all processed files with their output paths.",
+  description: "Process multiple audio files in a directory. If no directory is specified, uses the workspace's configured input directory. This tool uses workspace-level configuration automatically - no need to specify directories. Finds all audio files matching the configured extensions and processes them sequentially. Returns a summary of all processed files with their output paths.",
   inputSchema: {
     type: "object",
     properties: {
       inputDirectory: {
         type: "string",
-        description: "Absolute path to directory containing audio files"
+        description: "Optional: Directory containing audio files. If not specified, uses the workspace input directory."
       },
       extensions: {
         type: "array",
         items: { type: "string" },
         description: 'Audio file extensions to process (default: [".m4a", ".mp3", ".wav", ".webm"])'
       },
-      contextDirectory: {
-        type: "string",
-        description: "Path to the .protokoll context directory"
-      },
       outputDirectory: {
         type: "string",
-        description: "Override the default output directory"
+        description: "Override the workspace output directory"
       }
     },
-    required: ["inputDirectory"]
+    required: []
   }
 };
 async function handleProcessAudio(args) {
-  const audioFile = resolve(args.audioFile);
-  if (!await fileExists(audioFile)) {
-    throw new Error(`Audio file not found: ${audioFile}`);
-  }
-  const context = await create({
-    startingDir: args.contextDirectory || dirname(audioFile)
-  });
-  const config = context.getConfig();
-  const outputDirectory = args.outputDirectory || config.outputDirectory || DEFAULT_OUTPUT_DIRECTORY;
-  const outputStructure = config.outputStructure || DEFAULT_OUTPUT_STRUCTURE;
-  const outputFilenameOptions = config.outputFilenameOptions || DEFAULT_OUTPUT_FILENAME_OPTIONS;
-  const processedDirectory = config.processedDirectory || void 0;
+  const ServerConfig = await Promise.resolve().then(() => serverConfig$1);
+  const audioFile = await findAudioFile(args.audioFile);
+  const config = ServerConfig.getServerConfig();
+  const context = config.context;
+  if (!context) {
+    throw new Error("Protokoll context not available. Ensure .protokoll directory exists in workspace.");
+  }
+  const contextConfig = context.getConfig();
+  const outputDirectory = args.outputDirectory || config.outputDirectory;
+  const outputStructure = contextConfig.outputStructure || DEFAULT_OUTPUT_STRUCTURE;
+  const outputFilenameOptions = contextConfig.outputFilenameOptions || DEFAULT_OUTPUT_FILENAME_OPTIONS;
+  const processedDirectory = config.processedDirectory ?? void 0;
   const { creationTime, hash } = await getAudioMetadata(audioFile);
   const pipeline = await create$3({
     model: args.model || DEFAULT_MODEL,
@@ -1236,13 +1488,13 @@ async function handleProcessAudio(args) {
     silent: true,
     debug: false,
     dryRun: false,
-    contextDirectory: args.contextDirectory,
+    contextDirectory: config.workspaceRoot || void 0,
     intermediateDir: DEFAULT_INTERMEDIATE_DIRECTORY,
     keepIntermediates: false,
     outputDirectory,
     outputStructure,
     outputFilenameOptions,
-    processedDirectory,
+    processedDirectory: processedDirectory || void 0,
     maxAudioSize: DEFAULT_MAX_AUDIO_SIZE,
     tempDirectory: DEFAULT_TEMP_DIRECTORY
   });
@@ -1263,7 +1515,7 @@ async function handleProcessAudio(args) {
   };
 }
 async function handleBatchProcess(args) {
-  const inputDir = resolve(args.inputDirectory);
+  const inputDir = args.inputDirectory ? resolve(args.inputDirectory) : await getConfiguredDirectory("inputDirectory");
   const extensions = args.extensions || [".m4a", ".mp3", ".wav", ".webm"];
   if (!await fileExists(inputDir)) {
     throw new Error(`Input directory not found: ${inputDir}`);
@@ -1279,7 +1531,6 @@ async function handleBatchProcess(args) {
     try {
       const result = await handleProcessAudio({
         audioFile: file,
-        contextDirectory: args.contextDirectory,
         outputDirectory: args.outputDirectory
       });
       processed.push(result);
@@ -2184,7 +2435,7 @@ async function handleEditPerson(args) {
   } else if (existingPerson.sounds_like && (args.sounds_like !== void 0 || args.remove_sounds_like)) {
     delete updatedPerson.sounds_like;
   }
-  await context.saveEntity(updatedPerson);
+  await context.saveEntity(updatedPerson, true);
   const changes = [];
   if (args.name !== void 0) changes.push(`name: "${args.name}"`);
   if (args.firstName !== void 0) changes.push(`firstName: "${args.firstName}"`);
@@ -2398,7 +2649,7 @@ async function handleEditProject(args) {
       updatedProject.relationships.relatedTerms = updatedRelatedTerms;
     }
   }
-  await context.saveEntity(updatedProject);
+  await context.saveEntity(updatedProject, true);
   const changes = [];
   if (args.name !== void 0) changes.push(`name: "${args.name}"`);
   if (args.description !== void 0) changes.push(`description updated`);
@@ -2465,7 +2716,7 @@ async function handleUpdateProject(args) {
     },
     updatedAt: /* @__PURE__ */ new Date()
   };
-  await context.saveEntity(updatedProject);
+  await context.saveEntity(updatedProject, true);
   return {
     success: true,
     message: `Updated project "${existingProject.name}" from source`,
@@ -2558,7 +2809,7 @@ async function handleEditTerm(args) {
   } else if (existingTerm.projects && (args.projects !== void 0 || args.remove_projects)) {
     delete updatedTerm.projects;
   }
-  await context.saveEntity(updatedTerm);
+  await context.saveEntity(updatedTerm, true);
   const changes = [];
   if (args.expansion !== void 0) changes.push(`expansion: "${args.expansion}"`);
   if (args.domain !== void 0) changes.push(`domain: "${args.domain}"`);
@@ -2629,7 +2880,7 @@ async function handleUpdateTerm(args) {
     const projects = termContextHelper.findProjectsByTopic(suggestions.topics);
     suggestedProjects = projects.map((p) => p.id);
   }
-  await context.saveEntity(updatedTerm);
+  await context.saveEntity(updatedTerm, true);
   return {
     success: true,
     message: `Updated term "${existingTerm.name}" from source`,
@@ -2876,15 +3127,48 @@ async function handleSuggestTermMetadata(args) {
   };
 }
 
+async function findTranscript(filenameOrPath, contextDirectory) {
+  if (filenameOrPath.startsWith("/") && await fileExists(filenameOrPath)) {
+    return filenameOrPath;
+  }
+  const outputDirectory = await getConfiguredDirectory("outputDirectory");
+  const result = await listTranscripts({
+    directory: outputDirectory,
+    search: filenameOrPath,
+    limit: 10
+  });
+  if (result.transcripts.length === 0) {
+    throw new Error(
+      `No transcript found matching "${filenameOrPath}" in ${outputDirectory}. Try using protokoll_list_transcripts to see available transcripts.`
+    );
+  }
+  if (result.transcripts.length === 1) {
+    return result.transcripts[0].path;
+  }
+  const exactMatch = result.transcripts.find(
+    (t) => t.filename === filenameOrPath || t.filename.includes(filenameOrPath)
+  );
+  if (exactMatch) {
+    return exactMatch.path;
+  }
+  const matches = result.transcripts.map((t) => t.filename).join(", ");
+  throw new Error(
+    `Multiple transcripts match "${filenameOrPath}": ${matches}. Please be more specific.`
+  );
+}
 const readTranscriptTool = {
   name: "protokoll_read_transcript",
-  description: "Read a transcript file and parse its metadata and content. Returns structured data including title, metadata, routing info, and content.",
+  description: "Read a transcript file and parse its metadata and content. You can provide either an absolute path OR just a filename/partial filename. If you provide a filename, it will search in the configured output directory. Returns structured data including title, metadata, routing info, and content.",
   inputSchema: {
     type: "object",
     properties: {
       transcriptPath: {
         type: "string",
-        description: "Absolute path to the transcript file"
+        description: 'Filename, partial filename, or absolute path to the transcript. Examples: "meeting-notes.md", "2026-01-29", "/full/path/to/transcript.md"'
+      },
+      contextDirectory: {
+        type: "string",
+        description: "Optional: Path to the .protokoll context directory"
       }
     },
     required: ["transcriptPath"]
@@ -2892,13 +3176,13 @@ const readTranscriptTool = {
 };
 const listTranscriptsTool = {
   name: "protokoll_list_transcripts",
-  description: "List transcripts in a directory with pagination, filtering, and search. Returns transcript metadata including date, time, title, and file path. Supports sorting by date (default), filename, or title. Can filter by date range and search within transcript content.",
+  description: "List transcripts with pagination, filtering, and search. If no directory is specified, uses the configured output directory. Returns transcript metadata including date, time, title, and file path. Supports sorting by date (default), filename, or title. Can filter by date range and search within transcript content.",
   inputSchema: {
     type: "object",
     properties: {
       directory: {
         type: "string",
-        description: "Directory to search for transcripts (searches recursively)"
+        description: "Optional: Directory to search for transcripts (searches recursively). If not specified, uses the configured output directory."
       },
       limit: {
         type: "number",
@@ -2927,20 +3211,24 @@ const listTranscriptsTool = {
       search: {
         type: "string",
         description: "Search for transcripts containing this text (searches filename and content)"
+      },
+      contextDirectory: {
+        type: "string",
+        description: "Optional: Path to the .protokoll context directory"
       }
     },
-    required: ["directory"]
+    required: []
   }
 };
 const editTranscriptTool = {
   name: "protokoll_edit_transcript",
-  description: "Edit an existing transcript's title and/or project assignment. IMPORTANT: When you change the title, this tool RENAMES THE FILE to match the new title (slugified). Always use this tool instead of directly editing transcript files when changing titles. Changing the project will update metadata and may move the file to a new location based on the project's routing configuration.",
+  description: "Edit an existing transcript's title and/or project assignment. You can provide either an absolute path OR just a filename/partial filename. IMPORTANT: When you change the title, this tool RENAMES THE FILE to match the new title (slugified). Always use this tool instead of directly editing transcript files when changing titles. Changing the project will update metadata and may move the file to a new location based on the project's routing configuration.",
   inputSchema: {
     type: "object",
     properties: {
       transcriptPath: {
         type: "string",
-        description: "Absolute path to the transcript file"
+        description: 'Filename, partial filename, or absolute path to the transcript. Examples: "meeting-notes.md", "2026-01-29", "/full/path/to/transcript.md"'
       },
       title: {
         type: "string",
@@ -2952,7 +3240,7 @@ const editTranscriptTool = {
       },
       contextDirectory: {
         type: "string",
-        description: "Path to the .protokoll context directory"
+        description: "Optional: Path to the .protokoll context directory"
       }
     },
     required: ["transcriptPath"]
@@ -2960,14 +3248,14 @@ const editTranscriptTool = {
 };
 const combineTranscriptsTool = {
   name: "protokoll_combine_transcripts",
-  description: "Combine multiple transcripts into a single document. Source files are automatically deleted after combining. Metadata from the first transcript is preserved, and content is organized into sections.",
+  description: "Combine multiple transcripts into a single document. You can provide absolute paths OR filenames/partial filenames. Source files are automatically deleted after combining. Metadata from the first transcript is preserved, and content is organized into sections.",
   inputSchema: {
     type: "object",
     properties: {
       transcriptPaths: {
         type: "array",
         items: { type: "string" },
-        description: "Array of transcript file paths to combine"
+        description: 'Array of filenames, partial filenames, or absolute paths. Examples: ["meeting-1.md", "meeting-2.md"] or ["2026-01-29", "2026-01-30"]'
       },
       title: {
         type: "string",
@@ -2979,7 +3267,7 @@ const combineTranscriptsTool = {
       },
       contextDirectory: {
         type: "string",
-        description: "Path to the .protokoll context directory"
+        description: "Optional: Path to the .protokoll context directory"
       }
     },
     required: ["transcriptPaths"]
@@ -2987,13 +3275,13 @@ const combineTranscriptsTool = {
 };
 const provideFeedbackTool = {
   name: "protokoll_provide_feedback",
-  description: 'Provide natural language feedback to correct a transcript. The feedback is processed by an agentic model that can: - Fix spelling and term errors - Add new terms, people, or companies to context - Change project assignment - Update the title Example: "YB should be Wibey" or "San Jay Grouper is actually Sanjay Gupta"',
+  description: 'Provide natural language feedback to correct a transcript. You can provide either an absolute path OR just a filename/partial filename. The feedback is processed by an agentic model that can: - Fix spelling and term errors - Add new terms, people, or companies to context - Change project assignment - Update the title Example: "YB should be Wibey" or "San Jay Grouper is actually Sanjay Gupta"',
   inputSchema: {
     type: "object",
     properties: {
       transcriptPath: {
         type: "string",
-        description: "Absolute path to the transcript file"
+        description: 'Filename, partial filename, or absolute path to the transcript. Examples: "meeting-notes.md", "2026-01-29", "/full/path/to/transcript.md"'
       },
       feedback: {
         type: "string",
@@ -3005,17 +3293,14 @@ const provideFeedbackTool = {
       },
       contextDirectory: {
         type: "string",
-        description: "Path to the .protokoll context directory"
+        description: "Optional: Path to the .protokoll context directory"
       }
     },
     required: ["transcriptPath", "feedback"]
   }
 };
 async function handleReadTranscript(args) {
-  const transcriptPath = resolve(args.transcriptPath);
-  if (!await fileExists(transcriptPath)) {
-    throw new Error(`Transcript not found: ${transcriptPath}`);
-  }
+  const transcriptPath = await findTranscript(args.transcriptPath, args.contextDirectory);
   const parsed = await parseTranscript(transcriptPath);
   return {
     filePath: transcriptPath,
@@ -3026,7 +3311,7 @@ async function handleReadTranscript(args) {
   };
 }
 async function handleListTranscripts(args) {
-  const directory = resolve(args.directory);
+  const directory = args.directory ? resolve(args.directory) : await getConfiguredDirectory("outputDirectory", args.contextDirectory);
   if (!await fileExists(directory)) {
     throw new Error(`Directory not found: ${directory}`);
   }
@@ -3065,16 +3350,14 @@ async function handleListTranscripts(args) {
   };
 }
 async function handleEditTranscript(args) {
-  const transcriptPath = resolve(args.transcriptPath);
-  if (!await fileExists(transcriptPath)) {
-    throw new Error(`Transcript not found: ${transcriptPath}`);
-  }
+  const transcriptPath = await findTranscript(args.transcriptPath, args.contextDirectory);
   if (!args.title && !args.projectId) {
     throw new Error("Must specify title and/or projectId");
   }
   const result = await editTranscript(transcriptPath, {
     title: args.title,
-    projectId: args.projectId
+    projectId: args.projectId,
+    contextDirectory: args.contextDirectory
   });
   await mkdir(dirname(result.outputPath), { recursive: true });
   await writeFile(result.outputPath, result.content, "utf-8");
@@ -3093,16 +3376,15 @@ async function handleCombineTranscripts(args) {
   if (args.transcriptPaths.length < 2) {
     throw new Error("At least 2 transcript files are required");
   }
+  const resolvedPaths = [];
   for (const path of args.transcriptPaths) {
-    const resolved = resolve(path);
-    if (!await fileExists(resolved)) {
-      throw new Error(`Transcript not found: ${resolved}`);
-    }
+    const resolved = await findTranscript(path, args.contextDirectory);
+    resolvedPaths.push(resolved);
   }
-  const resolvedPaths = args.transcriptPaths.map((p) => resolve(p));
   const result = await combineTranscripts(resolvedPaths, {
     title: args.title,
-    projectId: args.projectId
+    projectId: args.projectId,
+    contextDirectory: args.contextDirectory
   });
   await mkdir(dirname(result.outputPath), { recursive: true });
   await writeFile(result.outputPath, result.content, "utf-8");
@@ -3123,10 +3405,7 @@ async function handleCombineTranscripts(args) {
   };
 }
 async function handleProvideFeedback(args) {
-  const transcriptPath = resolve(args.transcriptPath);
-  if (!await fileExists(transcriptPath)) {
-    throw new Error(`Transcript not found: ${transcriptPath}`);
-  }
+  const transcriptPath = await findTranscript(args.transcriptPath, args.contextDirectory);
   const transcriptContent = await readFile(transcriptPath, "utf-8");
   const context = await create({
     startingDir: args.contextDirectory || dirname(transcriptPath)
@@ -3288,6 +3567,151 @@ async function handleToolCall(name, args) {
   }
 }
 
+let cachedRoots = null;
+function setRoots(roots) {
+  cachedRoots = roots;
+}
+function getCachedRoots() {
+  return cachedRoots;
+}
+function fileUriToPath(uri) {
+  if (!uri.startsWith("file://")) {
+    return null;
+  }
+  try {
+    const url = new URL(uri);
+    return decodeURIComponent(url.pathname);
+  } catch {
+    return null;
+  }
+}
+
+let serverConfig = {
+  context: null,
+  workspaceRoot: null,
+  inputDirectory: null,
+  outputDirectory: null,
+  processedDirectory: null,
+  initialized: false
+};
+async function initializeServerConfig(roots) {
+  const workspaceRoot = roots.length > 0 ? fileUriToPath(roots[0].uri) : null;
+  if (!workspaceRoot) {
+    serverConfig = {
+      context: null,
+      workspaceRoot: process.cwd(),
+      inputDirectory: resolve(process.cwd(), "./recordings"),
+      outputDirectory: resolve(process.cwd(), "./notes"),
+      processedDirectory: resolve(process.cwd(), "./processed"),
+      initialized: true
+    };
+    return;
+  }
+  try {
+    const context = await create({
+      startingDir: workspaceRoot
+    });
+    const config = context.getConfig();
+    serverConfig = {
+      context,
+      workspaceRoot,
+      inputDirectory: resolveDirectory(config.inputDirectory, workspaceRoot, "./recordings"),
+      outputDirectory: resolveDirectory(config.outputDirectory, workspaceRoot, "./notes"),
+      processedDirectory: resolveDirectory(config.processedDirectory, workspaceRoot, "./processed"),
+      initialized: true
+    };
+  } catch {
+    serverConfig = {
+      context: null,
+      workspaceRoot,
+      inputDirectory: resolve(workspaceRoot, "./recordings"),
+      outputDirectory: resolve(workspaceRoot, "./notes"),
+      processedDirectory: resolve(workspaceRoot, "./processed"),
+      initialized: true
+    };
+  }
+}
+async function reloadServerConfig(roots) {
+  await initializeServerConfig(roots);
+}
+function clearServerConfig() {
+  serverConfig = {
+    context: null,
+    workspaceRoot: null,
+    inputDirectory: null,
+    outputDirectory: null,
+    processedDirectory: null,
+    initialized: false
+  };
+}
+function getServerConfig() {
+  if (!serverConfig.initialized) {
+    throw new Error("Server configuration not initialized. Call initializeServerConfig() first.");
+  }
+  return {
+    context: serverConfig.context,
+    workspaceRoot: serverConfig.workspaceRoot,
+    inputDirectory: serverConfig.inputDirectory,
+    outputDirectory: serverConfig.outputDirectory,
+    processedDirectory: serverConfig.processedDirectory,
+    initialized: serverConfig.initialized
+  };
+}
+function getContext() {
+  return serverConfig.context;
+}
+function getWorkspaceRoot() {
+  return serverConfig.workspaceRoot;
+}
+function getInputDirectory() {
+  if (!serverConfig.initialized || !serverConfig.inputDirectory) {
+    return resolve(process.cwd(), "./recordings");
+  }
+  return serverConfig.inputDirectory;
+}
+function getOutputDirectory() {
+  if (!serverConfig.initialized || !serverConfig.outputDirectory) {
+    return resolve(process.cwd(), "./notes");
+  }
+  return serverConfig.outputDirectory;
+}
+function getProcessedDirectory() {
+  if (!serverConfig.initialized) {
+    return null;
+  }
+  return serverConfig.processedDirectory;
+}
+function isInitialized() {
+  return serverConfig.initialized;
+}
+function resolveDirectory(configValue, workspaceRoot, defaultRelative) {
+  if (configValue) {
+    if (configValue.startsWith("~")) {
+      const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+      return resolve(homeDir, configValue.substring(1));
+    }
+    if (configValue.startsWith("/")) {
+      return configValue;
+    }
+    return resolve(workspaceRoot, configValue);
+  }
+  return resolve(workspaceRoot, defaultRelative);
+}
+
+const serverConfig$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    clearServerConfig,
+    getContext,
+    getInputDirectory,
+    getOutputDirectory,
+    getProcessedDirectory,
+    getServerConfig,
+    getWorkspaceRoot,
+    initializeServerConfig,
+    isInitialized,
+    reloadServerConfig
+}, Symbol.toStringTag, { value: 'Module' }));
+
 async function main() {
   const server = new Server(
     {
@@ -3308,6 +3732,10 @@ async function main() {
       }
     }
   );
+  server.setRequestHandler(ListRootsRequestSchema, async () => {
+    const roots = getCachedRoots() || [];
+    return { roots };
+  });
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools
   }));
@@ -3354,6 +3782,13 @@ async function main() {
   });
   const transport = new StdioServerTransport();
   await server.connect(transport);
+  const workspaceRoot = process.env.WORKSPACE_ROOT || process.cwd();
+  const initialRoots = [{
+    uri: `file://${workspaceRoot}`,
+    name: "Workspace"
+  }];
+  setRoots(initialRoots);
+  await initializeServerConfig(initialRoots);
   await new Promise(() => {
   });
 }