@daniel156161/prism 0.2.78 → 0.2.82

package/src/prism-extensions/integrations/ai-memory-system.ts

@@ -2,24 +2,39 @@ type ExtensionAPI = any
 
 import { Type } from "typebox"
 import { readSettings } from "../core/shared-config.js"
+import { formatDegradedNotice } from "./ai-memory-errors.js"
+import {
+  aiMemoryBaseUrl,
+  aiMemoryInjectCacheTtlMs,
+  aiMemoryInjectTimeoutMs,
+  aiMemoryRequestTimeoutMs,
+  aiMemoryStatusTimeoutMs,
+  deleteJson,
+  getJson,
+  methodJson,
+  postJson,
+  putJson,
+} from "./ai-memory-http.js"
+import { isAiMemoryWriteTool, renderAiMemoryWriteResult } from "./ai-memory-write-preview.js"
 import { renderCollapsibleTextResult } from "../ui/collapsed-text-rendering.js"
-import { formatBracketedToolCall, renderSingleLineToolCall, type ThemeLike } from "../ui/tool-call-rendering.js"
+import { obsidianOpenUrl } from "./obsidian-memory.js"
+import { ansiHyperlink, formatBracketedToolCall, renderSingleLineToolCall, type ThemeLike } from "../ui/tool-call-rendering.js"
 
-const DEFAULT_BASE_URL = "http://127.0.0.1:8765"
 const DEFAULT_LIMIT = 8
 const DEFAULT_CONTEXT_LIMIT = 5
 const DEFAULT_CONTEXT_SCORE_THRESHOLD = 0.15
-const DEFAULT_REQUEST_TIMEOUT_MS = 30_000
-const DEFAULT_STATUS_TIMEOUT_MS = 1_500
-const DEFAULT_INJECT_TIMEOUT_MS = 1_200
-const DEFAULT_INJECT_CACHE_TTL_MS = 60_000
 const DEFAULT_ALWAYS_CONTEXT_CACHE_TTL_MS = 60_000
 
 const injectCache = new Map<string, { expiresAt: number; results: any[] }>()
 const alwaysContextCache = { expiresAt: 0, content: "" }
-
-function aiMemoryBaseUrl(env: NodeJS.ProcessEnv = process.env): string {
-  return (env.PRISM_AI_MEMORY_BASE_URL || env.AI_MEMORY_BASE_URL || DEFAULT_BASE_URL).replace(/\/+$/, "")
+const reportedBackgroundFailures = new Set<string>()
+
+/** Test hook: drop injection caches and one-shot failure notices. */
+export function resetAiMemoryCaches(): void {
+  injectCache.clear()
+  alwaysContextCache.expiresAt = 0
+  alwaysContextCache.content = ""
+  reportedBackgroundFailures.clear()
 }
 
 function clampLimit(value: unknown, fallback = DEFAULT_LIMIT): number {
@@ -68,28 +83,6 @@ function aiMemoryContextScoreThreshold(env: NodeJS.ProcessEnv = process.env): nu
   return Number.isFinite(parsed) ? Math.max(0, parsed) : DEFAULT_CONTEXT_SCORE_THRESHOLD
 }
 
-function positiveIntegerSetting(value: unknown, fallback: number): number {
-  const parsed = Number(value)
-  if (!Number.isFinite(parsed)) return fallback
-  return Math.max(1, Math.trunc(parsed))
-}
-
-function aiMemoryRequestTimeoutMs(env: NodeJS.ProcessEnv = process.env): number {
-  return positiveIntegerSetting(env.PRISM_AI_MEMORY_TIMEOUT_MS ?? env.PI_AI_MEMORY_TIMEOUT_MS, DEFAULT_REQUEST_TIMEOUT_MS)
-}
-
-function aiMemoryStatusTimeoutMs(env: NodeJS.ProcessEnv = process.env): number {
-  return positiveIntegerSetting(env.PRISM_AI_MEMORY_STATUS_TIMEOUT_MS ?? env.PI_AI_MEMORY_STATUS_TIMEOUT_MS, DEFAULT_STATUS_TIMEOUT_MS)
-}
-
-function aiMemoryInjectTimeoutMs(env: NodeJS.ProcessEnv = process.env): number {
-  return positiveIntegerSetting(env.PRISM_AI_MEMORY_INJECT_TIMEOUT_MS ?? env.PI_AI_MEMORY_INJECT_TIMEOUT_MS, DEFAULT_INJECT_TIMEOUT_MS)
-}
-
-function aiMemoryInjectCacheTtlMs(env: NodeJS.ProcessEnv = process.env): number {
-  return positiveIntegerSetting(env.PRISM_AI_MEMORY_INJECT_CACHE_TTL_MS ?? env.PI_AI_MEMORY_INJECT_CACHE_TTL_MS, DEFAULT_INJECT_CACHE_TTL_MS)
-}
-
 function cleanFilters(params: any): Record<string, string> {
   const filters: Record<string, string> = {}
   for (const key of ["source", "project", "type", "status", "tag", "path"]) {
@@ -99,74 +92,6 @@ function cleanFilters(params: any): Record<string, string> {
   return filters
 }
 
-async function postJson<T>(path: string, body: unknown, timeoutMs = aiMemoryRequestTimeoutMs()): Promise<T> {
-  const baseUrl = aiMemoryBaseUrl()
-  const response = await fetch(`${baseUrl}${path}`, {
-    method: "POST",
-    headers: { "content-type": "application/json; charset=utf-8", accept: "application/json" },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(timeoutMs),
-  })
-  const text = await response.text()
-  if (!response.ok) throw new Error(`AI Memory request failed: HTTP ${response.status} ${text.slice(0, 500)}`)
-  return JSON.parse(text) as T
-}
-
-async function putJson<T>(path: string, body: unknown, timeoutMs = aiMemoryRequestTimeoutMs()): Promise<T> {
-  const baseUrl = aiMemoryBaseUrl()
-  const response = await fetch(`${baseUrl}${path}`, {
-    method: "PUT",
-    headers: { "content-type": "application/json; charset=utf-8", accept: "application/json" },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(timeoutMs),
-  })
-  const text = await response.text()
-  if (!response.ok) throw new Error(`AI Memory request failed: HTTP ${response.status} ${text.slice(0, 500)}`)
-  return JSON.parse(text) as T
-}
-
-async function deleteJson<T>(path: string, body: unknown, timeoutMs = aiMemoryRequestTimeoutMs()): Promise<T> {
-  const baseUrl = aiMemoryBaseUrl()
-  const response = await fetch(`${baseUrl}${path}`, {
-    method: "DELETE",
-    headers: { "content-type": "application/json; charset=utf-8", accept: "application/json" },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(timeoutMs),
-  })
-  const text = await response.text()
-  if (!response.ok) throw new Error(`AI Memory request failed: HTTP ${response.status} ${text.slice(0, 500)}`)
-  return JSON.parse(text) as T
-}
-
-async function methodJson<T>(
-  method: string,
-  path: string,
-  timeoutMs = aiMemoryRequestTimeoutMs(),
-  body?: unknown,
-): Promise<T> {
-  const baseUrl = aiMemoryBaseUrl()
-  const response = await fetch(`${baseUrl}${path}`, {
-    method,
-    headers: { accept: "application/json", ...(body === undefined ? {} : { "content-type": "application/json; charset=utf-8" }) },
-    body: body === undefined ? undefined : JSON.stringify(body),
-    signal: AbortSignal.timeout(timeoutMs),
-  })
-  const text = await response.text()
-  if (!response.ok) throw new Error(`AI Memory request failed: HTTP ${response.status} ${text.slice(0, 500)}`)
-  return JSON.parse(text) as T
-}
-
-async function getJson<T>(path: string, timeoutMs = aiMemoryStatusTimeoutMs()): Promise<T> {
-  const baseUrl = aiMemoryBaseUrl()
-  const response = await fetch(`${baseUrl}${path}`, {
-    headers: { accept: "application/json" },
-    signal: AbortSignal.timeout(timeoutMs),
-  })
-  const text = await response.text()
-  if (!response.ok) throw new Error(`AI Memory request failed: HTTP ${response.status} ${text.slice(0, 500)}`)
-  return JSON.parse(text) as T
-}
-
 function formatSearchResults(results: any[]): string {
   if (!Array.isArray(results) || results.length === 0) return "No AI Memory results found. Is the index built?"
   return results.map((row, index) => {
@@ -176,11 +101,19 @@ function formatSearchResults(results: any[]): string {
     const lexical = Number(row.lexical_score ?? 0).toFixed(4)
     const graph = Number(row.graph_score ?? 0).toFixed(1)
     const fact = Number(row.fact_score ?? 0).toFixed(1)
+    const feedback = Number(row.feedback_score ?? 0).toFixed(2)
+    const stale = Number(row.stale_score ?? 0).toFixed(2)
     const excerpt = String(row.text ?? "").replace(/\s+/g, " ").trim().slice(0, 700)
-    return `${index + 1}. score=${score} vector=${vector} keyword=${keyword} lexical=${lexical} graph=${graph} fact=${fact}\nsource=${row.source}:${row.path} > ${row.heading}\n${excerpt}`
+    return `${index + 1}. score=${score} vector=${vector} keyword=${keyword} lexical=${lexical} graph=${graph} fact=${fact} feedback=${feedback} stale=${stale}\nsource=${row.source}:${row.path} > ${row.heading}\n${excerpt}`
   }).join("\n\n")
 }
 
+export function formatSearchResponse(data: any): string {
+  const results = Array.isArray(data?.results) ? data.results : []
+  const notices = [formatDegradedNotice(data?.degraded), String(data?.hint ?? "").trim()].filter(Boolean)
+  return [...notices, formatSearchResults(results)].join("\n\n")
+}
+
 function formatReadResult(data: any): string {
   const source = String(data?.source ?? "unknown")
   const path = String(data?.path ?? "unknown")
@@ -277,9 +210,37 @@ function renderAiMemoryResult(result: any, options: { expanded?: boolean; isPart
   })
 }
 
-function formatAiMemoryToolCall(toolName: string, args: any, theme: ThemeLike): string {
+export function formatAiMemoryToolCall(toolName: string, args: any, theme: ThemeLike): string {
   const label = toolName.replace(/^ai_memory_/, "ai memory ").replace(/_/g, " ")
-  return formatBracketedToolCall(label, args?.query || args?.id || args?.path || args?.session || "", theme)
+  const rawValue = args?.query || args?.id || args?.path || args?.session || ""
+  const value = typeof rawValue === "string" && rawValue.trim() ? rawValue.trim() : "..."
+  const linksToVaultNote = isAiMemoryWriteTool(toolName) || toolName === "ai_memory_vault_delete"
+  if (linksToVaultNote && value !== "...") {
+    return `${theme.fg("toolTitle", theme.bold(label))} ${theme.fg("accent", ansiHyperlink(obsidianOpenUrl(value), value))}`
+  }
+  return formatBracketedToolCall(label, value, theme)
+}
+
+/**
+ * Surface background (non-tool) failures once per distinct reason. The dedupe key
+ * ignores the per-turn query so a broken API does not warn on every prompt.
+ */
+function reportBackgroundFailure(ctx: any, label: string, error: unknown): void {
+  const message = `AI Memory ${label} failed: ${error instanceof Error ? error.message : String(error)}`
+  const key = `${label}|${message.split(" | query=")[0]}`
+  if (reportedBackgroundFailures.has(key)) return
+  reportedBackgroundFailures.add(key)
+  ctx?.ui?.notify?.(message, "warning")
+}
+
+function formatVaultWriteResult(action: "Wrote" | "Edited", params: any, responsePath: unknown): string {
+  const path = String(responsePath ?? params.path ?? "")
+  const frontmatter = params.frontmatter === undefined ? "" : String(params.frontmatter).trim()
+  const heading = action === "Edited" ? `# ${String(params.heading ?? "").trim()}` : ""
+  const body = String(params.body ?? "")
+  const writtenContent = [frontmatter, heading, body].filter(Boolean).join("\n\n") || "(empty)"
+  const status = action === "Wrote" ? `Wrote: ${path}\n\n` : ""
+  return `${status}Write content:\n${writtenContent}`
 }
 
 export default function aiMemorySystemExtension(pi: ExtensionAPI): void {
@@ -305,12 +266,12 @@ export default function aiMemorySystemExtension(pi: ExtensionAPI): void {
       path: Type.Optional(Type.String({ description: "Path substring filter" })),
     }),
     async execute(_id: string, params: any) {
-      const data = await postJson<{ results: any[] }>("/search", {
+      const data = await postJson<{ results: any[]; degraded?: any; hint?: string }>("/search", {
         query: String(params.query ?? ""),
         limit: clampLimit(params.limit),
         filters: cleanFilters(params),
       })
-      return { content: [{ type: "text", text: formatSearchResults(data.results) }], details: { count: data.results?.length ?? 0, results: data.results } }
+      return { content: [{ type: "text", text: formatSearchResponse(data) }], details: { count: data.results?.length ?? 0, results: data.results, degraded: data.degraded, hint: data.hint } }
     },
     renderCall(args: any, theme: ThemeLike, context: any) {
       return renderSingleLineToolCall(formatAiMemoryToolCall("ai_memory_search", args, theme), context)
@@ -369,6 +330,130 @@ export default function aiMemorySystemExtension(pi: ExtensionAPI): void {
     },
   })
 
+  pi.registerTool({
+    name: "ai_memory_rate_result",
+    label: "AI Memory Rate Result",
+    description: "Rate one retrieved memory result so future ranking learns from it.",
+    promptSnippet: "Use ai_memory_rate_result when a retrieved memory was clearly helpful, irrelevant, outdated, or wrong.",
+    promptGuidelines: [
+      "Rate the path exactly as returned by ai_memory_search.",
+      "Use 'outdated' or 'wrong' when the user corrects information that came from memory.",
+      "This changes ranking only; it never writes or deletes a note.",
+    ],
+    parameters: Type.Object({
+      path: Type.String({ description: "Path of the rated result, e.g. 02 Projekte/Memory.md" }),
+      rating: Type.String({ description: "helpful, irrelevant, outdated, or wrong" }),
+      query: Type.Optional(Type.String({ description: "Search query that produced the result" })),
+      reason: Type.Optional(Type.String({ description: "Short reason in German" })),
+      source: Type.Optional(Type.String({ description: "obsidian or prism_session" })),
+      chunk_id: Type.Optional(Type.String({ description: "Exact chunk id if known" })),
+      session_id: Type.Optional(Type.String({ description: "Originating session id" })),
+    }),
+    async execute(_id: string, params: any) {
+      const data = await postJson<any>("/retrieval-feedback", {
+        path: String(params.path ?? ""),
+        rating: String(params.rating ?? ""),
+        query: String(params.query ?? ""),
+        reason: String(params.reason ?? ""),
+        source: String(params.source ?? ""),
+        chunk_id: String(params.chunk_id ?? ""),
+        session_id: String(params.session_id ?? ""),
+      })
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }], details: data }
+    },
+    renderCall(args: any, theme: ThemeLike, context: any) {
+      return renderSingleLineToolCall(formatAiMemoryToolCall("ai_memory_rate_result", args, theme), context)
+    },
+  })
+
+  pi.registerTool({
+    name: "ai_memory_session_review",
+    label: "AI Memory Session Review",
+    description: "Review a Prism session for outcome evidence and human-approved durable lesson proposals.",
+    promptSnippet: "Review a completed session and return pending lessons; this does not approve them.",
+    parameters: Type.Object({
+      session: Type.Optional(Type.String({ description: "Session path/id or latest" })),
+      force: Type.Optional(Type.Boolean({ description: "Review an unchanged session again" })),
+    }),
+    async execute(_id: string, params: any) {
+      const data = await postJson<any>("/session-review", {
+        session: typeof params.session === "string" ? params.session : "latest",
+        force: params.force === true,
+      })
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }], details: data }
+    },
+    renderCall(args: any, theme: ThemeLike, context: any) {
+      return renderSingleLineToolCall(formatAiMemoryToolCall("ai_memory_session_review", args, theme), context)
+    },
+  })
+
+  pi.registerTool({
+    name: "ai_memory_propose_lesson",
+    label: "AI Memory Propose Lesson",
+    description: "Create a pending durable lesson proposal. User approval is still required before writing memory.",
+    promptSnippet: "Propose a lesson from explicit user feedback without promoting it automatically.",
+    parameters: Type.Object({
+      category: Type.String({ description: "correction, decision, preference, workflow, or quality" }),
+      title: Type.String({ description: "Short German title" }),
+      rule: Type.String({ description: "Proposed durable rule in German" }),
+      rationale: Type.Optional(Type.String({ description: "Why the rule matters" })),
+      evidence: Type.String({ description: "Exact user feedback supporting the proposal" }),
+      session_id: Type.Optional(Type.String({ description: "Originating session id" })),
+      confidence: Type.Optional(Type.Number({ description: "Confidence from 0 to 1" })),
+    }),
+    async execute(_id: string, params: any) {
+      const data = await postJson<any>("/lessons", {
+        category: String(params.category ?? ""),
+        title: String(params.title ?? ""),
+        rule: String(params.rule ?? ""),
+        rationale: String(params.rationale ?? ""),
+        evidence: String(params.evidence ?? ""),
+        session_id: String(params.session_id ?? "manual"),
+        confidence: params.confidence === undefined ? 0.8 : Number(params.confidence),
+      })
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }], details: data }
+    },
+    renderCall(args: any, theme: ThemeLike, context: any) {
+      return renderSingleLineToolCall(formatAiMemoryToolCall("ai_memory_propose_lesson", args, theme), context)
+    },
+  })
+
+  pi.registerTool({
+    name: "ai_memory_feedback",
+    label: "AI Memory Feedback",
+    description: "List pending lessons or approve/reject one proposal. Approval writes durable memory.",
+    promptSnippet: "Use only after explicit user approval to approve a proposed durable lesson.",
+    promptGuidelines: ["Never approve a lesson without explicit user approval in the current conversation."],
+    parameters: Type.Object({
+      action: Type.Optional(Type.String({ description: "list (default), approve, or reject" })),
+      proposal_id: Type.Optional(Type.String({ description: "Required for approve/reject" })),
+      status: Type.Optional(Type.String({ description: "List filter: pending, approved, or rejected" })),
+      session_id: Type.Optional(Type.String({ description: "Optional session filter for listing" })),
+    }),
+    async execute(_id: string, params: any) {
+      const action = String(params.action ?? "list")
+      let data: any
+      if (action === "list") {
+        const query = new URLSearchParams()
+        if (params.status) query.set("status", String(params.status))
+        if (params.session_id) query.set("session_id", String(params.session_id))
+        data = await getJson<any>(`/lessons${query.size ? `?${query}` : ""}`, aiMemoryRequestTimeoutMs())
+      } else {
+        if (!["approve", "reject"].includes(action) || !params.proposal_id) {
+          throw new Error("action must be list, approve, or reject; proposal_id is required for decisions")
+        }
+        data = await methodJson<any>("DECISION", "/lessons", aiMemoryRequestTimeoutMs(), {
+          proposal_id: String(params.proposal_id),
+          decision: action,
+        })
+      }
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }], details: data }
+    },
+    renderCall(args: any, theme: ThemeLike, context: any) {
+      return renderSingleLineToolCall(formatAiMemoryToolCall("ai_memory_feedback", args, theme), context)
+    },
+  })
+
   // ── File-backed vault ops (write/edit/list/delete) ──
 
   pi.registerTool({
@@ -396,7 +481,7 @@ export default function aiMemorySystemExtension(pi: ExtensionAPI): void {
     name: "ai_memory_vault_write",
     label: "AI Memory Vault Write",
     description: "Create/overwrite a Markdown file in the configured Obsidian vault.",
-    promptSnippet: "Write vault file [path + body/frontmatter]",
+    promptSnippet: "Write vault file [show path and written body/frontmatter]",
     parameters: Type.Object({
       path: Type.String({ description: "Vault-relative path, e.g. 02 Projekte/Test.md" }),
       frontmatter: Type.Optional(Type.String({ description: "Optional YAML frontmatter including leading/trailing --- lines" })),
@@ -408,18 +493,21 @@ export default function aiMemorySystemExtension(pi: ExtensionAPI): void {
         frontmatter: params.frontmatter !== undefined ? String(params.frontmatter) : null,
         body: String(params.body ?? ""),
       })
-      return { content: [{ type: "text", text: `Wrote: ${data.path ?? params.path}` }], details: data }
+      return { content: [{ type: "text", text: formatVaultWriteResult("Wrote", params, data.path) }], details: data }
     },
     renderCall(args: any, theme: ThemeLike, context: any) {
       return renderSingleLineToolCall(formatAiMemoryToolCall("ai_memory_vault_write", args, theme), context)
     },
+    renderResult(result: any, options: any, theme: ThemeLike, context: any) {
+      return renderAiMemoryWriteResult("ai_memory_vault_write", result, options, theme, context)
+    },
   })
 
   pi.registerTool({
     name: "ai_memory_vault_edit",
     label: "AI Memory Vault Edit",
     description: "Replace the content block under a given heading in a Markdown file (or append if missing).",
-    promptSnippet: "Edit vault file section by heading",
+    promptSnippet: "Edit vault file section [show path, heading, and written body/frontmatter]",
     parameters: Type.Object({
       path: Type.String({ description: "Vault-relative path" }),
       heading: Type.String({ description: "Heading text without leading #, e.g. 'Update 2026-01-01 — Thema'" }),
@@ -433,11 +521,14 @@ export default function aiMemorySystemExtension(pi: ExtensionAPI): void {
         frontmatter: params.frontmatter !== undefined ? String(params.frontmatter) : null,
         body: String(params.body ?? ""),
       })
-      return { content: [{ type: "text", text: `Edited: ${data.path ?? params.path}` }], details: data }
+      return { content: [{ type: "text", text: formatVaultWriteResult("Edited", params, data.path) }], details: data }
     },
     renderCall(args: any, theme: ThemeLike, context: any) {
       return renderSingleLineToolCall(formatAiMemoryToolCall("ai_memory_vault_edit", args, theme), context)
     },
+    renderResult(result: any, options: any, theme: ThemeLike, context: any) {
+      return renderAiMemoryWriteResult("ai_memory_vault_edit", result, options, theme, context)
+    },
   })
 
   pi.registerTool({
@@ -482,36 +573,34 @@ export default function aiMemorySystemExtension(pi: ExtensionAPI): void {
       .catch(() => ctx.ui.setStatus?.("ai-memory", undefined))
   })
 
-  pi.on?.("before_agent_start", async (event: any) => {
+  pi.on?.("before_agent_start", async (event: any, ctx: any) => {
+    const patch: { systemPrompt?: string; message?: any } = {}
+
     // Always-loaded durable context (mapped from 00 Kontext) is injected as a
     // system-prompt chunk so it remains in the cached prefix.
-    let alwaysBlock: string | undefined
     try {
-      const alwaysContent = await loadAlwaysContext()
-      const alwaysMessage = buildAlwaysContextMessage(alwaysContent)
-      alwaysBlock = alwaysMessage?.content
-    } catch {
-      // Ignore — always-context is best-effort.
-    }
-
-    const prev = String(event?.systemPrompt ?? "")
-    if (alwaysBlock && alwaysBlock.trim()) {
-      const block = alwaysBlock.trim()
-      return { systemPrompt: `${prev}${prev ? "\n\n" : ""}${block}` }
+      const alwaysBlock = buildAlwaysContextMessage(await loadAlwaysContext())?.content?.trim()
+      if (alwaysBlock) {
+        const prev = String(event?.systemPrompt ?? "")
+        patch.systemPrompt = `${prev}${prev ? "\n\n" : ""}${alwaysBlock}`
+      }
+    } catch (error) {
+      // Best-effort, but never silent: a broken API would otherwise drop durable
+      // context without anyone noticing.
+      reportBackgroundFailure(ctx, "always-context injection", error)
     }
 
-    // Query-specific candidates
-    if (!shouldInjectAiMemoryCandidates()) return
+    // Query-specific candidates (independent of the always-context block).
     const query = String(event?.prompt ?? "").trim()
-    if (!query) return
-    try {
-      const results = await loadAiMemoryInjectResults(query)
-      const message = buildAiMemoryContextMessage(results)
-      return message ? { message } : undefined
-    } catch {
-      // Candidate injection is opportunistic. The explicit ai_memory_search tool
-      // remains available and will surface API errors when the model calls it.
-      return undefined
+    if (shouldInjectAiMemoryCandidates() && query) {
+      try {
+        const message = buildAiMemoryContextMessage(await loadAiMemoryInjectResults(query))
+        if (message) patch.message = message
+      } catch (error) {
+        reportBackgroundFailure(ctx, "candidate injection", error)
+      }
     }
+
+    return patch.systemPrompt === undefined && patch.message === undefined ? undefined : patch
   })
 }

package/src/prism-extensions/integrations/ai-memory-write-preview.ts

@@ -0,0 +1,83 @@
+/**
+ * Live preview and rendering of memory writes.
+ *
+ * Vault writes used to be invisible until the tool finished: the call row only
+ * showed the path and the result slot said "Searching AI Memory...". This module
+ * formats the *partially streamed* arguments so the note content is readable
+ * while the model is still producing it, and keeps the row expandable with
+ * Ctrl+O / Strg+O (`app.tools.expand`) in both states.
+ */
+
+import { renderCollapsibleText, renderCollapsibleTextResult } from "../ui/collapsed-text-rendering.js"
+import { truncateToWidth, type ThemeLike } from "../ui/tool-call-rendering.js"
+
+/** Collapsed height while arguments stream in; the newest lines stay visible. */
+export const WRITE_STREAM_COLLAPSED_LINES = 16
+/** Collapsed height of a finished write result. */
+export const WRITE_RESULT_COLLAPSED_LINES = 24
+
+const WRITE_PREVIEW_TOOLS = new Set(["ai_memory_vault_write", "ai_memory_vault_edit"])
+
+export function isAiMemoryWriteTool(toolName: string): boolean {
+  return WRITE_PREVIEW_TOOLS.has(toolName)
+}
+
+function text(value: unknown): string {
+  return value === undefined || value === null ? "" : String(value)
+}
+
+export function formatAiMemoryWriteTarget(toolName: string, args: any): string {
+  const path = text(args?.path).trim() || "(path pending)"
+  const heading = text(args?.heading).trim()
+  return toolName === "ai_memory_vault_edit" && heading ? `${path} > # ${heading}` : path
+}
+
+/**
+ * @param args partially streamed tool arguments (may miss fields entirely)
+ * @param streaming true while arguments are still arriving
+ */
+export function buildAiMemoryWritePreview(toolName: string, args: any, streaming = true): { header: string; content: string } {
+  const label = toolName === "ai_memory_vault_edit" ? "Editing" : "Writing"
+  const frontmatter = text(args?.frontmatter).trim()
+  const heading = text(args?.heading).trim()
+  const headingLine = toolName === "ai_memory_vault_edit" && heading ? `# ${heading}` : ""
+  const body = text(args?.body)
+  const written = [frontmatter, headingLine, body.trimEnd()].filter(Boolean).join("\n\n")
+
+  const header = `${label}: ${formatAiMemoryWriteTarget(toolName, args)}${streaming ? " … streaming" : ""}`
+  const content = written || (streaming ? "(waiting for content…)" : "(empty)")
+  return { header, content }
+}
+
+export function formatAiMemoryWritePreview(toolName: string, args: any, streaming = true): string {
+  const { header, content } = buildAiMemoryWritePreview(toolName, args, streaming)
+  return `${header}\n\n${content}`
+}
+
+/**
+ * Result slot for vault writes: streams the note content while the model writes,
+ * shows the confirmed content afterwards. Both states honour `expanded`, so
+ * Ctrl+O / Strg+O toggles between the collapsed excerpt and the full text.
+ */
+export function renderAiMemoryWriteResult(
+  toolName: string,
+  result: any,
+  options: { expanded?: boolean; isPartial?: boolean } = {},
+  theme: ThemeLike,
+  context?: any,
+): { render(width: number): string[] } {
+  if (!options.isPartial) {
+    return renderCollapsibleTextResult(result, options, theme, {
+      partialLabel: "Writing AI Memory...",
+      emptyLabel: "No AI Memory write result",
+      maxLines: WRITE_RESULT_COLLAPSED_LINES,
+    })
+  }
+
+  const { header, content } = buildAiMemoryWritePreview(toolName, context?.args ?? {}, context?.argsComplete !== true)
+  // Keep the target pinned above the streamed tail so it never scrolls away.
+  const body = renderCollapsibleText(content, options, theme, { maxLines: WRITE_STREAM_COLLAPSED_LINES, keep: "tail" })
+  return {
+    render: (width: number) => [theme.fg("accent", truncateToWidth(header, Math.max(10, width - 2))), ...body.render(width)],
+  }
+}

package/src/prism-extensions/integrations/research-tools.ts

@@ -332,7 +332,7 @@ export async function webSearch(query: string, limit = 10): Promise<string> {
 export async function webFetch(url: string, maxChars = 20_000): Promise<string> {
   const safeUrl = validateHttpUrl(url)
   const safeMaxChars = clampLimit(maxChars, 20_000, 1_000, 100_000)
-  if (isYouTubeUrl(safeUrl)) return fetchYouTubeContent(safeUrl, safeMaxChars)
+  if (isYouTubeUrl(safeUrl)) return fetchYouTubeContent(safeUrl)
   const response = await fetch(safeUrl, { headers: { "User-Agent": "Mozilla/5.0 (compatible; prism-research/1.0)" }, signal: AbortSignal.timeout(15_000) })
   const text = await response.text()
   if (!response.ok) throw new Error(`Fetch failed for ${safeUrl}: HTTP ${response.status}`)
@@ -392,8 +392,8 @@ export default function researchToolsExtension(pi: ExtensionAPI): void {
   pi.registerTool({
     name: "web_fetch",
     label: "web fetch",
-    description: "Fetch readable text from a web page for citation-backed research. For YouTube URLs, extracts structured video metadata (title, channel, description, duration, views, publish date) and transcript when available.",
-    promptSnippet: "Fetch readable text from a web page. For YouTube URLs, extracts structured video metadata (title, channel, description, duration, views, publish date) and transcript when available.",
+    description: "Fetch readable text from a web page for citation-backed research. For YouTube URLs, extracts structured video metadata and the complete transcript without applying maxChars truncation.",
+    promptSnippet: "Fetch readable text from a web page. For YouTube URLs, extracts structured video metadata and the complete transcript without truncation.",
     parameters: Type.Object({ url: Type.String(), maxChars: Type.Optional(Type.Number()) }),
     async execute(_id: string, params: any) {
       return { content: [{ type: "text", text: await webFetch(params.url, params.maxChars || 20_000) }], details: { url: params.url } }

package/src/prism-extensions/integrations/youtube.ts

@@ -215,7 +215,7 @@ export function formatDuration(seconds: number): string {
 // Format the final YouTube result
 // ---------------------------------------------------------------------------
 
-export function formatYouTubeResult(meta: YouTubeMetadata, transcript: string, maxChars: number): string {
+export function formatYouTubeResult(meta: YouTubeMetadata, transcript: string, _maxChars?: number): string {
   const lines: string[] = []
 
   lines.push(`# ${meta.title}`)
@@ -240,16 +240,16 @@ export function formatYouTubeResult(meta: YouTubeMetadata, transcript: string, m
     lines.push(transcript)
   }
 
-  let result = lines.join("\n")
-  if (result.length > maxChars) result = `${result.slice(0, maxChars - 20)}\n\n[truncated]`
-  return result
+  // YouTube transcripts must stay complete. The generic web_fetch maxChars
+  // limit is intentionally ignored here so long videos are not cut off.
+  return lines.join("\n")
 }
 
 // ---------------------------------------------------------------------------
 // Main entry point for web_fetch YouTube handling
 // ---------------------------------------------------------------------------
 
-export async function fetchYouTubeContent(url: string, maxChars = 20_000): Promise<string> {
+export async function fetchYouTubeContent(url: string, _maxChars?: number): Promise<string> {
   const videoId = extractVideoId(url)
   if (!videoId) throw new Error(`Could not extract video ID from URL: ${url}`)
 
@@ -288,5 +288,5 @@ export async function fetchYouTubeContent(url: string, maxChars = 20_000): Promi
     transcript = await fetchTranscriptYtDlp(videoId, "en")
   }
 
-  return formatYouTubeResult(meta, transcript, maxChars)
+  return formatYouTubeResult(meta, transcript)
 }

package/src/prism-extensions/ui/collapsed-text-rendering.ts

@@ -9,6 +9,8 @@ export type CollapsibleTextRenderConfig = {
   partialLabel: string
   emptyLabel: string
   maxLines: number
+  /** "head" keeps the first lines (default), "tail" keeps the newest lines. */
+  keep?: "head" | "tail"
   lines?: (text: string) => string[]
   strip?: (text: string) => string
 }
@@ -31,26 +33,30 @@ export function renderCollapsibleText(
   text: string,
   options: CollapsibleTextRenderOptions = {},
   theme: ThemeLike,
-  config: Pick<CollapsibleTextRenderConfig, "maxLines" | "lines" | "strip">,
+  config: Pick<CollapsibleTextRenderConfig, "maxLines" | "keep" | "lines" | "strip">,
 ): { render(width: number): string[] } {
   const body = config.strip ? config.strip(text) : text
   const lines = config.lines ? config.lines(body) : body.split(/\r?\n/)
-  const shown = options.expanded ? lines : lines.slice(0, config.maxLines)
+  const keepTail = config.keep === "tail"
+  const shown = options.expanded ? lines : keepTail ? lines.slice(-config.maxLines) : lines.slice(0, config.maxLines)
+  const hidden = lines.length - shown.length
 
   return {
     render: (width: number) => {
       const maxWidth = Math.max(10, width - 2)
+      const hint = hidden > 0 && !options.expanded
+        ? theme.fg("muted", truncateToWidth(collapseHint(hidden, keepTail ? "above" : "below"), maxWidth))
+        : undefined
       const rendered = shown.map((line) => theme.fg("dim", truncateToWidth(line, maxWidth)))
-      if (!options.expanded && lines.length > shown.length) {
-        rendered.push(theme.fg("muted", truncateToWidth(collapseHint(lines.length - shown.length), maxWidth)))
-      }
-      return rendered
+      if (!hint) return rendered
+      return keepTail ? [hint, ...rendered] : [...rendered, hint]
     },
   }
 }
 
-export function collapseHint(hiddenLineCount: number): string {
-  return `... ${hiddenLineCount} more lines (Ctrl+O / Strg+O to expand)`
+export function collapseHint(hiddenLineCount: number, position: "below" | "above" = "below"): string {
+  const what = position === "above" ? "earlier lines" : "more lines"
+  return `... ${hiddenLineCount} ${what} (Ctrl+O / Strg+O to expand)`
 }
 
 export function stripLeadingPathHeader(text: string, relPath: string): string {