@daniel156161/prism 0.2.92 → 0.2.97

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

@@ -0,0 +1,264 @@
+import { Type } from "typebox"
+import {
+  buildCheckArgs,
+  buildGetArgs,
+  buildGraphArgs,
+  buildImpactArgs,
+  buildLogArgs,
+  buildQueryArgs,
+  buildScopeArgs,
+  buildTimelineArgs,
+  hasMexScaffold,
+  isMexAvailable,
+  MEX_LOG_TYPES,
+  MEX_RELATIONS,
+  runMex,
+  type MexRunOptions,
+} from "../core/mex-cli.js"
+import {
+  describeMexGraphEnsure,
+  ensureMexGraphDb,
+  hasMexGraphDb,
+  isMexAutoGraphEnabled,
+  needsMexGraphAction,
+  type MexGraphEnsureResult,
+} from "../core/mex-graph-db.js"
+import { textToolResult } from "../tools/toolbox-utils.js"
+import { formatBracketedToolCall, renderSingleLineToolCall, type ThemeLike } from "../ui/tool-call-rendering.js"
+
+type ExtensionAPI = any
+
+const MEX_STATUS_KEY = "mex"
+const MEX_STATUS_LABEL = "🕸 mex"
+const MEX_STATUS_BUILDING_LABEL = "🕸 mex ⟳"
+
+const RETRIEVAL_PARAMS = {
+  detail: Type.Optional(Type.String({ description: "minimal | standard | source. Default minimal." })),
+  maxNodes: Type.Optional(Type.Number({ description: "Maximum nodes to return." })),
+  maxOutputTokens: Type.Optional(Type.Number({ description: "Hard output token ceiling." })),
+  maxSourceLines: Type.Optional(Type.Number({ description: "Per-node source line cap (detail=source)." })),
+}
+
+export function formatMexOutput(action: string, result: { ok: boolean; exitCode: number; output: string }) {
+  const text = result.output || (result.ok ? `mex ${action} produced no output.` : `mex ${action} failed.`)
+  return textToolResult(text, { action, ok: result.ok, exitCode: result.exitCode })
+}
+
+/** Registers the mex code-graph tools. Exported for tests. */
+export function registerMexTools(pi: ExtensionAPI, options: MexRunOptions = {}): string[] {
+  const registered: string[] = []
+  const exec = async (action: string, args: string[]) => {
+    // For code-graph actions we must have a `.mex/` scaffold.
+    // Otherwise `mex` itself may auto-create the scaffold/DB, which we explicitly want to avoid.
+    if (needsMexGraphAction(action)) {
+      const ensured = await ensureMexGraphDb(graphEnsureOptions(options))
+      if (ensured.status === "no-scaffold" || ensured.status === "disabled") {
+        return formatMexOutput(action, {
+          ok: false,
+          exitCode: 1,
+          output: `mex ${action} disabled: missing .mex scaffold (needed for graph.db). Run npx mex-agent setup in the repo root, or disable mex via PRISM_DISABLE_MEX=1.`,
+        })
+      }
+    }
+    return formatMexOutput(action, await runMex(args, options))
+  }
+
+  function register(tool: any): void {
+    registered.push(tool.name)
+    pi.registerTool(tool)
+  }
+
+  register({
+    name: "mex_scope",
+    label: "Mex Scope",
+    description: "Retrieve a compact, task-relevant code neighborhood from the local mex code graph (JSONL: symbols, signatures, relations, node ids).",
+    promptSnippet: "Use mex_scope first for codebase questions to get a compact set of relevant symbols instead of scanning files.",
+    promptGuidelines: [
+      "Describe the task in natural language, e.g. 'trace the authentication flow'.",
+      "Scope matching is word-based, not semantic. If results look weak, rephrase once, then fall back to grep/read.",
+      "Expand promising node ids with mex_get instead of reading whole files.",
+    ],
+    parameters: Type.Object({
+      task: Type.String({ description: "Task description, e.g. 'trace the authentication flow'." }),
+      ...RETRIEVAL_PARAMS,
+      fingerprint: Type.Optional(Type.Boolean({ description: "Attach node fingerprints (grounding workflow)." })),
+    }),
+    async execute(_id: string, params: any) {
+      return exec("scope", buildScopeArgs(params.task, params))
+    },
+    renderCall(args: any, theme: ThemeLike, context: any) {
+      return renderSingleLineToolCall(formatBracketedToolCall("mex scope", args?.task, theme), context)
+    },
+  })
+
+  register({
+    name: "mex_get",
+    label: "Mex Get",
+    description: "Expand source code for specific mex code-graph node ids returned by mex_scope, mex_query, or mex_impact.",
+    promptSnippet: "Expand mex node ids to source instead of reading whole files.",
+    parameters: Type.Object({
+      ids: Type.Array(Type.String({ description: "Node id, e.g. function:a3f8...c21" })),
+      maxSourceLines: Type.Optional(Type.Number({ description: "Per-node source line cap." })),
+      maxOutputTokens: Type.Optional(Type.Number({ description: "Hard output token ceiling." })),
+    }),
+    async execute(_id: string, params: any) {
+      return exec("get", buildGetArgs(params.ids, params))
+    },
+    renderCall(args: any, theme: ThemeLike, context: any) {
+      const ids = Array.isArray(args?.ids) ? args.ids : []
+      return renderSingleLineToolCall(formatBracketedToolCall("mex get", ids.length > 1 ? `${ids[0]} +${ids.length - 1}` : ids[0], theme), context)
+    },
+  })
+
+  register({
+    name: "mex_query",
+    label: "Mex Query",
+    description: `Query structural code relations in the mex graph: ${MEX_RELATIONS.join(", ")}.`,
+    promptSnippet: "Use mex_query for precise structural questions like who calls a function or where a symbol is defined.",
+    parameters: Type.Object({
+      relation: Type.String({ description: MEX_RELATIONS.join(" | ") }),
+      target: Type.String({ description: "Symbol or file name." }),
+      ...RETRIEVAL_PARAMS,
+    }),
+    async execute(_id: string, params: any) {
+      return exec("query", buildQueryArgs(params.relation, params.target, params))
+    },
+    renderCall(args: any, theme: ThemeLike, context: any) {
+      return renderSingleLineToolCall(formatBracketedToolCall("mex query", [args?.relation, args?.target].filter(Boolean).join(" "), theme), context)
+    },
+  })
+
+  register({
+    name: "mex_impact",
+    label: "Mex Impact",
+    description: "Show the transitive code and wiki blast radius for a symbol or file before refactoring.",
+    promptSnippet: "Use mex_impact before refactors to see what a symbol or file change touches.",
+    parameters: Type.Object({
+      target: Type.String({ description: "Symbol name or file path." }),
+      depth: Type.Optional(Type.Number({ description: "Transitive caller depth. Default 2." })),
+      ...RETRIEVAL_PARAMS,
+    }),
+    async execute(_id: string, params: any) {
+      return exec("impact", buildImpactArgs(params.target, params))
+    },
+    renderCall(args: any, theme: ThemeLike, context: any) {
+      return renderSingleLineToolCall(formatBracketedToolCall("mex impact", args?.target, theme), context)
+    },
+  })
+
+  register({
+    name: "mex_log",
+    label: "Mex Log",
+    description: `Append a ${MEX_LOG_TYPES.join("/")} entry to the repo-local mex event log (.mex/events).`,
+    promptSnippet: "Log durable repo decisions, risks, or todos into the mex event log.",
+    promptGuidelines: [
+      "Log decisions only when they are actually settled in this conversation.",
+      "Keep entries short and repo-specific; no secrets, credentials, or private hostnames.",
+    ],
+    parameters: Type.Object({
+      message: Type.String({ description: "Short entry text." }),
+      type: Type.Optional(Type.String({ description: `${MEX_LOG_TYPES.join(" | ")}. Default note.` })),
+      files: Type.Optional(Type.Array(Type.String({ description: "Related file path." }))),
+      status: Type.Optional(Type.String({ description: "Lifecycle status, e.g. decided or implemented." })),
+    }),
+    async execute(_id: string, params: any) {
+      return exec("log", buildLogArgs(params.message, params))
+    },
+    renderCall(args: any, theme: ThemeLike, context: any) {
+      return renderSingleLineToolCall(formatBracketedToolCall(`mex log ${String(args?.type ?? "note")}`, args?.message, theme), context)
+    },
+  })
+
+  return registered
+}
+
+export default function mexMemoryExtension(pi: ExtensionAPI): void {
+  const cwd = process.cwd()
+  if (!isMexAvailable(process.env, cwd)) return
+
+  registerMexTools(pi, { cwd })
+
+  pi.on?.("session_start", (_event: any, ctx: any) => {
+    ctx?.ui?.setStatus?.(MEX_STATUS_KEY, mexStatusLabel(cwd))
+    void autoBuildMissingGraph(cwd, ctx)
+  })
+
+  pi.registerCommand("mex", {
+    description: "Mex code graph: /mex [status] | graph | check | timeline | scope <task>",
+    handler: async (args: string, ctx: any) => {
+      const [sub, ...rest] = (args || "").trim().split(/\s+/)
+      const argument = rest.join(" ").trim()
+      const action = (sub || "status").toLowerCase()
+      try {
+        if (action === "status") {
+          const result = await runMex(buildCheckArgs({ quiet: true }), { cwd })
+          const lines = [
+            `mex scaffold: ${hasMexScaffold(cwd) ? mexPathLabel(cwd) : "missing"}`,
+            `mex graph.db: ${hasMexGraphDb(cwd) ? "present" : isMexAutoGraphEnabled() ? "missing (auto-build on demand)" : "missing (auto-build disabled)"}`,
+            result.output,
+          ]
+          ctx.ui.notify(lines.filter(Boolean).join("\n"), result.ok ? "info" : "warning")
+          return
+        }
+        if (action === "graph") {
+          // Never let `mex graph` create a scaffold/DB in `~/.mex` when we're running outside a repo scaffold.
+          // Don't rebuild when graph.db already exists; just skip to avoid touching ~/.mex.
+          const ensured = await ensureMexGraphDb({ cwd, env: process.env, runner: undefined, timeoutMs: 300_000 })
+          const message = describeMexGraphEnsure(ensured)
+          if (message) ctx.ui.notify(message, ensured.status === "built" ? "info" : "warning")
+          else ctx.ui.notify("mex graph skipped.", ensured.status === "built" ? "info" : "warning")
+          return
+        }
+        if (action === "check") {
+          const result = await runMex(buildCheckArgs({}), { cwd, timeoutMs: 300_000 })
+          ctx.ui.notify(result.output || "No drift output.", result.ok ? "info" : "warning")
+          return
+        }
+        if (action === "timeline") {
+          const result = await runMex(buildTimelineArgs({ limit: 20 }), { cwd })
+          ctx.ui.notify(result.output || "No mex events.", "info")
+          return
+        }
+        if (action === "scope") {
+          if (!argument) return ctx.ui.notify("Usage: /mex scope <task>", "warning")
+          const result = await runMex(buildScopeArgs(argument, {}), { cwd })
+          ctx.ui.notify(result.output || "No scope results.", result.ok ? "info" : "warning")
+          return
+        }
+        ctx.ui.notify("Usage: /mex [status] | graph | check | timeline | scope <task>", "warning")
+      } catch (error) {
+        ctx.ui.notify(`mex command failed:\n${error instanceof Error ? error.message : String(error)}`, "error")
+      }
+    },
+  })
+}
+
+function mexPathLabel(cwd: string): string {
+  return `${cwd.replace(/\/+$/, "")}/.mex`
+}
+
+function graphEnsureOptions(options: MexRunOptions): MexRunOptions {
+  return { cwd: options.cwd, env: options.env, runner: options.runner }
+}
+
+/** Only a scaffold with a usable code graph counts as "mex is working"; otherwise the segment stays hidden. */
+export function mexStatusLabel(cwd: string = process.cwd()): string | undefined {
+  return hasMexScaffold(cwd) && hasMexGraphDb(cwd) ? MEX_STATUS_LABEL : undefined
+}
+
+/** Builds a missing code graph in the background so the first graph tool call is not blocked. */
+async function autoBuildMissingGraph(cwd: string, ctx: any): Promise<MexGraphEnsureResult | undefined> {
+  if (!hasMexScaffold(cwd) || hasMexGraphDb(cwd) || !isMexAutoGraphEnabled()) return undefined
+  ctx?.ui?.setStatus?.(MEX_STATUS_KEY, MEX_STATUS_BUILDING_LABEL)
+  try {
+    const result = await ensureMexGraphDb({ cwd })
+    const message = describeMexGraphEnsure(result)
+    if (message) ctx?.ui?.notify?.(message, result.status === "built" ? "info" : "warning")
+    return result
+  } catch (error) {
+    ctx?.ui?.notify?.(`mex graph build failed:\n${error instanceof Error ? error.message : String(error)}`, "warning")
+    return undefined
+  } finally {
+    ctx?.ui?.setStatus?.(MEX_STATUS_KEY, mexStatusLabel(cwd))
+  }
+}

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

@@ -2,6 +2,7 @@ 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 { createMexToolboxTools } from "./mex-tools.js"
 
 export function defineToolboxTool(definition: ToolboxToolDefinition): ToolboxToolDefinition {
   return { source: "toolbox/builtin", ...definition }
@@ -11,6 +12,7 @@ export const builtinToolboxTools: ToolboxToolDefinition[] = [
   createSshConfigTool(),
   ...createDiagnosticToolboxTools(),
   ...createPrismDiagnosticToolboxTools(),
+  ...createMexToolboxTools(),
 ]
 
 export function createBuiltinToolboxTools(): ToolboxToolDefinition[] {

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

@@ -0,0 +1,93 @@
+import { Type } from "typebox"
+import {
+  buildCheckArgs,
+  buildGraphArgs,
+  buildTimelineArgs,
+  hasMexScaffold,
+  isMexCliInstalled,
+  MEX_LOG_TYPES,
+  runMex,
+  type MexRunOptions,
+} from "../core/mex-cli.js"
+import type { ToolboxToolDefinition } from "./toolbox.js"
+import { textToolResult, timeoutMs, type ToolInput } from "./toolbox-utils.js"
+
+const MEX_TAGS = ["mex", "codegraph", "graph", "wiki", "scaffold", "drift", "documentation", "memory"]
+
+function runOptions(params: ToolInput, fallbackTimeout: number): MexRunOptions {
+  return {
+    cwd: typeof params.cwd === "string" && params.cwd.trim() ? params.cwd.trim() : process.cwd(),
+    timeoutMs: timeoutMs(params.timeoutMs, fallbackTimeout),
+  }
+}
+
+function guardScaffold(cwd: string): void {
+  if (!isMexCliInstalled()) throw new Error("mex CLI not found. Install it with: npm install -g mex-agent")
+  if (!hasMexScaffold(cwd)) throw new Error(`No .mex scaffold in ${cwd}. Run 'npx mex-agent setup' first.`)
+}
+
+async function execute(action: string, args: string[], options: MexRunOptions) {
+  guardScaffold(options.cwd ?? process.cwd())
+  const result = await runMex(args, options)
+  return textToolResult(result.output || `mex ${action} produced no output.`, { action, ok: result.ok, exitCode: result.exitCode, cwd: options.cwd })
+}
+
+function createMexGraphBuildTool(): ToolboxToolDefinition {
+  return {
+    name: "mex_graph_build",
+    label: "Mex Graph Build",
+    description: "Rebuild the local mex code knowledge graph (.mex/graph.db) so scope/query/impact results are current.",
+    tags: [...MEX_TAGS, "build", "index", "rebuild"],
+    parameters: Type.Object({
+      cwd: Type.Optional(Type.String({ description: "Repository root. Defaults to the current working directory." })),
+      json: Type.Optional(Type.Boolean({ description: "Return the build summary as JSON." })),
+      timeoutMs: Type.Optional(Type.Number({ description: "Command timeout in milliseconds. Default 120000." })),
+    }),
+    async execute(_id: string, params: ToolInput) {
+      const options = runOptions(params, 120_000)
+      return execute("graph", buildGraphArgs({ json: params.json, root: params.cwd }), options)
+    },
+  }
+}
+
+function createMexCheckTool(): ToolboxToolDefinition {
+  return {
+    name: "mex_check",
+    label: "Mex Check",
+    description: "Run mex drift detection between the .mex wiki and the codebase (paths, commands, dependencies, links, grounded symbols).",
+    tags: [...MEX_TAGS, "check", "health", "stale", "validate"],
+    parameters: Type.Object({
+      cwd: Type.Optional(Type.String({ description: "Repository root. Defaults to the current working directory." })),
+      json: Type.Optional(Type.Boolean({ description: "Return the full drift report as JSON." })),
+      quiet: Type.Optional(Type.Boolean({ description: "Single-line summary only." })),
+      timeoutMs: Type.Optional(Type.Number({ description: "Command timeout in milliseconds. Default 120000." })),
+    }),
+    async execute(_id: string, params: ToolInput) {
+      return execute("check", buildCheckArgs({ json: params.json, quiet: params.quiet }), runOptions(params, 120_000))
+    },
+  }
+}
+
+function createMexTimelineTool(): ToolboxToolDefinition {
+  return {
+    name: "mex_timeline",
+    label: "Mex Timeline",
+    description: `Read recent entries from the mex event log (${MEX_LOG_TYPES.join("/")}) for repo history and past decisions.`,
+    tags: [...MEX_TAGS, "timeline", "events", "decisions", "history", "log"],
+    parameters: Type.Object({
+      cwd: Type.Optional(Type.String({ description: "Repository root. Defaults to the current working directory." })),
+      since: Type.Optional(Type.String({ description: "YYYY-MM-DD or relative like 30d." })),
+      type: Type.Optional(Type.String({ description: MEX_LOG_TYPES.join(" | ") })),
+      limit: Type.Optional(Type.Number({ description: "Maximum entries." })),
+      json: Type.Optional(Type.Boolean({ description: "Return events as JSON." })),
+      timeoutMs: Type.Optional(Type.Number({ description: "Command timeout in milliseconds. Default 30000." })),
+    }),
+    async execute(_id: string, params: ToolInput) {
+      return execute("timeline", buildTimelineArgs(params), runOptions(params, 30_000))
+    },
+  }
+}
+
+export function createMexToolboxTools(): ToolboxToolDefinition[] {
+  return [createMexGraphBuildTool(), createMexCheckTool(), createMexTimelineTool()]
+}

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

@@ -66,21 +66,21 @@ function createPrismRuntimeStatusTool(): ToolboxToolDefinition {
   }
 }
 
-function createGiteaPackageVersionTool(): ToolboxToolDefinition {
+function createNpmPackageVersionTool(): 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"],
+    name: "npm_package_version",
+    label: "Npm Package Version",
+    description: "Check an npm-compatible registry metadata endpoint for the latest published version.",
+    tags: ["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" })),
+      registry: Type.Optional(Type.String({ description: "Registry base URL. Default https://registry.npmjs.org" })),
+      packageName: Type.Optional(Type.String({ description: "Package name. Default @daniel156161/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 registry = String(params.registry || "https://registry.npmjs.org").replace(/\/+$/, "")
+      const packageName = String(params.packageName || "@daniel156161/prism")
       const encodedName = packageName.startsWith("@") ? `@${encodeURIComponent(packageName.slice(1))}` : encodeURIComponent(packageName)
       const url = `${registry}/${encodedName}`
       const started = Date.now()
@@ -153,7 +153,7 @@ function createPrismDeployCheckTool(): ToolboxToolDefinition {
 export function createPrismDiagnosticToolboxTools(): ToolboxToolDefinition[] {
   return [
     createPrismRuntimeStatusTool(),
-    createGiteaPackageVersionTool(),
+    createNpmPackageVersionTool(),
     createPortainerWebhookTool(),
     createPrismDeployCheckTool(),
   ]

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

@@ -89,7 +89,7 @@ function formatResults(results: ToolboxSearchResult[]): string {
 }
 
 const AUTO_SUGGEST_DOMAIN_TERMS = new Set([
-  "backup", "borg", "container", "deploy", "diagnostic", "docker", "gitea", "health", "http", "logs", "netbird", "npm", "opnsense", "package", "pfsense", "port", "portainer", "process", "prism", "registry", "redeploy", "router", "runtime", "service", "services", "ssh", "stack", "status", "systemd", "vpn", "webhook",
+  "backup", "borg", "container", "deploy", "diagnostic", "docker", "health", "http", "logs", "netbird", "npm", "opnsense", "package", "pfsense", "port", "portainer", "process", "prism", "registry", "redeploy", "router", "runtime", "service", "services", "ssh", "stack", "status", "systemd", "vpn", "webhook",
 ])
 
 const AUTO_SUGGEST_STOPWORDS = new Set([

package/src/prism-extensions/ui/toolbar.ts

@@ -72,6 +72,13 @@ export function toolbarAccent(theme: ThemeLike, text: string): string {
   return fg(theme, "accent", text)
 }
 
+/** Role-play status is only worth a toolbar slot while a role-play is actually running. */
+export function rpLabel(status: string | undefined): string | undefined {
+  const value = status?.trim()
+  if (!value || /^RP:\s*off$/i.test(value)) return undefined
+  return value
+}
+
 export function cavemanColor(mode: string): number {
   const normalized = mode.toLowerCase()
   if (normalized === "lite") return 226
@@ -185,8 +192,10 @@ class ToolbarFooter {
     const obsidian = statuses?.get("obsidian-memory")
     const logseq = statuses?.get("logseq-memory")
     const aiMemory = statuses?.get("ai-memory")
+    const mex = statuses?.get("mex")
+    const rp = rpLabel(statuses?.get("rp"))
 
-    return [joinDistributed([mode ? fg(this.theme, "success", mode) : undefined, model, fg(this.theme, "accent", `🔧 ${toolCalls}`), fg(this.theme, "dim", `↑${formatTokens(input)}`), fg(this.theme, "dim", `↓${formatTokens(output)}`), fg(this.theme, "success", `$${cost.toFixed(4)}`), context, caveman, obsidian, logseq, aiMemory ? `AI Memory: ${aiMemory}` : undefined, thinking].filter(Boolean) as string[], Math.max(0, width))]
+    return [joinDistributed([mode ? fg(this.theme, "success", mode) : undefined, model, fg(this.theme, "accent", `🔧 ${toolCalls}`), fg(this.theme, "dim", `↑${formatTokens(input)}`), fg(this.theme, "dim", `↓${formatTokens(output)}`), fg(this.theme, "success", `$${cost.toFixed(4)}`), context, caveman, obsidian, logseq, aiMemory ? `AI Memory: ${aiMemory}` : undefined, mex, rp, thinking].filter(Boolean) as string[], Math.max(0, width))]
   }
 }
 

package/src/prism-extensions/commands/voice-command.ts

@@ -1,49 +0,0 @@
-import { LocalVoiceRuntime, parseVoiceMode, voiceStatus, type VoiceMode } from "../core/voice-runtime.js"
-
-type ExtensionAPI = any
-
-export default function voiceCommandExtension(pi: ExtensionAPI): void {
-  let runtime: LocalVoiceRuntime | undefined
-  let mode: VoiceMode = "off"
-
-  function ensureRuntime(ctx: any): LocalVoiceRuntime {
-    runtime ??= new LocalVoiceRuntime({
-      sendUserMessage: (message) => pi.sendUserMessage(message),
-      notify: (message, level) => ctx?.ui?.notify?.(message, level),
-      setStatus: (value) => ctx?.ui?.setStatus?.("voice", value),
-    })
-    return runtime
-  }
-
-  pi.registerCommand("voice", {
-    description: "Local voice mode: /voice on | output | input | off",
-    handler: async (args: string, ctx: any) => {
-      const next = parseVoiceMode(args)
-      if (!next) {
-        ctx.ui.notify(`Voice mode: ${mode}. Use /voice on, /voice output, /voice input, or /voice off.`, "info")
-        return
-      }
-      mode = next
-      const voice = ensureRuntime(ctx)
-      voice.setMode(mode)
-      ctx.ui.setStatus("voice", voiceStatus(mode))
-      if (mode === "output" || mode === "on") {
-        const ok = await voice.ensureVoicebox()
-        if (voice.isVoiceboxEnabled() && !ok) {
-          ctx.ui.notify("Voicebox is not reachable and could not be started. Check voicebox settings/PRISM_VOICEBOX_URL.", "warning")
-        }
-      }
-      ctx.ui.notify(mode === "off" ? "Voice off" : `Voice ${mode}`, "info")
-    },
-  })
-
-  pi.on("session_start", (_event: any, ctx: any) => {
-    if (mode !== "off") ensureRuntime(ctx).setMode(mode)
-  })
-
-  pi.on("message_end", async (event: any, ctx: any) => {
-    if (mode === "on" || mode === "output") await ensureRuntime(ctx).speakAssistantMessage(event.message)
-  })
-
-  pi.on?.("session_shutdown", () => runtime?.shutdown())
-}