@redaksjon/protokoll-engine 0.1.1-dev.0

package/dist/index30.js

@@ -0,0 +1,173 @@
+import { getLogger } from './index41.js';
+
+const create = (reasoning, context, config) => {
+  const logger = getLogger();
+  const analyze = async (feedback) => {
+    logger.info("Analyzing feedback for: %s", feedback.transcriptPath);
+    const allProjects = context.getAllProjects();
+    const projectSummary = allProjects.map((p) => ({
+      id: p.id,
+      name: p.name,
+      phrases: p.classification?.explicit_phrases || [],
+      topics: p.classification?.topics || [],
+      contextType: p.classification?.context_type,
+      destination: p.routing?.destination
+    }));
+    const prompt = `You are analyzing why a transcription routing system made a classification error.
+
+## Original Classification Decision
+- **Chosen Project**: ${feedback.originalDecision.projectId || "none (default routing)"}
+- **Destination**: ${feedback.originalDecision.destination}
+- **Confidence**: ${(feedback.originalDecision.confidence * 100).toFixed(1)}%
+- **System's Reasoning**: ${feedback.originalDecision.reasoning}
+
+## User's Correction
+- **Correct Project**: ${feedback.correction.projectId || "not specified"}
+- **Correct Destination**: ${feedback.correction.destination || "not specified"}
+- **Topics**: ${feedback.correction.topics?.join(", ") || "not specified"}
+- **Context Type**: ${feedback.correction.contextType || "not specified"}
+
+## User's Explanation
+"${feedback.userReason}"
+
+## Current Project Context
+${JSON.stringify(projectSummary, null, 2)}
+
+## Your Task
+Analyze why the classification failed and suggest specific updates to the context system.
+
+Return a JSON object with:
+1. "diagnosis": A clear explanation of what went wrong
+2. "suggestedUpdates": Array of updates to make, each with:
+   - "type": "new_project" | "new_phrase" | "new_topic" | "context_type" | "association"
+   - "entityType": "project" | "person" | "company" | "term"
+   - "entityId": The entity to update (or new ID if creating)
+   - "changes": Array of { "field": string, "newValue": any }
+   - "reasoning": Why this update helps
+   - "confidence": 0-1 how confident you are
+3. "clarificationQuestions": Optional questions if more info needed
+4. "confidence": Overall confidence in this analysis (0-1)
+
+Focus on:
+- Missing trigger phrases that should match the correct project
+- Topics that should be associated with projects
+- Context type mismatches (work vs personal)
+- New projects that need to be created
+
+Respond with ONLY the JSON object.`;
+    try {
+      const response = await reasoning.complete({
+        systemPrompt: "You are an expert at analyzing classification systems and suggesting improvements. Always respond with valid JSON.",
+        prompt
+      });
+      const analysis = JSON.parse(response.content);
+      logger.info("Feedback analysis complete: %d suggested updates", analysis.suggestedUpdates.length);
+      return analysis;
+    } catch (error) {
+      logger.error("Failed to analyze feedback", { error });
+      return {
+        diagnosis: "Unable to analyze feedback automatically. Manual review recommended.",
+        suggestedUpdates: [],
+        confidence: 0
+      };
+    }
+  };
+  const applyUpdates = async (updates) => {
+    logger.info("Applying %d context updates", updates.length);
+    for (const update of updates) {
+      if (update.confidence < config.autoApplyThreshold) {
+        logger.info(
+          "Skipping low-confidence update: %s (%.1f%% < %.1f%%)",
+          update.entityId,
+          update.confidence * 100,
+          config.autoApplyThreshold * 100
+        );
+        continue;
+      }
+      try {
+        if (update.type === "new_project") {
+          const classification = {
+            context_type: "work",
+            explicit_phrases: [],
+            topics: []
+          };
+          const newProject = {
+            id: update.entityId,
+            name: update.entityId,
+            type: "project",
+            description: update.reasoning,
+            classification,
+            routing: {
+              // No destination - will use global default
+              structure: "month",
+              filename_options: ["date", "time", "subject"]
+            },
+            active: true
+          };
+          for (const change of update.changes) {
+            if (change.field === "name") newProject.name = String(change.newValue);
+            if (change.field === "destination") newProject.routing.destination = String(change.newValue);
+            if (change.field === "context_type") {
+              newProject.classification.context_type = change.newValue;
+            }
+            if (change.field === "explicit_phrases") {
+              newProject.classification.explicit_phrases = change.newValue;
+            }
+            if (change.field === "topics") {
+              newProject.classification.topics = change.newValue;
+            }
+          }
+          await context.saveEntity(newProject);
+          logger.info("Created new project: %s", update.entityId);
+        } else if (update.type === "new_phrase" || update.type === "new_topic" || update.type === "context_type") {
+          const existing = context.getProject(update.entityId);
+          if (!existing) {
+            logger.warn("Project not found for update: %s", update.entityId);
+            continue;
+          }
+          const updated = { ...existing };
+          for (const change of update.changes) {
+            if (change.field === "explicit_phrases") {
+              const newPhrases = change.newValue;
+              updated.classification = {
+                ...updated.classification,
+                explicit_phrases: [
+                  ...updated.classification?.explicit_phrases || [],
+                  ...newPhrases.filter(
+                    (p) => !updated.classification?.explicit_phrases?.includes(p)
+                  )
+                ]
+              };
+            }
+            if (change.field === "topics") {
+              const newTopics = change.newValue;
+              updated.classification = {
+                ...updated.classification,
+                topics: [
+                  ...updated.classification?.topics || [],
+                  ...newTopics.filter(
+                    (t) => !updated.classification?.topics?.includes(t)
+                  )
+                ]
+              };
+            }
+            if (change.field === "context_type") {
+              updated.classification = {
+                ...updated.classification,
+                context_type: change.newValue
+              };
+            }
+          }
+          await context.saveEntity(updated);
+          logger.info("Updated project: %s", update.entityId);
+        }
+      } catch (error) {
+        logger.error("Failed to apply update", { update, error });
+      }
+    }
+  };
+  return { analyze, applyUpdates };
+};
+
+export { create };
+//# sourceMappingURL=index30.js.map

package/dist/index30.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index30.js","sources":["../src/feedback/analyzer.ts"],"sourcesContent":["/**\n * Feedback Analyzer\n * \n * Uses a reasoning model to analyze user feedback on classification\n * decisions and suggest context updates.\n */\n\nimport { ClassificationFeedback, FeedbackAnalysis, LearningUpdate } from './types';\nimport * as Reasoning from '../reasoning';\nimport * as Context from '@redaksjon/context';\nimport * as Logging from '../logging';\n\nexport interface AnalyzerInstance {\n    analyze(feedback: ClassificationFeedback): Promise<FeedbackAnalysis>;\n    applyUpdates(updates: LearningUpdate[]): Promise<void>;\n}\n\nexport interface AnalyzerConfig {\n    model: string;\n    autoApplyThreshold: number;\n}\n\nexport const create = (\n    reasoning: Reasoning.ReasoningInstance,\n    context: Context.ContextInstance,\n    config: AnalyzerConfig\n): AnalyzerInstance => {\n    const logger = Logging.getLogger();\n\n    const analyze = async (feedback: ClassificationFeedback): Promise<FeedbackAnalysis> => {\n        logger.info('Analyzing feedback for: %s', feedback.transcriptPath);\n\n        // Gather current context for the model to understand\n        const allProjects = context.getAllProjects();\n        const projectSummary = allProjects.map(p => ({\n            id: p.id,\n            name: p.name,\n            phrases: p.classification?.explicit_phrases || [],\n            topics: p.classification?.topics || [],\n            contextType: p.classification?.context_type,\n            destination: p.routing?.destination,\n        }));\n\n        const prompt = `You are analyzing why a transcription routing system made a classification error.\n\n## Original Classification Decision\n- **Chosen Project**: ${feedback.originalDecision.projectId || 'none (default routing)'}\n- **Destination**: ${feedback.originalDecision.destination}\n- **Confidence**: ${(feedback.originalDecision.confidence * 100).toFixed(1)}%\n- **System's Reasoning**: ${feedback.originalDecision.reasoning}\n\n## User's Correction\n- **Correct Project**: ${feedback.correction.projectId || 'not specified'}\n- **Correct Destination**: ${feedback.correction.destination || 'not specified'}\n- **Topics**: ${feedback.correction.topics?.join(', ') || 'not specified'}\n- **Context Type**: ${feedback.correction.contextType || 'not specified'}\n\n## User's Explanation\n\"${feedback.userReason}\"\n\n## Current Project Context\n${JSON.stringify(projectSummary, null, 2)}\n\n## Your Task\nAnalyze why the classification failed and suggest specific updates to the context system.\n\nReturn a JSON object with:\n1. \"diagnosis\": A clear explanation of what went wrong\n2. \"suggestedUpdates\": Array of updates to make, each with:\n   - \"type\": \"new_project\" | \"new_phrase\" | \"new_topic\" | \"context_type\" | \"association\"\n   - \"entityType\": \"project\" | \"person\" | \"company\" | \"term\"\n   - \"entityId\": The entity to update (or new ID if creating)\n   - \"changes\": Array of { \"field\": string, \"newValue\": any }\n   - \"reasoning\": Why this update helps\n   - \"confidence\": 0-1 how confident you are\n3. \"clarificationQuestions\": Optional questions if more info needed\n4. \"confidence\": Overall confidence in this analysis (0-1)\n\nFocus on:\n- Missing trigger phrases that should match the correct project\n- Topics that should be associated with projects\n- Context type mismatches (work vs personal)\n- New projects that need to be created\n\nRespond with ONLY the JSON object.`;\n\n        try {\n            const response = await reasoning.complete({\n                systemPrompt: 'You are an expert at analyzing classification systems and suggesting improvements. Always respond with valid JSON.',\n                prompt,\n            });\n\n            // Parse the response\n            const analysis = JSON.parse(response.content) as FeedbackAnalysis;\n            logger.info('Feedback analysis complete: %d suggested updates', analysis.suggestedUpdates.length);\n\n            return analysis;\n        } catch (error) {\n            logger.error('Failed to analyze feedback', { error });\n            \n            // Return a basic analysis if reasoning fails\n            return {\n                diagnosis: 'Unable to analyze feedback automatically. Manual review recommended.',\n                suggestedUpdates: [],\n                confidence: 0,\n            };\n        }\n    };\n\n    const applyUpdates = async (updates: LearningUpdate[]): Promise<void> => {\n        logger.info('Applying %d context updates', updates.length);\n\n        for (const update of updates) {\n            // Skip low-confidence updates unless auto-apply threshold is 0\n            if (update.confidence < config.autoApplyThreshold) {\n                logger.info('Skipping low-confidence update: %s (%.1f%% < %.1f%%)',\n                    update.entityId, \n                    update.confidence * 100, \n                    config.autoApplyThreshold * 100\n                );\n                continue;\n            }\n\n            try {\n                if (update.type === 'new_project') {\n                    // Create new project\n                    const classification: {\n                        context_type: 'work' | 'personal' | 'mixed';\n                        explicit_phrases: string[];\n                        topics: string[];\n                    } = {\n                        context_type: 'work',\n                        explicit_phrases: [],\n                        topics: [],\n                    };\n                    \n                    const newProject: {\n                        id: string;\n                        name: string;\n                        type: 'project';\n                        description: string;\n                        classification: typeof classification;\n                        routing: {\n                            destination?: string;\n                            structure: 'none' | 'year' | 'month' | 'day';\n                            filename_options: Array<'date' | 'time' | 'subject'>;\n                        };\n                        active: boolean;\n                    } = {\n                        id: update.entityId,\n                        name: update.entityId,\n                        type: 'project' as const,\n                        description: update.reasoning,\n                        classification,\n                        routing: {\n                            // No destination - will use global default\n                            structure: 'month' as const,\n                            filename_options: ['date', 'time', 'subject'] as Array<'date' | 'time' | 'subject'>,\n                        },\n                        active: true,\n                    };\n\n                    // Apply changes\n                    for (const change of update.changes) {\n                        if (change.field === 'name') newProject.name = String(change.newValue);\n                        if (change.field === 'destination') newProject.routing.destination = String(change.newValue);\n                        if (change.field === 'context_type') {\n                            newProject.classification.context_type = change.newValue as 'work' | 'personal' | 'mixed';\n                        }\n                        if (change.field === 'explicit_phrases') {\n                            newProject.classification.explicit_phrases = change.newValue as string[];\n                        }\n                        if (change.field === 'topics') {\n                            newProject.classification.topics = change.newValue as string[];\n                        }\n                    }\n\n                    await context.saveEntity(newProject);\n                    logger.info('Created new project: %s', update.entityId);\n\n                } else if (update.type === 'new_phrase' || update.type === 'new_topic' || update.type === 'context_type') {\n                    // Update existing project\n                    const existing = context.getProject(update.entityId);\n                    if (!existing) {\n                        logger.warn('Project not found for update: %s', update.entityId);\n                        continue;\n                    }\n\n                    // Create updated entity\n                    const updated = { ...existing };\n                    \n                    for (const change of update.changes) {\n                        if (change.field === 'explicit_phrases') {\n                            const newPhrases = change.newValue as string[];\n                            updated.classification = {\n                                ...updated.classification,\n                                explicit_phrases: [\n                                    ...(updated.classification?.explicit_phrases || []),\n                                    ...newPhrases.filter(p => \n                                        !updated.classification?.explicit_phrases?.includes(p)\n                                    ),\n                                ],\n                            };\n                        }\n                        if (change.field === 'topics') {\n                            const newTopics = change.newValue as string[];\n                            updated.classification = {\n                                ...updated.classification,\n                                topics: [\n                                    ...(updated.classification?.topics || []),\n                                    ...newTopics.filter(t => \n                                        !updated.classification?.topics?.includes(t)\n                                    ),\n                                ],\n                            };\n                        }\n                        if (change.field === 'context_type') {\n                            updated.classification = {\n                                ...updated.classification,\n                                context_type: change.newValue as 'work' | 'personal' | 'mixed',\n                            };\n                        }\n                    }\n\n                    await context.saveEntity(updated);\n                    logger.info('Updated project: %s', update.entityId);\n                }\n            } catch (error) {\n                logger.error('Failed to apply update', { update, error });\n            }\n        }\n    };\n\n    return { analyze, applyUpdates };\n};\n\n"],"names":["Logging.getLogger"],"mappings":"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"}

package/dist/index31.js

@@ -0,0 +1,423 @@
+import * as Context from '@redaksjon/context';
+import { create as create$1 } from './index6.js';
+import { create as create$2 } from './index53.js';
+import { create as create$3 } from './index11.js';
+import { create as create$4 } from './index3.js';
+import { create as create$5 } from './index2.js';
+import { create as create$7 } from './index5.js';
+import { create as create$6 } from './index35.js';
+import { getLogger } from './index41.js';
+import { extractTagsFromSignals, createRoutingMetadata } from './index14.js';
+
+const create = async (config) => {
+  const logger = getLogger();
+  const currentWorkingDir = globalThis.process.cwd();
+  logger.debug("Initializing intelligent transcription pipeline...");
+  const context = await Context.create({
+    startingDir: config.contextDirectory || currentWorkingDir,
+    contextDirectories: config.contextDirectories
+  });
+  logger.debug("Context system initialized - ready to query entities via tools");
+  const defaultPath = config.outputDirectory || "~/notes";
+  const defaultStructure = config.outputStructure || "month";
+  const defaultFilenameOptions = config.outputFilenameOptions || ["date", "time", "subject"];
+  const contextProjects = context.getAllProjects();
+  const routingProjects = contextProjects.filter((project) => project.active !== false).map((project) => ({
+    projectId: project.id,
+    destination: {
+      path: project.routing?.destination || defaultPath,
+      structure: project.routing?.structure || defaultStructure,
+      filename_options: project.routing?.filename_options || defaultFilenameOptions,
+      createDirectories: true
+    },
+    classification: project.classification,
+    active: project.active,
+    auto_tags: project.routing?.auto_tags
+  }));
+  logger.debug("Loaded %d projects from context for routing", routingProjects.length);
+  const routingConfig = {
+    default: {
+      path: defaultPath,
+      structure: defaultStructure,
+      filename_options: defaultFilenameOptions,
+      createDirectories: true
+    },
+    projects: routingProjects,
+    conflict_resolution: "primary"
+  };
+  const routing = create$1(routingConfig, context);
+  logger.debug("Routing system initialized");
+  const output = create$2({
+    intermediateDir: config.intermediateDir || "./output/protokoll",
+    keepIntermediates: config.keepIntermediates ?? true});
+  logger.debug("Output manager initialized");
+  const reflection = config.selfReflection ? create$3({
+    format: "markdown",
+    includeConversation: false,
+    includeOutput: true
+  }) : null;
+  if (reflection) {
+    logger.debug("Self-reflection system enabled");
+  }
+  const transcription = create$4({
+    defaultModel: config.transcriptionModel
+  });
+  logger.debug("Transcription service initialized with model: %s", config.transcriptionModel);
+  const reasoning = create$5({
+    model: config.model,
+    reasoningLevel: config.reasoningLevel
+  });
+  logger.debug("Reasoning system initialized with model: %s, reasoning level: %s", config.model, config.reasoningLevel || "medium");
+  const complete = config.processedDirectory ? create$6({
+    processedDirectory: config.processedDirectory,
+    outputStructure: config.outputStructure,
+    dryRun: config.dryRun
+  }) : null;
+  if (complete) {
+    logger.debug("Complete phase initialized with processed directory: %s", config.processedDirectory);
+  }
+  const extractTitleFromPath = (outputPath) => {
+    const filename = outputPath.split("/").pop()?.replace(".md", "");
+    if (!filename) return void 0;
+    const withoutDate = filename.replace(/^\d{2}-\d{4}-/, "");
+    if (!withoutDate) return void 0;
+    return withoutDate.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  };
+  const isMeaningfulTitle = (title) => {
+    if (!title) return false;
+    const stripped = title.replace(/\s+/g, "");
+    const numberRatio = (stripped.match(/\d/g) || []).length / stripped.length;
+    if (numberRatio > 0.5) return false;
+    if (stripped.length < 3) return false;
+    const badPatterns = /^(i|i have|i am|the|a|an|um|uh|so|well|okay|oh|hey|hi)$/i;
+    if (badPatterns.test(title.trim())) return false;
+    return true;
+  };
+  const generateTitleFromContent = async (transcriptText, fallbackTitle) => {
+    try {
+      const textSample = transcriptText.slice(0, 2e3);
+      const response = await reasoning.complete({
+        systemPrompt: `You are a title generator. Given a transcript, generate a concise, descriptive title (3-8 words) that captures the main topic or theme.
+
+Rules:
+- Output ONLY the title, nothing else
+- No quotes around the title
+- Use Title Case
+- Be specific - avoid generic titles like "Meeting Notes" or "Discussion"
+- Focus on the main subject matter
+- If there are multiple topics, pick the most prominent one`,
+        prompt: `Generate a title for this transcript:
+
+${textSample}`
+      });
+      const title = response.content.trim().replace(/^["']|["']$/g, "").replace(/^#\s*/, "").trim();
+      if (title && title.length > 0 && title.length < 100) {
+        logger.debug("Generated title from content: %s", title);
+        return title;
+      }
+      logger.debug("Generated title was invalid, using fallback");
+      return fallbackTitle || "Untitled";
+    } catch (error) {
+      logger.warn("Title generation failed, using fallback", { error });
+      return fallbackTitle || "Untitled";
+    }
+  };
+  const processInput = async (input) => {
+    const startTime = Date.now();
+    const progressPrefix = input.progress ? `[${input.progress.current}/${input.progress.total}]` : "";
+    const log = (level, message, ...args) => {
+      const prefixedMessage = progressPrefix ? `${progressPrefix} ${message}` : message;
+      if (level === "info") {
+        logger.info(prefixedMessage, ...args);
+      } else {
+        logger.debug(prefixedMessage, ...args);
+      }
+    };
+    log("info", "Processing: %s (hash: %s)", input.audioFile, input.hash);
+    const state = {
+      input,
+      startTime: /* @__PURE__ */ new Date()
+    };
+    if (reflection) {
+      reflection.collector.start();
+    }
+    try {
+      log("debug", "Checking onboarding state...");
+      const onboardingState = { needsOnboarding: false };
+      if (onboardingState.needsOnboarding) ;
+      log("info", "Transcribing audio...");
+      const whisperStart = Date.now();
+      const transcriptionResult = await transcription.transcribe(input.audioFile, {
+        model: config.transcriptionModel
+      });
+      state.rawTranscript = transcriptionResult.text;
+      const whisperDuration = Date.now() - whisperStart;
+      log(
+        "info",
+        "Transcription: %d chars in %.1fs",
+        state.rawTranscript.length,
+        whisperDuration / 1e3
+      );
+      if (reflection) {
+        reflection.collector.recordWhisper(whisperDuration);
+      }
+      log("debug", "Determining routing destination...");
+      const routingContext = {
+        transcriptText: state.rawTranscript || "",
+        audioDate: input.creation,
+        sourceFile: input.audioFile,
+        hash: input.hash
+      };
+      const routeResult = routing.route(routingContext);
+      log(
+        "debug",
+        "Routing decision: project=%s, confidence=%.2f",
+        routeResult.projectId || "default",
+        routeResult.confidence
+      );
+      if (reflection) {
+        reflection.collector.recordRoutingDecision({
+          projectId: routeResult.projectId,
+          destination: routeResult.destination.path,
+          confidence: routeResult.confidence,
+          reasoning: routeResult.reasoning,
+          signals: routeResult.signals.map((s) => ({
+            type: s.type,
+            value: s.value,
+            weight: s.weight
+          })),
+          alternativesConsidered: routeResult.alternateMatches?.map((alt) => ({
+            projectId: alt.projectId,
+            confidence: alt.confidence,
+            whyNotChosen: `Lower confidence (${(alt.confidence * 100).toFixed(1)}%)`
+          }))
+        });
+      }
+      const outputPath = routing.buildOutputPath(routeResult, routingContext);
+      log("debug", "Output path: %s", outputPath);
+      log("debug", "Setting up output directories...");
+      const paths = output.createOutputPaths(
+        input.audioFile,
+        outputPath,
+        input.hash,
+        input.creation
+      );
+      await output.ensureDirectories(paths);
+      await output.writeIntermediate(paths, "transcript", {
+        text: state.rawTranscript,
+        model: config.transcriptionModel,
+        duration: whisperDuration
+      });
+      log("info", "Enhancing with %s...", config.model);
+      const agenticStart = Date.now();
+      const toolContext = {
+        transcriptText: state.rawTranscript || "",
+        audioDate: input.creation,
+        sourceFile: input.audioFile,
+        contextInstance: context,
+        routingInstance: routing,
+        interactiveMode: config.interactive
+        // Interactive moved to protokoll-cli
+        // interactiveInstance: interactive,
+      };
+      const executor = create$7(reasoning, toolContext);
+      const agenticResult = await executor.process(state.rawTranscript || "");
+      state.enhancedText = agenticResult.enhancedText;
+      const toolsUsed = agenticResult.toolsUsed;
+      const agenticDuration = Date.now() - agenticStart;
+      if (reflection) {
+        for (const tool of toolsUsed) {
+          reflection.collector.recordToolCall(tool, agenticDuration / toolsUsed.length, true);
+        }
+        reflection.collector.recordCorrection(state.rawTranscript || "", state.enhancedText);
+        if (agenticResult.totalTokens) {
+          reflection.collector.recordModelResponse(config.model, agenticResult.totalTokens);
+        }
+        if (agenticResult.contextChanges) {
+          for (const change of agenticResult.contextChanges) {
+            reflection.collector.recordContextChange(change);
+          }
+        }
+      }
+      await output.writeIntermediate(paths, "session", {
+        iterations: agenticResult.iterations,
+        toolsUsed: agenticResult.toolsUsed,
+        state: agenticResult.state
+      });
+      if (agenticResult.state.routeDecision?.destination?.path) {
+        const agenticRoute = agenticResult.state.routeDecision;
+        log(
+          "debug",
+          "Agentic processing found route: %s -> %s",
+          agenticRoute.projectId || "unknown",
+          agenticRoute.destination.path
+        );
+        routeResult.projectId = agenticRoute.projectId || routeResult.projectId;
+        routeResult.destination = {
+          ...routeResult.destination,
+          path: agenticRoute.destination.path,
+          structure: agenticRoute.destination.structure || routeResult.destination.structure
+        };
+        routeResult.confidence = agenticRoute.confidence || routeResult.confidence;
+        routeResult.reasoning = agenticRoute.reasoning || routeResult.reasoning;
+        if (agenticRoute.signals) {
+          routeResult.signals = agenticRoute.signals;
+        }
+        const newOutputPath = routing.buildOutputPath(routeResult, routingContext);
+        log("debug", "Updated output path: %s -> %s", outputPath, newOutputPath);
+        const newPaths = output.createOutputPaths(
+          input.audioFile,
+          newOutputPath,
+          input.hash,
+          input.creation
+        );
+        await output.ensureDirectories(newPaths);
+        Object.assign(paths, newPaths);
+      }
+      log("debug", "Writing raw transcript to .transcript/ directory...");
+      await output.writeRawTranscript(paths, {
+        text: state.rawTranscript,
+        model: config.transcriptionModel,
+        duration: whisperDuration,
+        audioFile: input.audioFile,
+        audioHash: input.hash,
+        transcribedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      log("debug", "Writing final transcript...");
+      if (state.enhancedText) {
+        const buildEntityReferences = () => {
+          const refs = agenticResult.state.referencedEntities;
+          if (!refs) return void 0;
+          const entities = {
+            people: [],
+            projects: [],
+            terms: [],
+            companies: []
+          };
+          for (const personId of refs.people) {
+            const person = context.getPerson(personId);
+            if (person) {
+              entities.people.push({ id: person.id, name: person.name, type: "person" });
+            }
+          }
+          for (const projectId of refs.projects) {
+            const project = context.getProject(projectId);
+            if (project) {
+              entities.projects.push({ id: project.id, name: project.name, type: "project" });
+            }
+          }
+          for (const termId of refs.terms) {
+            const term = context.getTerm(termId);
+            if (term) {
+              entities.terms.push({ id: term.id, name: term.name, type: "term" });
+            }
+          }
+          for (const companyId of refs.companies) {
+            const company = context.getCompany(companyId);
+            if (company) {
+              entities.companies.push({ id: company.id, name: company.name, type: "company" });
+            }
+          }
+          const hasEntities = entities.people.length > 0 || entities.projects.length > 0 || entities.terms.length > 0 || entities.companies.length > 0;
+          return hasEntities ? entities : void 0;
+        };
+        const pathTitle = extractTitleFromPath(paths.final);
+        let title;
+        if (isMeaningfulTitle(pathTitle)) {
+          title = pathTitle;
+        } else {
+          log("debug", "Path-derived title not meaningful (%s), generating from content...", pathTitle || "empty");
+          title = await generateTitleFromContent(state.enhancedText, pathTitle);
+          log("info", "Generated title: %s", title);
+          const contextWithTitle = {
+            ...routingContext,
+            subjectOverride: title
+          };
+          const newOutputPath = routing.buildOutputPath(routeResult, contextWithTitle);
+          if (newOutputPath !== paths.final) {
+            log("debug", "Updating output path with generated title: %s -> %s", paths.final, newOutputPath);
+            const newPaths = output.createOutputPaths(
+              input.audioFile,
+              newOutputPath,
+              input.hash,
+              input.creation
+            );
+            await output.ensureDirectories(newPaths);
+            Object.assign(paths, newPaths);
+          }
+        }
+        const transcriptMetadata = {
+          title,
+          projectId: routeResult.projectId || void 0,
+          project: routeResult.projectId || void 0,
+          date: input.creation,
+          routing: createRoutingMetadata(routeResult),
+          tags: extractTagsFromSignals(routeResult.signals),
+          confidence: routeResult.confidence,
+          entities: buildEntityReferences()
+        };
+        await output.writeTranscript(paths, state.enhancedText, transcriptMetadata);
+      }
+      log("debug", "Generating reflection report...");
+      let reflectionReport;
+      if (reflection) {
+        reflectionReport = reflection.generate(
+          input.audioFile,
+          paths.final,
+          void 0,
+          state.enhancedText
+        );
+        if (paths.intermediate.reflection) {
+          await reflection.save(reflectionReport, paths.intermediate.reflection);
+        }
+      }
+      log("debug", "Finalizing session...");
+      if (!config.keepIntermediates && !config.debug) {
+        await output.cleanIntermediates(paths);
+      }
+      let processedAudioPath;
+      if (complete) {
+        const subject = paths.final.split("/").pop()?.replace(".md", "") || void 0;
+        processedAudioPath = await complete.complete(
+          input.audioFile,
+          input.hash,
+          input.creation,
+          subject
+        );
+      }
+      const processingTime = Date.now() - startTime;
+      log(
+        "info",
+        "Enhancement: %d iterations, %d tools, %.1fs",
+        agenticResult.iterations,
+        toolsUsed.length,
+        agenticDuration / 1e3
+      );
+      if (agenticResult.totalTokens) {
+        log("info", "Tokens: %d total", agenticResult.totalTokens);
+      }
+      log("info", "Output: %s (%.1fs total)", paths.final, processingTime / 1e3);
+      return {
+        outputPath: paths.final,
+        enhancedText: state.enhancedText || "",
+        rawTranscript: state.rawTranscript || "",
+        routedProject: routeResult.projectId,
+        routingConfidence: routeResult.confidence,
+        processingTime,
+        toolsUsed,
+        correctionsApplied: agenticResult.state.resolvedEntities.size,
+        processedAudioPath,
+        reflection: reflectionReport,
+        // session, // Interactive moved to protokoll-cli
+        intermediatePaths: paths
+      };
+    } catch (error) {
+      logger.error("Pipeline error", { error });
+      throw error;
+    }
+  };
+  return { process: processInput };
+};
+
+export { create };
+//# sourceMappingURL=index31.js.map