@daniel156161/prism 0.2.81 → 0.2.82

package/node_modules/@earendil-works/pi-tui/dist/autocomplete.js

@@ -202,7 +202,7 @@ export class CombinedAutocompleteProvider {
                 prefix: atPrefix,
             };
         }
-        if (textBeforeCursor.startsWith("/")) {
+        if (!options.force && textBeforeCursor.startsWith("/")) {
             const spaceIndex = textBeforeCursor.indexOf(" ");
             if (spaceIndex === -1) {
                 const prefix = textBeforeCursor.slice(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daniel156161/prism",
-  "version": "0.2.81",
+  "version": "0.2.82",
   "description": "Prism-branded wrapper around pi that stores config in ~/.prism",
   "type": "module",
   "engines": {
@@ -27,7 +27,7 @@
   "dependencies": {
     "@earendil-works/pi-ai": "^0.84.1",
     "@earendil-works/pi-coding-agent": "^0.84.1",
-    "pi-mcp-adapter": "^2.21.1",
+    "pi-mcp-adapter": "^2.21.2",
     "pkce-challenge": "^6.0.0",
     "typebox": "^1.3.11"
   },
@@ -36,7 +36,7 @@
   ],
   "devDependencies": {
     "@types/node": "^26.2.0",
-    "tsx": "^4.23.11",
+    "tsx": "^4.23.12",
     "typescript": "^7.0.2"
   },
   "files": [

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

@@ -14,6 +14,11 @@ export type AiMemoryRequestContext = {
   filters?: Record<string, unknown>
 }
 
+export type AiMemoryTransportContext = AiMemoryRequestContext & {
+  baseUrl: string
+  timeoutMs: number
+}
+
 function parseBody(text: string): any {
   try {
     return JSON.parse(text)
@@ -44,6 +49,60 @@ export function formatApiFailure(status: number, text: string, context: AiMemory
   return parts.join(" | ")
 }
 
+function errorCode(error: unknown): string | undefined {
+  const candidates = [error as any, (error as any)?.cause]
+  for (const candidate of candidates) {
+    const code = candidate?.code ?? candidate?.errno
+    if (typeof code === "string" && code.trim()) return code.trim()
+  }
+  return undefined
+}
+
+function errorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    const cause = (error as any).cause
+    const causeMessage = cause instanceof Error ? cause.message : typeof cause === "string" ? cause : ""
+    return causeMessage && causeMessage !== error.message ? `${error.message}: ${causeMessage}` : error.message
+  }
+  return String(error)
+}
+
+/**
+ * A request that never reached the API (timeout, refused connection, DNS) must
+ * still explain itself. `fetch` alone only reports "fetch failed" or "The
+ * operation was aborted due to timeout", which is useless while debugging why a
+ * memory write did not land.
+ */
+export function formatTransportFailure(error: unknown, context: AiMemoryTransportContext): string {
+  const name = (error as any)?.name
+  const code = errorCode(error)
+  const timedOut = name === "TimeoutError" || name === "AbortError"
+  const reason = timedOut
+    ? `request timed out after ${context.timeoutMs}ms`
+    : `request failed before a response arrived: ${errorMessage(error)}`
+
+  const parts = [`AI Memory ${context.method} ${context.path} failed: ${reason}`]
+  if (code) parts.push(`code=${code}`)
+  parts.push(`base_url=${context.baseUrl}`)
+  if (code === "ECONNREFUSED" || code === "ENOTFOUND" || code === "EAI_AGAIN") {
+    parts.push(`hint=Is the AI Memory System API running and reachable at ${context.baseUrl}?`)
+  } else if (timedOut) {
+    parts.push("hint=Raise PRISM_AI_MEMORY_TIMEOUT_MS or check the API load; nothing was confirmed as written.")
+  }
+  if (context.query) parts.push(`query=${JSON.stringify(context.query)}`)
+  if (context.filters && Object.keys(context.filters).length > 0) parts.push(`filters=${JSON.stringify(context.filters)}`)
+  return parts.join(" | ")
+}
+
+/** A 2xx response with a body that is not JSON, e.g. an HTML proxy page. */
+export function formatInvalidJsonFailure(error: unknown, text: string, context: AiMemoryTransportContext): string {
+  const snippet = String(text ?? "").replace(/\s+/g, " ").trim().slice(0, 300)
+  const parts = [`AI Memory ${context.method} ${context.path} failed: response was not valid JSON: ${errorMessage(error)}`]
+  parts.push(`base_url=${context.baseUrl}`)
+  parts.push(`body=${snippet || "(empty)"}`)
+  return parts.join(" | ")
+}
+
 export function formatDegradedNotice(degraded: any): string {
   const stages: string[] = Array.isArray(degraded?.stages) ? degraded.stages : []
   if (stages.length === 0) return ""

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

@@ -0,0 +1,114 @@
+/**
+ * HTTP transport for the AI Memory System integration.
+ *
+ * Every request funnels through `requestJson` so that transport failures
+ * (timeout, refused connection, unreadable or non-JSON body) end up as
+ * descriptive errors instead of a bare "fetch failed" / "The operation was
+ * aborted". The tool call is still reported as an error to the model, but the
+ * message now explains *why* it failed and which route/base URL was involved.
+ */
+
+import { formatApiFailure, formatInvalidJsonFailure, formatTransportFailure, type AiMemoryRequestContext } from "./ai-memory-errors.js"
+
+const DEFAULT_BASE_URL = "http://127.0.0.1:8765"
+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
+
+export function aiMemoryBaseUrl(env: NodeJS.ProcessEnv = process.env): string {
+  return (env.PRISM_AI_MEMORY_BASE_URL || env.AI_MEMORY_BASE_URL || DEFAULT_BASE_URL).replace(/\/+$/, "")
+}
+
+function positiveIntegerSetting(value: unknown, fallback: number): number {
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed)) return fallback
+  return Math.max(1, Math.trunc(parsed))
+}
+
+export 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)
+}
+
+export 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)
+}
+
+export 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)
+}
+
+export 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)
+}
+
+export type AiMemoryRequest = {
+  method: string
+  path: string
+  body?: unknown
+  timeoutMs?: number
+  query?: string
+  filters?: Record<string, unknown>
+}
+
+function requestContext(request: AiMemoryRequest): AiMemoryRequestContext {
+  const payload = request.body as any
+  return {
+    method: request.method,
+    path: request.path,
+    query: request.query ?? (typeof payload?.query === "string" ? payload.query : undefined),
+    filters: request.filters ?? (payload?.filters as Record<string, unknown> | undefined),
+  }
+}
+
+export async function requestJson<T>(request: AiMemoryRequest): Promise<T> {
+  const baseUrl = aiMemoryBaseUrl()
+  const timeoutMs = request.timeoutMs ?? aiMemoryRequestTimeoutMs()
+  const context = requestContext(request)
+  const transport = { ...context, baseUrl, timeoutMs }
+
+  let response: Response
+  let text: string
+  try {
+    response = await fetch(`${baseUrl}${request.path}`, {
+      method: request.method,
+      headers: {
+        accept: "application/json",
+        ...(request.body === undefined ? {} : { "content-type": "application/json; charset=utf-8" }),
+      },
+      body: request.body === undefined ? undefined : JSON.stringify(request.body),
+      signal: AbortSignal.timeout(timeoutMs),
+    })
+    text = await response.text()
+  } catch (error) {
+    throw new Error(formatTransportFailure(error, transport))
+  }
+
+  if (!response.ok) throw new Error(formatApiFailure(response.status, text, context))
+
+  try {
+    return JSON.parse(text) as T
+  } catch (error) {
+    throw new Error(formatInvalidJsonFailure(error, text, transport))
+  }
+}
+
+export function postJson<T>(path: string, body: unknown, timeoutMs?: number): Promise<T> {
+  return requestJson<T>({ method: "POST", path, body, timeoutMs })
+}
+
+export function putJson<T>(path: string, body: unknown, timeoutMs?: number): Promise<T> {
+  return requestJson<T>({ method: "PUT", path, body, timeoutMs })
+}
+
+export function deleteJson<T>(path: string, body: unknown, timeoutMs?: number): Promise<T> {
+  return requestJson<T>({ method: "DELETE", path, body, timeoutMs })
+}
+
+export function methodJson<T>(method: string, path: string, timeoutMs?: number, body?: unknown): Promise<T> {
+  return requestJson<T>({ method, path, body, timeoutMs })
+}
+
+export function getJson<T>(path: string, timeoutMs: number = aiMemoryStatusTimeoutMs()): Promise<T> {
+  return requestJson<T>({ method: "GET", path, timeoutMs })
+}

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

@@ -2,26 +2,39 @@ type ExtensionAPI = any
 
 import { Type } from "typebox"
 import { readSettings } from "../core/shared-config.js"
-import { formatApiFailure, formatDegradedNotice } from "./ai-memory-errors.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 { 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: "" }
+const reportedBackgroundFailures = new Set<string>()
 
-function aiMemoryBaseUrl(env: NodeJS.ProcessEnv = process.env): string {
-  return (env.PRISM_AI_MEMORY_BASE_URL || env.AI_MEMORY_BASE_URL || DEFAULT_BASE_URL).replace(/\/+$/, "")
+/** 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 {
@@ -70,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"]) {
@@ -101,82 +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) {
-    const payload = body as any
-    throw new Error(formatApiFailure(response.status, text, {
-      method: "POST",
-      path,
-      query: typeof payload?.query === "string" ? payload.query : undefined,
-      filters: payload?.filters,
-    }))
-  }
-  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(formatApiFailure(response.status, text, { method: "PUT", path }))
-  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(formatApiFailure(response.status, text, { method: "DELETE", path }))
-  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(formatApiFailure(response.status, text, { method, path }))
-  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(formatApiFailure(response.status, text, { method: "GET", path }))
-  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) => {
@@ -299,13 +214,25 @@ export function formatAiMemoryToolCall(toolName: string, args: any, theme: Theme
   const label = toolName.replace(/^ai_memory_/, "ai memory ").replace(/_/g, " ")
   const rawValue = args?.query || args?.id || args?.path || args?.session || ""
   const value = typeof rawValue === "string" && rawValue.trim() ? rawValue.trim() : "..."
-  const linksToVaultNote = ["ai_memory_vault_write", "ai_memory_vault_edit", "ai_memory_vault_delete"].includes(toolName)
+  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()
@@ -571,8 +498,8 @@ export default function aiMemorySystemExtension(pi: ExtensionAPI): void {
     renderCall(args: any, theme: ThemeLike, context: any) {
       return renderSingleLineToolCall(formatAiMemoryToolCall("ai_memory_vault_write", args, theme), context)
     },
-    renderResult(result: any, options: any, theme: ThemeLike) {
-      return renderAiMemoryResult(result, options, theme)
+    renderResult(result: any, options: any, theme: ThemeLike, context: any) {
+      return renderAiMemoryWriteResult("ai_memory_vault_write", result, options, theme, context)
     },
   })
 
@@ -599,8 +526,8 @@ export default function aiMemorySystemExtension(pi: ExtensionAPI): void {
     renderCall(args: any, theme: ThemeLike, context: any) {
       return renderSingleLineToolCall(formatAiMemoryToolCall("ai_memory_vault_edit", args, theme), context)
     },
-    renderResult(result: any, options: any, theme: ThemeLike) {
-      return renderAiMemoryResult(result, options, theme)
+    renderResult(result: any, options: any, theme: ThemeLike, context: any) {
+      return renderAiMemoryWriteResult("ai_memory_vault_edit", result, options, theme, context)
     },
   })
 
@@ -646,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/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 {