comisai 1.0.36 → 1.0.40

package/node_modules/@comis/skills/dist/builtin/platform/unified-session-tool.js

@@ -1,130 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Unified Session Tool: single tool with action dispatch covering search, status, history, list.
- *
- * Consolidates 4 individual session tools into one tool with an `action` parameter:
- * - action "search" -> session.search RPC (from session-search-tool)
- * - action "status" -> session.status RPC (from session-status-tool)
- * - action "history" -> session.history RPC (from sessions-history-tool)
- * - action "list" -> session.list RPC (from sessions-list-tool)
- *
- * @module
- */
-import { Type } from "typebox";
-import { jsonResult, readStringParam, readNumberParam, readBooleanParam, readEnumParam } from "./tool-helpers.js";
-import { sanitizeFts5Query } from "./fts5-sanitizer.js";
-// -- Parameter Schema --------------------------------------------------------
-const VALID_ACTIONS = ["search", "status", "history", "list"];
-const UnifiedSessionParams = Type.Object({
-    action: Type.Union([
-        Type.Literal("search"),
-        Type.Literal("status"),
-        Type.Literal("history"),
-        Type.Literal("list"),
-    ], {
-        description: "Session action to perform. Valid values: search (search/browse session history), " +
-            "status (view current session info), history (view conversation history for a session), " +
-            "list (list active sessions)",
-    }),
-    // search params
-    query: Type.Optional(Type.String({ description: "Search query -- keywords, phrases, or boolean expressions. Omit for recent sessions metadata. (action: search)" })),
-    scope: Type.Optional(Type.Union([
-        Type.Literal("all"),
-        Type.Literal("user"),
-        Type.Literal("assistant"),
-        Type.Literal("tool"),
-    ], { description: "Filter by message role: 'all' (default), 'user', 'assistant', 'tool' (action: search)" })),
-    summarize: Type.Optional(Type.Boolean({ description: "Summarize matched sessions using LLM (default: true when query provided) (action: search)" })),
-    // history params
-    session_key: Type.Optional(Type.String({ description: "Session key for action: history. Use action 'list' first to discover available keys. Format: {tenantId}:{filename}, e.g. 'default:678314278~peer~678314278'" })),
-    offset: Type.Optional(Type.Integer({ description: "Pagination offset (default: 0) (action: history)" })),
-    // shared params
-    limit: Type.Optional(Type.Integer({ description: "Maximum results to return (action: search default 10 max 30, action: history default 20)" })),
-    // list params
-    kind: Type.Optional(Type.Union([
-        Type.Literal("all"),
-        Type.Literal("dm"),
-        Type.Literal("group"),
-        Type.Literal("sub-agent"),
-    ], { description: "Filter by session kind (default: all). (action: list)" })),
-    since_minutes: Type.Optional(Type.Integer({ description: "Only sessions active within N minutes (action: list)" })),
-});
-// -- Factory -----------------------------------------------------------------
-/**
- * Create a unified session tool with action dispatch covering search, status, history, list.
- *
- * @param rpcCall - RPC function for daemon communication
- * @returns AgentTool implementing session_tool
- */
-export function createUnifiedSessionTool(rpcCall) {
-    return {
-        name: "session_tool",
-        label: "Session Tool",
-        description: "Unified session management tool. Actions: " +
-            "search (search/browse full conversation history across sessions), " +
-            "status (view current session model, token usage, duration), " +
-            "history (view conversation history for a specific session with pagination), " +
-            "list (list active sessions filtered by kind and recency).",
-        parameters: UnifiedSessionParams,
-        async execute(_toolCallId, params) {
-            try {
-                const action = readEnumParam(params, "action", VALID_ACTIONS);
-                switch (action) {
-                    case "search": {
-                        const query = readStringParam(params, "query", false);
-                        const scope = readStringParam(params, "scope", false) ?? "all";
-                        const limit = readNumberParam(params, "limit", false) ?? 10;
-                        const summarize = readBooleanParam(params, "summarize", false);
-                        if (query) {
-                            const sanitizedQuery = sanitizeFts5Query(query);
-                            const effectiveSummarize = summarize ?? true;
-                            const result = await rpcCall("session.search", {
-                                query: sanitizedQuery,
-                                scope,
-                                limit,
-                                summarize: effectiveSummarize,
-                            });
-                            return jsonResult(result);
-                        }
-                        // Recent-sessions mode: no query, never summarize
-                        const result = await rpcCall("session.search", {
-                            scope,
-                            limit,
-                            summarize: false,
-                        });
-                        return jsonResult(result);
-                    }
-                    case "status": {
-                        const result = await rpcCall("session.status", {});
-                        return jsonResult(result);
-                    }
-                    case "history": {
-                        const sessionKey = readStringParam(params, "session_key");
-                        const offset = readNumberParam(params, "offset", false) ?? 0;
-                        const limit = readNumberParam(params, "limit", false) ?? 20;
-                        const result = await rpcCall("session.history", {
-                            session_key: sessionKey,
-                            offset,
-                            limit,
-                        });
-                        return jsonResult(result);
-                    }
-                    case "list": {
-                        const limit = readNumberParam(params, "limit", false);
-                        const result = await rpcCall("session.list", {
-                            kind: readStringParam(params, "kind", false) ?? "all",
-                            since_minutes: readNumberParam(params, "since_minutes", false),
-                            ...(limit !== undefined && { limit }),
-                        });
-                        return jsonResult(result);
-                    }
-                }
-            }
-            catch (err) {
-                if (err instanceof Error && err.message.startsWith("["))
-                    throw err;
-                throw err instanceof Error ? err : new Error(String(err));
-            }
-        },
-    };
-}

package/node_modules/@comis/skills/dist/builtin/platform/whatsapp-action-tool.d.ts

@@ -1,25 +0,0 @@
-/**
- * WhatsApp action tool: platform-specific actions for WhatsApp groups.
- *
- * Supports 11 actions: group_info, group_update_subject, group_update_description,
- * group_participants_add, group_participants_remove, group_promote, group_demote,
- * group_settings, group_invite_code, profile_status, group_leave.
- * Destructive actions (group_participants_remove, group_promote, group_leave)
- * require confirmation via action gates.
- * All actions delegate to the WhatsApp backend via rpcCall("whatsapp.action").
- *
- * @module
- */
-import { Type } from "typebox";
-import type { RpcCall } from "./cron-tool.js";
-/**
- * Create a WhatsApp action tool with 11 actions.
- *
- * Destructive actions (group_participants_remove, group_promote, group_leave)
- * are gated via createActionGate and return requiresConfirmation:true when
- * the action is classified as destructive.
- *
- * @param rpcCall - RPC call function for delegating to the WhatsApp backend
- * @returns AgentTool implementing the WhatsApp actions interface
- */
-export declare function createWhatsAppActionTool(rpcCall: RpcCall): import("@mariozechner/pi-agent-core").AgentTool<Type.TSchema, any>;

package/node_modules/@comis/skills/dist/builtin/platform/whatsapp-action-tool.js

@@ -1,79 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * WhatsApp action tool: platform-specific actions for WhatsApp groups.
- *
- * Supports 11 actions: group_info, group_update_subject, group_update_description,
- * group_participants_add, group_participants_remove, group_promote, group_demote,
- * group_settings, group_invite_code, profile_status, group_leave.
- * Destructive actions (group_participants_remove, group_promote, group_leave)
- * require confirmation via action gates.
- * All actions delegate to the WhatsApp backend via rpcCall("whatsapp.action").
- *
- * @module
- */
-import { Type } from "typebox";
-import { createPlatformActionTool } from "./platform-action-tool.js";
-// ---------------------------------------------------------------------------
-// Parameter schema
-// ---------------------------------------------------------------------------
-const WhatsAppActionParams = Type.Object({
-    action: Type.Union([
-        Type.Literal("group_info"),
-        Type.Literal("group_update_subject"),
-        Type.Literal("group_update_description"),
-        Type.Literal("group_participants_add"),
-        Type.Literal("group_participants_remove"),
-        Type.Literal("group_promote"),
-        Type.Literal("group_demote"),
-        Type.Literal("group_settings"),
-        Type.Literal("group_invite_code"),
-        Type.Literal("profile_status"),
-        Type.Literal("group_leave"),
-    ], { description: "WhatsApp-specific action. Valid values: group_info (get group details), group_update_subject (change group name), group_update_description (change group description), group_participants_add (add members), group_participants_remove (remove members), group_promote (grant admin), group_demote (revoke admin), group_settings (change group setting), group_invite_code (get invite link), profile_status (update status text), group_leave (leave group)" }),
-    group_jid: Type.Optional(Type.String({ description: "Group JID with @g.us suffix (for all group actions)" })),
-    participant_jids: Type.Optional(Type.Array(Type.String(), {
-        description: "Participant JIDs with @s.whatsapp.net suffix (for add/remove/promote/demote)",
-    })),
-    subject: Type.Optional(Type.String({ description: "New group subject/name (for group_update_subject)" })),
-    description: Type.Optional(Type.String({ description: "New group description (for group_update_description)" })),
-    setting: Type.Optional(Type.Union([
-        Type.Literal("announcement"),
-        Type.Literal("not_announcement"),
-        Type.Literal("locked"),
-        Type.Literal("unlocked"),
-    ], { description: "Group setting to change (for group_settings). Valid values: announcement (only admins send), not_announcement (all members send), locked (only admins edit info), unlocked (all members edit info)" })),
-    status_text: Type.Optional(Type.String({ description: "Profile status text (for profile_status)" })),
-    _confirmed: Type.Optional(Type.Boolean({
-        description: "Set to true when re-calling a destructive action after user approval. " +
-            "When a gated action returns requiresConfirmation, present the action to the user, " +
-            "and after they approve, call the same action again with _confirmed: true.",
-    })),
-});
-// ---------------------------------------------------------------------------
-// Descriptor + factory wrapper
-// ---------------------------------------------------------------------------
-const whatsappDescriptor = {
-    name: "whatsapp_action",
-    label: "WhatsApp Actions",
-    description: "Perform WhatsApp-specific actions: get group info, update group subject/description, add/remove/promote/demote participants, change group settings, get invite code, update profile status, leave group. JIDs must include @g.us (groups) or @s.whatsapp.net (users).",
-    parameters: WhatsAppActionParams,
-    rpcMethod: "whatsapp.action",
-    gatedActions: [
-        { action: "group_participants_remove", gateKey: "whatsapp.group_participants_remove", hint: "Ask the user to confirm this participant removal, then call again with _confirmed: true." },
-        { action: "group_promote", gateKey: "whatsapp.group_promote", hint: "Ask the user to confirm this participant promotion, then call again with _confirmed: true." },
-        { action: "group_leave", gateKey: "whatsapp.group_leave", hint: "Ask the user to confirm leaving this group, then call again with _confirmed: true." },
-    ],
-};
-/**
- * Create a WhatsApp action tool with 11 actions.
- *
- * Destructive actions (group_participants_remove, group_promote, group_leave)
- * are gated via createActionGate and return requiresConfirmation:true when
- * the action is classified as destructive.
- *
- * @param rpcCall - RPC call function for delegating to the WhatsApp backend
- * @returns AgentTool implementing the WhatsApp actions interface
- */
-export function createWhatsAppActionTool(rpcCall) {
-    return createPlatformActionTool(whatsappDescriptor, rpcCall);
-}

package/node_modules/@comis/skills/dist/builtin/process-registry.d.ts

@@ -1,74 +0,0 @@
-/**
- * ProcessRegistry: shared in-memory store for background process sessions.
- *
- * Created per-agent via factory function (NOT a global singleton).
- * Injected into both exec and process tool factories for shared state.
- *
- * @module
- */
-import type { ChildProcess } from "node:child_process";
-export interface ProcessSession {
-    readonly id: string;
-    readonly command: string;
-    pid: number | undefined;
-    readonly startedAt: number;
-    status: "running" | "completed" | "failed" | "killed";
-    exitCode: number | null | undefined;
-    stdout: string;
-    stderr: string;
-    child: ChildProcess | undefined;
-    readonly maxOutputChars: number;
-    readonly sandboxed: boolean;
-    readonly autoBackgrounded?: boolean;
-    readonly description?: string;
-}
-export interface ProcessRegistry {
-    add(session: ProcessSession): void;
-    get(id: string): ProcessSession | undefined;
-    list(): Array<{
-        sessionId: string;
-        status: string;
-        pid: number | undefined;
-        command: string;
-        startedAt: number;
-        runtimeMs: number;
-        tail: string;
-    }>;
-    kill(id: string): Promise<{
-        exitCode: number | null;
-        killed: boolean;
-    }>;
-    status(id: string): {
-        sessionId: string;
-        status: string;
-        exitCode: number | null | undefined;
-        stdoutLength: number;
-        stderrLength: number;
-        command: string;
-        startedAt: number;
-        runtimeMs: number;
-    } | undefined;
-    getLog(id: string, offset?: number, limit?: number): {
-        lines: string[];
-        total: number;
-    } | undefined;
-    cleanup(): Promise<number>;
-    size(): number;
-}
-/**
- * Append a chunk to a session output field, truncating from the beginning
- * if total length exceeds maxOutputChars.
- */
-export declare function appendOutput(session: ProcessSession, field: "stdout" | "stderr", chunk: string): void;
-/**
- * Create a new ProcessRegistry instance backed by an in-memory Map.
- *
- * Each registry is independent -- created per-agent in daemon wiring.
- *
- * @param maxOutputChars - Max chars to retain per output field (default 1MB)
- */
-export declare function createProcessRegistry(maxOutputChars?: number): ProcessRegistry;
-/**
- * Generate a unique session ID using crypto.randomUUID().
- */
-export declare function generateSessionId(): string;

package/node_modules/@comis/skills/dist/builtin/process-registry.js

@@ -1,213 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * ProcessRegistry: shared in-memory store for background process sessions.
- *
- * Created per-agent via factory function (NOT a global singleton).
- * Injected into both exec and process tool factories for shared state.
- *
- * @module
- */
-import { randomUUID } from "node:crypto";
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-const DEFAULT_MAX_OUTPUT_CHARS = 1024 * 1024; // 1MB
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-/**
- * Append a chunk to a session output field, truncating from the beginning
- * if total length exceeds maxOutputChars.
- */
-export function appendOutput(session, field, chunk) {
-    session[field] += chunk;
-    if (session[field].length > session.maxOutputChars) {
-        session[field] = session[field].slice(-session.maxOutputChars);
-    }
-}
-/**
- * Kill a process group: SIGTERM first, then SIGKILL after 5 seconds.
- * Returns a promise that resolves when the process is confirmed dead
- * or after the SIGKILL escalation.
- */
-function killProcessGroup(session) {
-    return new Promise((resolve) => {
-        const child = session.child;
-        const pid = session.pid;
-        // No child or pid -- already dead or never started
-        if (!child || !pid) {
-            session.status = "killed";
-            return resolve({ exitCode: session.exitCode ?? null, killed: true });
-        }
-        // Already exited
-        if (child.exitCode !== null && child.exitCode !== undefined) {
-            session.status = "killed";
-            session.exitCode = child.exitCode;
-            return resolve({ exitCode: child.exitCode, killed: true });
-        }
-        let resolved = false;
-        const onExit = (code) => {
-            if (resolved)
-                return;
-            resolved = true;
-            clearTimeout(escalationTimer);
-            session.status = "killed";
-            session.exitCode = code;
-            resolve({ exitCode: code, killed: true });
-        };
-        child.once("exit", onExit);
-        // Send SIGTERM: positive PID for sandboxed (bwrap --die-with-parent cascades),
-        // negative PID for unsandboxed (process group kill).
-        try {
-            if (session.sandboxed) {
-                process.kill(pid, "SIGTERM");
-            }
-            else {
-                process.kill(-pid, "SIGTERM");
-            }
-        }
-        catch {
-            // Process may already be dead
-            if (!resolved) {
-                resolved = true;
-                session.status = "killed";
-                resolve({ exitCode: session.exitCode ?? null, killed: true });
-                return;
-            }
-        }
-        // Escalate to SIGKILL after 5 seconds
-        const escalationTimer = setTimeout(() => {
-            if (resolved)
-                return;
-            try {
-                if (session.sandboxed) {
-                    process.kill(pid, "SIGKILL");
-                }
-                else {
-                    process.kill(-pid, "SIGKILL");
-                }
-            }
-            catch {
-                // Process already dead
-            }
-            // Give a brief moment for the exit event
-            setTimeout(() => {
-                if (!resolved) {
-                    resolved = true;
-                    child.removeListener("exit", onExit);
-                    session.status = "killed";
-                    resolve({ exitCode: session.exitCode ?? null, killed: true });
-                }
-            }, 500);
-        }, 5000);
-    });
-}
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-/**
- * Create a new ProcessRegistry instance backed by an in-memory Map.
- *
- * Each registry is independent -- created per-agent in daemon wiring.
- *
- * @param maxOutputChars - Max chars to retain per output field (default 1MB)
- */
-export function createProcessRegistry(
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-maxOutputChars = DEFAULT_MAX_OUTPUT_CHARS) {
-    const sessions = new Map();
-    function add(session) {
-        sessions.set(session.id, session);
-    }
-    function get(id) {
-        return sessions.get(id);
-    }
-    function list() {
-        const now = Date.now();
-        return Array.from(sessions.values()).map((s) => {
-            const lines = s.stdout.split("\n").filter((l) => l.length > 0);
-            const tail = lines.slice(-5).join("\n");
-            return {
-                sessionId: s.id,
-                status: s.status,
-                pid: s.pid,
-                command: s.command,
-                startedAt: s.startedAt,
-                runtimeMs: now - s.startedAt,
-                tail,
-                ...(s.description && { description: s.description }),
-            };
-        });
-    }
-    async function kill(id) {
-        const session = sessions.get(id);
-        if (!session) {
-            throw new Error(`Process session not found: ${id}`);
-        }
-        if (session.status !== "running") {
-            throw new Error(`Process session ${id} is not running (status: ${session.status})`);
-        }
-        return killProcessGroup(session);
-    }
-    function status(id) {
-        const session = sessions.get(id);
-        if (!session)
-            return undefined;
-        return {
-            sessionId: session.id,
-            status: session.status,
-            exitCode: session.exitCode,
-            stdoutLength: session.stdout.length,
-            stderrLength: session.stderr.length,
-            command: session.command,
-            startedAt: session.startedAt,
-            runtimeMs: Date.now() - session.startedAt,
-            ...(session.description && { description: session.description }),
-        };
-    }
-    function getLog(id, offset, limit) {
-        const session = sessions.get(id);
-        if (!session)
-            return undefined;
-        const combined = session.stdout + (session.stderr ? "\n" + session.stderr : "");
-        const allLines = combined.split("\n");
-        const total = allLines.length;
-        const effectiveLimit = limit ?? 200;
-        if (offset !== undefined) {
-            // Explicit offset: return lines from offset with limit
-            const slice = allLines.slice(offset, offset + effectiveLimit);
-            return { lines: slice, total };
-        }
-        // No offset: return last N lines
-        const slice = allLines.slice(-effectiveLimit);
-        return { lines: slice, total };
-    }
-    async function cleanup() {
-        let killed = 0;
-        const killPromises = [];
-        for (const session of sessions.values()) {
-            if (session.status === "running") {
-                killed++;
-                killPromises.push(killProcessGroup(session).then(() => {
-                    /* void */
-                }));
-            }
-        }
-        await Promise.all(killPromises);
-        sessions.clear();
-        return killed;
-    }
-    function size() {
-        return sessions.size;
-    }
-    return { add, get, list, kill, status, getLog, cleanup, size };
-}
-// ---------------------------------------------------------------------------
-// Utilities
-// ---------------------------------------------------------------------------
-/**
- * Generate a unique session ID using crypto.randomUUID().
- */
-export function generateSessionId() {
-    return randomUUID();
-}

package/node_modules/@comis/skills/dist/builtin/process-tool.d.ts

@@ -1,36 +0,0 @@
-/**
- * Process management tool: CRUD operations over background processes.
- *
- * Provides four actions:
- * - list: show all sessions with status, pid, command, tail output
- * - kill: terminate a running process (SIGTERM then SIGKILL)
- * - status: inspect a single process session
- * - log: read paginated output from a process
- *
- * All operations delegate to the injected ProcessRegistry.
- *
- * @module
- */
-import type { AgentTool } from "@mariozechner/pi-agent-core";
-import { Type } from "typebox";
-import type { ProcessRegistry } from "./process-registry.js";
-declare const ProcessParams: Type.TObject<{
-    action: Type.TUnion<[Type.TLiteral<"list">, Type.TLiteral<"kill">, Type.TLiteral<"status">, Type.TLiteral<"log">]>;
-    sessionId: Type.TOptional<Type.TString>;
-    offset: Type.TOptional<Type.TInteger>;
-    limit: Type.TOptional<Type.TInteger>;
-}>;
-/** Minimal pino-compatible logger for structured tool logging. */
-interface ToolLogger {
-    debug(obj: Record<string, unknown>, msg: string): void;
-    info(obj: Record<string, unknown>, msg: string): void;
-}
-/**
- * Create a process management tool that delegates to a ProcessRegistry.
- *
- * @param registry - ProcessRegistry for session CRUD operations
- * @param logger - Optional structured logger for DEBUG-level operation logging
- * @returns AgentTool implementing the process management interface
- */
-export declare function createProcessTool(registry: ProcessRegistry, logger?: ToolLogger): AgentTool<typeof ProcessParams>;
-export {};

package/node_modules/@comis/skills/dist/builtin/process-tool.js

@@ -1,104 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Process management tool: CRUD operations over background processes.
- *
- * Provides four actions:
- * - list: show all sessions with status, pid, command, tail output
- * - kill: terminate a running process (SIGTERM then SIGKILL)
- * - status: inspect a single process session
- * - log: read paginated output from a process
- *
- * All operations delegate to the injected ProcessRegistry.
- *
- * @module
- */
-import { Type } from "typebox";
-import { jsonResult, throwToolError, readEnumParam, readStringParam, readNumberParam, } from "./platform/tool-helpers.js";
-// ---------------------------------------------------------------------------
-// Parameter schema
-// ---------------------------------------------------------------------------
-const ProcessParams = Type.Object({
-    action: Type.Union([
-        Type.Literal("list"),
-        Type.Literal("kill"),
-        Type.Literal("status"),
-        Type.Literal("log"),
-    ], { description: "The process management action to perform" }),
-    sessionId: Type.Optional(Type.String({
-        description: "Process session ID (required for kill/status/log)",
-    })),
-    offset: Type.Optional(Type.Integer({ description: "Line offset for log pagination (0-indexed)" })),
-    limit: Type.Optional(Type.Integer({ description: "Max lines to return for log (default 200)" })),
-});
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-/**
- * Create a process management tool that delegates to a ProcessRegistry.
- *
- * @param registry - ProcessRegistry for session CRUD operations
- * @param logger - Optional structured logger for DEBUG-level operation logging
- * @returns AgentTool implementing the process management interface
- */
-export function createProcessTool(registry, logger) {
-    return {
-        name: "process",
-        label: "Process",
-        description: "Manage background processes. Actions: list (show all), kill (terminate), status (inspect), log (read output).",
-        parameters: ProcessParams,
-        async execute(_toolCallId, params) {
-            try {
-                const p = params;
-                const VALID_ACTIONS = ["list", "kill", "status", "log"];
-                const action = readEnumParam(p, "action", VALID_ACTIONS);
-                switch (action) {
-                    case "list": {
-                        logger?.debug({ toolName: "process", action: "list" }, "Process list queried");
-                        const sessions = registry.list();
-                        return jsonResult(sessions);
-                    }
-                    case "kill": {
-                        const sessionId = readStringParam(p, "sessionId");
-                        if (!sessionId) {
-                            throwToolError("missing_param", "Missing required parameter: sessionId");
-                        }
-                        const result = await registry.kill(sessionId);
-                        logger?.debug({ toolName: "process", action: "kill", sessionId, status: "killed" }, "Process killed");
-                        return jsonResult(result);
-                    }
-                    case "status": {
-                        const sessionId = readStringParam(p, "sessionId");
-                        if (!sessionId) {
-                            throwToolError("missing_param", "Missing required parameter: sessionId");
-                        }
-                        logger?.debug({ toolName: "process", action: "status", sessionId }, "Process status queried");
-                        const details = registry.status(sessionId);
-                        if (!details) {
-                            throwToolError("not_found", `Process session not found: ${sessionId}`);
-                        }
-                        return jsonResult(details);
-                    }
-                    case "log": {
-                        const sessionId = readStringParam(p, "sessionId");
-                        if (!sessionId) {
-                            throwToolError("missing_param", "Missing required parameter: sessionId");
-                        }
-                        logger?.debug({ toolName: "process", action: "log", sessionId }, "Process log read");
-                        const offset = readNumberParam(p, "offset", false);
-                        const limit = readNumberParam(p, "limit", false);
-                        const logData = registry.getLog(sessionId, offset, limit);
-                        if (!logData) {
-                            throwToolError("not_found", `Process session not found: ${sessionId}`);
-                        }
-                        return jsonResult(logData);
-                    }
-                }
-            }
-            catch (err) {
-                if (err instanceof Error && err.message.startsWith("["))
-                    throw err;
-                throw err instanceof Error ? err : new Error(String(err));
-            }
-        },
-    };
-}