@redaksjon/protokoll 1.0.20 → 1.0.21-dev.20260225190148.00bb9be

package/dist/configDiscovery.js

@@ -1,16 +1,17 @@
 import { resolve, isAbsolute, relative, extname, join, dirname, basename } from 'node:path';
 import * as Metadata from '@redaksjon/protokoll-engine';
-import { Transcript, Media, Util, Pipeline, findIgnoredResilient, findCompanyResilient, findTermResilient, findPersonResilient, findProjectResilient, Reasoning, VALID_STATUSES, isValidStatus } from '@redaksjon/protokoll-engine';
+import { Transcript, Media, Util, Pipeline, findIgnoredResilient, findCompanyResilient, findTermResilient, findPersonResilient, findProjectResilient, Routing, Phases, Reasoning, Agentic, VALID_STATUSES, isValidStatus } from '@redaksjon/protokoll-engine';
 import * as yaml from 'js-yaml';
-import { stat, readdir, mkdir, unlink } from 'node:fs/promises';
+import { stat, readdir, mkdir, mkdtemp, rm, unlink } from 'node:fs/promises';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { create as create$1, parseEntityUri as parseEntityUri$1, createRelationship, createDocumentContent, createCodeContent, createMarkdownContent, createTextContent, createUrlContent } from '@redaksjon/context';
-import os from 'node:os';
+import os, { tmpdir } from 'node:os';
 import winston from 'winston';
 import { glob } from 'glob';
 import { randomUUID } from 'crypto';
-import { PklTranscript, listTranscripts as listTranscripts$1, readTranscript } from '@redaksjon/protokoll-format';
+import { randomUUID as randomUUID$1 } from 'node:crypto';
+import { PklTranscript, readTranscript, listTranscripts as listTranscripts$1 } from '@redaksjon/protokoll-format';
 import * as Cardigantime from '@utilarium/cardigantime';
 
 const SCHEME = "protokoll";
@@ -204,7 +205,7 @@ function isProtokolUri(uri) {
   return uri.startsWith(`${SCHEME}://`);
 }
 
-const VERSION = "1.0.20 (HEAD/435bd4a T:v1.0.20 2026-02-24 07:49:25 -0800) linux arm64 v24.13.1";
+const VERSION = "1.0.21-dev.20260225190148.00bb9be (working/00bb9be  2026-02-25 11:00:08 -0800) linux arm64 v24.14.0";
 const PROGRAM_NAME = "protokoll";
 const DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS = "YYYY-M-D-HHmmss";
 const DEFAULT_AUDIO_EXTENSIONS = ["mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm", "qta"];
@@ -224,6 +225,7 @@ const DEFAULT_TERM_SOUNDS_LIKE_ON_ADD = true;
 const DEFAULT_TERM_DESCRIPTION_ON_ADD = true;
 const DEFAULT_TERM_TOPICS_ON_ADD = true;
 const DEFAULT_TERM_PROJECT_SUGGESTIONS = true;
+const MAX_CONTENT_LENGTH = 15e3;
 const ASSIST_TIMEOUT_MS = 3e4;
 const DEFAULT_MAX_AUDIO_SIZE = 26214400;
 const DEFAULT_TEMP_DIRECTORY = os.tmpdir();
@@ -912,6 +914,37 @@ const shared = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const { listTranscripts, resolveTranscriptPath, readTranscriptContent, stripTranscriptExtension } = Transcript;
+function parseStoredSummaries$1(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+      return [];
+    }
+    return parsed.map((item) => {
+      if (!item || typeof item !== "object") {
+        return null;
+      }
+      const record = item;
+      const id = String(record.id || "").trim();
+      const content = String(record.content || "").trim();
+      if (!id || !content) {
+        return null;
+      }
+      return {
+        id,
+        title: String(record.title || "").trim(),
+        audience: String(record.audience || "").trim(),
+        guidance: String(record.guidance || "").trim(),
+        stylePreset: String(record.stylePreset || "detailed").trim() || "detailed",
+        styleLabel: String(record.styleLabel || "Detailed summary").trim() || "Detailed summary",
+        content,
+        generatedAt: String(record.generatedAt || "").trim() || (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }).filter((summary) => summary !== null).sort((a, b) => b.generatedAt.localeCompare(a.generatedAt));
+  } catch {
+    return [];
+  }
+}
 async function readTranscriptResource(transcriptPath) {
   if (!transcriptPath || typeof transcriptPath !== "string") {
     throw new Error(`Invalid transcript path: ${transcriptPath}`);
@@ -927,6 +960,7 @@ async function readTranscriptResource(transcriptPath) {
     const { PklTranscript } = await import('@redaksjon/protokoll-format');
     const pklTranscript = PklTranscript.open(resolved.path, { readOnly: true });
     let rawTranscript = void 0;
+    let summaries = [];
     try {
       if (pklTranscript.hasRawTranscript) {
         const rawData = pklTranscript.rawTranscript;
@@ -939,6 +973,8 @@ async function readTranscriptResource(transcriptPath) {
           };
         }
       }
+      const historyArtifact = pklTranscript.getArtifact("summary_history");
+      summaries = parseStoredSummaries$1(historyArtifact?.data?.toString("utf8") || "[]");
     } finally {
       pklTranscript.close();
     }
@@ -965,7 +1001,8 @@ async function readTranscriptResource(transcriptPath) {
         } : void 0
       },
       content,
-      rawTranscript
+      rawTranscript,
+      summaries
     };
     return {
       uri: buildTranscriptUri(identifierPath),
@@ -1625,6 +1662,58 @@ function getPrompts() {
         }
       ]
     },
+    {
+      name: "identify_tasks_from_transcript",
+      description: "Identify task candidates from a transcript with a review-first flow. Instructs the assistant to identify first, present candidates with none preselected, and only create tasks after explicit user approval.",
+      arguments: [
+        {
+          name: "transcriptPath",
+          description: "Path or URI to the transcript to analyze",
+          required: true
+        },
+        {
+          name: "maxCandidates",
+          description: "Optional maximum number of task candidates to identify (default: 25)",
+          required: false
+        },
+        {
+          name: "includeTagSuggestions",
+          description: "Optional flag to include suggested tags (default: true)",
+          required: false
+        }
+      ]
+    },
+    {
+      name: "summarize_transcript",
+      description: "Create an audience-aware transcript summary with privacy guardrails and style presets.",
+      arguments: [
+        {
+          name: "transcriptPath",
+          description: "Path to the transcript to summarize",
+          required: true
+        },
+        {
+          name: "audience",
+          description: "Target audience for the summary (e.g. internal team, external attendee)",
+          required: true
+        },
+        {
+          name: "stylePreset",
+          description: "Summary style: quick_bullets, detailed, attendee_facing (default: detailed)",
+          required: false
+        },
+        {
+          name: "guidance",
+          description: "Additional instructions (especially privacy/sensitivity constraints)",
+          required: false
+        },
+        {
+          name: "summaryTitle",
+          description: "Optional title to use for the summary output",
+          required: false
+        }
+      ]
+    },
     {
       name: "enrich_entity",
       description: "Add or update an entity with smart assistance for generating metadata.",
@@ -1731,6 +1820,10 @@ async function getPrompt(name, args) {
       return generateSetupProjectPrompt(args);
     case "review_transcript":
       return generateReviewTranscriptPrompt(args);
+    case "identify_tasks_from_transcript":
+      return generateIdentifyTasksFromTranscriptPrompt(args);
+    case "summarize_transcript":
+      return generateSummarizeTranscriptPrompt(args);
     case "enrich_entity":
       return generateEnrichEntityPrompt(args);
     case "batch_transcription":
@@ -1852,6 +1945,75 @@ async function generateReviewTranscriptPrompt(args) {
     }
   ];
 }
+async function generateIdentifyTasksFromTranscriptPrompt(args) {
+  const transcriptPath = args.transcriptPath;
+  if (!transcriptPath) {
+    throw new Error("transcriptPath is required");
+  }
+  const maxCandidates = args.maxCandidates?.trim() || "25";
+  const includeTagSuggestions = args.includeTagSuggestions?.trim() || "true";
+  const template = loadTemplate("identify_tasks_from_transcript");
+  const content = fillTemplate(template, {
+    transcriptPath,
+    maxCandidates,
+    includeTagSuggestions
+  });
+  return [
+    {
+      role: "user",
+      content: {
+        type: "text",
+        text: content
+      }
+    }
+  ];
+}
+async function generateSummarizeTranscriptPrompt(args) {
+  const transcriptPath = args.transcriptPath;
+  const audience = args.audience;
+  if (!transcriptPath) {
+    throw new Error("transcriptPath is required");
+  }
+  if (!audience) {
+    throw new Error("audience is required");
+  }
+  const presetMap = {
+    quick_bullets: {
+      label: "Quick paragraph + bullet points",
+      instructions: "Write one concise paragraph followed by 4-8 bullets covering decisions, actions, and risks."
+    },
+    detailed: {
+      label: "Detailed summary",
+      instructions: "Write a structured summary with context, key discussion points, decisions, open questions, and next steps."
+    },
+    attendee_facing: {
+      label: "Attendee-facing summary",
+      instructions: "Write a professional external-facing summary suitable for attendees; avoid private/internal reflections unless explicitly approved."
+    }
+  };
+  const presetKey = (args.stylePreset || "detailed").trim();
+  const selectedPreset = presetMap[presetKey] ?? presetMap.detailed;
+  const summaryTitleLine = args.summaryTitle?.trim() ? `- Target title: "${args.summaryTitle.trim()}"` : "- Target title: (auto-generate from transcript title and date)";
+  const guidanceBlock = args.guidance?.trim() ? args.guidance.trim() : "No extra guidance provided.";
+  const template = loadTemplate("summarize_transcript");
+  const content = fillTemplate(template, {
+    transcriptPath,
+    audience: audience.trim(),
+    styleLabel: selectedPreset.label,
+    styleInstructions: selectedPreset.instructions,
+    summaryTitleLine,
+    guidanceBlock
+  });
+  return [
+    {
+      role: "user",
+      content: {
+        type: "text",
+        text: content
+      }
+    }
+  ];
+}
 async function generateEnrichEntityPrompt(args) {
   const template = loadTemplate("enrich_entity");
   const content = fillTemplate(template, args);
@@ -4026,6 +4188,125 @@ async function handleSuggestTermMetadata(args) {
 }
 
 const { ensurePklExtension, transcriptExists } = Transcript;
+function parseStoredSummaries(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+      return [];
+    }
+    return parsed.map((item) => {
+      if (!item || typeof item !== "object") {
+        return null;
+      }
+      const record = item;
+      const id = String(record.id || "").trim();
+      const content = String(record.content || "").trim();
+      if (!id || !content) {
+        return null;
+      }
+      return {
+        id,
+        title: String(record.title || "").trim(),
+        audience: String(record.audience || "").trim(),
+        guidance: String(record.guidance || "").trim(),
+        stylePreset: String(record.stylePreset || "detailed").trim() || "detailed",
+        styleLabel: String(record.styleLabel || "Detailed summary").trim() || "Detailed summary",
+        content,
+        generatedAt: String(record.generatedAt || "").trim() || (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }).filter((summary) => summary !== null).sort((a, b) => b.generatedAt.localeCompare(a.generatedAt));
+  } catch {
+    return [];
+  }
+}
+const SUMMARY_STYLE_PRESETS = {
+  quick_bullets: {
+    label: "Quick paragraph + bullet points",
+    instructions: "Write one concise paragraph followed by 4-8 bullets covering decisions, actions, and risks."
+  },
+  detailed: {
+    label: "Detailed summary",
+    instructions: "Write a structured summary with context, key discussion points, decisions, open questions, and next steps."
+  },
+  attendee_facing: {
+    label: "Attendee-facing summary",
+    instructions: "Write a professional external-facing summary suitable for attendees; avoid private/internal reflections unless explicitly approved."
+  }
+};
+function splitIntoCandidateSentences(content) {
+  return content.split(/\n+|(?<=[.!?])\s+/g).map((sentence) => sentence.trim()).filter((sentence) => sentence.length >= 8);
+}
+function normalizeTaskText(sentence) {
+  const normalized = sentence.replace(/^(?:i need to|we need to|i should|we should|let'?s|remember to|todo:|action item:)\s+/i, "").replace(/\s+/g, " ").trim();
+  return normalized.charAt(0).toUpperCase() + normalized.slice(1);
+}
+function inferDueDate(sentence) {
+  const lower = sentence.toLowerCase();
+  if (lower.includes("today")) {
+    return "today";
+  }
+  if (lower.includes("tomorrow")) {
+    return "tomorrow";
+  }
+  if (lower.includes("next week")) {
+    return "next week";
+  }
+  if (lower.includes("this week")) {
+    return "this week";
+  }
+  if (lower.includes("by friday")) {
+    return "by friday";
+  }
+  return null;
+}
+function extractHashtagTags(sentence) {
+  const matches = sentence.match(/#[a-z0-9_-]+/gi) || [];
+  return Array.from(new Set(matches.map((tag) => tag.slice(1).toLowerCase())));
+}
+function toConfidenceBucket(score) {
+  if (score >= 0.75) {
+    return "high";
+  }
+  if (score >= 0.5) {
+    return "medium";
+  }
+  return "low";
+}
+function scoreTaskCandidate(sentence) {
+  const explicitActionPattern = /\b(i need to|we need to|i should|we should|let'?s|remember to|todo|action item|i will|i'll|must)\b/i;
+  const inferredIntentPattern = /\b(follow up|check|review|investigate|confirm|decide|plan|schedule|reach out|send|draft|prepare|update|fix|create|write|call|email|look into|figure out)\b/i;
+  let score = 0;
+  const rationaleParts = [];
+  if (explicitActionPattern.test(sentence)) {
+    score += 0.55;
+    rationaleParts.push("explicit action language");
+  }
+  if (inferredIntentPattern.test(sentence)) {
+    score += 0.35;
+    rationaleParts.push("inferred follow-up intent");
+  }
+  if (inferDueDate(sentence)) {
+    score += 0.1;
+    rationaleParts.push("time cue detected");
+  }
+  if (score < 0.3) {
+    return null;
+  }
+  return {
+    score: Math.min(1, Number(score.toFixed(2))),
+    rationale: rationaleParts.join("; ")
+  };
+}
+function getSuggestedEntities(entities) {
+  if (!entities) {
+    return [];
+  }
+  const people = (entities.people || []).map((entity) => ({ ...entity, type: "person" }));
+  const projects = (entities.projects || []).map((entity) => ({ ...entity, type: "project" }));
+  const terms = (entities.terms || []).map((entity) => ({ ...entity, type: "term" }));
+  const companies = (entities.companies || []).map((entity) => ({ ...entity, type: "company" }));
+  return [...people, ...projects, ...terms, ...companies];
+}
 const readTranscriptTool = {
   name: "protokoll_read_transcript",
   description: "Read a transcript file and parse its metadata and content. Path is relative to the configured output directory. Returns structured data including title, metadata, routing info, and content.",
@@ -4099,6 +4380,34 @@ const listTranscriptsTool = {
     required: []
   }
 };
+const identifyTasksFromTranscriptTool = {
+  name: "protokoll_identify_tasks_from_transcript",
+  description: "Identify task candidates from transcript or note content without creating tasks. Returns structured candidates with confidence buckets, rationale, and metadata suggestions so users can review and choose which tasks to create.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      transcriptPath: {
+        type: "string",
+        description: 'Transcript URI (preferred) or relative path from output directory. URI format: "protokoll://transcript/2026/2/12-1606-meeting" (no file extension). Path format: "2026/2/12-1606-meeting" or "2026/2/12-1606-meeting.pkl"'
+      },
+      maxCandidates: {
+        type: "number",
+        description: "Maximum number of candidates to return (default: 25, max: 50)",
+        default: 25
+      },
+      includeTagSuggestions: {
+        type: "boolean",
+        description: "Whether to include suggested tags based on transcript metadata and hashtags (default: true)",
+        default: true
+      },
+      contextDirectory: {
+        type: "string",
+        description: "Optional: Path to the .protokoll context directory"
+      }
+    },
+    required: ["transcriptPath"]
+  }
+};
 const editTranscriptTool = {
   name: "protokoll_edit_transcript",
   description: "Edit an existing transcript's title, project assignment, tags, and/or status. Path is relative to the configured output directory. 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.",
@@ -4140,6 +4449,68 @@ const editTranscriptTool = {
     required: ["transcriptPath"]
   }
 };
+const summarizeTranscriptTool = {
+  name: "protokoll_summarize_transcript",
+  description: "Generate an audience-aware summary for a transcript using privacy/sensitivity guardrails. Returns markdown summary text and does not modify transcript content.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      transcriptPath: {
+        type: "string",
+        description: 'Transcript URI (preferred) or relative path from output directory. URI format: "protokoll://transcript/2026/2/12-1606-meeting" (no file extension). Path format: "2026/2/12-1606-meeting" or "2026/2/12-1606-meeting.pkl"'
+      },
+      audience: {
+        type: "string",
+        description: "Optional audience label (e.g. internal team, project attendees, external partner)"
+      },
+      stylePreset: {
+        type: "string",
+        enum: ["quick_bullets", "detailed", "attendee_facing"],
+        description: "Summary style preset (default: detailed)",
+        default: "detailed"
+      },
+      guidance: {
+        type: "string",
+        description: "Optional extra instructions, especially for privacy/sensitivity constraints"
+      },
+      summaryTitle: {
+        type: "string",
+        description: "Optional title to use in the generated summary"
+      },
+      model: {
+        type: "string",
+        description: `LLM model for summary generation (default: ${DEFAULT_MODEL})`
+      },
+      contextDirectory: {
+        type: "string",
+        description: "Optional: Path to the .protokoll context directory"
+      }
+    },
+    required: ["transcriptPath"]
+  }
+};
+const deleteTranscriptSummaryTool = {
+  name: "protokoll_delete_transcript_summary",
+  description: "Delete a previously generated summary from transcript artifact storage by summary ID. Path is relative to the configured output directory.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      transcriptPath: {
+        type: "string",
+        description: 'Transcript URI (preferred) or relative path from output directory. URI format: "protokoll://transcript/2026/2/12-1606-meeting" (no file extension). Path format: "2026/2/12-1606-meeting" or "2026/2/12-1606-meeting.pkl"'
+      },
+      summaryId: {
+        type: "string",
+        description: 'Summary ID to remove (for example: "summary-174..." )'
+      },
+      contextDirectory: {
+        type: "string",
+        description: "Optional: Path to the .protokoll context directory"
+      }
+    },
+    required: ["transcriptPath", "summaryId"]
+  }
+};
 const changeTranscriptDateTool = {
   name: "protokoll_change_transcript_date",
   description: "Change the date of an existing transcript. This will move the transcript file to a new location based on the new date and the project's routing configuration. The file will be moved to the appropriate YYYY/MM/ directory structure. Path is relative to the configured output directory. WARNING: This may remove the transcript from the current view if it moves to a different date folder.",
@@ -4215,6 +4586,32 @@ const provideFeedbackTool = {
     required: ["transcriptPath", "feedback"]
   }
 };
+const enhanceTranscriptTool = {
+  name: "protokoll_enhance_transcript",
+  description: "Enhance an existing transcript using the same post-transcription pipeline flow (simple-replace + agentic tool-based enhancement) used after Whisper completes. Reads from originalText when provided, otherwise uses raw transcript text if available, falling back to current transcript content. Writes enhanced content and updates metadata/status.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      transcriptPath: {
+        type: "string",
+        description: 'Transcript URI (preferred) or relative path from output directory. URI format: "protokoll://transcript/2026/2/12-1606-meeting" (no file extension). Path format: "2026/2/12-1606-meeting" or "2026/2/12-1606-meeting.pkl"'
+      },
+      originalText: {
+        type: "string",
+        description: "Optional explicit source text to enhance (usually the Original tab text). If omitted, tool uses raw transcript text when present, else current content."
+      },
+      model: {
+        type: "string",
+        description: `LLM model for enhancement (default: ${DEFAULT_MODEL})`
+      },
+      contextDirectory: {
+        type: "string",
+        description: "Optional: Path to the .protokoll context directory"
+      }
+    },
+    required: ["transcriptPath"]
+  }
+};
 const updateTranscriptContentTool = {
   name: "protokoll_update_transcript_content",
   description: "Update the content section of a transcript file while preserving all metadata. Path is relative to the configured output directory. This tool replaces only the content between the --- delimiters, keeping all metadata intact. IMPORTANT: The content parameter should contain ONLY the transcript body text (the text after the --- delimiter), NOT the full transcript file with headers and metadata. If the full transcript is provided, the tool will automatically extract only the content section to prevent duplication.",
@@ -4419,11 +4816,42 @@ const correctToEntityTool = {
     required: ["transcriptPath", "selectedText", "entityType"]
   }
 };
+const rejectCorrectionTool = {
+  name: "protokoll_reject_correction",
+  description: "Reject a previously applied enhancement correction and undo its text replacement in the transcript. Also logs the rejection in enhancement_log for auditability.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      transcriptPath: {
+        type: "string",
+        description: 'Transcript URI (preferred) or relative path from output directory. URI format: "protokoll://transcript/2026/2/12-1606-meeting" (no file extension). Path format: "2026/2/12-1606-meeting" or "2026/2/12-1606-meeting.pkl"'
+      },
+      correctionEntryId: {
+        type: "number",
+        description: "Enhancement log entry id for the correction_applied event to reject"
+      },
+      contextDirectory: {
+        type: "string",
+        description: "Optional: Path to the .protokoll context directory"
+      }
+    },
+    required: ["transcriptPath", "correctionEntryId"]
+  }
+};
 async function handleReadTranscript(args) {
   const absolutePath = await resolveTranscriptPath$1(args.transcriptPath, args.contextDirectory);
   const transcriptData = await readTranscript(absolutePath);
   const outputDirectory = await getConfiguredDirectory("outputDirectory", args.contextDirectory);
   const relativePath = await sanitizePath(absolutePath, outputDirectory);
+  const transcriptHandle = PklTranscript.open(absolutePath, { readOnly: true });
+  let summaries = [];
+  try {
+    const historyArtifact = transcriptHandle.getArtifact("summary_history");
+    const rawHistory = historyArtifact?.data?.toString("utf8") || "[]";
+    summaries = parseStoredSummaries(rawHistory);
+  } finally {
+    transcriptHandle.close();
+  }
   return {
     filePath: relativePath,
     title: transcriptData.metadata.title || "",
@@ -4443,7 +4871,8 @@ async function handleReadTranscript(args) {
     },
     content: transcriptData.content,
     hasRawTranscript: transcriptData.hasRawTranscript,
-    contentLength: transcriptData.content.length
+    contentLength: transcriptData.content.length,
+    summaries
   };
 }
 async function handleListTranscripts(args) {
@@ -4496,6 +4925,236 @@ async function handleListTranscripts(args) {
     }
   };
 }
+async function handleIdentifyTasksFromTranscript(args) {
+  const absolutePath = await resolveTranscriptPath$1(args.transcriptPath, args.contextDirectory);
+  const transcriptData = await readTranscript(absolutePath);
+  const content = transcriptData.content?.trim() || "";
+  if (!content) {
+    return {
+      transcriptPath: args.transcriptPath,
+      candidates: [],
+      totalCandidates: 0,
+      message: "Transcript content is empty; no task candidates identified."
+    };
+  }
+  const limit = Math.max(1, Math.min(50, args.maxCandidates ?? 25));
+  const includeTagSuggestions = args.includeTagSuggestions !== false;
+  const existingTags = transcriptData.metadata.tags || [];
+  const suggestedEntities = getSuggestedEntities(transcriptData.metadata.entities);
+  const suggestedProject = {
+    id: transcriptData.metadata.projectId || null,
+    name: transcriptData.metadata.project || null
+  };
+  const candidates = splitIntoCandidateSentences(content).map((sentence, index) => {
+    const scored = scoreTaskCandidate(sentence);
+    if (!scored) {
+      return null;
+    }
+    const sentenceTags = includeTagSuggestions ? extractHashtagTags(sentence) : [];
+    const mergedTags = includeTagSuggestions ? Array.from(/* @__PURE__ */ new Set([...existingTags.map((tag) => tag.toLowerCase()), ...sentenceTags])) : [];
+    const candidate = {
+      id: `candidate-${index + 1}`,
+      taskText: normalizeTaskText(sentence),
+      confidence: scored.score,
+      confidenceBucket: toConfidenceBucket(scored.score),
+      rationale: scored.rationale,
+      sourceExcerpt: sentence,
+      suggestedDueDate: inferDueDate(sentence),
+      suggestedProject,
+      suggestedEntities,
+      suggestedTags: mergedTags
+    };
+    return candidate;
+  }).filter((candidate) => candidate !== null).sort((a, b) => b.confidence - a.confidence).slice(0, limit);
+  return {
+    transcriptPath: args.transcriptPath,
+    candidates,
+    totalCandidates: candidates.length,
+    message: candidates.length > 0 ? `Identified ${candidates.length} task candidate(s).` : "No likely task candidates found in transcript content."
+  };
+}
+async function handleSummarizeTranscript(args) {
+  const startedAt = Date.now();
+  const logSummary = (message, data) => {
+    process.stdout.write(`Protokoll: [SUMMARY] ${message} ${JSON.stringify(data)}
+`);
+  };
+  logSummary("Tool call received", {
+    transcriptPath: args.transcriptPath,
+    audience: args.audience,
+    stylePreset: args.stylePreset || "detailed",
+    hasGuidance: !!args.guidance?.trim(),
+    hasSummaryTitle: !!args.summaryTitle?.trim(),
+    model: args.model || DEFAULT_MODEL
+  });
+  const absolutePath = await resolveTranscriptPath$1(args.transcriptPath, args.contextDirectory);
+  logSummary("Resolved transcript path", {
+    transcriptPath: args.transcriptPath,
+    absolutePath
+  });
+  const transcriptData = await readTranscript(absolutePath);
+  const transcriptContent = (transcriptData.content || "").trim();
+  if (!transcriptContent) {
+    logSummary("Transcript content empty, cannot summarize", {
+      transcriptPath: args.transcriptPath,
+      absolutePath
+    });
+    throw new Error("Transcript content is empty; cannot generate summary.");
+  }
+  const audience = (args.audience || "").trim() || "General audience";
+  const stylePreset = (args.stylePreset || "detailed").trim();
+  const selectedStyle = SUMMARY_STYLE_PRESETS[stylePreset] || SUMMARY_STYLE_PRESETS.detailed;
+  const guidance = (args.guidance || "").trim();
+  const model = args.model || DEFAULT_MODEL;
+  const transcriptTitle = transcriptData.metadata.title || "Untitled transcript";
+  const transcriptDate = transcriptData.metadata.date instanceof Date ? transcriptData.metadata.date.toISOString().slice(0, 10) : "unknown date";
+  const preferredTitle = (args.summaryTitle || "").trim();
+  const boundedContent = transcriptContent.length > MAX_CONTENT_LENGTH ? `${transcriptContent.slice(0, MAX_CONTENT_LENGTH)}
+
+[...transcript truncated for summarization input length...]` : transcriptContent;
+  const truncated = transcriptContent.length > MAX_CONTENT_LENGTH;
+  logSummary("Prepared summary input", {
+    transcriptTitle,
+    transcriptDate,
+    transcriptLength: transcriptContent.length,
+    boundedLength: boundedContent.length,
+    truncated,
+    stylePreset
+  });
+  const reasoning = Reasoning.create({
+    model,
+    reasoningLevel: "medium"
+  });
+  const prompt = [
+    "Create an audience-aware summary for the transcript below.",
+    "",
+    `Transcript title: ${transcriptTitle}`,
+    `Transcript date: ${transcriptDate}`,
+    `Audience: ${audience}`,
+    `Style preset: ${selectedStyle.label}`,
+    preferredTitle ? `Preferred summary title: ${preferredTitle}` : "Preferred summary title: (generate one)",
+    "",
+    "Style instructions:",
+    selectedStyle.instructions,
+    "",
+    "Privacy and sensitivity guardrails:",
+    "- Treat transcript content as potentially sensitive by default.",
+    "- Exclude private internal reflections, personal judgments, or sensitive notes not appropriate for the audience.",
+    "- If unsure whether a detail is audience-appropriate, exclude it or generalize safely.",
+    "- Prefer factual and neutral language over speculative interpretation.",
+    "",
+    "Additional guidance:",
+    guidance || "No extra guidance provided.",
+    "",
+    "Required output shape:",
+    "1) Title",
+    "2) Summary body matching the selected style preset",
+    '3) Optional "Redactions / Exclusions" section listing what was intentionally omitted for audience safety',
+    "",
+    "Transcript:",
+    boundedContent
+  ].join("\n");
+  const result = await reasoning.complete({
+    prompt,
+    systemPrompt: "You are an expert meeting summarizer. Return markdown only."
+  });
+  logSummary("Reasoning call completed", {
+    transcriptPath: args.transcriptPath,
+    model: result.model || model,
+    durationMs: result.duration ?? null,
+    finishReason: result.finishReason ?? null
+  });
+  const summary = (result.content || "").trim();
+  if (!summary) {
+    logSummary("Empty summary response", {
+      transcriptPath: args.transcriptPath,
+      model: result.model || model
+    });
+    throw new Error("No summary text generated.");
+  }
+  logSummary("Summary generated successfully", {
+    transcriptPath: args.transcriptPath,
+    summaryLength: summary.length,
+    elapsedMs: Date.now() - startedAt
+  });
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const summaryId = `summary-${Date.now()}-${randomUUID$1().slice(0, 8)}`;
+  const stylePresetKey = SUMMARY_STYLE_PRESETS[stylePreset] ? stylePreset : "detailed";
+  const storedSummary = {
+    id: summaryId,
+    title: preferredTitle || `${transcriptTitle} Summary`,
+    audience,
+    guidance,
+    stylePreset: stylePresetKey,
+    styleLabel: selectedStyle.label,
+    content: summary,
+    generatedAt
+  };
+  const transcriptHandle = PklTranscript.open(absolutePath, { readOnly: false });
+  try {
+    const existingHistory = transcriptHandle.getArtifact("summary_history");
+    const existingSummaries = parseStoredSummaries(existingHistory?.data?.toString("utf8") || "[]");
+    const nextSummaries = [storedSummary, ...existingSummaries.filter((entry) => entry.id !== summaryId)];
+    transcriptHandle.addArtifact(
+      "summary_history",
+      Buffer.from(JSON.stringify(nextSummaries), "utf8"),
+      {
+        version: 1,
+        count: nextSummaries.length,
+        updatedAt: generatedAt,
+        model: result.model || model
+      }
+    );
+  } finally {
+    transcriptHandle.close();
+  }
+  logSummary("Summary persisted to transcript artifact storage", {
+    transcriptPath: args.transcriptPath,
+    summaryId,
+    generatedAt
+  });
+  return {
+    summary,
+    audience,
+    stylePreset: stylePresetKey,
+    model: result.model || model,
+    summaryId,
+    generatedAt
+  };
+}
+async function handleDeleteTranscriptSummary(args) {
+  const summaryId = (args.summaryId || "").trim();
+  if (!summaryId) {
+    throw new Error("summaryId is required");
+  }
+  const absolutePath = await resolveTranscriptPath$1(args.transcriptPath, args.contextDirectory);
+  const transcriptHandle = PklTranscript.open(absolutePath, { readOnly: false });
+  try {
+    const historyArtifact = transcriptHandle.getArtifact("summary_history");
+    const existingSummaries = parseStoredSummaries(historyArtifact?.data?.toString("utf8") || "[]");
+    const remainingSummaries = existingSummaries.filter((entry) => entry.id !== summaryId);
+    if (remainingSummaries.length === existingSummaries.length) {
+      throw new Error(`Summary not found: ${summaryId}`);
+    }
+    transcriptHandle.addArtifact(
+      "summary_history",
+      Buffer.from(JSON.stringify(remainingSummaries), "utf8"),
+      {
+        version: 1,
+        count: remainingSummaries.length,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        deletedSummaryId: summaryId
+      }
+    );
+    return {
+      success: true,
+      summaryId,
+      remaining: remainingSummaries.length
+    };
+  } finally {
+    transcriptHandle.close();
+  }
+}
 async function handleEditTranscript(args) {
   await validateNotRemoteMode(args.contextDirectory);
   const outputDirectory = await getConfiguredDirectory("outputDirectory", args.contextDirectory);
@@ -4821,6 +5480,220 @@ async function handleProvideFeedback(args) {
     transcript.close();
   }
 }
+async function handleEnhanceTranscript(args) {
+  const absolutePath = await resolveTranscriptPath$1(args.transcriptPath, args.contextDirectory);
+  const pklPath = ensurePklExtension(absolutePath);
+  const transcript = PklTranscript.open(pklPath, { readOnly: false });
+  let tempDir = null;
+  try {
+    const explicitOriginal = (args.originalText || "").trim();
+    const rawOriginal = (transcript.rawTranscript?.text || "").trim();
+    const currentContent = (transcript.content || "").trim();
+    const sourceText = explicitOriginal || rawOriginal || currentContent;
+    if (!sourceText) {
+      throw new Error("No source text available to enhance. Save or provide Original content first.");
+    }
+    const model = args.model || DEFAULT_MODEL;
+    const startedAt = Date.now();
+    let toolCallCount = 0;
+    const contextDirectories = await getContextDirectories();
+    const context = await create({
+      startingDir: args.contextDirectory || dirname(pklPath),
+      contextDirectories
+    });
+    const outputDirectory = await getConfiguredDirectory("outputDirectory", args.contextDirectory);
+    const defaultStructure = "month";
+    const defaultFilenameOptions = ["date", "time", "subject"];
+    const routingProjects = context.getAllProjects().filter((project) => project.active !== false).map((project) => ({
+      projectId: project.id,
+      destination: {
+        path: project.routing?.destination || outputDirectory,
+        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
+    }));
+    const routing = Routing.create({
+      default: {
+        path: outputDirectory,
+        structure: defaultStructure,
+        filename_options: [...defaultFilenameOptions],
+        createDirectories: true
+      },
+      projects: routingProjects,
+      conflict_resolution: "primary"
+    }, context);
+    const fallbackDate = transcript.metadata.date instanceof Date ? transcript.metadata.date : /* @__PURE__ */ new Date();
+    const fallbackHash = transcript.metadata.audioHash || transcript.metadata.id || "";
+    const routingContext = {
+      transcriptText: sourceText,
+      audioDate: fallbackDate,
+      sourceFile: pklPath,
+      hash: fallbackHash
+    };
+    const routeResult = routing.route(routingContext);
+    const projectForReplace = routeResult.projectId || transcript.metadata.projectId || transcript.metadata.project;
+    transcript.enhancementLog.logStep(/* @__PURE__ */ new Date(), "enhance", "enhancement_start", {
+      model,
+      transcriptPath: args.transcriptPath,
+      hasExplicitOriginal: explicitOriginal.length > 0,
+      source: explicitOriginal ? "explicit_original_text" : rawOriginal ? "raw_transcript" : "enhanced_content_fallback",
+      routedProject: routeResult.projectId || null,
+      routedConfidence: routeResult.confidence
+    });
+    tempDir = await mkdtemp(resolve(tmpdir(), "protokoll-enhance-"));
+    const simpleReplace = Phases.createSimpleReplacePhase({ debug: false }, context);
+    const simpleReplaceResult = await simpleReplace.replace(
+      sourceText,
+      {
+        project: projectForReplace || void 0,
+        confidence: routeResult.confidence
+      },
+      tempDir,
+      transcript.metadata.id || "manual-enhancement"
+    );
+    if (simpleReplaceResult.stats.totalReplacements > 0) {
+      transcript.enhancementLog.logStep(/* @__PURE__ */ new Date(), "simple-replace", "phase_complete", {
+        totalReplacements: simpleReplaceResult.stats.totalReplacements,
+        tier1Replacements: simpleReplaceResult.stats.tier1Replacements,
+        tier2Replacements: simpleReplaceResult.stats.tier2Replacements,
+        projectContext: simpleReplaceResult.stats.projectContext,
+        processingTimeMs: simpleReplaceResult.stats.processingTimeMs
+      });
+      for (const mapping of simpleReplaceResult.stats.appliedMappings) {
+        transcript.enhancementLog.logStep(/* @__PURE__ */ new Date(), "simple-replace", "correction_applied", {
+          original: mapping.soundsLike,
+          replacement: mapping.correctText,
+          tier: mapping.tier,
+          occurrences: mapping.occurrences,
+          entityId: mapping.entityId,
+          entityType: mapping.entityType
+        });
+      }
+    }
+    const preIdentifiedEntities = {
+      people: /* @__PURE__ */ new Set(),
+      projects: /* @__PURE__ */ new Set(),
+      terms: /* @__PURE__ */ new Set(),
+      companies: /* @__PURE__ */ new Set()
+    };
+    for (const mapping of simpleReplaceResult.stats.appliedMappings) {
+      if (!mapping.entityId || !mapping.entityType) {
+        continue;
+      }
+      if (mapping.entityType === "person") {
+        preIdentifiedEntities.people.add(mapping.entityId);
+      } else if (mapping.entityType === "project") {
+        preIdentifiedEntities.projects.add(mapping.entityId);
+      } else if (mapping.entityType === "term") {
+        preIdentifiedEntities.terms.add(mapping.entityId);
+      }
+    }
+    const reasoning = Reasoning.create({ model, reasoningLevel: "medium" });
+    const executor = Agentic.create(reasoning, {
+      transcriptText: simpleReplaceResult.text,
+      audioDate: fallbackDate,
+      sourceFile: pklPath,
+      contextInstance: context,
+      routingInstance: routing,
+      interactiveMode: false,
+      preIdentifiedEntities,
+      onToolCallStart: (tool, input) => {
+        toolCallCount++;
+        transcript.enhancementLog.logStep(/* @__PURE__ */ new Date(), "enhance", "tool_start", {
+          callIndex: toolCallCount,
+          tool,
+          input
+        });
+      },
+      onToolCallComplete: (entry) => {
+        transcript.enhancementLog.logStep(entry.timestamp, "enhance", "tool_complete", {
+          tool: entry.tool,
+          input: entry.input,
+          output: entry.output,
+          durationMs: entry.durationMs,
+          success: entry.success
+        });
+      }
+    });
+    const agenticResult = await executor.process(simpleReplaceResult.text);
+    const enhancedText = (agenticResult.enhancedText || "").trim() || sourceText;
+    const enhancementSucceeded = enhancedText.length > 50 && enhancedText !== sourceText;
+    const finalStatus = enhancementSucceeded ? "enhanced" : transcript.metadata.status || "initial";
+    const referenced = agenticResult.state.referencedEntities;
+    const entities = {
+      people: [],
+      projects: [],
+      terms: [],
+      companies: []
+    };
+    for (const personId of referenced.people) {
+      const person = context.getPerson(personId);
+      if (person) {
+        entities.people.push({ id: person.id, name: person.name, type: "person" });
+      }
+    }
+    for (const projectId of referenced.projects) {
+      const project = context.getProject(projectId);
+      if (project) {
+        entities.projects.push({ id: project.id, name: project.name, type: "project" });
+      }
+    }
+    for (const termId of referenced.terms) {
+      const term = context.getTerm(termId);
+      if (term) {
+        entities.terms.push({ id: term.id, name: term.name, type: "term" });
+      }
+    }
+    for (const companyId of referenced.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;
+    const decidedProjectId = agenticResult.state.routeDecision?.projectId || routeResult.projectId || void 0;
+    const decidedProject = decidedProjectId ? context.getProject(decidedProjectId) : void 0;
+    const decidedConfidence = agenticResult.state.routeDecision?.confidence ?? routeResult.confidence;
+    transcript.updateContent(enhancedText);
+    transcript.updateMetadata({
+      status: finalStatus,
+      projectId: decidedProjectId || transcript.metadata.projectId,
+      project: decidedProject?.name || transcript.metadata.project,
+      confidence: typeof decidedConfidence === "number" ? decidedConfidence : transcript.metadata.confidence,
+      entities: hasEntities ? entities : transcript.metadata.entities
+    });
+    transcript.enhancementLog.logStep(/* @__PURE__ */ new Date(), "enhance", "enhancement_complete", {
+      status: finalStatus,
+      toolsUsed: agenticResult.toolsUsed,
+      totalToolCalls: toolCallCount,
+      iterations: agenticResult.iterations,
+      processingTimeMs: Date.now() - startedAt
+    });
+    return {
+      success: true,
+      transcriptPath: args.transcriptPath,
+      status: finalStatus,
+      projectId: decidedProjectId || null,
+      projectName: decidedProject?.name || null,
+      toolsUsed: agenticResult.toolsUsed,
+      totalToolCalls: toolCallCount,
+      iterations: agenticResult.iterations,
+      processingTimeMs: Date.now() - startedAt,
+      sourceLength: sourceText.length,
+      enhancedLength: enhancedText.length,
+      changed: enhancedText !== sourceText
+    };
+  } finally {
+    if (tempDir) {
+      await rm(tempDir, { recursive: true, force: true });
+    }
+    transcript.close();
+  }
+}
 async function handleCreateNote(args) {
   const outputDirectory = await getConfiguredDirectory("outputDirectory", args.contextDirectory);
   const noteDate = args.date ? new Date(args.date) : /* @__PURE__ */ new Date();
@@ -4927,8 +5800,89 @@ function applyCorrections(transcriptText, corrections) {
   }
   return correctedText;
 }
+function countOccurrencesCaseInsensitive(text, target) {
+  if (!target.trim()) {
+    return 0;
+  }
+  const regex = new RegExp(target.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "gi");
+  const matches = text.match(regex);
+  return matches ? matches.length : 0;
+}
+async function handleRejectCorrection(args) {
+  if (!Number.isInteger(args.correctionEntryId) || args.correctionEntryId < 1) {
+    throw new Error("correctionEntryId must be a positive integer");
+  }
+  const absolutePath = await resolveTranscriptPath$1(args.transcriptPath, args.contextDirectory);
+  const transcript = PklTranscript.open(absolutePath, { readOnly: false });
+  try {
+    const allEntries = transcript.getEnhancementLog();
+    const correctionEntry = allEntries.find((entry) => entry.id === args.correctionEntryId);
+    if (!correctionEntry) {
+      throw new Error(`Correction entry not found: ${args.correctionEntryId}`);
+    }
+    if (correctionEntry.action !== "correction_applied") {
+      throw new Error(`Entry ${args.correctionEntryId} is not a correction_applied action`);
+    }
+    const details = correctionEntry.details || {};
+    const original = String(details.original || "").trim();
+    const replacement = String(details.replacement || "").trim();
+    if (!original || !replacement) {
+      throw new Error(`Correction entry ${args.correctionEntryId} is missing original/replacement details`);
+    }
+    const alreadyRejected = allEntries.some((entry) => {
+      if (entry.action !== "correction_rejected") {
+        return false;
+      }
+      const rejectDetails = entry.details || {};
+      return Number(rejectDetails.correctionEntryId) === args.correctionEntryId;
+    });
+    if (alreadyRejected) {
+      return {
+        success: true,
+        alreadyRejected: true,
+        correctionEntryId: args.correctionEntryId,
+        original,
+        replacement,
+        revertedOccurrences: 0,
+        message: `Correction #${args.correctionEntryId} is already rejected`
+      };
+    }
+    const originalContent = transcript.content || "";
+    const beforeCount = countOccurrencesCaseInsensitive(originalContent, replacement);
+    const revertedContent = applyCorrections(
+      originalContent,
+      /* @__PURE__ */ new Map([[replacement, original]])
+    );
+    const afterCount = countOccurrencesCaseInsensitive(revertedContent, replacement);
+    const revertedOccurrences = Math.max(0, beforeCount - afterCount);
+    const rejectionPhase = correctionEntry.phase === "transcribe" || correctionEntry.phase === "enhance" || correctionEntry.phase === "simple-replace" ? correctionEntry.phase : "simple-replace";
+    transcript.updateContent(revertedContent);
+    transcript.enhancementLog.logStep(
+      /* @__PURE__ */ new Date(),
+      rejectionPhase,
+      "correction_rejected",
+      {
+        correctionEntryId: args.correctionEntryId,
+        original,
+        replacement,
+        revertedOccurrences,
+        sourceTimestamp: correctionEntry.timestamp.toISOString()
+      }
+    );
+    return {
+      success: true,
+      correctionEntryId: args.correctionEntryId,
+      original,
+      replacement,
+      revertedOccurrences,
+      message: `Rejected correction #${args.correctionEntryId} and restored "${replacement}" to "${original}"`
+    };
+  } finally {
+    transcript.close();
+  }
+}
 async function handleCorrectToEntity(args) {
-  const { randomUUID } = await import('node:crypto');
+  const { randomUUID: randomUUID2 } = await import('node:crypto');
   const { slugify } = await Promise.resolve().then(() => shared);
   const ServerConfig = await Promise.resolve().then(() => serverConfig$1);
   const context = ServerConfig.getContext();
@@ -4941,7 +5895,7 @@ async function handleCorrectToEntity(args) {
   let finalEntityName;
   let isNewEntity = false;
   if (args.entityName) {
-    const id = randomUUID();
+    const id = randomUUID2();
     const slug = slugify(args.entityName);
     const entityBase = {
       id,
@@ -6259,15 +7213,20 @@ const tools = [
   // Transcript Operations
   readTranscriptTool,
   listTranscriptsTool,
+  identifyTasksFromTranscriptTool,
+  summarizeTranscriptTool,
+  deleteTranscriptSummaryTool,
   editTranscriptTool,
   changeTranscriptDateTool,
   combineTranscriptsTool,
   provideFeedbackTool,
+  enhanceTranscriptTool,
   updateTranscriptContentTool,
   updateTranscriptEntityReferencesTool,
   createNoteTool,
   getEnhancementLogTool,
   correctToEntityTool,
+  rejectCorrectionTool,
   // Lifecycle Status & Tasks
   setStatusTool,
   createTaskTool,
@@ -6368,6 +7327,12 @@ async function handleToolCall(name, args) {
       return handleReadTranscript(args);
     case "protokoll_list_transcripts":
       return handleListTranscripts(args);
+    case "protokoll_identify_tasks_from_transcript":
+      return handleIdentifyTasksFromTranscript(args);
+    case "protokoll_summarize_transcript":
+      return handleSummarizeTranscript(args);
+    case "protokoll_delete_transcript_summary":
+      return handleDeleteTranscriptSummary(args);
     case "protokoll_edit_transcript":
       return handleEditTranscript(args);
     case "protokoll_change_transcript_date":
@@ -6376,6 +7341,8 @@ async function handleToolCall(name, args) {
       return handleCombineTranscripts(args);
     case "protokoll_provide_feedback":
       return handleProvideFeedback(args);
+    case "protokoll_enhance_transcript":
+      return handleEnhanceTranscript(args);
     case "protokoll_update_transcript_content":
       return handleUpdateTranscriptContent(args);
     case "protokoll_update_transcript_entity_references":
@@ -6386,6 +7353,8 @@ async function handleToolCall(name, args) {
       return handleGetEnhancementLog(args);
     case "protokoll_correct_to_entity":
       return handleCorrectToEntity(args);
+    case "protokoll_reject_correction":
+      return handleRejectCorrection(args);
     // Lifecycle Status & Tasks
     case "protokoll_set_status":
       return handleSetStatus(args);