@daniel156161/prism 0.2.78 → 0.2.81

package/node_modules/@types/node/sqlite.d.ts

@@ -298,10 +298,23 @@ declare module "node:sqlite" {
          * Loads a shared library into the database connection. This method is a wrapper
          * around [`sqlite3_load_extension()`](https://www.sqlite.org/c3ref/load_extension.html). It is required to enable the
          * `allowExtension` option when constructing the `DatabaseSync` instance.
+         *
+         * ```js
+         * import { DatabaseSync } from 'node:sqlite';
+         * const database = new DatabaseSync(':memory:', { allowExtension: true });
+         *
+         * // Load using the entry point derived from the filename.
+         * database.loadExtension('./decimal.dylib');
+         *
+         * // Override the entry point when the derived name does not match.
+         * database.loadExtension('./base64.dylib', 'sqlite3_base64_init');
          * @since v22.13.0
          * @param path The path to the shared library to load.
+         * @param entryPoint The name of the extension's entry-point function. When
+         * omitted, SQLite derives the entry point from the shared library's filename;
+         * pass this argument explicitly when the derived name does not match.
          */
-        loadExtension(path: string): void;
+        loadExtension(path: string, entryPoint?: string): void;
         /**
          * Enables or disables the `loadExtension` SQL function, and the `loadExtension()`
          * method. When `allowExtension` is `false` when constructing, you cannot enable

package/node_modules/@types/node/stream/iter.d.ts

@@ -311,8 +311,9 @@ declare module "node:stream/iter" {
      * return `false` or `-1`, deferring to the async path. The per-write
      * `options.signal` parameter from the Writer interface is also ignored.
      *
-     * The result is cached per instance -- calling `fromWritable()` twice with the
-     * same stream returns the same Writer.
+     * The result is cached per instance and backpressure policy -- calling
+     * `fromWritable()` twice with the same stream and `backpressure` option returns
+     * the same Writer.
      *
      * For duck-typed streams that do not expose `writableHighWaterMark`,
      * `writableLength`, or similar properties, sensible defaults are used.

package/node_modules/@types/node/test.d.ts

@@ -264,6 +264,15 @@ declare module "node:test" {
              * @since v22.1.0
              */
             testSkipPatterns?: string | RegExp | ReadonlyArray<string | RegExp> | undefined;
+            /**
+             * A tag name, or an array of tag names,
+             * used to filter tests by their declared tags. Tests must contain every
+             * listed tag to run. Equivalent to passing `--experimental-test-tag-filter`
+             * on the command line. See [Test tags](https://nodejs.org/docs/latest-v26.x/api/test.html#test-tags).
+             * @default undefined
+             * @since v26.2.0
+             */
+            testTagFilters?: string | readonly string[] | undefined;
             /**
              * The number of milliseconds after which the test execution will fail.
              * If unspecified, subtests inherit this value from their parent.
@@ -668,6 +677,12 @@ declare module "node:test" {
                  * The nesting level of the test.
                  */
                 nesting: number;
+                /**
+                 * The flattened lowercased tags declared on the test
+                 * and its ancestor suites, in declaration order. Empty for untagged tests.
+                 * See [Test tags](https://nodejs.org/docs/latest-v26.x/api/test.html#test-tags).
+                 */
+                tags: string[];
                 /**
                  * A numeric identifier for this test instance, unique
                  * within the test file's process. Consistent across all events for the same
@@ -696,6 +711,12 @@ declare module "node:test" {
                  * The nesting level of the test.
                  */
                 nesting: number;
+                /**
+                 * The flattened lowercased tags declared on the test
+                 * and its ancestor suites, in declaration order. Empty for untagged tests.
+                 * See [Test tags](https://nodejs.org/docs/latest-v26.x/api/test.html#test-tags).
+                 */
+                tags: string[];
                 /**
                  * A numeric identifier for this test instance, unique
                  * within the test file's process. Consistent across all events for the same
@@ -717,6 +738,12 @@ declare module "node:test" {
                  * The nesting level of the test.
                  */
                 nesting: number;
+                /**
+                 * The flattened lowercased tags declared on the test
+                 * and its ancestor suites, in declaration order. Empty for untagged tests.
+                 * See [Test tags](https://nodejs.org/docs/latest-v26.x/api/test.html#test-tags).
+                 */
+                tags: string[];
                 /**
                  * A numeric identifier for this test instance, unique
                  * within the test file's process. Consistent across all events for the same
@@ -762,6 +789,12 @@ declare module "node:test" {
                  * The nesting level of the test.
                  */
                 nesting: number;
+                /**
+                 * The flattened lowercased tags declared on the test
+                 * and its ancestor suites, in declaration order. Empty for untagged tests.
+                 * See [Test tags](https://nodejs.org/docs/latest-v26.x/api/test.html#test-tags).
+                 */
+                tags: string[];
                 /**
                  * A numeric identifier for this test instance, unique
                  * within the test file's process. Consistent across all events for the same
@@ -823,6 +856,12 @@ declare module "node:test" {
                  * The nesting level of the test.
                  */
                 nesting: number;
+                /**
+                 * The flattened lowercased tags declared on the test
+                 * and its ancestor suites, in declaration order. Empty for untagged tests.
+                 * See [Test tags](https://nodejs.org/docs/latest-v26.x/api/test.html#test-tags).
+                 */
+                tags: string[];
                 /**
                  * A numeric identifier for this test instance, unique
                  * within the test file's process. Consistent across all events for the same
@@ -861,6 +900,12 @@ declare module "node:test" {
                  * The nesting level of the test.
                  */
                 nesting: number;
+                /**
+                 * The flattened lowercased tags declared on the test
+                 * and its ancestor suites, in declaration order. Empty for untagged tests.
+                 * See [Test tags](https://nodejs.org/docs/latest-v26.x/api/test.html#test-tags).
+                 */
+                tags: string[];
                 /**
                  * A numeric identifier for this test instance, unique
                  * within the test file's process. Consistent across all events for the same
@@ -1082,6 +1127,13 @@ declare module "node:test" {
              * @since v21.7.0, v20.12.0
              */
             readonly attempt: number;
+            /**
+             * A frozen array of the test's flattened lowercased tags, in declaration
+             * order, including any tags inherited from ancestor suites. Empty when the
+             * test has no tags. See [Test tags](https://nodejs.org/docs/latest-v26.x/api/test.html#test-tags).
+             * @since v26.2.0
+             */
+            readonly tags: readonly string[];
             /**
              * The unique identifier of the worker running the current test file. This value is
              * derived from the `NODE_TEST_WORKER_ID` environment variable. When running tests
@@ -1443,6 +1495,15 @@ declare module "node:test" {
              * @default false
              */
             skip?: boolean | string | undefined;
+            /**
+             * An array of string labels associated with the test.
+             * Used together with `--experimental-test-tag-filter` to filter which
+             * tests run. Tags inherit from suites to nested tests by union. See
+             * [Test tags](https://nodejs.org/docs/latest-v26.x/api/test.html#test-tags).
+             * @default []
+             * @since v26.2.0
+             */
+            tags?: readonly string[] | undefined;
             /**
              * A number of milliseconds the test will fail after. If unspecified, subtests inherit this
              * value from their parent.

package/node_modules/@types/node/v8.d.ts

@@ -89,23 +89,22 @@ declare module "node:v8" {
      * `total_allocated_bytes` The value of total allocated bytes since the Isolate
      * creation.
      *
-     * ```js
+     * ```json
      * {
-     *   total_heap_size: 7326976,
-     *   total_heap_size_executable: 4194304,
-     *   total_physical_size: 7326976,
-     *   total_available_size: 1152656,
-     *   used_heap_size: 3476208,
-     *   heap_size_limit: 1535115264,
-     *   malloced_memory: 16384,
-     *   peak_malloced_memory: 1127496,
-     *   does_zap_garbage: 0,
-     *   number_of_native_contexts: 1,
-     *   number_of_detached_contexts: 0,
-     *   total_global_handles_size: 8192,
-     *   used_global_handles_size: 3296,
-     *   external_memory: 318824,
-     *   total_allocated_bytes: 45224088
+     *   "total_heap_size": 7326976,
+     *   "total_heap_size_executable": 4194304,
+     *   "total_physical_size": 7326976,
+     *   "total_available_size": 1152656,
+     *   "used_heap_size": 3476208,
+     *   "heap_size_limit": 1535115264,
+     *   "malloced_memory": 16384,
+     *   "peak_malloced_memory": 1127496,
+     *   "does_zap_garbage": 0,
+     *   "number_of_native_contexts": 1,
+     *   "number_of_detached_contexts": 0,
+     *   "total_global_handles_size": 8192,
+     *   "used_global_handles_size": 3296,
+     *   "external_memory": 318824
      * }
      * ```
      * @since v1.0.0
@@ -386,12 +385,12 @@ declare module "node:v8" {
      * V8 [`GetHeapCodeAndMetadataStatistics`](https://v8docs.nodesource.com/node-13.2/d5/dda/classv8_1_1_isolate.html#a6079122af17612ef54ef3348ce170866) API. Returns an object with the
      * following properties:
      *
-     * ```js
+     * ```json
      * {
-     *   code_and_metadata_size: 212208,
-     *   bytecode_and_metadata_size: 161368,
-     *   external_script_source_size: 1410794,
-     *   cpu_profiler_metadata_size: 0,
+     *   "code_and_metadata_size": 212208,
+     *   "bytecode_and_metadata_size": 161368,
+     *   "external_script_source_size": 1410794,
+     *   "cpu_profiler_metadata_size": 0
      * }
      * ```
      * @since v12.8.0
@@ -963,8 +962,6 @@ declare module "node:v8" {
      * For example, if the `entry.js` contains the following script:
      *
      * ```js
-     * 'use strict';
-     *
      * import fs from 'node:fs';
      * import zlib from 'node:zlib';
      * import path from 'node:path';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daniel156161/prism",
-  "version": "0.2.78",
+  "version": "0.2.81",
   "description": "Prism-branded wrapper around pi that stores config in ~/.prism",
   "type": "module",
   "engines": {
@@ -25,9 +25,9 @@
     "package:publish:npm": "node scripts/publish-npm-package.mjs"
   },
   "dependencies": {
-    "@earendil-works/pi-ai": "^0.84.0",
-    "@earendil-works/pi-coding-agent": "^0.84.0",
-    "pi-mcp-adapter": "^2.20.1",
+    "@earendil-works/pi-ai": "^0.84.1",
+    "@earendil-works/pi-coding-agent": "^0.84.1",
+    "pi-mcp-adapter": "^2.21.1",
     "pkce-challenge": "^6.0.0",
     "typebox": "^1.3.11"
   },
@@ -35,8 +35,8 @@
     "@earendil-works/pi-coding-agent"
   ],
   "devDependencies": {
-    "@types/node": "^26.1.2",
-    "tsx": "^4.23.9",
+    "@types/node": "^26.2.0",
+    "tsx": "^4.23.11",
     "typescript": "^7.0.2"
   },
   "files": [

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

@@ -0,0 +1,53 @@
+/**
+ * Error and diagnostics formatting for the AI Memory System integration.
+ *
+ * The API returns a structured error body (`{"error": {...}, "request_id": ...}`).
+ * Collapsing that into "HTTP 500 <raw json>" made intermittent failures
+ * impossible to trace, so the request id, the failing route and the query are
+ * kept in the message the model and the user actually see.
+ */
+
+export type AiMemoryRequestContext = {
+  method: string
+  path: string
+  query?: string
+  filters?: Record<string, unknown>
+}
+
+function parseBody(text: string): any {
+  try {
+    return JSON.parse(text)
+  } catch {
+    return undefined
+  }
+}
+
+function errorDetail(body: any, fallback: string): string {
+  if (!body || typeof body !== "object") return fallback.slice(0, 500)
+  const error = body.error ?? body
+  const detail = error?.message ?? error?.detail ?? body?.detail
+  if (typeof detail === "string" && detail.trim()) return detail.trim()
+  if (Array.isArray(detail)) return detail.map((item: any) => item?.msg ?? JSON.stringify(item)).join("; ")
+  return fallback.slice(0, 500)
+}
+
+export function formatApiFailure(status: number, text: string, context: AiMemoryRequestContext): string {
+  const body = parseBody(text)
+  const requestId = body?.request_id ?? body?.error?.request_id
+  const code = body?.error?.code ?? body?.code
+  const parts = [`AI Memory ${context.method} ${context.path} failed: HTTP ${status}`]
+  parts.push(errorDetail(body, text))
+  if (code) parts.push(`code=${code}`)
+  if (requestId) parts.push(`request_id=${requestId}`)
+  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(" | ")
+}
+
+export function formatDegradedNotice(degraded: any): string {
+  const stages: string[] = Array.isArray(degraded?.stages) ? degraded.stages : []
+  if (stages.length === 0) return ""
+  const errors = degraded?.errors ?? {}
+  const details = stages.map((stage) => (errors?.[stage] ? `${stage} (${errors[stage]})` : stage)).join(", ")
+  return `Warnung: Teilausfall im Retrieval — degradierte Stufen: ${details}. Ergebnisse können unvollständig sein.`
+}

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

@@ -2,8 +2,10 @@ type ExtensionAPI = any
 
 import { Type } from "typebox"
 import { readSettings } from "../core/shared-config.js"
+import { formatApiFailure, formatDegradedNotice } from "./ai-memory-errors.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
@@ -108,7 +110,15 @@ async function postJson<T>(path: string, body: unknown, timeoutMs = aiMemoryRequ
     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)}`)
+  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
 }
 
@@ -121,7 +131,7 @@ async function putJson<T>(path: string, body: unknown, timeoutMs = aiMemoryReque
     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)}`)
+  if (!response.ok) throw new Error(formatApiFailure(response.status, text, { method: "PUT", path }))
   return JSON.parse(text) as T
 }
 
@@ -134,7 +144,7 @@ async function deleteJson<T>(path: string, body: unknown, timeoutMs = aiMemoryRe
     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)}`)
+  if (!response.ok) throw new Error(formatApiFailure(response.status, text, { method: "DELETE", path }))
   return JSON.parse(text) as T
 }
 
@@ -152,7 +162,7 @@ async function methodJson<T>(
     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)}`)
+  if (!response.ok) throw new Error(formatApiFailure(response.status, text, { method, path }))
   return JSON.parse(text) as T
 }
 
@@ -163,7 +173,7 @@ async function getJson<T>(path: string, timeoutMs = aiMemoryStatusTimeoutMs()):
     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)}`)
+  if (!response.ok) throw new Error(formatApiFailure(response.status, text, { method: "GET", path }))
   return JSON.parse(text) as T
 }
 
@@ -176,11 +186,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 +295,25 @@ 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 = ["ai_memory_vault_write", "ai_memory_vault_edit", "ai_memory_vault_delete"].includes(toolName)
+  if (linksToVaultNote && value !== "...") {
+    return `${theme.fg("toolTitle", theme.bold(label))} ${theme.fg("accent", ansiHyperlink(obsidianOpenUrl(value), value))}`
+  }
+  return formatBracketedToolCall(label, value, theme)
+}
+
+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 +339,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 +403,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 +554,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 +566,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) {
+      return renderAiMemoryResult(result, options, theme)
+    },
   })
 
   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 +594,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) {
+      return renderAiMemoryResult(result, options, theme)
+    },
   })
 
   pi.registerTool({

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 } }