@redaksjon/protokoll 1.0.0 → 1.0.2

package/dist/transcript.js

@@ -2,23 +2,26 @@ import * as readline from 'readline';
 import { spawn } from 'child_process';
 import * as path from 'node:path';
 import path__default from 'node:path';
-import * as fs$1 from 'fs/promises';
+import * as fs$2 from 'fs/promises';
 import OpenAI$1, { OpenAI } from 'openai';
 import ffmpeg from 'fluent-ffmpeg';
 import * as os from 'node:os';
 import os__default from 'node:os';
+import { IterationStrategyFactory, ToolRegistry, ConversationBuilder } from '@riotprompt/riotprompt';
+import { z } from 'zod';
 import * as fs from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
 import { glob } from 'glob';
 import crypto from 'node:crypto';
-import * as fs$2 from 'node:fs/promises';
+import * as fs$1 from 'node:fs/promises';
 import { htmlToText } from 'html-to-text';
 import { Command } from 'commander';
+import { discoverOvercontext, discoverContextRoot } from '@theunwalked/overcontext';
+import { redaksjonPluralNames, redaksjonSchemas } from '@redaksjon/context';
 import * as yaml from 'js-yaml';
-import { existsSync, statSync } from 'fs';
 import winston from 'winston';
-import { IterationStrategyFactory } from '@riotprompt/riotprompt';
 
-const VERSION = "1.0.0 (HEAD/9fe7b5f T:v1.0.0 2026-01-24 09:49:02 -0800) linux x64 v24.13.0";
+const VERSION = "1.0.2 (HEAD/bcca7ab T:v1.0.2 2026-01-28 09:24:52 -0800) linux x64 v24.13.0";
 const PROGRAM_NAME = "protokoll";
 const DEFAULT_DIFF = true;
 const DEFAULT_LOG = false;
@@ -242,216 +245,168 @@ const create$w = (params) => {
   };
 };
 
-const isParentProject = (projectA, projectB) => {
-  return projectB.relationships?.parent === projectA.id;
-};
-const isChildProject = (projectA, projectB) => {
-  return projectA.relationships?.parent === projectB.id;
-};
-const areSiblingProjects = (projectA, projectB) => {
-  const aSiblings = projectA.relationships?.siblings || [];
-  const bSiblings = projectB.relationships?.siblings || [];
-  return aSiblings.includes(projectB.id) || bSiblings.includes(projectA.id);
-};
-const getProjectRelationshipDistance = (projectA, projectB) => {
-  if (projectA.id === projectB.id) return 0;
-  if (isParentProject(projectA, projectB) || isChildProject(projectA, projectB)) return 1;
-  if (areSiblingProjects(projectA, projectB)) return 2;
-  if (projectA.relationships?.parent && projectB.relationships?.parent && projectA.relationships.parent === projectB.relationships.parent) {
-    return 2;
-  }
-  return -1;
+const protokollDiscoveryOptions = {
+  contextDirName: ".protokoll/context",
+  maxLevels: 10
 };
 
-const DIRECTORY_TO_TYPE = {
-  "people": "person",
-  "projects": "project",
-  "companies": "company",
-  "terms": "term",
-  "ignored": "ignored"
-};
 const TYPE_TO_DIRECTORY = {
-  "person": "people",
-  "project": "projects",
-  "company": "companies",
-  "term": "terms",
-  "ignored": "ignored"
+  person: "people",
+  project: "projects",
+  company: "companies",
+  term: "terms",
+  ignored: "ignored"
 };
 const create$v = () => {
-  const entities = /* @__PURE__ */ new Map([
-    ["person", /* @__PURE__ */ new Map()],
-    ["project", /* @__PURE__ */ new Map()],
-    ["company", /* @__PURE__ */ new Map()],
-    ["term", /* @__PURE__ */ new Map()],
-    ["ignored", /* @__PURE__ */ new Map()]
-  ]);
-  const load = async (contextDirs) => {
-    for (const contextDir of contextDirs) {
-      for (const dirName of Object.keys(DIRECTORY_TO_TYPE)) {
-        const typeDir = path.join(contextDir, dirName);
-        const entityType = DIRECTORY_TO_TYPE[dirName];
-        try {
-          const files = await fs$1.readdir(typeDir);
-          for (const file of files) {
-            if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
-            const content = await fs$1.readFile(path.join(typeDir, file), "utf-8");
-            const parsed = yaml.load(content);
-            if (parsed && parsed.id) {
-              entities.get(entityType)?.set(parsed.id, {
-                ...parsed,
-                type: entityType
-              });
-            }
-          }
-        } catch {
-        }
+  const cache = /* @__PURE__ */ new Map();
+  let api;
+  let loadedContextDirs = [];
+  const initCache = () => {
+    cache.set("person", /* @__PURE__ */ new Map());
+    cache.set("project", /* @__PURE__ */ new Map());
+    cache.set("company", /* @__PURE__ */ new Map());
+    cache.set("term", /* @__PURE__ */ new Map());
+    cache.set("ignored", /* @__PURE__ */ new Map());
+  };
+  initCache();
+  return {
+    async load(contextDirs) {
+      initCache();
+      loadedContextDirs = contextDirs;
+      if (contextDirs.length === 0) {
+        api = void 0;
+        return;
       }
-    }
-  };
-  const save = async (entity, targetDir) => {
-    const dirName = TYPE_TO_DIRECTORY[entity.type];
-    const dirPath = path.join(targetDir, "context", dirName);
-    await fs$1.mkdir(dirPath, { recursive: true });
-    const filePath = path.join(dirPath, `${entity.id}.yaml`);
-    const { type: _entityType, ...entityWithoutType } = entity;
-    const content = yaml.dump(entityWithoutType, { lineWidth: -1 });
-    await fs$1.writeFile(filePath, content, "utf-8");
-    entities.get(entity.type)?.set(entity.id, entity);
-  };
-  const deleteEntity = async (type, id, targetDir) => {
-    const dirName = TYPE_TO_DIRECTORY[type];
-    const possiblePaths = [
-      path.join(targetDir, dirName, `${id}.yaml`),
-      path.join(targetDir, dirName, `${id}.yml`),
-      path.join(targetDir, "context", dirName, `${id}.yaml`),
-      path.join(targetDir, "context", dirName, `${id}.yml`)
-    ];
-    for (const filePath of possiblePaths) {
       try {
-        await fs$1.unlink(filePath);
-        entities.get(type)?.delete(id);
-        return true;
-      } catch {
-      }
-    }
-    return false;
-  };
-  const getEntityFilePath = (type, id, contextDirs) => {
-    const dirName = TYPE_TO_DIRECTORY[type];
-    for (const contextDir of [...contextDirs].reverse()) {
-      const possiblePaths = [
-        path.join(contextDir, dirName, `${id}.yaml`),
-        path.join(contextDir, dirName, `${id}.yml`)
-      ];
-      for (const filePath of possiblePaths) {
-        if (existsSync(filePath)) {
-          const stat = statSync(filePath);
-          if (stat.isFile()) {
-            return filePath;
+        const lastContextDir = contextDirs[contextDirs.length - 1];
+        const protokollDir = lastContextDir.replace(/\/context$/, "");
+        const startDir = protokollDir.replace(/\/\.protokoll$/, "");
+        api = await discoverOvercontext({
+          schemas: redaksjonSchemas,
+          pluralNames: redaksjonPluralNames,
+          startDir,
+          ...protokollDiscoveryOptions
+        });
+        for (const type of ["person", "project", "company", "term", "ignored"]) {
+          const entities = await api.getAll(type);
+          for (const entity of entities) {
+            cache.get(type)?.set(entity.id, entity);
           }
         }
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("No context directory found")) {
+          api = void 0;
+        } else {
+          throw error;
+        }
       }
-    }
-    return void 0;
-  };
-  const get = (type, id) => {
-    return entities.get(type)?.get(id);
-  };
-  const getAll = (type) => {
-    return Array.from(entities.get(type)?.values() ?? []);
-  };
-  const search = (query) => {
-    const normalizedQuery = query.toLowerCase();
-    const results = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const entityMap of entities.values()) {
-      for (const entity of entityMap.values()) {
-        let matched = false;
-        if (entity.name.toLowerCase().includes(normalizedQuery)) {
-          matched = true;
+    },
+    async save(entity, _targetDir) {
+      if (!api) {
+        const existing = cache.get(entity.type)?.get(entity.id);
+        if (existing) {
+          throw new Error(`Entity with id "${entity.id}" already exists`);
         }
-        if (!matched) {
-          const entityWithSoundsLike = entity;
-          const variants = entityWithSoundsLike.sounds_like;
-          if (variants?.some((v) => v.toLowerCase().includes(normalizedQuery))) {
-            matched = true;
+        cache.get(entity.type)?.set(entity.id, entity);
+        return;
+      }
+      const saved = await api.upsert(entity.type, entity);
+      cache.get(entity.type)?.set(saved.id, saved);
+    },
+    async delete(type, id, _targetDir) {
+      if (!api) return false;
+      const deleted = await api.delete(type, id);
+      if (deleted) {
+        cache.get(type)?.delete(id);
+      }
+      return deleted;
+    },
+    get(type, id) {
+      return cache.get(type)?.get(id);
+    },
+    getAll(type) {
+      return Array.from(cache.get(type)?.values() ?? []);
+    },
+    search(query) {
+      const normalizedQuery = query.toLowerCase();
+      const results = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const entityMap of cache.values()) {
+        for (const entity of entityMap.values()) {
+          if (seen.has(entity.id)) continue;
+          if (entity.name.toLowerCase().includes(normalizedQuery)) {
+            results.push(entity);
+            seen.add(entity.id);
+            continue;
           }
-        }
-        if (!matched) {
-          const entityWithSoundsLike = entity;
-          const variants = entityWithSoundsLike.sounds_like;
-          if (variants?.some((v) => v.toLowerCase() === normalizedQuery)) {
-            matched = true;
+          const sounds = entity.sounds_like;
+          if (sounds?.some((s) => s.toLowerCase().includes(normalizedQuery))) {
+            results.push(entity);
+            seen.add(entity.id);
           }
         }
-        if (matched && !seen.has(entity.id)) {
-          results.push(entity);
-          seen.add(entity.id);
+      }
+      return results;
+    },
+    findBySoundsLike(phonetic) {
+      const normalized = phonetic.toLowerCase().trim();
+      for (const entityMap of cache.values()) {
+        for (const entity of entityMap.values()) {
+          const sounds = entity.sounds_like;
+          if (sounds?.some((s) => s.toLowerCase() === normalized)) {
+            return entity;
+          }
         }
       }
-    }
-    return results;
-  };
-  const findBySoundsLike = (phonetic) => {
-    const normalized = phonetic.toLowerCase().trim();
-    for (const entityMap of entities.values()) {
-      for (const entity of entityMap.values()) {
-        const entityWithSoundsLike = entity;
-        const variants = entityWithSoundsLike.sounds_like;
-        if (variants?.some((v) => v.toLowerCase() === normalized)) {
-          return entity;
+      return void 0;
+    },
+    clear() {
+      initCache();
+      api = void 0;
+    },
+    getEntityFilePath(type, id, contextDirs) {
+      const dirName = TYPE_TO_DIRECTORY[type];
+      const dirsToSearch = contextDirs.length > 0 ? contextDirs : loadedContextDirs;
+      for (const contextDir of [...dirsToSearch].reverse()) {
+        const possiblePaths = [
+          path.join(contextDir, dirName, `${id}.yaml`),
+          path.join(contextDir, dirName, `${id}.yml`)
+        ];
+        for (const filePath of possiblePaths) {
+          if (existsSync(filePath)) {
+            const stat = statSync(filePath);
+            if (stat.isFile()) {
+              return filePath;
+            }
+          }
         }
       }
-    }
-    return void 0;
-  };
-  const clear = () => {
-    for (const entityMap of entities.values()) {
-      entityMap.clear();
+      return void 0;
     }
   };
-  return { load, save, delete: deleteEntity, get, getAll, search, findBySoundsLike, clear, getEntityFilePath };
 };
 
 const discoverConfigDirectories = async (options) => {
-  const {
-    configDirName,
-    maxLevels = 10,
-    startingDir = process.cwd()
-  } = options;
-  const discovered = [];
-  let currentDir = path.resolve(startingDir);
-  let level = 0;
-  const visited = /* @__PURE__ */ new Set();
-  while (level < maxLevels) {
-    const realPath = path.resolve(currentDir);
-    if (visited.has(realPath)) break;
-    visited.add(realPath);
-    const configDirPath = path.join(currentDir, configDirName);
-    try {
-      const stat = await fs$1.stat(configDirPath);
-      if (stat.isDirectory()) {
-        discovered.push({ path: configDirPath, level });
-      }
-    } catch {
-    }
-    const parentDir = path.dirname(currentDir);
-    if (parentDir === currentDir) break;
-    currentDir = parentDir;
-    level++;
-  }
-  return discovered;
+  const contextRoot = await discoverContextRoot({
+    startDir: options.startingDir || process.cwd(),
+    contextDirName: options.configDirName,
+    maxLevels: options.maxLevels || 10
+  });
+  return contextRoot.directories.map((dir) => ({
+    path: dir.path,
+    level: dir.level
+  }));
 };
 const loadHierarchicalConfig = async (options) => {
-  const discoveredDirs = await discoverConfigDirectories(options);
-  if (discoveredDirs.length === 0) {
+  const discovered = await discoverConfigDirectories(options);
+  if (discovered.length === 0) {
     return {
       config: {},
       discoveredDirs: [],
       contextDirs: []
     };
   }
-  const sortedDirs = [...discoveredDirs].sort((a, b) => b.level - a.level);
+  const sortedDirs = [...discovered].sort((a, b) => b.level - a.level);
   const configs = [];
   const contextDirs = [];
   for (const dir of sortedDirs) {
@@ -474,41 +429,36 @@ const loadHierarchicalConfig = async (options) => {
     }
   }
   const mergedConfig = configs.reduce(
-    (acc, curr) => deepMerge(acc, curr),
+    (acc, curr) => ({ ...acc, ...curr }),
     {}
   );
   return {
     config: mergedConfig,
-    discoveredDirs,
+    discoveredDirs: discovered,
     contextDirs
   };
 };
-function deepMerge(target, source) {
-  if (source === null || source === void 0) return target;
-  if (target === null || target === void 0) return source;
-  if (typeof source !== "object" || typeof target !== "object") {
-    return source;
-  }
-  if (Array.isArray(source)) {
-    return [...source];
-  }
-  const result = { ...target };
-  for (const key in source) {
-    if (Object.prototype.hasOwnProperty.call(source, key)) {
-      const targetVal = result[key];
-      const sourceVal = source[key];
-      if (typeof targetVal === "object" && typeof sourceVal === "object" && targetVal !== null && sourceVal !== null && !Array.isArray(targetVal) && !Array.isArray(sourceVal)) {
-        result[key] = deepMerge(
-          targetVal,
-          sourceVal
-        );
-      } else {
-        result[key] = sourceVal;
-      }
-    }
+
+const isParentProject = (projectA, projectB) => {
+  return projectB.relationships?.parent === projectA.id;
+};
+const isChildProject = (projectA, projectB) => {
+  return projectA.relationships?.parent === projectB.id;
+};
+const areSiblingProjects = (projectA, projectB) => {
+  const aSiblings = projectA.relationships?.siblings || [];
+  const bSiblings = projectB.relationships?.siblings || [];
+  return aSiblings.includes(projectB.id) || bSiblings.includes(projectA.id);
+};
+const getProjectRelationshipDistance = (projectA, projectB) => {
+  if (projectA.id === projectB.id) return 0;
+  if (isParentProject(projectA, projectB) || isChildProject(projectA, projectB)) return 1;
+  if (areSiblingProjects(projectA, projectB)) return 2;
+  if (projectA.relationships?.parent && projectB.relationships?.parent && projectA.relationships.parent === projectB.relationships.parent) {
+    return 2;
   }
-  return result;
-}
+  return -1;
+};
 
 const getSmartAssistanceConfig = (config) => {
   const smartConfig = config.smartAssistance;
@@ -576,10 +526,6 @@ const create$u = async (options = {}) => {
     },
     search: (query) => storage.search(query),
     findBySoundsLike: (phonetic) => storage.findBySoundsLike(phonetic),
-    /**
-     * Context-aware search that prefers entities related to context project.
-     * Still returns standard search results if no context provided.
-     */
     searchWithContext: (query, contextProjectId) => {
       const results = storage.search(query);
       if (!contextProjectId) {
@@ -607,10 +553,6 @@ const create$u = async (options = {}) => {
       });
       return scoredResults.sort((a, b) => b.score - a.score).map((r) => r.entity);
     },
-    /**
-     * Get all projects related to a given project within maxDistance
-     * Distance: 0 = same, 1 = parent/child, 2 = siblings/cousins
-     */
     getRelatedProjects: (projectId, maxDistance = 2) => {
       const project = storage.get("project", projectId);
       if (!project) return [];
@@ -1170,7 +1112,7 @@ const create$p = () => {
           error: `Unsupported file type: ${ext}. Supported: ${supportedExtensions.join(", ")}`
         };
       }
-      let content = await fs$2.readFile(filePath, "utf-8");
+      let content = await fs$1.readFile(filePath, "utf-8");
       if (content.length > MAX_CONTENT_LENGTH) {
         content = content.substring(0, MAX_CONTENT_LENGTH) + "\n\n[Content truncated...]";
       }
@@ -1192,7 +1134,7 @@ const create$p = () => {
   const fetchDirectory = async (dirPath) => {
     logger.debug("Reading directory: %s", dirPath);
     try {
-      const files = await fs$2.readdir(dirPath);
+      const files = await fs$1.readdir(dirPath);
       const priorityFiles = [
         "README.md",
         "readme.md",
@@ -1251,7 +1193,7 @@ const create$p = () => {
         return await fetchUrl(source);
       }
       const resolvedPath = path.resolve(source);
-      const stat = await fs$2.stat(resolvedPath);
+      const stat = await fs$1.stat(resolvedPath);
       if (stat.isDirectory()) {
         return await fetchDirectory(resolvedPath);
       } else {
@@ -2443,9 +2385,9 @@ const create$l = (config) => {
     };
   };
   const ensureDirectories = async (paths) => {
-    await fs$1.mkdir(path.dirname(paths.intermediate.transcript), { recursive: true });
-    await fs$1.mkdir(path.dirname(paths.final), { recursive: true });
-    await fs$1.mkdir(path.dirname(paths.rawTranscript), { recursive: true });
+    await fs$2.mkdir(path.dirname(paths.intermediate.transcript), { recursive: true });
+    await fs$2.mkdir(path.dirname(paths.final), { recursive: true });
+    await fs$2.mkdir(path.dirname(paths.rawTranscript), { recursive: true });
     logger.debug("Ensured output directories", {
       intermediate: path.dirname(paths.intermediate.transcript),
       final: path.dirname(paths.final),
@@ -2458,7 +2400,7 @@ const create$l = (config) => {
       throw new Error(`Invalid intermediate type: ${type}`);
     }
     const contentStr = typeof content === "string" ? content : JSON.stringify(content, null, 2);
-    await fs$1.writeFile(filePath, contentStr, "utf-8");
+    await fs$2.writeFile(filePath, contentStr, "utf-8");
     logger.debug("Wrote intermediate file", { type, path: filePath });
     return filePath;
   };
@@ -2472,7 +2414,7 @@ const create$l = (config) => {
         finalContent = finalContent + entitySection;
       }
     }
-    await fs$1.writeFile(paths.final, finalContent, "utf-8");
+    await fs$2.writeFile(paths.final, finalContent, "utf-8");
     logger.info("Wrote final transcript", { path: paths.final });
     return paths.final;
   };
@@ -2484,7 +2426,7 @@ const create$l = (config) => {
     for (const [type, filePath] of Object.entries(paths.intermediate)) {
       if (filePath) {
         try {
-          await fs$1.unlink(filePath);
+          await fs$2.unlink(filePath);
           logger.debug("Removed intermediate file", { type, path: filePath });
         } catch {
         }
@@ -2493,7 +2435,7 @@ const create$l = (config) => {
   };
   const writeRawTranscript = async (paths, data) => {
     const filePath = paths.rawTranscript;
-    await fs$1.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+    await fs$2.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
     logger.debug("Wrote raw transcript to .transcript/", { path: filePath });
     return filePath;
   };
@@ -2502,7 +2444,7 @@ const create$l = (config) => {
     const finalBasename = path.basename(finalOutputPath, path.extname(finalOutputPath));
     const rawTranscriptPath = path.join(finalDir, ".transcript", `${finalBasename}.json`);
     try {
-      const content = await fs$1.readFile(rawTranscriptPath, "utf-8");
+      const content = await fs$2.readFile(rawTranscriptPath, "utf-8");
       return JSON.parse(content);
     } catch (error) {
       if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
@@ -2928,7 +2870,7 @@ const create$i = (config) => {
   };
   const save = async (report, path) => {
     const content = formatMarkdown(report) ;
-    await fs$1.writeFile(path, content, "utf-8");
+    await fs$2.writeFile(path, content, "utf-8");
     logger.info("Saved reflection report", { path });
   };
   return {
@@ -3913,6 +3855,17 @@ const create$7 = (_ctx) => ({
   }
 });
 
+const toRiotTool = (tool, category) => ({
+  name: tool.name,
+  description: tool.description,
+  parameters: tool.parameters,
+  category,
+  cost: "cheap",
+  execute: async (params) => {
+    const result = await tool.execute(params);
+    return result;
+  }
+});
 const create$6 = (ctx) => {
   const tools = [
     create$b(ctx),
@@ -3922,13 +3875,19 @@ const create$6 = (ctx) => {
     create$7()
   ];
   const toolMap = new Map(tools.map((t) => [t.name, t]));
+  const riotRegistry = ToolRegistry.create();
+  riotRegistry.register(toRiotTool(tools[0], "lookup"));
+  riotRegistry.register(toRiotTool(tools[1], "lookup"));
+  riotRegistry.register(toRiotTool(tools[2], "verification"));
+  riotRegistry.register(toRiotTool(tools[3], "routing"));
+  riotRegistry.register(toRiotTool(tools[4], "storage"));
   return {
     getTools: () => tools,
-    // Return flat tool definitions - reasoning client handles OpenAI formatting
-    getToolDefinitions: () => tools.map((tool) => ({
-      name: tool.name,
-      description: tool.description,
-      parameters: tool.parameters
+    // Use RiotPrompt's OpenAI format export
+    getToolDefinitions: () => riotRegistry.toOpenAIFormat().map((t) => ({
+      name: t.function.name,
+      description: t.function.description,
+      parameters: t.function.parameters
     })),
     executeTool: async (name, args) => {
       const tool = toolMap.get(name);
@@ -3939,20 +3898,36 @@ const create$6 = (ctx) => {
         };
       }
       return tool.execute(args);
-    }
+    },
+    getRiotRegistry: () => riotRegistry
   };
 };
 
+const toRiotToolCalls = (toolCalls) => {
+  return toolCalls.map((tc) => ({
+    id: tc.id,
+    type: "function",
+    function: {
+      name: tc.name,
+      arguments: JSON.stringify(tc.arguments)
+    }
+  }));
+};
 const cleanResponseContent = (content) => {
   let cleaned = content.replace(/^(?:Using tools?|Let me|I'll|I will|Now I'll|First,?\s*I(?:'ll| will)).*?[\r\n]+/gim, "");
-  cleaned = cleaned.replace(/\{"tool":\s*"[^"]+",\s*"input":\s*\{[^}]*\}\}/g, "");
+  cleaned = cleaned.replace(/\{"tool":\s*"[^"]+",\s*"(?:args|input)":\s*\{[^}]*\}\}/g, "");
   cleaned = cleaned.replace(/\b\w+_\w+\(\{[^}]*\}\)/g, "");
+  cleaned = cleaned.replace(/^.*\s+to=\w+\.\w+.*$/gm, "");
+  const spamPattern = /^.*[\u4E00-\u9FFF].*(app|官网|彩票|中彩票).*$/gm;
+  cleaned = cleaned.replace(spamPattern, "");
+  const corruptionStartPattern = /^[\u0530-\u058F\u0E00-\u0E7F\u0A80-\u0AFF\u0C00-\u0C7F].*$/gm;
+  cleaned = cleaned.replace(corruptionStartPattern, "");
   const lines = cleaned.split("\n");
   let startIndex = 0;
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i].trim();
     if (line === "") continue;
-    const isCommentary = /^(checking|verifying|looking|searching|analyzing|processing|determining|using|calling|executing|I'm|I am|Let me)/i.test(line) || line.includes("tool") || line.includes('{"') || line.includes("reasoning");
+    const isCommentary = /^(checking|verifying|looking|searching|analyzing|processing|determining|using|calling|executing|I'm|I am|Let me)/i.test(line) || line.includes("tool") || line.includes('{"') || line.includes("reasoning") || line.includes("undefined");
     if (!isCommentary) {
       startIndex = i;
       break;
@@ -3961,6 +3936,7 @@ const cleanResponseContent = (content) => {
   if (startIndex > 0) {
     cleaned = lines.slice(startIndex).join("\n");
   }
+  cleaned = cleaned.replace(/\n{3,}/g, "\n\n");
   return cleaned.trim();
 };
 const create$5 = (reasoning, ctx) => {
@@ -3986,7 +3962,20 @@ const create$5 = (reasoning, ctx) => {
     let iterations = 0;
     let totalTokens = 0;
     const maxIterations = 15;
-    const conversationHistory = [];
+    const conversation = ConversationBuilder.create({ model: "gpt-4o" }).withTokenBudget({
+      max: 1e5,
+      // 100k token context window
+      reserveForResponse: 4e3,
+      // Reserve 4k tokens for response
+      strategy: "summarize",
+      // Summarize old messages if budget exceeded
+      onBudgetExceeded: "compress",
+      // Automatically compress when exceeded
+      preserveSystem: true,
+      // Always keep system messages
+      preserveRecent: 5
+      // Keep last 5 messages
+    });
     const systemPrompt = `You are an intelligent transcription assistant. Your job is to:
 1. Analyze the transcript for names, projects, and companies
 2. Use the available tools to verify spellings and gather context
@@ -4015,7 +4004,7 @@ Available tools:
 - verify_spelling: Ask user about unknown terms (if interactive mode)
 - route_note: Determine where to file this note
 - store_context: Remember new information for future use`;
-    conversationHistory.push({ role: "system", content: systemPrompt });
+    conversation.addSystemMessage(systemPrompt);
     const initialPrompt = `Here is the raw transcript to process:
 
 --- BEGIN TRANSCRIPT ---
@@ -4030,7 +4019,7 @@ Please:
 
 CRITICAL: Your response must contain ONLY the transcript text - no commentary, no explanations, no tool information.
 Remember: preserve ALL content, only fix transcription errors.`;
-    conversationHistory.push({ role: "user", content: initialPrompt });
+    conversation.addUserMessage(initialPrompt);
     try {
       logger.debug("Starting agentic transcription - analyzing for names and routing...");
       let response = await reasoning.complete({
@@ -4042,15 +4031,14 @@ Remember: preserve ALL content, only fix transcription errors.`;
       if (response.usage) {
         totalTokens += response.usage.totalTokens;
       }
-      conversationHistory.push({
-        role: "assistant",
-        content: response.content,
-        tool_calls: response.toolCalls?.map((tc) => ({
-          id: tc.id,
-          name: tc.name,
-          arguments: tc.arguments
-        }))
-      });
+      if (response.toolCalls && response.toolCalls.length > 0) {
+        conversation.addAssistantWithToolCalls(
+          response.content,
+          toRiotToolCalls(response.toolCalls)
+        );
+      } else {
+        conversation.addAssistantMessage(response.content);
+      }
       while (response.toolCalls && response.toolCalls.length > 0 && iterations < maxIterations) {
         iterations++;
         logger.debug("Iteration %d: Processing %d tool calls...", iterations, response.toolCalls.length);
@@ -4534,11 +4522,7 @@ ${termName}: ${wizardResult.termDescription}`.trim() : linkedProject.description
           }
         }
         for (const tr of toolResults) {
-          conversationHistory.push({
-            role: "tool",
-            tool_call_id: tr.id,
-            content: tr.result
-          });
+          conversation.addToolResult(tr.id, tr.result, tr.name);
         }
         const continuationPrompt = `Tool results received. Here's a reminder of your task:
 
@@ -4554,7 +4538,7 @@ When you're done with tool calls, output the COMPLETE corrected transcript as Ma
 Do NOT summarize - include ALL original content with corrections applied.
 
 CRITICAL REMINDER: Your response must contain ONLY the transcript text. Do NOT include any commentary, explanations, or processing notes - those will leak into the user-facing document.`;
-        conversationHistory.push({ role: "user", content: continuationPrompt });
+        conversation.addUserMessage(continuationPrompt);
         response = await reasoning.complete({
           systemPrompt,
           prompt: continuationPrompt,
@@ -4563,24 +4547,38 @@ CRITICAL REMINDER: Your response must contain ONLY the transcript text. Do NOT i
         if (response.usage) {
           totalTokens += response.usage.totalTokens;
         }
-        conversationHistory.push({
-          role: "assistant",
-          content: response.content,
-          tool_calls: response.toolCalls?.map((tc) => ({
-            id: tc.id,
-            name: tc.name,
-            arguments: tc.arguments
-          }))
-        });
+        if (response.toolCalls && response.toolCalls.length > 0) {
+          conversation.addAssistantWithToolCalls(
+            response.content,
+            toRiotToolCalls(response.toolCalls)
+          );
+        } else {
+          conversation.addAssistantMessage(response.content);
+        }
       }
       if (response.content && response.content.length > 50) {
         const cleanedContent = cleanResponseContent(response.content);
         if (cleanedContent !== response.content) {
+          const removedChars = response.content.length - cleanedContent.length;
           logger.warn(
-            "Removed leaked internal processing from response (%d -> %d chars)",
+            "Removed leaked internal processing from response (%d -> %d chars, removed %d chars)",
             response.content.length,
-            cleanedContent.length
+            cleanedContent.length,
+            removedChars
           );
+          const corruptionRatio = removedChars / response.content.length;
+          const hasSuspiciousUnicode = /[\u0530-\u058F\u0E00-\u0E7F\u4E00-\u9FFF\u0A80-\u0AFF\u0C00-\u0C7F]/.test(response.content);
+          if (corruptionRatio > 0.1 || hasSuspiciousUnicode) {
+            logger.error(
+              "SEVERE CORRUPTION DETECTED in LLM response (%.1f%% removed, suspicious unicode: %s)",
+              corruptionRatio * 100,
+              hasSuspiciousUnicode
+            );
+            logger.error(
+              "Raw response preview (first 500 chars): %s",
+              response.content.substring(0, 500).replace(/\n/g, "\\n")
+            );
+          }
         }
         state.correctedText = cleanedContent;
         state.confidence = 0.9;
@@ -4607,11 +4605,26 @@ CRITICAL: Your response must contain ONLY the corrected transcript text - absolu
         }
         const cleanedFinalContent = cleanResponseContent(finalResponse.content || transcriptText);
         if (cleanedFinalContent !== finalResponse.content) {
+          const removedChars = (finalResponse.content?.length || 0) - cleanedFinalContent.length;
           logger.warn(
-            "Removed leaked internal processing from final response (%d -> %d chars)",
+            "Removed leaked internal processing from final response (%d -> %d chars, removed %d chars)",
             finalResponse.content?.length || 0,
-            cleanedFinalContent.length
+            cleanedFinalContent.length,
+            removedChars
           );
+          const corruptionRatio = removedChars / (finalResponse.content?.length || 1);
+          const hasSuspiciousUnicode = /[\u0530-\u058F\u0E00-\u0E7F\u4E00-\u9FFF\u0A80-\u0AFF\u0C00-\u0C7F]/.test(finalResponse.content || "");
+          if (corruptionRatio > 0.1 || hasSuspiciousUnicode) {
+            logger.error(
+              "SEVERE CORRUPTION DETECTED in final LLM response (%.1f%% removed, suspicious unicode: %s)",
+              corruptionRatio * 100,
+              hasSuspiciousUnicode
+            );
+            logger.error(
+              "Raw response preview (first 500 chars): %s",
+              (finalResponse.content || "").substring(0, 500).replace(/\n/g, "\\n")
+            );
+          }
         }
         state.correctedText = cleanedFinalContent;
         state.confidence = 0.8;
@@ -4633,6 +4646,40 @@ CRITICAL: Your response must contain ONLY the corrected transcript text - absolu
   return { process };
 };
 
+z.object({
+  original: z.string().describe("Original text from transcript"),
+  corrected: z.string().describe("Corrected spelling/name"),
+  type: z.enum(["person", "project", "term", "company"]).describe("Entity type"),
+  confidence: z.number().min(0).max(1).describe("Confidence in correction")
+});
+z.object({
+  projectId: z.string().optional().describe("Matched project ID"),
+  destination: z.object({
+    path: z.string().describe("File destination path"),
+    structure: z.enum(["none", "year", "month", "day"]).default("month")
+  }),
+  confidence: z.number().min(0).max(1).describe("Confidence in routing"),
+  signals: z.array(z.object({
+    type: z.enum(["explicit_phrase", "associated_person", "associated_company", "topic", "context_type"]),
+    value: z.string(),
+    weight: z.number()
+  })).optional(),
+  reasoning: z.string().optional().describe("Why this destination was chosen")
+});
+z.object({
+  people: z.array(z.string()).describe("IDs of people mentioned"),
+  projects: z.array(z.string()).describe("IDs of projects mentioned"),
+  terms: z.array(z.string()).describe("IDs of terms mentioned"),
+  companies: z.array(z.string()).describe("IDs of companies mentioned")
+});
+z.object({
+  success: z.boolean(),
+  data: z.any().optional(),
+  error: z.string().optional(),
+  needsUserInput: z.boolean().optional(),
+  userPrompt: z.string().optional()
+});
+
 const create$4 = (reasoning, toolContext) => {
   const executor = create$5(reasoning, toolContext);
   return {
@@ -5301,7 +5348,7 @@ const projectAssist = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.definePrope
 
 const print$1 = (text) => process.stdout.write(text + "\n");
 const parseTranscript = async (filePath) => {
-  const rawText = await fs$1.readFile(filePath, "utf-8");
+  const rawText = await fs$2.readFile(filePath, "utf-8");
   const lines = rawText.split("\n");
   const result = {
     filePath,
@@ -5727,7 +5774,7 @@ const executeAction = async (file, options) => {
     }
     for (const filePath of filePaths) {
       try {
-        await fs$1.access(filePath);
+        await fs$2.access(filePath);
       } catch {
         print$1(`Error: File not found: ${filePath}`);
         process.exit(1);
@@ -5771,15 +5818,15 @@ Custom title: ${options.title}`);
           print$1("...");
         }
       } else {
-        await fs$1.mkdir(path.dirname(result.outputPath), { recursive: true });
-        await fs$1.writeFile(result.outputPath, result.content, "utf-8");
+        await fs$2.mkdir(path.dirname(result.outputPath), { recursive: true });
+        await fs$2.writeFile(result.outputPath, result.content, "utf-8");
         print$1(`Combined transcript created: ${result.outputPath}`);
         if (options.verbose) {
           print$1("\nDeleting source files...");
         }
         for (const fp of filePaths) {
           try {
-            await fs$1.unlink(fp);
+            await fs$2.unlink(fp);
             if (options.verbose) {
               print$1(`  Deleted: ${fp}`);
             }
@@ -5799,7 +5846,7 @@ Custom title: ${options.title}`);
       process.exit(1);
     }
     try {
-      await fs$1.access(file);
+      await fs$2.access(file);
     } catch {
       print$1(`Error: File not found: ${file}`);
       process.exit(1);
@@ -5839,10 +5886,10 @@ Custom title: ${options.title}`);
           print$1("...");
         }
       } else {
-        await fs$1.mkdir(path.dirname(result.outputPath), { recursive: true });
-        await fs$1.writeFile(result.outputPath, result.content, "utf-8");
+        await fs$2.mkdir(path.dirname(result.outputPath), { recursive: true });
+        await fs$2.writeFile(result.outputPath, result.content, "utf-8");
         if (isRename) {
-          await fs$1.unlink(file);
+          await fs$2.unlink(file);
           print$1(`Transcript updated and renamed:`);
           print$1(`  From: ${file}`);
           print$1(`  To: ${result.outputPath}`);
@@ -6417,11 +6464,11 @@ const applyChanges = async (feedbackCtx) => {
       moved = true;
     }
   }
-  await fs$1.mkdir(path.dirname(newPath), { recursive: true });
+  await fs$2.mkdir(path.dirname(newPath), { recursive: true });
   if (!feedbackCtx.dryRun) {
-    await fs$1.writeFile(newPath, feedbackCtx.transcriptContent, "utf-8");
+    await fs$2.writeFile(newPath, feedbackCtx.transcriptContent, "utf-8");
     if (newPath !== feedbackCtx.transcriptPath) {
-      await fs$1.unlink(feedbackCtx.transcriptPath);
+      await fs$2.unlink(feedbackCtx.transcriptPath);
     }
   }
   logger.info("Applied %d changes to transcript", feedbackCtx.changes.length);
@@ -6429,12 +6476,12 @@ const applyChanges = async (feedbackCtx) => {
 };
 const runFeedback = async (transcriptPath, options) => {
   try {
-    await fs$1.access(transcriptPath);
+    await fs$2.access(transcriptPath);
   } catch {
     print(`Error: File not found: ${transcriptPath}`);
     process.exit(1);
   }
-  const transcriptContent = await fs$1.readFile(transcriptPath, "utf-8");
+  const transcriptContent = await fs$2.readFile(transcriptPath, "utf-8");
   const context = await create$u();
   const reasoning = create$c({ model: options.model || DEFAULT_MODEL });
   const feedbackCtx = {
@@ -6559,7 +6606,7 @@ const getRawTranscriptPath = (finalPath) => {
 const readRawTranscript = async (finalPath) => {
   const rawPath = getRawTranscriptPath(finalPath);
   try {
-    const content = await fs$1.readFile(rawPath, "utf-8");
+    const content = await fs$2.readFile(rawPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
@@ -6570,7 +6617,7 @@ const readRawTranscript = async (finalPath) => {
 };
 const readFinalTranscript = async (finalPath) => {
   try {
-    return await fs$1.readFile(finalPath, "utf-8");
+    return await fs$2.readFile(finalPath, "utf-8");
   } catch (error) {
     if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
       return null;
@@ -6729,7 +6776,7 @@ const listTranscripts = async (options) => {
     if (endDate && dateTime && dateTime.date > endDate) continue;
     let stats;
     try {
-      stats = await fs$1.stat(filePath);
+      stats = await fs$2.stat(filePath);
       if (!stats.isFile()) {
         continue;
       }
@@ -6738,7 +6785,7 @@ const listTranscripts = async (options) => {
     }
     let content;
     try {
-      content = await fs$1.readFile(filePath, "utf-8");
+      content = await fs$2.readFile(filePath, "utf-8");
     } catch {
       continue;
     }