wotann 0.5.0 → 0.5.39

package/dist/daemon/kairos-rpc.js

@@ -7,7 +7,7 @@
  *
  * This handler routes incoming RPC calls to the WotannRuntime methods.
  */
-import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync, realpathSync, } from "node:fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync, realpathSync, unlinkSync, } from "node:fs";
 import { join, dirname, resolve as resolvePath } from "node:path";
 import { parse as yamlParse, stringify as yamlStringify } from "yaml";
 import { resolveWotannHome, resolveWotannHomeSubdir } from "../utils/wotann-home.js";
@@ -24,7 +24,17 @@ import { AuditTrail } from "../telemetry/audit-trail.js";
 // the route-table-driven `executeDesktopAction(action)` from
 // platform-bindings. Wiring this unblocks the entire F-series RPC
 // surface (iOS → daemon → action → UI feedback).
-import { executeDesktopAction, } from "../computer-use/platform-bindings.js";
+import { executeDesktopAction, takeScreenshot, } from "../computer-use/platform-bindings.js";
+import { buildObservationFrame, executeComputerAction, normalizeComputerAction, } from "../computer-use/driver-contract.js";
+// V9 T1.x — `computer.session.safeStep` routes the same step payload as
+// `computer.session.step` through the safe-execute composer, layering
+// validateAction → confidence-gate → coordinate-scaling → action-replay
+// on top of the existing platform-bindings dispatch. The four sibling
+// modules already exist; this wire turns kairos-rpc.ts from "step → drive
+// the machine + dispatch" into the runtime caller of the safe-execute
+// pipeline so guardrails apply at the daemon RPC boundary.
+import { safeExecute } from "../computer-use/safe-execute.js";
+import { startRecording, } from "../computer-use/action-replay.js";
 import { createECDH, hkdfSync, randomUUID } from "node:crypto";
 import { sanitizeCommand } from "../security/command-sanitizer.js";
 import { VoicePipeline } from "../voice/voice-pipeline.js";
@@ -49,6 +59,9 @@ import { streamMethodForChunkType } from "../desktop/companion-server.js";
 import { registerSandboxHandlers } from "./rpc-handlers/sandbox-rpc.js";
 import { registerOrchestrationHandlers } from "./rpc-handlers/orchestration-rpc.js";
 import { registerIntelligenceHandlers } from "./rpc-handlers/intelligence-rpc.js";
+import { probeMcpServers } from "../mcp/health-probe.js";
+import { parsePromptCorpusText } from "../snippets/prompt-corpus.js";
+import { getMarkitdownCapabilities } from "../tools/markitdown-bridge.js";
 // ── Voice pipeline singleton + streaming bookkeeping ──────
 //
 // Session-5 wiring for `voice.transcribe` and `voice.stream.{start,poll,
@@ -181,6 +194,127 @@ function serializeEvent(e) {
         payload: e.payload,
     };
 }
+// ── safe-execute → desktop translation ────────────────────────
+//
+// `computer.session.safeStep` accepts the AtomicAction shape from
+// action-repertoire (model-friendly: {type:"click", at:{x,y}}). The
+// existing dispatch surface (executeComputerAction → executeDesktopAction)
+// expects the {action:"click", params:{x:"…",y:"…"}} envelope used by the
+// legacy `computer.session.step` handler. This helper bridges the two
+// shapes WITHOUT duplicating the dispatch table — translation is a flat
+// switch and every variant maps onto a normalizeComputerAction-known
+// action name. Returns null when the atomic action has no desktop
+// counterpart (e.g. `zoom` is a perception-side concern, not a dispatch).
+function atomicToDesktopShape(atomic) {
+    const type = atomic["type"];
+    if (typeof type !== "string")
+        return null;
+    const stringify = (params) => {
+        const out = {};
+        for (const [k, v] of Object.entries(params)) {
+            if (v === undefined || v === null)
+                continue;
+            out[k] = String(v);
+        }
+        return out;
+    };
+    switch (type) {
+        case "click":
+        case "double_click":
+        case "right_click": {
+            const at = atomic["at"];
+            const button = type === "right_click" ? "right" : (atomic["button"] ?? "left");
+            const clicks = type === "double_click" ? 2 : 1;
+            return {
+                action: "click",
+                params: stringify({ x: at?.x, y: at?.y, button, clicks }),
+            };
+        }
+        case "type": {
+            return { action: "type", params: stringify({ text: atomic["text"] }) };
+        }
+        case "key": {
+            const keys = atomic["keys"];
+            if (!Array.isArray(keys) || keys.length === 0)
+                return null;
+            return { action: "key", params: { key: keys.join("+") } };
+        }
+        case "scroll": {
+            const at = atomic["at"];
+            return {
+                action: "scroll",
+                params: stringify({
+                    x: at?.x,
+                    y: at?.y,
+                    direction: atomic["direction"],
+                    amount: atomic["amount"],
+                }),
+            };
+        }
+        case "drag": {
+            const path = atomic["path"];
+            if (!Array.isArray(path) || path.length < 2)
+                return null;
+            const start = path[0];
+            const end = path[path.length - 1];
+            return {
+                action: "drag",
+                params: stringify({ x: start.x, y: start.y, endX: end.x, endY: end.y }),
+            };
+        }
+        case "mouse_move": {
+            const to = atomic["to"];
+            return { action: "move", params: stringify({ x: to?.x, y: to?.y }) };
+        }
+        case "screenshot":
+        case "take_screenshot": {
+            return { action: "screenshot", params: {} };
+        }
+        case "wait": {
+            return { action: "wait", params: stringify({ ms: atomic["ms"] }) };
+        }
+        case "cursor_position":
+            return { action: "get-active-window", params: {} };
+        case "screen_size":
+            return { action: "screen-size", params: {} };
+        case "zoom":
+            // perception-side action — no desktop dispatch counterpart
+            return null;
+        default:
+            return null;
+    }
+}
+const SECRET_ARG_NAME_PATTERN = /(?:token|secret|password|passwd|api[-_]?key|access[-_]?key|private[-_]?key|credential|auth|bearer)/i;
+const SECRET_VALUE_PATTERN = /\b(?:Bearer\s+)[^\s]+|\b(?:sk-[A-Za-z0-9_-]{8,}|gh[pousr]_[A-Za-z0-9_]{8,})\b|(?:api[-_]?key|token|secret|password|passwd|credential|auth)\s*[=:]\s*[^\s,;]+/gi;
+function redactSecretText(value) {
+    return value.replace(SECRET_VALUE_PATTERN, (match) => {
+        if (/^Bearer\s+/i.test(match))
+            return "Bearer [redacted]";
+        const separator = match.includes("=") ? "=" : match.includes(":") ? ":" : "";
+        if (!separator)
+            return "[redacted]";
+        const [key] = match.split(separator, 1);
+        return `${key}${separator}[redacted]`;
+    });
+}
+function redactMcpArgs(args) {
+    let redactNext = false;
+    return args.map((arg) => {
+        if (redactNext) {
+            redactNext = false;
+            return "[redacted]";
+        }
+        if (!SECRET_ARG_NAME_PATTERN.test(arg)) {
+            return redactSecretText(arg);
+        }
+        if (arg.includes("=")) {
+            const [key] = arg.split("=", 1);
+            return `${key}=[redacted]`;
+        }
+        redactNext = true;
+        return arg;
+    });
+}
 function serializeApprovalRecord(r) {
     // The typed payload is serialised as-is — JSON-RPC consumers rely on
     // `payload.kind` to discriminate (shell-exec/file-write/destructive/custom)
@@ -738,10 +872,72 @@ export function extractImageCandidatesFromParams(params) {
     }
     return candidates;
 }
+function normalizeP256PublicKey(publicKey) {
+    if (publicKey.length === 65 && publicKey[0] === 0x04)
+        return publicKey;
+    if (publicKey.length === 64)
+        return Buffer.concat([Buffer.from([0x04]), publicKey]);
+    throw new Error(`Invalid P-256 public key: expected 64-byte raw X/Y or 65-byte X9.63, got ${publicKey.length} bytes`);
+}
 const MAX_FRAME_BUFFER = 30;
+const MCP_SERVER_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/;
+const BLOCKED_MCP_COMMANDS = new Set([
+    "bash",
+    "sh",
+    "zsh",
+    "fish",
+    "curl",
+    "wget",
+    "nc",
+    "netcat",
+    "osascript",
+    "powershell",
+    "pwsh",
+]);
+const TRUSTED_MCP_COMMANDS = new Set([
+    "node",
+    "npm",
+    "npx",
+    "pnpm",
+    "yarn",
+    "bun",
+    "python",
+    "python3",
+    "uv",
+    "uvx",
+    "docker",
+    "deno",
+]);
+function validateMcpAddRequest(input) {
+    if (!MCP_SERVER_NAME_PATTERN.test(input.name)) {
+        return "MCP server name must be 1-80 chars and contain only letters, numbers, dot, underscore, or dash";
+    }
+    if (input.transport !== "stdio" && input.transport !== "http") {
+        return "MCP server transport must be stdio or http";
+    }
+    if (!Array.isArray(input.args) || input.args.some((arg) => typeof arg !== "string")) {
+        return "MCP server args must be strings";
+    }
+    const command = input.command.trim();
+    if (command.length === 0)
+        return "MCP server command required";
+    if (/[;&|`$<>]/.test(command)) {
+        return "MCP server command must be an executable name or path, not a shell expression";
+    }
+    const executable = command.split(/[\\/]/).pop()?.toLowerCase() ?? command.toLowerCase();
+    if (BLOCKED_MCP_COMMANDS.has(executable)) {
+        return `MCP server command '${executable}' is blocked; register a concrete MCP executable instead`;
+    }
+    const pathLike = command.includes("/") || command.includes("\\") || command.startsWith(".");
+    if ((pathLike || !TRUSTED_MCP_COMMANDS.has(executable)) && !input.trusted) {
+        return "untrusted MCP command requires trusted:true after explicit user confirmation";
+    }
+    return null;
+}
 export class KairosRPCHandler {
     handlers = new Map();
     runtime = null;
+    runtimeReady = null;
     daemon = null;
     // State for iOS surface handlers (node registry, ECDH keys, frame buffer).
     nodeRegistry = new Map();
@@ -879,6 +1075,16 @@ export class KairosRPCHandler {
     sweepTimer = null;
     constructor() {
         this.registerBuiltinMethods();
+        // iOS/TUI surface methods are part of the base daemon contract. Register
+        // them explicitly here so they are available even if future builtin blocks
+        // are reorganized before the legacy end-of-method registration site.
+        this.registerIOSSurfaceHandlers();
+        // registerSurfaceHandlers() also runs from setRuntime() — re-running here
+        // is idempotent (handlers Map.set is replace-on-collision) and lets the
+        // runtime-independent handlers (ingest.capabilities, hooks.list with null
+        // guards, etc.) answer pre-setRuntime calls. Runtime-dependent handlers
+        // close over `this.runtime` and pick up the value at invocation time.
+        this.registerSurfaceHandlers();
         this.startSubscriptionSweep();
     }
     /**
@@ -1097,8 +1303,9 @@ export class KairosRPCHandler {
     /**
      * Attach a WotannRuntime instance to route RPC calls to.
      */
-    setRuntime(runtime) {
+    setRuntime(runtime, ready) {
         this.runtime = runtime;
+        this.runtimeReady = ready ?? null;
         // Register self-improvement handlers now that runtime and daemon are available
         this.registerSelfImprovementHandlers();
         this.registerSurfaceHandlers();
@@ -1278,6 +1485,23 @@ export class KairosRPCHandler {
             };
             return;
         }
+        if (this.runtimeReady) {
+            try {
+                await this.runtimeReady;
+            }
+            catch (err) {
+                yield {
+                    jsonrpc: "2.0",
+                    method: "stream.error",
+                    params: {
+                        type: "error",
+                        content: `Runtime initialization failed: ${err instanceof Error ? err.message : String(err)}`,
+                        sessionId: "",
+                    },
+                };
+                return;
+            }
+        }
         const prompt = request.params?.prompt ?? "";
         const sessionId = request.params?.sessionId ?? "default";
         const requestedModel = request.params?.model ?? "";
@@ -1382,6 +1606,9 @@ export class KairosRPCHandler {
                         sessionId,
                         provider: chunk.provider,
                         model: chunk.model,
+                        ...(chunk.toolName ? { toolName: chunk.toolName } : {}),
+                        ...(chunk.toolInput ? { toolInput: chunk.toolInput } : {}),
+                        ...(chunk.toolCallId ? { toolCallId: chunk.toolCallId } : {}),
                     },
                 };
             }
@@ -1626,8 +1853,13 @@ export class KairosRPCHandler {
         try {
             const { execFile } = await import("node:child_process");
             const { promisify } = await import("node:util");
+            const { tmpdir } = await import("node:os");
+            const { join } = await import("node:path");
             const execFileAsync = promisify(execFile);
-            const tmpFile = `/tmp/wotann-codex-${Date.now()}.txt`;
+            // Use os.tmpdir() so this works on Windows (TEMP/TMP) — literal
+            // /tmp returned ENOENT on Windows because the directory doesn't
+            // exist.
+            const tmpFile = join(tmpdir(), `wotann-codex-${Date.now()}.txt`);
             const codexModel = targetModel || getProviderDefaults("codex").defaultModel;
             await execFileAsync("codex", ["exec", "-c", `model="${codexModel}"`, "-o", tmpFile, prompt], {
                 timeout: 60000,
@@ -1716,6 +1948,23 @@ export class KairosRPCHandler {
             };
             return;
         }
+        if (this.runtimeReady) {
+            try {
+                await this.runtimeReady;
+            }
+            catch (err) {
+                yield {
+                    jsonrpc: "2.0",
+                    method: "stream.error",
+                    params: {
+                        type: "error",
+                        content: `Runtime initialization failed: ${err instanceof Error ? err.message : String(err)}`,
+                        sessionId,
+                    },
+                };
+                return;
+            }
+        }
         const requestedModel = params["model"] ?? "";
         const requestedProvider = params["provider"] ?? "";
         // Round 63 turn-24: convert iOS-supplied images (base64) to VisionInput[]
@@ -1792,6 +2041,9 @@ export class KairosRPCHandler {
                             sessionId,
                             provider: chunk.provider,
                             model: chunk.model,
+                            ...(chunk.toolName ? { toolName: chunk.toolName } : {}),
+                            ...(chunk.toolInput ? { toolInput: chunk.toolInput } : {}),
+                            ...(chunk.toolCallId ? { toolCallId: chunk.toolCallId } : {}),
                         },
                     };
                 }
@@ -2018,6 +2270,35 @@ export class KairosRPCHandler {
                 connected: activeDeviceIds.has(device.id),
             }));
         });
+        const getCompanionServerForRemoteAccess = () => {
+            const companionServer = this.daemon?.getCompanionServer();
+            if (!companionServer || !companionServer.isRunning()) {
+                throw new Error("Companion server not running");
+            }
+            return companionServer;
+        };
+        const getRemoteAccessSnapshot = async () => {
+            const companionServer = getCompanionServerForRemoteAccess();
+            return companionServer.getRemoteAccessSnapshot();
+        };
+        const configureRemoteAccess = async (params) => {
+            const companionServer = getCompanionServerForRemoteAccess();
+            const url = typeof params.url === "string" ? params.url.trim() : "";
+            if (!url) {
+                throw new Error("url required");
+            }
+            return companionServer.configureRemoteAccessUrl(url);
+        };
+        const clearRemoteAccess = async () => {
+            const companionServer = getCompanionServerForRemoteAccess();
+            return companionServer.clearConfiguredRemoteAccessUrl();
+        };
+        this.handlers.set("companion.remote.status", getRemoteAccessSnapshot);
+        this.handlers.set("companion.remote.configure", configureRemoteAccess);
+        this.handlers.set("companion.remote.clear", clearRemoteAccess);
+        this.handlers.set("remote.access.status", getRemoteAccessSnapshot);
+        this.handlers.set("remote.access.configure", configureRemoteAccess);
+        this.handlers.set("remote.access.clear", clearRemoteAccess);
         this.handlers.set("companion.sessions", async () => {
             const companionServer = this.daemon?.getCompanionServer();
             if (!companionServer || !companionServer.isRunning()) {
@@ -2106,6 +2387,13 @@ export class KairosRPCHandler {
             const service = getProviderService();
             const force = params["force"] === true;
             const snapshot = await service.getSnapshot({ force });
+            if (this.runtimeReady) {
+                await this.runtimeReady;
+            }
+            const runtimeStatus = this.runtime?.getStatus();
+            const active = runtimeStatus
+                ? { provider: runtimeStatus.activeProvider, model: runtimeStatus.activeModel }
+                : snapshot.active;
             return {
                 providers: snapshot.providers.map((p) => ({
                     id: p.id,
@@ -2123,7 +2411,7 @@ export class KairosRPCHandler {
                     envKeys: service.getSpec(p.id)?.envKeys ?? [],
                     docsUrl: service.getSpec(p.id)?.docsUrl ?? null,
                 })),
-                active: snapshot.active,
+                active,
                 lastRefreshedAt: snapshot.lastRefreshedAt,
             };
         });
@@ -2555,7 +2843,11 @@ export class KairosRPCHandler {
             // a descriptive error if the provider is unconfigured or the model is
             // not available so the UI surfaces a clear message.
             const { getProviderService } = await import("../providers/provider-service.js");
+            if (this.runtimeReady) {
+                await this.runtimeReady;
+            }
             getProviderService().setActive(provider, model);
+            this.runtime?.setActiveProvider(provider, model);
             return { success: true, provider, model };
         });
         // Cost — returns real cost data from the runtime session and status
@@ -3208,44 +3500,6 @@ export class KairosRPCHandler {
             }
             return { workspaces };
         });
-        // Plugins list
-        this.handlers.set("plugins.list", async () => {
-            if (!this.runtime)
-                return { plugins: [] };
-            try {
-                const lifecycle = this.runtime.getPluginLifecycle();
-                const stats = lifecycle.getStats();
-                // Build a plugin list from the lifecycle hook registrations.
-                // Each unique pluginName across all events represents a registered plugin.
-                const pluginSet = new Map();
-                for (const event of Object.keys(stats)) {
-                    const hooks = lifecycle.getHooks(event);
-                    for (const hook of hooks) {
-                        const existing = pluginSet.get(hook.pluginName);
-                        if (existing) {
-                            if (!existing.events.includes(event)) {
-                                existing.events.push(event);
-                            }
-                            existing.hookCount++;
-                        }
-                        else {
-                            pluginSet.set(hook.pluginName, { events: [event], hookCount: 1 });
-                        }
-                    }
-                }
-                const plugins = [...pluginSet.entries()].map(([name, info]) => ({
-                    name,
-                    events: info.events,
-                    hookCount: info.hookCount,
-                    enabled: true,
-                }));
-                return { plugins };
-            }
-            catch {
-                // Best-effort path — caller gets a safe fallback, no user-facing error.
-                return { plugins: [] };
-            }
-        });
         // Connectors list
         this.handlers.set("connectors.list", async () => {
             if (!this.runtime)
@@ -3973,6 +4227,315 @@ export class KairosRPCHandler {
                 return { success: false, reason: "Failed to read sessions" };
             }
         });
+        // session.rewind — drop the last N turns or messages from a session.
+        // mode:"steps" (default) rewinds whole user→assistant→tool turns;
+        // mode:"messages" trims raw messages. Returns the new snapshot plus
+        // the count + payload of the removed events for caller-side undo UX.
+        this.handlers.set("session.rewind", async (params) => {
+            const sessionId = params["sessionId"];
+            const n = Number(params["n"] ?? 1);
+            const mode = (params["mode"] ?? "steps");
+            if (!sessionId)
+                return { success: false, reason: "sessionId required" };
+            if (!Number.isFinite(n) || n <= 0) {
+                return { success: false, reason: "n must be a positive integer" };
+            }
+            if (mode !== "steps" && mode !== "messages") {
+                return { success: false, reason: "mode must be 'steps' or 'messages'" };
+            }
+            if (!/^[a-zA-Z0-9_-]+$/.test(sessionId)) {
+                return { success: false, reason: "Invalid sessionId format" };
+            }
+            const sessionsDir = resolveWotannHomeSubdir("sessions");
+            const filePath = join(sessionsDir, `${sessionId}.json`);
+            const resolved = resolvePath(filePath);
+            const safeRoot = resolvePath(sessionsDir) + "/";
+            if (!resolved.startsWith(safeRoot)) {
+                return { success: false, reason: "Invalid sessionId path" };
+            }
+            if (!existsSync(resolved)) {
+                return { success: false, reason: `Session ${sessionId} not found` };
+            }
+            try {
+                const raw = readFileSync(resolved, "utf-8");
+                const snapshot = JSON.parse(raw);
+                const messages = Array.isArray(snapshot["messages"])
+                    ? snapshot["messages"]
+                    : [];
+                // Reconstruct the minimal SessionState shape rewind expects.
+                const session = {
+                    id: sessionId,
+                    startedAt: new Date(),
+                    provider: snapshot["provider"] ?? "anthropic",
+                    model: snapshot["model"] ?? "",
+                    totalTokens: Number(snapshot["totalTokens"] ?? 0),
+                    totalCost: Number(snapshot["totalCost"] ?? 0),
+                    toolCalls: Number(snapshot["toolCalls"] ?? 0),
+                    messages: messages,
+                    incognito: Boolean(snapshot["incognito"] ?? false),
+                    ...(typeof snapshot["title"] === "string" ? { title: snapshot["title"] } : {}),
+                };
+                const { rewindBySteps, rewindByMessages } = await import("../core/session-rewind.js");
+                const result = mode === "steps" ? rewindBySteps(session, n) : rewindByMessages(session, n);
+                if (!result.changed) {
+                    return { success: true, changed: false, removed: 0 };
+                }
+                const updated = {
+                    ...snapshot,
+                    messages: result.session.messages,
+                    totalTokens: result.session.totalTokens,
+                    totalCost: result.session.totalCost,
+                    toolCalls: result.session.toolCalls,
+                };
+                writeFileAtomic(resolved, JSON.stringify(updated, null, 2), {
+                    encoding: "utf-8",
+                });
+                return {
+                    success: true,
+                    changed: true,
+                    mode,
+                    removed: result.removed.length,
+                    removedMessages: result.removed,
+                };
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    reason: `rewind failed: ${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+        });
+        // research.run — surface dual-confidence + iterdrag strategies for
+        // GUI/iOS callers. Mode "dual-confidence" is cheap (2 search calls);
+        // "iterdrag" walks a depth-bounded decomposition tree. Search is
+        // honest-stub by default so the call always returns a structured
+        // payload even without a backend wired.
+        this.handlers.set("research.run", async (params) => {
+            const query = params["query"] ?? "";
+            if (!query)
+                return { ok: false, error: "query required" };
+            const strategy = (params["strategy"] ?? "dual-confidence").toLowerCase();
+            const maxDepth = Number(params["maxDepth"] ?? 2);
+            const hitsPerCall = Number(params["hitsPerCall"] ?? 10);
+            const strategies = await import("../intelligence/research-strategies.js");
+            const search = (async (q) => [
+                { url: `wotann://stub/${encodeURIComponent(q)}`, title: q },
+            ]);
+            try {
+                if (strategy === "iterdrag") {
+                    const decompose = async (q) => {
+                        const parts = q
+                            .split(/\s+(?:and|or)\s+|;\s*/i)
+                            .filter((p) => p.trim().length > 0);
+                        return parts.length > 1 ? parts : [];
+                    };
+                    const root = await strategies.iterDrag(query, search, decompose, {
+                        maxDepth,
+                        hitsPerNode: hitsPerCall,
+                    });
+                    return { ok: true, strategy: "iterdrag", root };
+                }
+                const result = await strategies.dualConfidenceSearch(query, search, {
+                    hitsPerCall,
+                });
+                return { ok: true, strategy: "dual-confidence", result };
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    error: err instanceof Error ? err.message : String(err),
+                };
+            }
+        });
+        // skill.optimize_description — surface the description-optimizer.
+        // Caller passes the current description + labeled corpus
+        // (positives/negatives). Returns the best variant + its eval.
+        this.handlers.set("skill.optimize_description", async (params) => {
+            const current = params["current"];
+            const positives = params["positives"] ?? [];
+            const negatives = params["negatives"] ?? [];
+            const threshold = Number(params["threshold"] ?? 0.5);
+            if (!current)
+                return { ok: false, error: "current required" };
+            try {
+                const { optimizeDescription } = await import("../skills/description-optimizer.js");
+                const result = await optimizeDescription({
+                    current,
+                    positives,
+                    negatives,
+                    threshold,
+                });
+                return { ok: true, ...result };
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    error: err instanceof Error ? err.message : String(err),
+                };
+            }
+        });
+        // manifest.render — surface run-manifest. Caller passes a path to
+        // a saved trajectory JSON; we render Markdown + JSON forms so
+        // desktop/iOS can show whichever fits their UI.
+        this.handlers.set("manifest.render", async (params) => {
+            const trajectoryPath = params["trajectoryPath"];
+            if (!trajectoryPath)
+                return { ok: false, error: "trajectoryPath required" };
+            try {
+                // Reuse the existing path-traversal guard pattern from session.resume.
+                const safeRoot = resolvePath(resolveWotannHomeSubdir("trajectories")) + "/";
+                const resolved = resolvePath(trajectoryPath);
+                const homeRoot = resolvePath(resolveWotannHomeSubdir("")) + "/";
+                if (!resolved.startsWith(safeRoot) && !resolved.startsWith(homeRoot)) {
+                    return { ok: false, error: "trajectoryPath must be inside ~/.wotann" };
+                }
+                if (!existsSync(resolved)) {
+                    return { ok: false, error: `trajectory not found: ${resolved}` };
+                }
+                const { loadTrajectory } = await import("../autopilot/trajectory-recorder.js");
+                const { buildManifest, renderManifestMarkdown, renderManifestJson } = await import("../autopilot/run-manifest.js");
+                const trajectory = await loadTrajectory(resolved);
+                const buildOpts = {};
+                if (typeof params["taskTitle"] === "string") {
+                    buildOpts.taskTitle = params["taskTitle"];
+                }
+                if (typeof params["costUsd"] === "number") {
+                    buildOpts.costUsd = params["costUsd"];
+                }
+                const manifest = buildManifest(trajectory, buildOpts);
+                return {
+                    ok: true,
+                    manifest,
+                    markdown: renderManifestMarkdown(manifest),
+                    json: renderManifestJson(manifest),
+                };
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    error: err instanceof Error ? err.message : String(err),
+                };
+            }
+        });
+        // skill.telemetry_record — append a skill-activation event to the
+        // shared telemetry log. Cross-surface (CLI/desktop/iOS) callers all
+        // hit the same path so the corpus mined for the description-optimizer
+        // is consistent regardless of which surface the user prefers.
+        this.handlers.set("skill.telemetry_record", async (params) => {
+            try {
+                const { SkillActivationTelemetry } = await import("../skills/activation-telemetry.js");
+                const sessionId = params["sessionId"];
+                const prompt = params["prompt"];
+                if (!sessionId || typeof prompt !== "string") {
+                    return { ok: false, error: "sessionId + prompt required" };
+                }
+                const telemetryPath = resolveWotannHomeSubdir("skill-telemetry.jsonl");
+                const t = new SkillActivationTelemetry({ path: telemetryPath });
+                const triggered = (params["triggered"] ?? null);
+                const candidatesRaw = params["candidates"] ?? [];
+                const candidates = candidatesRaw
+                    .filter((c) => !!c &&
+                    typeof c === "object" &&
+                    typeof c.skill === "string" &&
+                    typeof c.score === "number")
+                    .map((c) => ({ skill: c.skill, score: c.score }));
+                const event = await t.record({
+                    sessionId,
+                    prompt,
+                    triggered,
+                    candidates,
+                    ...(typeof params["outcome"] === "string"
+                        ? { outcome: params["outcome"] }
+                        : {}),
+                });
+                return { ok: true, event };
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    error: err instanceof Error ? err.message : String(err),
+                };
+            }
+        });
+        // skill.telemetry_mark_outcome — flag the last activation for a
+        // session as ok | regret | unknown. The patch is appended to the
+        // shared telemetry JSONL so a reload sees the corrected outcome.
+        this.handlers.set("skill.telemetry_mark_outcome", async (params) => {
+            try {
+                const sessionId = params["sessionId"];
+                const outcome = params["outcome"];
+                if (!sessionId)
+                    return { ok: false, error: "sessionId required" };
+                if (outcome !== "ok" && outcome !== "regret" && outcome !== "unknown") {
+                    return {
+                        ok: false,
+                        error: 'outcome must be "ok" | "regret" | "unknown"',
+                    };
+                }
+                const { SkillActivationTelemetry } = await import("../skills/activation-telemetry.js");
+                const t = new SkillActivationTelemetry({
+                    path: resolveWotannHomeSubdir("skill-telemetry.jsonl"),
+                });
+                const patched = await t.markOutcome(sessionId, outcome);
+                return { ok: true, patched };
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    error: err instanceof Error ? err.message : String(err),
+                };
+            }
+        });
+        // skill.telemetry_corpus — mine a positive/negative corpus for the
+        // named skill from the telemetry log. Surfaces extractCorpusForSkill
+        // so GUIs can preview what the optimizer will see before running it.
+        this.handlers.set("skill.telemetry_corpus", async (params) => {
+            try {
+                const { loadTelemetryLog, extractCorpusForSkill } = await import("../skills/activation-telemetry.js");
+                const skill = params["skill"];
+                if (!skill)
+                    return { ok: false, error: "skill required" };
+                const telemetryPath = resolveWotannHomeSubdir("skill-telemetry.jsonl");
+                const result = loadTelemetryLog(telemetryPath);
+                const maxEach = Number(params["maxEach"] ?? 200);
+                const corpus = extractCorpusForSkill(result.events, skill, {
+                    maxEach: Number.isFinite(maxEach) && maxEach > 0 ? maxEach : 200,
+                });
+                return {
+                    ok: true,
+                    path: telemetryPath,
+                    skipped: result.skipped,
+                    ...corpus,
+                };
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    error: err instanceof Error ? err.message : String(err),
+                };
+            }
+        });
+        // effort.classify — surface the effort-cascade tier classifier so
+        // GUI/iOS can preview the routing decision before execution.
+        // Distinct from the existing `route.classify` handler (which delegates
+        // to runtime.classifyAndRoute and returns an error envelope when the
+        // runtime is uninitialised); this one is pure heuristics.
+        this.handlers.set("effort.classify", async (params) => {
+            const prompt = params["prompt"];
+            if (typeof prompt !== "string")
+                return { ok: false, error: "prompt required" };
+            const { classifyEffort, EFFORT_ORDER } = await import("../providers/effort-cascade.js");
+            const isTier = (t) => typeof t === "string" && EFFORT_ORDER.includes(t);
+            const hints = {};
+            if (isTier(params["minTier"]))
+                hints.minTier = params["minTier"];
+            if (isTier(params["maxTier"]))
+                hints.maxTier = params["maxTier"];
+            if (params["bump"] === true)
+                hints.bump = true;
+            const tier = classifyEffort(prompt, hints);
+            return { ok: true, tier, ladder: EFFORT_ORDER };
+        });
         // architect — route through runtime query with architect system prompt
         this.handlers.set("architect", async (params) => {
             const prompt = params.prompt ?? params.question;
@@ -4302,25 +4865,113 @@ export class KairosRPCHandler {
                 };
             }
         });
-        // mcp.list — list MCP servers (installed and available)
-        this.handlers.set("mcp.list", async () => {
-            // MCP servers are config-based; read from wotann.yaml
+        // mcp.list — list MCP servers with live health/tool counts.
+        this.handlers.set("mcp.list", async (params) => {
             const configPath = resolveWotannHomeSubdir("wotann.yaml");
             if (!existsSync(configPath))
-                return { servers: [], count: 0 };
+                return { servers: [], count: 0, healthyCount: 0, unhealthyCount: 0 };
             try {
+                const probe = params["probe"] !== false;
+                const timeoutMs = Math.max(200, Math.min(10_000, Number(params["timeoutMs"]) || 1_500));
                 const raw = readFileSync(configPath, "utf-8");
                 const config = (yamlParse(raw) ?? {});
                 const mcpServers = config["mcpServers"] ?? config["mcp_servers"] ?? {};
-                const servers = Object.entries(mcpServers).map(([name, entry]) => ({
-                    name,
-                    ...(typeof entry === "object" && entry !== null ? entry : {}),
-                }));
-                return { servers, count: servers.length };
+                const servers = Object.entries(mcpServers).map(([name, entry]) => {
+                    const record = typeof entry === "object" && entry !== null ? entry : {};
+                    const rawArgs = Array.isArray(record["args"])
+                        ? record["args"].filter((arg) => typeof arg === "string")
+                        : [];
+                    const command = typeof record["command"] === "string" ? record["command"] : "";
+                    const enabled = record["enabled"] !== false;
+                    return {
+                        name,
+                        enabled,
+                        command: command.length > 0 ? command : null,
+                        args: redactMcpArgs(rawArgs),
+                        rawArgs,
+                        transport: typeof record["transport"] === "string" ? record["transport"] : "stdio",
+                        status: enabled
+                            ? command.length > 0
+                                ? "configured"
+                                : "missing_command"
+                            : "disabled",
+                    };
+                });
+                const targets = servers
+                    .filter((server) => probe && server.enabled && typeof server.command === "string")
+                    .map((server) => {
+                    const entry = mcpServers[server.name];
+                    const envSource = typeof entry === "object" && entry !== null
+                        ? entry["env"]
+                        : undefined;
+                    const env = typeof envSource === "object" && envSource !== null
+                        ? Object.fromEntries(Object.entries(envSource).filter((entry) => typeof entry[1] === "string"))
+                        : undefined;
+                    return {
+                        name: server.name,
+                        command: server.command,
+                        args: server.rawArgs,
+                        ...(env ? { env } : {}),
+                    };
+                });
+                const healthByName = probe ? await probeMcpServers(targets, { timeoutMs }) : {};
+                const enriched = servers.map((server) => {
+                    const publicServer = {
+                        name: server.name,
+                        enabled: server.enabled,
+                        command: server.command,
+                        args: server.args,
+                        transport: server.transport,
+                        status: server.status,
+                    };
+                    const health = healthByName[server.name];
+                    if (!server.enabled) {
+                        return { ...publicServer, status: "disabled", ok: false, toolCount: null, error: null };
+                    }
+                    if (server.command === null) {
+                        return {
+                            ...publicServer,
+                            status: "missing_command",
+                            ok: false,
+                            toolCount: null,
+                            error: "command required",
+                        };
+                    }
+                    if (!probe || !health) {
+                        return {
+                            ...publicServer,
+                            status: "not_probed",
+                            ok: null,
+                            toolCount: null,
+                            error: null,
+                        };
+                    }
+                    return {
+                        ...publicServer,
+                        status: health.ok ? "healthy" : "unhealthy",
+                        ok: health.ok,
+                        latencyMs: health.latencyMs,
+                        toolCount: health.toolCount,
+                        serverInfo: health.serverInfo,
+                        error: health.error ? redactSecretText(health.error) : null,
+                    };
+                });
+                return {
+                    servers: enriched,
+                    count: enriched.length,
+                    healthyCount: enriched.filter((s) => s.status === "healthy").length,
+                    unhealthyCount: enriched.filter((s) => s.status === "unhealthy").length,
+                    probed: probe,
+                };
             }
-            catch {
-                // Best-effort path — caller gets a safe fallback, no user-facing error.
-                return { servers: [], count: 0 };
+            catch (err) {
+                return {
+                    servers: [],
+                    count: 0,
+                    healthyCount: 0,
+                    unhealthyCount: 0,
+                    error: err instanceof Error ? err.message : String(err),
+                };
             }
         });
         // composer.apply — apply a batch of multi-file edits.
@@ -4445,8 +5096,44 @@ export class KairosRPCHandler {
             const command = p["command"];
             const args = p["args"] ?? [];
             const transport = (p["transport"] ?? "stdio");
+            const trusted = p["trusted"] === true || p["confirmUnsafe"] === true;
+            const skipMalwareCheck = p["skipMalwareCheck"] === true;
+            const strictMalwareCheck = p["strictMalwareCheck"] === true;
             if (!name || !command)
                 return { ok: false, error: "name and command required" };
+            const validationError = validateMcpAddRequest({ name, command, args, transport, trusted });
+            if (validationError)
+                return { ok: false, error: validationError };
+            // OSV.dev malware/CVE pre-flight — gated before write so a typosquat
+            // or compromised package never reaches user config. Unlike the CLI
+            // path which prints + exits, the RPC returns a structured error so
+            // the GUI/iOS surface can render a confirmation dialog.
+            if (!skipMalwareCheck) {
+                const { preflight: osvPreflight } = await import("../security/osv-check.js");
+                const silentLogger = {
+                    info: (_m) => { },
+                    warn: (_m) => { },
+                    error: (_m) => { },
+                };
+                const verdict = await osvPreflight([{ name, command, args }], {
+                    strict: strictMalwareCheck,
+                    logger: silentLogger,
+                });
+                if (!verdict.proceed) {
+                    const blockedResult = verdict.results[name];
+                    return {
+                        ok: false,
+                        error: "blocked by OSV malware/CVE pre-flight",
+                        blocked: true,
+                        packageRef: blockedResult?.packageRef ?? null,
+                        advisories: blockedResult?.vulnerabilities.map((v) => ({
+                            id: v.id,
+                            summary: v.summary ?? null,
+                            severity: blockedResult.highestSeverity,
+                        })) ?? [],
+                    };
+                }
+            }
             const configPath = resolveWotannHomeSubdir("wotann.yaml");
             try {
                 if (!existsSync(dirname(configPath)))
@@ -5640,6 +6327,7 @@ export class KairosRPCHandler {
                 const rawAction = stepObj["action"];
                 const rawParams = stepObj["params"];
                 let execution = null;
+                let computerResult = null;
                 let actionError = null;
                 if (typeof rawAction === "string" && session.status === "running") {
                     const params = {};
@@ -5651,9 +6339,27 @@ export class KairosRPCHandler {
                                 params[k] = String(v);
                         }
                     }
-                    const action = { action: rawAction, params };
+                    const normalized = normalizeComputerAction({ action: rawAction, params });
                     try {
-                        execution = executeDesktopAction(action);
+                        if (normalized.ok) {
+                            computerResult = await executeComputerAction({
+                                action: normalized.action,
+                                executeDesktopAction,
+                            });
+                            execution =
+                                computerResult.error === "desktop route returned no result"
+                                    ? null
+                                    : {
+                                        success: computerResult.ok,
+                                        output: computerResult.output ?? computerResult.error ?? "",
+                                    };
+                        }
+                        else {
+                            const action = { action: rawAction, params };
+                            execution = executeDesktopAction(action);
+                            if (!execution)
+                                actionError = normalized.error;
+                        }
                     }
                     catch (execErr) {
                         actionError = execErr instanceof Error ? execErr.message : "executeDesktopAction threw";
@@ -5724,6 +6430,7 @@ export class KairosRPCHandler {
                 return {
                     ...serializeSession(session),
                     execution: execution ?? null,
+                    ...(computerResult ? { computerResult } : {}),
                     ...(actionError ? { actionError } : {}),
                 };
             }
@@ -5731,6 +6438,215 @@ export class KairosRPCHandler {
                 throw toRpcError(err);
             }
         });
+        // computer.session.safeStep — guardrailed sibling of computer.session.step.
+        //
+        // Same state-machine advance as `step`, but the action is routed through
+        // the safe-execute composer so it is:
+        //   1. Validated against the AtomicAction schema (validateAction)
+        //   2. Tagged with a sensitivity (caller override > inferSensitivity)
+        //   3. Gated on confidence (gateAction → execute / ask-user / abort)
+        //   4. Coordinate-remapped from view-space → screen-space when a
+        //      ScaleContext is supplied (so model-emitted clicks land at the
+        //      correct OS pixel even on retina / downscaled displays)
+        //   5. Dispatched to executeComputerAction → executeDesktopAction
+        //      (the same Layer-4 surface the legacy `step` handler uses)
+        //   6. Recorded into the caller-threaded ReplaySession so step history
+        //      survives the RPC boundary and can be returned for replay UI
+        //
+        // The legacy `computer.session.step` handler is intentionally untouched
+        // — callers that need raw dispatch keep it; new callers (computer-agent
+        // step loop, iOS guarded-step UI) opt into safe-execute via this RPC.
+        this.handlers.set("computer.session.safeStep", async (params) => {
+            const sessionId = params["sessionId"];
+            const deviceId = params["deviceId"];
+            const action = params["action"];
+            const confidence = params["confidence"];
+            if (typeof sessionId !== "string")
+                throw new Error("sessionId required");
+            if (typeof deviceId !== "string")
+                throw new Error("deviceId required");
+            if (!action || typeof action !== "object") {
+                throw new Error("action (object) required");
+            }
+            if (typeof confidence !== "number" || !Number.isFinite(confidence)) {
+                throw new Error("confidence (finite number 0..1) required");
+            }
+            // Optional sensitivity override — when omitted, safe-execute infers
+            // it from the action.type via inferSensitivity().
+            const rawSensitivity = params["sensitivity"];
+            let sensitivityOverride;
+            if (rawSensitivity !== undefined) {
+                if (rawSensitivity !== "read-only" &&
+                    rawSensitivity !== "navigation" &&
+                    rawSensitivity !== "input" &&
+                    rawSensitivity !== "destructive") {
+                    throw new Error("sensitivity must be one of: read-only|navigation|input|destructive");
+                }
+                sensitivityOverride = rawSensitivity;
+            }
+            // Optional ScaleContext — when provided, all coordinate fields on the
+            // action are remapped from view-space → screen-space before dispatch.
+            const rawScale = params["scale"];
+            let scaleContext;
+            if (rawScale !== undefined) {
+                if (!rawScale || typeof rawScale !== "object") {
+                    throw new Error("scale must be an object");
+                }
+                const s = rawScale;
+                const sw = s["screenWidth"];
+                const sh = s["screenHeight"];
+                const vw = s["viewWidth"];
+                const vh = s["viewHeight"];
+                if (typeof sw !== "number" ||
+                    typeof sh !== "number" ||
+                    typeof vw !== "number" ||
+                    typeof vh !== "number") {
+                    throw new Error("scale requires numeric screenWidth, screenHeight, viewWidth, viewHeight");
+                }
+                scaleContext = {
+                    screenWidth: sw,
+                    screenHeight: sh,
+                    viewWidth: vw,
+                    viewHeight: vh,
+                };
+            }
+            // Optional caller-threaded ReplaySession — when omitted, a fresh one
+            // is started using the sessionId so each RPC call still produces a
+            // recorded step. Threading lets agents accumulate steps across calls.
+            const rawSession = params["session"];
+            let replaySession;
+            if (rawSession === undefined) {
+                replaySession = startRecording(sessionId);
+            }
+            else {
+                if (!rawSession || typeof rawSession !== "object") {
+                    throw new Error("session must be an object");
+                }
+                const rs = rawSession;
+                const rsId = rs["id"];
+                const rsStartedAt = rs["startedAt"];
+                const rsSteps = rs["steps"];
+                if (typeof rsId !== "string" ||
+                    typeof rsStartedAt !== "number" ||
+                    !Array.isArray(rsSteps)) {
+                    throw new Error("session requires {id: string, startedAt: number, steps: array}");
+                }
+                // Honest stub: we accept the caller's session shape but freeze it
+                // before threading so the immutability contract holds.
+                replaySession = Object.freeze({
+                    id: rsId,
+                    startedAt: rsStartedAt,
+                    steps: Object.freeze(rsSteps.slice()),
+                });
+            }
+            try {
+                // Layer 1: advance the session state machine — same as `step`.
+                // We feed the entire safeStep payload into the store so the audit
+                // trail records BOTH the action and its confidence/sensitivity for
+                // post-hoc analysis (this is why guardrailed steps exist).
+                const session = this.computerSessionStore.step({
+                    sessionId,
+                    deviceId,
+                    step: {
+                        action,
+                        confidence,
+                        ...(sensitivityOverride ? { sensitivity: sensitivityOverride } : {}),
+                    },
+                });
+                // Build the executor by wrapping executeComputerAction so that
+                // safe-execute can dispatch through the same Layer-4 surface as the
+                // legacy `step` handler. The atomic-action shape from
+                // action-repertoire is converted on-the-fly into the
+                // ComputerAction shape that executeComputerAction consumes.
+                const executor = {
+                    async execute(atomic) {
+                        // Translate AtomicAction → {action: string, params} envelope so
+                        // normalizeComputerAction can produce the ComputerAction shape
+                        // the dispatch table expects. We mirror the same translation
+                        // surface as the legacy `step` handler so route-table behavior
+                        // is identical between guarded and raw paths.
+                        const translated = atomicToDesktopShape(atomic);
+                        if (!translated) {
+                            return {
+                                outcome: "",
+                                error: `unsupported atomic action: ${atomic.type}`,
+                            };
+                        }
+                        const normalized = normalizeComputerAction({
+                            action: translated.action,
+                            params: translated.params,
+                        });
+                        if (!normalized.ok) {
+                            return { outcome: "", error: normalized.error };
+                        }
+                        try {
+                            const result = await executeComputerAction({
+                                action: normalized.action,
+                                executeDesktopAction,
+                            });
+                            if (!result.ok) {
+                                return {
+                                    outcome: result.output ?? "",
+                                    error: result.error ?? "executor reported failure",
+                                };
+                            }
+                            return { outcome: result.output ?? "ok" };
+                        }
+                        catch (err) {
+                            return {
+                                outcome: "",
+                                error: err instanceof Error ? err.message : String(err),
+                            };
+                        }
+                    },
+                };
+                const safeReq = {
+                    action,
+                    confidence,
+                    ...(sensitivityOverride ? { sensitivity: sensitivityOverride } : {}),
+                    ...(scaleContext ? { scale: scaleContext } : {}),
+                    session: replaySession,
+                    executor,
+                };
+                const outcome = await safeExecute(safeReq);
+                // Build a return envelope that mirrors safe-execute's tagged union
+                // so callers can switch on `status` without re-deriving types.
+                // `replaySession` is included on every branch (rejected returns
+                // the unmodified session; executed/skipped return the appended one).
+                if (outcome.status === "executed") {
+                    return {
+                        ...serializeSession(session),
+                        status: outcome.status,
+                        action: outcome.action,
+                        outcome: outcome.outcome,
+                        decision: outcome.decision,
+                        replaySession: outcome.session,
+                    };
+                }
+                if (outcome.status === "skipped") {
+                    return {
+                        ...serializeSession(session),
+                        status: outcome.status,
+                        action: outcome.action,
+                        outcome: outcome.reason,
+                        decision: outcome.decision,
+                        replaySession: outcome.session,
+                    };
+                }
+                // rejected — no action narrowed, no decision was made.
+                return {
+                    ...serializeSession(session),
+                    status: outcome.status,
+                    action: null,
+                    outcome: outcome.reason,
+                    decision: null,
+                    replaySession: outcome.session,
+                };
+            }
+            catch (err) {
+                throw toRpcError(err);
+            }
+        });
         this.handlers.set("computer.session.requestApproval", async (params) => {
             const sessionId = params["sessionId"];
             const deviceId = params["deviceId"];
@@ -7583,10 +8499,16 @@ export class KairosRPCHandler {
                 if (typeof params["category"] === "string") {
                     filter.category = params["category"];
                 }
+                if (typeof params["tag"] === "string")
+                    filter.tag = params["tag"];
+                if (typeof params["source"] === "string")
+                    filter.source = params["source"];
                 if (params["favOnly"] === true)
                     filter.favOnly = true;
                 if (typeof params["query"] === "string")
                     filter.query = params["query"];
+                if (typeof params["limit"] === "number")
+                    filter.limit = params["limit"];
                 const snippets = store.list(filter);
                 return { snippets, count: snippets.length };
             }
@@ -7618,6 +8540,16 @@ export class KairosRPCHandler {
                 const upsertInput = { title, body, category, tags, isFavorite };
                 if (id !== undefined)
                     upsertInput.id = id;
+                if (typeof params["source"] === "string")
+                    upsertInput.source = params["source"];
+                if (typeof params["externalId"] === "string") {
+                    upsertInput.externalId = params["externalId"];
+                }
+                if (typeof params["sourceUrl"] === "string") {
+                    upsertInput.sourceUrl = params["sourceUrl"];
+                }
+                if (typeof params["version"] === "string")
+                    upsertInput.version = params["version"];
                 const snippet = store.upsert(upsertInput);
                 return { ok: true, snippet };
             }
@@ -7676,6 +8608,58 @@ export class KairosRPCHandler {
                 return { error: err instanceof Error ? err.message : String(err) };
             }
         });
+        this.handlers.set("snippet.import", async (params) => {
+            if (!this.runtime)
+                return { error: "Runtime not initialized" };
+            const store = this.runtime.getSnippetStore();
+            if (!store)
+                return { error: "SnippetStore not available" };
+            try {
+                const tags = Array.isArray(params["tags"])
+                    ? params["tags"].filter((tag) => typeof tag === "string")
+                    : [];
+                const options = {
+                    ...(typeof params["source"] === "string" ? { source: params["source"] } : {}),
+                    ...(typeof params["version"] === "string"
+                        ? { version: params["version"] }
+                        : {}),
+                    ...(typeof params["sourceUrl"] === "string"
+                        ? { sourceUrl: params["sourceUrl"] }
+                        : {}),
+                    ...(typeof params["category"] === "string"
+                        ? { category: params["category"] }
+                        : {}),
+                    ...(tags.length > 0 ? { tags } : {}),
+                };
+                if (typeof params["text"] === "string") {
+                    const corpus = parsePromptCorpusText(params["text"], options);
+                    const result = store.importCorpus(corpus);
+                    return { ok: true, ...result, count: result.snippets.length };
+                }
+                if (Array.isArray(params["snippets"])) {
+                    const source = typeof params["source"] === "string" && params["source"].trim().length > 0
+                        ? params["source"]
+                        : "manual-import";
+                    const corpus = {
+                        source,
+                        snippets: params["snippets"].filter((item) => typeof item === "object" &&
+                            item !== null &&
+                            typeof item["title"] === "string" &&
+                            typeof item["body"] === "string"),
+                        ...(options.version ? { version: options.version } : {}),
+                        ...(options.sourceUrl ? { sourceUrl: options.sourceUrl } : {}),
+                        ...(options.category ? { category: options.category } : {}),
+                        ...(options.tags ? { tags: options.tags } : {}),
+                    };
+                    const result = store.importCorpus(corpus);
+                    return { ok: true, ...result, count: result.snippets.length };
+                }
+                return { error: "text or snippets required" };
+            }
+            catch (err) {
+                return { error: err instanceof Error ? err.message : String(err) };
+            }
+        });
         this.handlers.set("snippet.get", async (params) => {
             if (!this.runtime)
                 return { error: "Runtime not initialized" };
@@ -7708,6 +8692,25 @@ export class KairosRPCHandler {
                 return { error: err instanceof Error ? err.message : String(err) };
             }
         });
+        this.handlers.set("ingest.capabilities", async () => {
+            try {
+                const markitdown = await getMarkitdownCapabilities();
+                return {
+                    ok: true,
+                    markitdown,
+                    modalities: {
+                        documents: ["pdf", "docx", "xlsx", "pptx", "text"],
+                        images: ["ocr"],
+                        audio: ["transcription"],
+                        notes: ["markdown", "text", "org", "frontmatter", "wikilinks"],
+                    },
+                    notes: "This report is runtime-probed: unavailable entries are honest capability gaps, not hidden stubs.",
+                };
+            }
+            catch (err) {
+                return { error: err instanceof Error ? err.message : String(err) };
+            }
+        });
         // 23. Hooks Inventory — list registered hooks. Audit found the
         // daemon registered zero `hooks.*` methods despite shipping 21
         // hook events + 23 BUILT_IN guards (per CLAUDE.md). UIs had no
@@ -7968,65 +8971,172 @@ export class KairosRPCHandler {
             }
         });
         // ── Screen control (3 methods) ─────────────────────────────
+        this.handlers.set("screen.stream", async () => {
+            try {
+                const testCapture = takeScreenshot();
+                if (!testCapture) {
+                    return {
+                        streamId: `stream-${Date.now()}`,
+                        status: "unavailable",
+                        format: "mjpeg",
+                        reason: "Screen recording permission required",
+                    };
+                }
+                try {
+                    unlinkSync(testCapture.path);
+                }
+                catch {
+                    /* best-effort cleanup */
+                }
+                return {
+                    streamId: `stream-${Date.now()}`,
+                    status: "active",
+                    format: "mjpeg",
+                    captureAvailable: true,
+                };
+            }
+            catch (err) {
+                return {
+                    streamId: `stream-${Date.now()}`,
+                    status: "unavailable",
+                    format: "mjpeg",
+                    reason: err instanceof Error ? err.message : String(err),
+                };
+            }
+        });
         this.handlers.set("screen.capture", async () => {
-            const bindings = ext()?.getComputerBindings?.();
-            if (!bindings)
-                return { error: "Computer bindings not available" };
             try {
-                const img = await bindings.screenshot();
+                const img = takeScreenshot();
+                if (!img)
+                    return { error: "Screen recording permission required" };
+                const image = readFileSync(img.path).toString("base64");
+                const observation = buildObservationFrame({
+                    screenshot: img,
+                    image,
+                    environment: process.platform === "darwin"
+                        ? "macos"
+                        : process.platform === "linux"
+                            ? "linux"
+                            : "unknown",
+                });
+                try {
+                    unlinkSync(img.path);
+                }
+                catch {
+                    /* best-effort cleanup */
+                }
                 return {
-                    image: img.base64,
+                    image,
                     width: img.width,
                     height: img.height,
                     format: img.format ?? "png",
-                    timestamp: Date.now(),
+                    timestamp: observation.timestamp,
+                    observation,
                 };
             }
             catch (err) {
                 return { error: err instanceof Error ? err.message : String(err) };
             }
         });
+        this.handlers.set("computer.driver.observe", async () => {
+            try {
+                const img = takeScreenshot();
+                if (!img)
+                    return { error: "Screen recording permission required" };
+                const image = readFileSync(img.path).toString("base64");
+                const observation = buildObservationFrame({
+                    screenshot: img,
+                    image,
+                    environment: process.platform === "darwin"
+                        ? "macos"
+                        : process.platform === "linux"
+                            ? "linux"
+                            : process.platform === "win32"
+                                ? "windows"
+                                : "unknown",
+                });
+                try {
+                    unlinkSync(img.path);
+                }
+                catch {
+                    /* best-effort cleanup */
+                }
+                return observation;
+            }
+            catch (err) {
+                return { error: err instanceof Error ? err.message : String(err) };
+            }
+        });
+        this.handlers.set("computer.driver.execute", async (params) => {
+            const normalized = normalizeComputerAction({
+                action: params["action"],
+                params: params["params"],
+            });
+            if (!normalized.ok)
+                return { success: false, error: normalized.error };
+            const result = await executeComputerAction({
+                action: normalized.action,
+                executeDesktopAction,
+            });
+            return {
+                success: result.ok,
+                ...result,
+            };
+        });
         this.handlers.set("screen.input", async (params) => {
-            const bindings = ext()?.getComputerBindings?.();
-            if (!bindings)
-                return { error: "Computer bindings not available" };
-            const kind = params["kind"];
+            const raw = params;
+            const kind = String(raw["action"] ?? raw["kind"] ?? "").toLowerCase();
+            const routeParams = {};
+            for (const key of ["x", "y", "endX", "endY", "direction", "amount", "button", "clicks"]) {
+                const value = raw[key];
+                if (value !== undefined)
+                    routeParams[key] = String(value);
+            }
             try {
-                if (kind === "click") {
-                    const { x, y, button } = params;
-                    await bindings.mouseClick(x, y, button ?? "left");
-                    return { ok: true };
+                let action = kind;
+                if (kind === "doubleclick") {
+                    action = "click";
+                    routeParams["clicks"] = "2";
                 }
-                if (kind === "move") {
-                    const { x, y } = params;
-                    await bindings.mouseMove(x, y);
-                    return { ok: true };
-                }
-                if (kind === "scroll") {
-                    const { dx, dy } = params;
-                    await bindings.scroll(dx ?? 0, dy ?? 0);
-                    return { ok: true };
+                else if (kind === "rightclick") {
+                    action = "click";
+                    routeParams["button"] = "right";
                 }
-                return { error: `unknown kind: ${kind}` };
+                const result = executeDesktopAction({ action, params: routeParams });
+                if (!result)
+                    return { success: false, error: `unknown kind: ${kind}` };
+                return result.success
+                    ? { success: true, ok: true, output: result.output }
+                    : { success: false, error: result.output };
             }
             catch (err) {
-                return { error: err instanceof Error ? err.message : String(err) };
+                return { success: false, error: err instanceof Error ? err.message : String(err) };
             }
         });
         this.handlers.set("screen.keyboard", async (params) => {
-            const bindings = ext()?.getComputerBindings?.();
-            if (!bindings)
-                return { error: "Computer bindings not available" };
-            const { text, keys } = params;
-            try {
-                if (text)
-                    await bindings.typeText(text);
-                if (keys && Array.isArray(keys))
-                    await bindings.keyPress(keys);
-                return { ok: true };
+            const raw = params;
+            try {
+                const text = typeof raw.text === "string" ? raw.text : "";
+                if (text.length > 0) {
+                    const result = executeDesktopAction({ action: "type", params: { text } });
+                    return result?.success
+                        ? { success: true, ok: true, output: result.output }
+                        : { success: false, error: result?.output ?? "Typing failed" };
+                }
+                const combo = typeof raw.key === "string"
+                    ? raw.key
+                    : typeof raw.combo === "string"
+                        ? raw.combo
+                        : Array.isArray(raw.keys)
+                            ? raw.keys.filter((key) => typeof key === "string").join("+")
+                            : "";
+                const result = executeDesktopAction({ action: "key", params: { key: combo } });
+                return result?.success
+                    ? { success: true, ok: true, output: result.output }
+                    : { success: false, error: result?.output ?? "Key press failed" };
             }
             catch (err) {
-                return { error: err instanceof Error ? err.message : String(err) };
+                return { success: false, error: err instanceof Error ? err.message : String(err) };
             }
         });
         // ── Morning briefing ───────────────────────────────────────
@@ -8042,19 +9152,9 @@ export class KairosRPCHandler {
                     return { error: err instanceof Error ? err.message : String(err) };
                 }
             }
-            // Fallback: assemble from available subsystems
-            const costTracker = this.runtime.getCostTracker();
-            const sessions = ext()?.getSessionManager?.()?.listRecent?.(5) ?? [];
             return {
-                date: new Date().toISOString().slice(0, 10),
-                cost: {
-                    today: costTracker.getTodayCost(),
-                    weekly: costTracker.getWeeklyCost(),
-                },
-                recentSessions: sessions,
-                weather: null,
-                calendar: [],
-                tasks: [],
+                available: false,
+                error: "Daily briefing is not connected to real overnight activity yet.",
             };
         });
         // ── Meet summarize ─────────────────────────────────────────
@@ -8151,8 +9251,9 @@ export class KairosRPCHandler {
             try {
                 // iOS sends its public key as base64 of the raw SEC 1 uncompressed
                 // representation (65 bytes with 0x04 prefix). Buffer.from handles
-                // the base64 decode; createECDH accepts raw format directly.
-                const clientPubRaw = Buffer.from(publicKey, "base64");
+                // CryptoKit may send raw X/Y bytes; Node ECDH expects X9.63 with
+                // the 0x04 prefix.
+                const clientPubRaw = normalizeP256PublicKey(Buffer.from(publicKey, "base64"));
                 const ecdh = createECDH("prime256v1");
                 ecdh.generateKeys();
                 const serverPubRaw = ecdh.getPublicKey(); // 65-byte uncompressed SEC 1
@@ -8169,6 +9270,7 @@ export class KairosRPCHandler {
                         this.ecdhSessions.delete(k);
                 }
                 return {
+                    publicKey: serverPubRaw.toString("base64"),
                     serverPublicKey: serverPubRaw.toString("base64"),
                     sessionId: sid,
                     keyFingerprint: derivedKey.subarray(0, 8).toString("hex"),
@@ -8747,7 +9849,8 @@ export class KairosRPCHandler {
                     return { ok: true, empty: true, message: "no WOTANN home — nothing to export" };
                 }
                 const ts = new Date().toISOString().replace(/[:.]/g, "-");
-                const outDir = process.env["TMPDIR"] ?? "/tmp";
+                const { tmpdir } = await import("node:os");
+                const outDir = tmpdir();
                 const path = await import("node:path");
                 const outPath = path.join(outDir, `wotann-export-${ts}.tar.gz`);
                 const { execFileNoThrow } = await import("../utils/execFileNoThrow.js");
@@ -8862,22 +9965,62 @@ export class KairosRPCHandler {
         // Surfaces the local plugin directory's `plugin.json` manifests so the
         // marketplace UI can list installed plugins and what they expose.
         this.handlers.set("plugins.list", async (params) => {
+            let runtimePlugins = [];
             try {
                 const { loadPlugins } = await import("../marketplace/plugin-loader.js");
                 const { resolveWotannHome } = await import("../utils/wotann-home.js");
+                runtimePlugins = (() => {
+                    if (!this.runtime)
+                        return [];
+                    try {
+                        const lifecycle = this.runtime.getPluginLifecycle();
+                        const stats = lifecycle.getStats();
+                        const pluginSet = new Map();
+                        for (const event of Object.keys(stats)) {
+                            const hooks = lifecycle.getHooks(event);
+                            for (const hook of hooks) {
+                                const existing = pluginSet.get(hook.pluginName);
+                                if (existing) {
+                                    if (!existing.events.includes(event))
+                                        existing.events.push(event);
+                                    existing.hookCount++;
+                                }
+                                else {
+                                    pluginSet.set(hook.pluginName, { events: [event], hookCount: 1 });
+                                }
+                            }
+                        }
+                        return [...pluginSet.entries()].map(([name, info]) => ({
+                            name,
+                            events: info.events,
+                            hookCount: info.hookCount,
+                            enabled: true,
+                        }));
+                    }
+                    catch {
+                        return [];
+                    }
+                })();
                 const root = params.pluginsRoot ?? `${resolveWotannHome()}/plugins`;
                 const result = loadPlugins({ pluginsRoot: root });
                 if (result.ok) {
                     return {
                         ok: true,
                         plugins: result.plugins,
+                        runtimePlugins,
                         skipped: result.skipped,
                     };
                 }
-                return { ok: false, error: result.error };
+                return { ok: false, error: result.error, runtimePlugins };
             }
             catch (err) {
-                return { error: err instanceof Error ? err.message : String(err) };
+                return {
+                    ok: false,
+                    error: err instanceof Error ? err.message : String(err),
+                    plugins: [],
+                    runtimePlugins,
+                    skipped: [],
+                };
             }
         });
         // ── Connector webhook server (resurrected). Lifecycle is opt-in via
@@ -9703,11 +10846,16 @@ export class KairosRPCHandler {
         if (this.cloudOffloadRegistry)
             return this.cloudOffloadRegistry;
         const { createCloudOffloadRegistry } = await import("../providers/cloud-offload/adapter.js");
+        const { loadCloudOffloadAdaptersFromFile } = await import("../providers/cloud-offload/config-loader.js");
         this.cloudOffloadRegistry = createCloudOffloadRegistry();
-        // Adapters require explicit register() with config — the registry
-        // is intentionally empty until a future startup-config wire reads
-        // ~/.wotann/cloud-offload.yaml. Until then `available: false` is
-        // the honest answer for all three providers.
+        const configPath = join(resolveWotannHome(), "cloud-offload.yaml");
+        const loaded = loadCloudOffloadAdaptersFromFile({ filePath: configPath, env: process.env });
+        for (const adapter of loaded.adapters) {
+            this.cloudOffloadRegistry.register(adapter);
+        }
+        for (const warning of loaded.warnings) {
+            console.warn(`[kairos-rpc] ${warning}`);
+        }
         return this.cloudOffloadRegistry;
     }
     /**