@daniel156161/prism 0.2.59 → 0.2.76

package/src/prism-extensions/integrations/obsidian-memory.ts

@@ -3,9 +3,10 @@ import * as path from "node:path"
 import { execFile as execFileCallback } from "node:child_process"
 import { promisify } from "node:util"
 import { createRequire } from "node:module"
-import { getObsidianCliTimeoutMs, getPrismSessionDbPath, getPrismSessionsDir, getPrismSettingsPath, getVaultPath, readVaultPathFromSettings, getObsidianVaultName, obsidianCliEnv } from "../core/shared-config.js"
+import { getObsidianCliTimeoutMs, getPrismSessionDbPath, getPrismSessionsDir, getPrismSettingsPath, getVaultPath, readSettings, readVaultPathFromSettings, getObsidianVaultName, obsidianCliEnv } from "../core/shared-config.js"
 import { excerpt, fileExists as exists, listMarkdownFiles as listVaultMarkdownFiles, readCappedFile, schema, scoreContent, slugify, todayDate, CONTEXT_SEARCH_LIMIT, MAX_ALWAYS_CONTEXT_BYTES, MAX_FILE_BYTES, MAX_READ_RENDER_LINES, MAX_SEARCH_FILES } from "../core/vault.js"
 import { fuzzyFilter } from "../core/fuzzy.js"
+import { descriptionFromMarkdown, formatNewObsidianNoteBody, sanitizeObsidianDescription } from "./obsidian-formatting.js"
 
 const _require = createRequire(import.meta.url)
 import { renderCollapsibleTextResult, stripLeadingPathHeader, stripLeadingSearchTerms } from "../ui/collapsed-text-rendering.js"
@@ -31,6 +32,23 @@ function shouldUseObsidianCli(): boolean {
   return !!cliVaultName()
 }
 
+function booleanSetting(value: unknown): boolean | undefined {
+  if (typeof value === "boolean") return value
+  if (typeof value !== "string") return undefined
+  const normalized = value.trim().toLowerCase()
+  if (["1", "true", "yes", "on"].includes(normalized)) return true
+  if (["0", "false", "no", "off"].includes(normalized)) return false
+  return undefined
+}
+
+function shouldInjectObsidianCandidates(env: NodeJS.ProcessEnv = process.env): boolean {
+  const envValue = booleanSetting(env.PRISM_OBSIDIAN_INJECT_CANDIDATES ?? env.PI_OBSIDIAN_INJECT_CANDIDATES)
+  if (envValue !== undefined) return envValue
+  const settings = readSettings(undefined, env)
+  const settingsValue = booleanSetting(settings?.obsidian?.injectCandidates ?? settings?.obsidianInjectCandidates)
+  return settingsValue ?? true
+}
+
 async function obsidianCli(command: string, args: string[] = []): Promise<string> {
   const name = cliVaultName()
   if (!name) throw new Error("PRISM_OBSIDIAN_VAULT_NAME is not configured")
@@ -154,22 +172,16 @@ export function inferType(relPath: string): string {
   return "note"
 }
 
+export const sanitizeDescription = sanitizeObsidianDescription
+
 export function inferDescriptionFromMemoryText(text: string, fallback = ""): string {
-  const clean = stripFrontmatter(String(text ?? ""))
-    .replace(/```[\s\S]*?```/g, " ")
-    .replace(/^#{1,6}\s+(?:Update|Fix)\s+\d{4}-\d{2}-\d{2}.*$/gmi, "")
-    .replace(/^#{1,6}\s+/gm, "")
-    .replace(/^[-*+]\s+/gm, "")
-    .replace(/`+/g, "")
-    .replace(/\s+/g, " ")
-    .trim()
-  return compactLine(clean || fallback, 220)
+  return descriptionFromMarkdown(stripFrontmatter(String(text ?? "")), fallback)
 }
 
 export function buildFrontmatter(relPath: string, description?: string): string {
   const tags = inferTags(relPath)
   const name = noteName(relPath)
-  const summary = description?.trim() ? description.trim() : name
+  const summary = sanitizeDescription(description?.trim() ? description : name)
   return [
     "---",
     `name: ${yamlString(name)}`,
@@ -193,7 +205,7 @@ export function upsertFrontmatterStatusAndUpdated(text: string, date = todayDate
   const parsed = splitLeadingFrontmatter(text)
   if (!parsed) return text
   let frontmatter = parsed.frontmatter.replace(/\r\n/g, "\n").replace(/\n?---\n?$/, "")
-  const summary = description?.trim()
+  const summary = sanitizeDescription(description ?? "")
   if (summary) {
     const current = frontmatter.match(/^description:\s*(.*?)\s*$/m)?.[1]?.replace(/^['"]|['"]$/g, "") ?? ""
     if (/^description:\s*.*$/m.test(frontmatter)) {
@@ -250,23 +262,17 @@ export function normalizeUpdateHeadings(text: string): string {
   const lines = String(text ?? "").split("\n")
   const out: string[] = []
   for (const line of lines) {
-    const titled = line.match(/^(#{2,6})\s+(Update|Fix)\s+(\d{4}-\d{2}-\d{2})\s+[—-]\s+(.+?)\s*$/)
-    if (titled) {
-      const [, level, kind, date, title] = titled
+    const dated = line.match(/^(#{2,6})\s+(Update|Fix|Recherche)\s+(\d{4}-\d{2}-\d{2})(?:\s*(?:[—–:-]\s*)?(.+?))?\s*$/)
+    if (dated) {
+      const [, level, kind, date, rawTitle] = dated
+      const title = rawTitle?.trim() ?? ""
       if (!seenDates.has(date)) {
         out.push(`## Update ${date}`)
         seenDates.add(date)
       }
-      const cleanTitle = kind === "Update" ? title.trim() : `${kind} ${title.trim()}`
-      out.push(`${level.length === 2 ? "###" : level} ${cleanTitle}`)
-      continue
-    }
-    const plain = line.match(/^##\s+Update\s+(\d{4}-\d{2}-\d{2})\s*$/)
-    if (plain) {
-      const [, date] = plain
-      if (!seenDates.has(date)) {
-        out.push(`## Update ${date}`)
-        seenDates.add(date)
+      if (title) {
+        const cleanTitle = kind === "Update" ? title : `${kind} ${title}`
+        out.push(`${level.length === 2 ? "###" : level} ${cleanTitle}`)
       }
       continue
     }
@@ -275,8 +281,9 @@ export function normalizeUpdateHeadings(text: string): string {
   return out.join("\n").replace(/\n{3,}/g, "\n\n")
 }
 
-export function buildMemoryAppendEntry(text: string, heading?: string, date = todayDate()): string {
+export function buildMemoryAppendEntry(text: string, heading?: string, date = todayDate(), existingNote = true): string {
   const clean = stripFrontmatter(String(text ?? "")).trim()
+  if (!existingNote) return formatNewObsidianNoteBody(clean)
   if (/^##\s+Update\s+\d{4}-\d{2}-\d{2}(?:\s+[—-]\s+.+?)?\s*$/m.test(clean)) return clean
   const title = typeof heading === "string" && heading.trim() ? heading.trim() : ""
   const dateHeading = title ? `## Update ${date} — ${title}` : `## Update ${date}`
@@ -313,7 +320,10 @@ export async function appendMemoryWithResult(relPath: string, text: string, head
   if (!vault && !useCli) requireVaultPath()
   const rel = normalizeVaultRelativePath(relPath || DEFAULT_MEMORY_NOTE)
   const abs = vault ? absoluteVaultPath(vault, rel).abs : rel
-  const entry = buildMemoryAppendEntry(text, heading)
+  const existingNote = useCli
+    ? await obsidianCliRead(rel).then(() => true).catch(() => false)
+    : await exists(abs)
+  const entry = buildMemoryAppendEntry(text, heading, todayDate(), existingNote)
   const description = inferDescriptionFromMemoryText(entry, noteName(rel))
 
   if (useCli) {
@@ -340,19 +350,24 @@ export async function appendMemory(relPath: string, text: string, heading?: stri
   return (await appendMemoryWithResult(relPath, text, heading)).abs
 }
 
+function capMemoryText(content: string): string {
+  const buf = Buffer.from(content, "utf-8")
+  const text = buf.subarray(0, MAX_FILE_BYTES).toString("utf-8")
+  return buf.length > MAX_FILE_BYTES ? `${text}\n\n[truncated: ${buf.length} bytes]` : text
+}
+
 export async function readMemory(relPath = DEFAULT_MEMORY_NOTE): Promise<string> {
   const vault = getVaultPath()
-  const useCli = shouldUseObsidianCli() && !vault
+  const useCli = shouldUseObsidianCli()
   if (!vault && !useCli) requireVaultPath()
   const rel = normalizeVaultRelativePath(relPath, DEFAULT_MEMORY_NOTE)
   const abs = vault ? absoluteVaultPath(vault, rel).abs : rel
-  if (useCli) {
-    const content = await obsidianCliRead(rel)
-    const buf = Buffer.from(content, "utf-8")
-    const text = buf.subarray(0, MAX_FILE_BYTES).toString("utf-8")
-    return buf.length > MAX_FILE_BYTES ? `${text}\n\n[truncated: ${buf.length} bytes]` : text
+  if (vault) {
+    try { return readCappedFile(abs) } catch (error) {
+      if (!useCli) throw error
+    }
   }
-  return readCappedFile(abs)
+  return capMemoryText(await obsidianCliRead(rel))
 }
 
 export function listMarkdownFiles(vault: string, subdir = ""): Promise<string[]> {
@@ -424,8 +439,13 @@ function formatSearchResults(results: SearchVaultResult[]): string {
 
 export async function searchMemory(query: string, limit = 10, subdir = ""): Promise<string> {
   if (shouldUseObsidianCli()) {
-    const output = await obsidianCliSearch(query, limit, subdir)
-    if (!isEmptyCliSearch(output)) return output.trim()
+    try {
+      const output = await obsidianCliSearch(query, limit, subdir)
+      if (!isEmptyCliSearch(output)) return output.trim()
+    } catch {
+      // If the desktop-backed Obsidian CLI is broken or unavailable, keep memory
+      // search working through the configured filesystem vault path.
+    }
     // The Obsidian CLI's search:context matches AND across all query terms, so a
     // multi-term natural-language query returns nothing as soon as a single term is
     // missing from a note. Fall back to the local OR-based ranking (same scoring the
@@ -446,20 +466,42 @@ export async function listMemoryNotes(subdir = ""): Promise<string[]> {
   return listMarkdownFiles(requireVaultPath(), subdir)
 }
 
-async function readAlwaysContext(vault: string): Promise<string[]> {
-  const files = await listMarkdownFiles(vault, ALWAYS_CONTEXT_DIR)
+async function readAlwaysContext(vault: string | undefined): Promise<string[]> {
   const sections: string[] = []
   let totalBytes = 0
-  for (const rel of files) {
-    const { abs } = absoluteVaultPath(vault, rel)
-    const stat = await fs.stat(abs).catch(() => undefined)
-    if (!stat || stat.size > MAX_FILE_BYTES) continue
-    if (totalBytes + stat.size > MAX_ALWAYS_CONTEXT_BYTES) break
-    const content = await fs.readFile(abs, "utf-8")
+
+  async function addSection(rel: string, content: string): Promise<void> {
+    const bytes = Buffer.byteLength(content, "utf-8")
+    if (bytes > MAX_FILE_BYTES || totalBytes + bytes > MAX_ALWAYS_CONTEXT_BYTES) return
     const body = stripFrontmatter(content).trim().replace(/^#(?!#)\s+/m, "## ")
-    totalBytes += Buffer.byteLength(content, "utf-8")
+    totalBytes += bytes
     sections.push(`## ${rel}\n${body}`)
   }
+
+  if (vault) {
+    try {
+      const files = await listMarkdownFiles(vault, ALWAYS_CONTEXT_DIR)
+      for (const rel of files) {
+        const { abs } = absoluteVaultPath(vault, rel)
+        const stat = await fs.stat(abs).catch(() => undefined)
+        if (!stat || stat.size > MAX_FILE_BYTES) continue
+        if (totalBytes + stat.size > MAX_ALWAYS_CONTEXT_BYTES) break
+        await addSection(rel, await fs.readFile(abs, "utf-8"))
+      }
+      if (sections.length > 0 || !shouldUseObsidianCli()) return sections
+    } catch {
+      if (!shouldUseObsidianCli()) return sections
+    }
+  }
+
+  if (shouldUseObsidianCli()) {
+    const files = await obsidianCliListMarkdown(ALWAYS_CONTEXT_DIR).catch(() => [])
+    for (const rel of files) {
+      if (totalBytes >= MAX_ALWAYS_CONTEXT_BYTES) break
+      const content = await obsidianCliRead(rel).catch(() => "")
+      if (content) await addSection(rel, content)
+    }
+  }
   return sections
 }
 
@@ -717,9 +759,10 @@ export default async function obsidianMemoryExtension(pi: ExtensionAPI): Promise
   })
 
   pi.on("before_agent_start", async (event: any) => {
-    if (!vault) return
+    if (!vault && !shouldUseObsidianCli()) return
     const alwaysContext = await readAlwaysContext(vault)
-    const results = await searchVault(vault, event.prompt, CONTEXT_SEARCH_LIMIT, process.env.PI_OBSIDIAN_CONTEXT_DIR ?? "")
+    const injectCandidates = shouldInjectObsidianCandidates()
+    const results = injectCandidates && vault ? await searchVault(vault, event.prompt, CONTEXT_SEARCH_LIMIT, process.env.PI_OBSIDIAN_CONTEXT_DIR ?? "").catch(() => []) : []
     if (alwaysContext.length === 0 && results.length === 0) return
 
     const out: { systemPrompt?: string; message?: any } = {}

package/src/prism-extensions/providers/manifest-provider.ts

@@ -1,9 +1,11 @@
-import { createAssistantMessageEventStream } from "@earendil-works/pi-ai"
+import { calculateCost, createAssistantMessageEventStream } from "@earendil-works/pi-ai"
+import { getBuiltinModel as getTypedBuiltinModel } from "@earendil-works/pi-ai/providers/all"
 import { getPrismManifestRoutingTier } from "../core/manifest-routing.js"
 export { DEFAULT_MANIFEST_BASE_URL, DEFAULT_MANIFEST_CONTEXT_WINDOW, DEFAULT_MANIFEST_MAX_TOKENS, DEFAULT_MANIFEST_MODEL, applyManifestTierHeader, buildManifestRequestHeaders, normalizeManifestBaseUrl, normalizeManifestTier, readManifestProviderSettings, resolveManifestProviderConfig } from "./manifest-config.js"
 import { DEFAULT_MANIFEST_MODEL, type ManifestProviderConfig, applyManifestTierHeader, buildManifestRequestHeaders, normalizeManifestTier, resolveManifestProviderConfig } from "./manifest-config.js"
 
 type ExtensionAPI = any
+const getBuiltinModel = getTypedBuiltinModel as (provider: string, modelId: string) => any
 
 function sanitizeManifestSystemText(text: string): string {
   // Manifest may route to Anthropic. Its OpenAI-to-Anthropic bridge currently rejects some
@@ -180,6 +182,23 @@ export function manifestResponseSummary(headers: Record<string, string | undefin
   return `Manifest: ${parts.join(" · ")}`
 }
 
+export function applyManifestResponseCost(message: any, headers: Record<string, string | undefined>): any {
+  if (message?.role !== "assistant" || message.provider !== "manifest" || !message.usage) return message
+  const provider = headers["x-manifest-provider"]?.trim()
+  const responseModel = headers["x-manifest-model"]?.trim()
+  if (!provider || !responseModel) return message
+
+  const model = getBuiltinModel(provider, responseModel) ?? getBuiltinModel(provider, responseModel.split("/").pop() ?? responseModel)
+  if (!model?.cost) return { ...message, responseModel: `${provider}/${responseModel}` }
+
+  const usage = {
+    ...message.usage,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+  }
+  calculateCost(model, usage)
+  return { ...message, responseModel: `${provider}/${responseModel}`, usage }
+}
+
 function registerManifestProvider(pi: ExtensionAPI, config: ManifestProviderConfig): void {
   if (!config.baseUrl) return
   pi.registerProvider("manifest", {
@@ -207,6 +226,7 @@ function registerManifestProvider(pi: ExtensionAPI, config: ManifestProviderConf
 export default function manifestProviderExtension(pi: ExtensionAPI): void {
   let config = resolveManifestProviderConfig()
   let lastSummary: string | undefined
+  let lastHeaders: Record<string, string | undefined> = {}
   registerManifestProvider(pi, config)
 
   pi.on?.("before_provider_headers", (event: any, ctx: any) => {
@@ -221,10 +241,17 @@ export default function manifestProviderExtension(pi: ExtensionAPI): void {
 
   pi.on?.("after_provider_response", (event: any, ctx: any) => {
     if (ctx.model?.provider !== "manifest") return
-    lastSummary = manifestResponseSummary(event.headers ?? {})
+    lastHeaders = event.headers ?? {}
+    lastSummary = manifestResponseSummary(lastHeaders)
     if (lastSummary) ctx.ui?.setStatus?.("manifest", lastSummary)
   })
 
+  pi.on?.("message_end", (event: any, ctx: any) => {
+    if (ctx.model?.provider !== "manifest") return
+    const message = applyManifestResponseCost(event.message, lastHeaders)
+    return message === event.message ? undefined : { message }
+  })
+
   pi.registerCommand?.("manifest", {
     description: "Show or set Manifest routing override: status | tier <custom-tier|auto>",
     handler: async (args: string, ctx: any) => {

package/src/prism-extensions/tools/builtin-tools.ts

@@ -1,164 +1,16 @@
-import { createHash, randomUUID } from "node:crypto"
-import { Type } from "typebox"
 import type { ToolboxToolDefinition } from "./toolbox.js"
 import { createDiagnosticToolboxTools } from "./diagnostic-tools.js"
+import { createPrismDiagnosticToolboxTools } from "./prism-diagnostic-tools.js"
 import { createSshConfigTool } from "./ssh-config-tool.js"
-import { clampInteger, normalizedAction, textToolResult, type ToolInput } from "./toolbox-utils.js"
-
-const MAX_RESULTS = 500
 
 export function defineToolboxTool(definition: ToolboxToolDefinition): ToolboxToolDefinition {
   return { source: "toolbox/builtin", ...definition }
 }
 
-function stableSort(value: any): any {
-  if (Array.isArray(value)) return value.map(stableSort)
-  if (!value || typeof value !== "object" || value.constructor !== Object) return value
-  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stableSort(value[key])]))
-}
-
-function parseJsonInput(input: unknown): any {
-  if (typeof input === "string") return JSON.parse(input)
-  return input
-}
-
 export const builtinToolboxTools: ToolboxToolDefinition[] = [
-  defineToolboxTool({
-    name: "json_format",
-    label: "JSON Format",
-    description: "Format, minify, validate, and optionally sort JSON input.",
-    tags: ["json", "format", "validate", "minify"],
-    parameters: Type.Object({
-      input: Type.Any({ description: "JSON string or JSON-compatible value" }),
-      minify: Type.Optional(Type.Boolean({ description: "Return compact JSON instead of pretty JSON" })),
-      sortKeys: Type.Optional(Type.Boolean({ description: "Sort object keys recursively" })),
-    }),
-    async execute(_id: string, params: ToolInput) {
-      const parsed = parseJsonInput(params.input)
-      const normalized = params.sortKeys ? stableSort(parsed) : parsed
-      return textToolResult(JSON.stringify(normalized, null, params.minify ? 0 : 2), { valid: true })
-    },
-  }),
-
-  defineToolboxTool({
-    name: "base64_codec",
-    label: "Base64 Codec",
-    description: "Encode or decode UTF-8 text with Base64.",
-    tags: ["base64", "encode", "decode", "text"],
-    parameters: Type.Object({
-      action: Type.String({ description: "encode or decode" }),
-      text: Type.String({ description: "Input text" }),
-    }),
-    async execute(_id: string, params: ToolInput) {
-      const action = normalizedAction(params.action, "")
-      if (action === "encode") return textToolResult(Buffer.from(String(params.text ?? ""), "utf8").toString("base64"), { action })
-      if (action === "decode") return textToolResult(Buffer.from(String(params.text ?? ""), "base64").toString("utf8"), { action })
-      throw new Error("action must be encode or decode")
-    },
-  }),
-
-  defineToolboxTool({
-    name: "url_codec",
-    label: "URL Codec",
-    description: "Encode or decode URL components.",
-    tags: ["url", "encode", "decode", "uri"],
-    parameters: Type.Object({
-      action: Type.String({ description: "encode or decode" }),
-      text: Type.String({ description: "Input text" }),
-    }),
-    async execute(_id: string, params: ToolInput) {
-      const action = normalizedAction(params.action, "")
-      if (action === "encode") return textToolResult(encodeURIComponent(String(params.text ?? "")), { action })
-      if (action === "decode") return textToolResult(decodeURIComponent(String(params.text ?? "")), { action })
-      throw new Error("action must be encode or decode")
-    },
-  }),
-
-  defineToolboxTool({
-    name: "hash_text",
-    label: "Hash Text",
-    description: "Hash text using sha256, sha1, or md5.",
-    tags: ["hash", "sha256", "sha1", "md5", "checksum"],
-    parameters: Type.Object({
-      text: Type.String({ description: "Text to hash" }),
-      algorithm: Type.Optional(Type.String({ description: "sha256 (default), sha1, or md5" })),
-    }),
-    async execute(_id: string, params: ToolInput) {
-      const algorithm = normalizedAction(params.algorithm, "sha256")
-      if (!["sha256", "sha1", "md5"].includes(algorithm)) throw new Error("algorithm must be sha256, sha1, or md5")
-      return textToolResult(createHash(algorithm).update(String(params.text ?? ""), "utf8").digest("hex"), { algorithm })
-    },
-  }),
-
-  defineToolboxTool({
-    name: "regex_extract",
-    label: "Regex Extract",
-    description: "Extract regex matches from text, with optional capture group selection.",
-    tags: ["regex", "extract", "text", "match"],
-    parameters: Type.Object({
-      text: Type.String({ description: "Text to search" }),
-      pattern: Type.String({ description: "JavaScript regular expression pattern, without slashes" }),
-      flags: Type.Optional(Type.String({ description: "Regex flags. g is added automatically. Allowed: gimsyu" })),
-      group: Type.Optional(Type.Number({ description: "Capture group index, default 0 for whole match" })),
-      limit: Type.Optional(Type.Number({ description: "Maximum matches, default 100, max 500" })),
-    }),
-    async execute(_id: string, params: ToolInput) {
-      const rawFlags = String(params.flags ?? "")
-      if (!/^[gimsyu]*$/.test(rawFlags)) throw new Error("flags may only contain g, i, m, s, y, u")
-      const flags = rawFlags.includes("g") ? rawFlags : `${rawFlags}g`
-      const regex = new RegExp(String(params.pattern ?? ""), flags)
-      const group = Math.max(0, Math.trunc(Number(params.group ?? 0)))
-      const limit = clampInteger(params.limit, 100, 1, MAX_RESULTS)
-      const matches: string[] = []
-      for (const match of String(params.text ?? "").matchAll(regex)) {
-        matches.push(match[group] ?? "")
-        if (matches.length >= limit) break
-      }
-      return textToolResult(matches.join("\n") || "No matches", { count: matches.length, group, flags })
-    },
-  }),
-
-  defineToolboxTool({
-    name: "time_convert",
-    label: "Time Convert",
-    description: "Convert timestamps or date strings to ISO, Unix seconds, and Unix milliseconds. Uses current time when value is omitted.",
-    tags: ["time", "date", "timestamp", "unix", "iso"],
-    parameters: Type.Object({
-      value: Type.Optional(Type.Any({ description: "Date string, Unix seconds, Unix milliseconds, or empty for now" })),
-      unit: Type.Optional(Type.String({ description: "auto (default), seconds, milliseconds, or iso" })),
-    }),
-    async execute(_id: string, params: ToolInput) {
-      const unit = normalizedAction(params.unit, "auto")
-      const value = params.value
-      let date: Date
-      if (value === undefined || value === null || value === "") date = new Date()
-      else if (unit === "seconds") date = new Date(Number(value) * 1000)
-      else if (unit === "milliseconds") date = new Date(Number(value))
-      else if (unit === "iso") date = new Date(String(value))
-      else if (typeof value === "number" || /^\d+$/.test(String(value))) {
-        const numeric = Number(value)
-        date = new Date(numeric < 10_000_000_000 ? numeric * 1000 : numeric)
-      } else date = new Date(String(value))
-      if (!Number.isFinite(date.getTime())) throw new Error("Invalid date/time value")
-      const unixMs = date.getTime()
-      return textToolResult(JSON.stringify({ iso: date.toISOString(), unixSeconds: Math.floor(unixMs / 1000), unixMilliseconds: unixMs }, null, 2), { unixMs })
-    },
-  }),
-
-  defineToolboxTool({
-    name: "uuid_generate",
-    label: "UUID Generate",
-    description: "Generate one or more random UUID v4 values.",
-    tags: ["uuid", "random", "id"],
-    parameters: Type.Object({ count: Type.Optional(Type.Number({ description: "How many UUIDs to generate, default 1, max 100" })) }),
-    async execute(_id: string, params: ToolInput) {
-      const count = clampInteger(params.count, 1, 1, 100)
-      return textToolResult(Array.from({ length: count }, () => randomUUID()).join("\n"), { count })
-    },
-  }),
-
   createSshConfigTool(),
   ...createDiagnosticToolboxTools(),
+  ...createPrismDiagnosticToolboxTools(),
 ]
 
 export function createBuiltinToolboxTools(): ToolboxToolDefinition[] {

package/src/prism-extensions/tools/prism-diagnostic-tools.ts

@@ -0,0 +1,160 @@
+import * as fs from "node:fs"
+import * as path from "node:path"
+import { execFile } from "node:child_process"
+import { promisify } from "node:util"
+import { Type } from "typebox"
+import type { ToolboxToolDefinition } from "./toolbox.js"
+import { clampInteger, normalizedAction, requiredString, textToolResult, timeoutMs, MAX_TOOL_OUTPUT_CHARS, type ToolInput } from "./toolbox-utils.js"
+
+const execFileAsync = promisify(execFile)
+type ExecRunner = typeof execFileAsync
+
+async function run(command: string, args: string[], timeout: number, runner: ExecRunner = execFileAsync): Promise<string> {
+  try {
+    const { stdout, stderr } = await runner(command, args, { timeout, maxBuffer: MAX_TOOL_OUTPUT_CHARS * 2 })
+    return [stdout, stderr && `STDERR:\n${stderr}`].filter(Boolean).join("\n").trim()
+  } catch (error: any) {
+    const stdout = error?.stdout ? String(error.stdout) : ""
+    const stderr = error?.stderr ? String(error.stderr) : ""
+    const message = [stdout, stderr, error?.message ? `ERROR: ${error.message}` : ""].filter(Boolean).join("\n").trim()
+    return message || `ERROR: ${command} failed`
+  }
+}
+
+function jsonText(value: unknown): string {
+  return JSON.stringify(value, null, 2)
+}
+
+function prismHome(env: NodeJS.ProcessEnv = process.env): string {
+  return env.PRISM_CODING_AGENT_DIR || path.join(env.HOME || process.env.HOME || ".", ".prism")
+}
+
+function createPrismRuntimeStatusTool(): ToolboxToolDefinition {
+  return {
+    name: "prism_runtime_status",
+    label: "Prism Runtime Status",
+    description: "Inspect local Prism runtime/config paths, package version, pi dependency versions, sessions DB, and auth profile marker.",
+    tags: ["prism", "runtime", "version", "config", "sessions", "auth", "diagnostic"],
+    source: "toolbox/prism-diagnostics",
+    parameters: Type.Object({ cwd: Type.Optional(Type.String({ description: "Project directory to inspect. Defaults to current working directory." })) }),
+    async execute(_id: string, params: ToolInput, _signal, _onUpdate, ctx) {
+      const env = ctx?.env ?? process.env
+      const cwd = path.resolve(String(params.cwd || ctx?.cwd || process.cwd()))
+      const packagePath = path.join(cwd, "package.json")
+      const pkg = fs.existsSync(packagePath) ? JSON.parse(fs.readFileSync(packagePath, "utf-8")) : undefined
+      const home = prismHome(env)
+      const authProfilePath = path.join(home, "auth.profile")
+      const sessionsDb = path.join(home, "sessions.db")
+      const result = {
+        cwd,
+        package: pkg ? { name: pkg.name, version: pkg.version, piCodingAgent: pkg.dependencies?.["@earendil-works/pi-coding-agent"], piAi: pkg.dependencies?.["@earendil-works/pi-ai"] } : undefined,
+        prismHome: home,
+        settingsPath: path.join(home, "settings.json"),
+        settingsExists: fs.existsSync(path.join(home, "settings.json")),
+        sessionsDb,
+        sessionsDbExists: fs.existsSync(sessionsDb),
+        authProfile: fs.existsSync(authProfilePath) ? fs.readFileSync(authProfilePath, "utf-8").trim() : undefined,
+        env: {
+          PRISM_AI_MEMORY_BASE_URL: env.PRISM_AI_MEMORY_BASE_URL,
+          PRISM_OBSIDIAN_VAULT_NAME: env.PRISM_OBSIDIAN_VAULT_NAME,
+          PRISM_OBSIDIAN_VAULT: env.PRISM_OBSIDIAN_VAULT,
+          PRISM_CODING_AGENT_DIR: env.PRISM_CODING_AGENT_DIR,
+        },
+      }
+      return textToolResult(jsonText(result), result)
+    },
+  }
+}
+
+function createGiteaPackageVersionTool(): ToolboxToolDefinition {
+  return {
+    name: "gitea_package_version",
+    label: "Gitea Package Version",
+    description: "Check a Gitea/npm package metadata endpoint for the latest published version.",
+    tags: ["gitea", "package", "npm", "version", "registry", "prism", "deploy"],
+    source: "toolbox/prism-diagnostics",
+    parameters: Type.Object({
+      registry: Type.Optional(Type.String({ description: "Registry base URL. Default https://git.yiprawr.dev/api/packages/ai/npm" })),
+      packageName: Type.Optional(Type.String({ description: "Package name. Default @ai/prism" })),
+      timeoutMs: Type.Optional(Type.Number({ description: "Request timeout in milliseconds. Default 5000." })),
+    }),
+    async execute(_id: string, params: ToolInput) {
+      const registry = String(params.registry || "https://git.yiprawr.dev/api/packages/ai/npm").replace(/\/+$/, "")
+      const packageName = String(params.packageName || "@ai/prism")
+      const encodedName = packageName.startsWith("@") ? `@${encodeURIComponent(packageName.slice(1))}` : encodeURIComponent(packageName)
+      const url = `${registry}/${encodedName}`
+      const started = Date.now()
+      const response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs(params.timeoutMs, 5_000)), headers: { accept: "application/json" } })
+      const body = await response.text()
+      const ms = Date.now() - started
+      if (!response.ok) return textToolResult(`${response.status} ${response.statusText} (${ms}ms)\n${body.slice(0, 2000)}`, { ok: false, status: response.status, ms, url })
+      const data = JSON.parse(body)
+      const result = { ok: true, url, ms, name: data.name, latest: data?.["dist-tags"]?.latest, versions: Object.keys(data.versions ?? {}).slice(-10) }
+      return textToolResult(jsonText(result), result)
+    },
+  }
+}
+
+function createPortainerWebhookTool(): ToolboxToolDefinition {
+  return {
+    name: "portainer_webhook",
+    label: "Portainer Webhook",
+    description: "Inspect or trigger a Portainer webhook URL for stack redeploys. Defaults to dry-run.",
+    tags: ["portainer", "webhook", "redeploy", "docker", "stack", "deploy"],
+    source: "toolbox/prism-diagnostics",
+    parameters: Type.Object({
+      url: Type.String({ description: "Portainer webhook URL." }),
+      action: Type.Optional(Type.String({ description: "dry-run or trigger. Default dry-run." })),
+      timeoutMs: Type.Optional(Type.Number({ description: "Request timeout in milliseconds. Default 10000." })),
+    }),
+    async execute(_id: string, params: ToolInput) {
+      const url = requiredString(params.url, "url")
+      if (!/^https?:\/\//i.test(url)) throw new Error("url must start with http:// or https://")
+      const action = normalizedAction(params.action, "dry-run")
+      if (action === "dry-run") return textToolResult(`Dry-run only. Would POST Portainer webhook:\n${url}`, { action, url })
+      if (action !== "trigger") throw new Error("action must be dry-run or trigger")
+      const started = Date.now()
+      const response = await fetch(url, { method: "POST", signal: AbortSignal.timeout(timeoutMs(params.timeoutMs, 10_000)) })
+      const body = await response.text()
+      const result = { action, url, status: response.status, ok: response.ok, ms: Date.now() - started, body: body.slice(0, 2000) }
+      return textToolResult(jsonText(result), result)
+    },
+  }
+}
+
+function createPrismDeployCheckTool(): ToolboxToolDefinition {
+  return {
+    name: "prism_deploy_check",
+    label: "Prism Deploy Check",
+    description: "Run read-only checks for a deployed Prism SSH/tmux container over SSH: docker ps, image id, and recent logs.",
+    tags: ["prism", "deploy", "ssh", "docker", "container", "logs", "portainer", "zeus"],
+    source: "toolbox/prism-diagnostics",
+    parameters: Type.Object({
+      host: Type.String({ description: "SSH host alias." }),
+      container: Type.Optional(Type.String({ description: "Container name. Default prism-ssh." })),
+      lines: Type.Optional(Type.Number({ description: "Recent log lines. Default 80." })),
+      timeoutMs: Type.Optional(Type.Number({ description: "SSH timeout in milliseconds. Default 30000." })),
+    }),
+    async execute(_id: string, params: ToolInput, _signal, _onUpdate, ctx) {
+      const host = requiredString(params.host, "host")
+      const container = String(params.container || "prism-ssh")
+      const lines = clampInteger(params.lines, 80, 1, 500)
+      const remote = [
+        `echo '== container =='; docker ps --filter name=${JSON.stringify(container)} --format 'table {{.Names}}\t{{.Image}}\t{{.Status}}\t{{.Ports}}'`,
+        `echo; echo '== image =='; docker inspect ${JSON.stringify(container)} --format '{{.Image}} {{.Config.Image}}' 2>/dev/null || true`,
+        `echo; echo '== logs =='; docker logs --tail ${lines} ${JSON.stringify(container)} 2>&1 || true`,
+      ].join("; ")
+      const output = await run("ssh", ["-o", "BatchMode=yes", host, remote], timeoutMs(params.timeoutMs, 30_000), ctx?.execFileAsync ?? execFileAsync)
+      return textToolResult(output || `No Prism deploy output from ${host}.`, { host, container, lines })
+    },
+  }
+}
+
+export function createPrismDiagnosticToolboxTools(): ToolboxToolDefinition[] {
+  return [
+    createPrismRuntimeStatusTool(),
+    createGiteaPackageVersionTool(),
+    createPortainerWebhookTool(),
+    createPrismDeployCheckTool(),
+  ]
+}