@aria-cli/tools 1.0.12 → 1.0.14

package/dist/executors/self-diagnose.js

@@ -1,398 +0,0 @@
-/**
- * @aria/tools - Self-diagnose tool executor
- *
- * Pure signal diagnostic tool. 5 sections, zero noise:
- * 1. runtime  — process health + resource leaks
- * 2. errors   — structured errors from JSONL (active + rotated)
- * 3. crashes  — crash markers + dumps
- * 4. databases — sizes, WAL health, schema version
- * 5. daemon   — daemon audit + delegation journal
- */
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import * as os from "node:os";
-import { success, fail } from "./utils.js";
-// ============================================================================
-// Constants
-// ============================================================================
-const ALL_SECTIONS = ["runtime", "errors", "crashes", "databases", "daemon", "network"];
-const ARIA_HOME = path.join(os.homedir(), ".aria");
-// ============================================================================
-// Helpers
-// ============================================================================
-async function safeStat(p) {
-    try {
-        const s = await fs.stat(p);
-        return { size: s.size, mtime: s.mtime };
-    }
-    catch {
-        return null;
-    }
-}
-function truncate(s, max) {
-    if (!s)
-        return "";
-    return s.length <= max ? s : s.slice(0, max - 3) + "...";
-}
-async function dirCount(dir) {
-    try {
-        const entries = await fs.readdir(dir);
-        return entries.length;
-    }
-    catch {
-        return 0;
-    }
-}
-async function tailJsonl(filePath, maxLines) {
-    try {
-        const content = await fs.readFile(filePath, "utf-8");
-        const lines = content.trim().split("\n").slice(-maxLines);
-        return lines
-            .map((l) => {
-            try {
-                return JSON.parse(l);
-            }
-            catch {
-                return null;
-            }
-        })
-            .filter(Boolean);
-    }
-    catch {
-        return [];
-    }
-}
-// ============================================================================
-// Section: runtime
-// ============================================================================
-async function getRuntime(ctx) {
-    const mem = process.memoryUsage();
-    // Resource leak detection
-    const socketDirs = await dirCount(path.join(ARIA_HOME, "sock"));
-    const ownerFiles = await dirCount(path.join(ARIA_HOME, "run/owners"));
-    // Stuck restart detection
-    let relaunchPending = false;
-    try {
-        const entries = await fs.readdir(path.join(ARIA_HOME, "relaunch-pending"));
-        relaunchPending = entries.length > 0;
-    }
-    catch {
-        /* dir may not exist */
-    }
-    return {
-        pid: process.pid,
-        uptime_s: Math.round(process.uptime()),
-        heap_mb: Math.round(mem.heapUsed / 1e6),
-        rss_mb: Math.round(mem.rss / 1e6),
-        node_version: process.version,
-        platform: process.platform,
-        arch: process.arch,
-        cwd: process.cwd(),
-        session_id: ctx.currentSessionId ?? null,
-        socket_dirs: socketDirs,
-        owner_files: ownerFiles,
-        relaunch_pending: relaunchPending,
-    };
-}
-// ============================================================================
-// Section: errors (active + rotated JSONL, merged, filtered)
-// ============================================================================
-async function getErrors(since, focus, limit) {
-    // Read both active and rotated logs
-    const active = path.join(ARIA_HOME, "error-events.jsonl");
-    const rotated = path.join(ARIA_HOME, "error-events.jsonl.1");
-    const [activeEntries, rotatedEntries] = await Promise.all([
-        tailJsonl(active, 200),
-        tailJsonl(rotated, 100),
-    ]);
-    const all = [
-        ...rotatedEntries.map((e) => ({ ...e, _src: "rotated" })),
-        ...activeEntries.map((e) => ({ ...e, _src: "active" })),
-    ];
-    const filtered = all.filter((entry) => {
-        const ts = entry.timestamp;
-        if (ts) {
-            const d = new Date(ts);
-            if (d < since)
-                return false;
-        }
-        if (focus) {
-            const haystack = [
-                String(entry.message ?? ""),
-                String(entry.category ?? ""),
-                String(entry.stackTrace ?? ""),
-            ]
-                .join(" ")
-                .toLowerCase();
-            if (!haystack.includes(focus))
-                return false;
-        }
-        return true;
-    });
-    return filtered.slice(-limit).map((entry) => ({
-        timestamp: String(entry.timestamp ?? ""),
-        severity: String(entry.severity ?? "unknown"),
-        category: String(entry.category ?? ""),
-        message: String(entry.message ?? ""),
-        stackTrace: truncate(String(entry.stackTrace ?? ""), 500),
-        source: String(entry._src),
-    }));
-}
-// ============================================================================
-// Section: crashes
-// ============================================================================
-async function getCrashes(limit) {
-    const results = [];
-    for (const subdir of ["crash-markers", "crash-dumps"]) {
-        const dir = path.join(ARIA_HOME, subdir);
-        try {
-            const files = await fs.readdir(dir);
-            const jsonFiles = files.filter((f) => f.endsWith(".json"));
-            const stats = await Promise.all(jsonFiles.map(async (f) => {
-                const p = path.join(dir, f);
-                const s = await safeStat(p);
-                return { file: f, path: p, stat: s };
-            }));
-            const sorted = stats
-                .filter((f) => f.stat)
-                .sort((a, b) => b.stat.mtime.getTime() - a.stat.mtime.getTime());
-            for (const { file, path: fp, stat } of sorted.slice(0, limit)) {
-                try {
-                    const raw = await fs.readFile(fp, "utf-8");
-                    const parsed = JSON.parse(raw);
-                    if (subdir === "crash-markers") {
-                        results.push({
-                            file: `${subdir}/${file}`,
-                            timestamp: stat.mtime.toISOString(),
-                            content: parsed,
-                        });
-                    }
-                    else {
-                        const msg = parsed.error_message ?? parsed.message ?? parsed.error ?? "";
-                        results.push({
-                            file: `${subdir}/${file}`,
-                            size: stat.size,
-                            timestamp: stat.mtime.toISOString(),
-                            error_message: truncate(String(msg), 200),
-                        });
-                    }
-                }
-                catch {
-                    results.push({
-                        file: `${subdir}/${file}`,
-                        timestamp: stat.mtime.toISOString(),
-                        error_message: "Failed to parse",
-                    });
-                }
-            }
-        }
-        catch {
-            /* dir may not exist */
-        }
-    }
-    return results;
-}
-// ============================================================================
-// Section: databases (sizes, WAL health, schema version)
-// ============================================================================
-async function getDatabases() {
-    const results = [];
-    // Key database paths (only real ones, not empty legacy ghosts)
-    const dbPaths = [
-        {
-            name: "memory.db (main)",
-            path: path.join(ARIA_HOME, "arions/ARIA/memory.db"),
-            checkSchema: true,
-        },
-        { name: "history.db", path: path.join(ARIA_HOME, "history.db") },
-        { name: "investigation-metrics.db", path: path.join(ARIA_HOME, "investigation-metrics.db") },
-        { name: "network/state.db", path: path.join(ARIA_HOME, "network/state.db") },
-        { name: "node/node-state.db", path: path.join(ARIA_HOME, "node/node-state.db") },
-    ];
-    for (const db of dbPaths) {
-        const stat = await safeStat(db.path);
-        if (!stat || stat.size === 0)
-            continue;
-        // WAL size — a large WAL means checkpoint isn't running
-        const walStat = await safeStat(db.path + "-wal");
-        const walMb = walStat && walStat.size > 0 ? (walStat.size / 1e6).toFixed(1) : null;
-        // Schema version for the main DB (lightweight: only reads one int)
-        let schemaVersion;
-        if (db.checkSchema) {
-            try {
-                // Use a child process to avoid importing better-sqlite3 / locking the DB
-                const { execFileSync } = await import("node:child_process");
-                const out = execFileSync("sqlite3", [db.path, "SELECT MAX(version) FROM schema_version;"], {
-                    timeout: 1000,
-                    encoding: "utf-8",
-                }).trim();
-                schemaVersion = parseInt(out, 10) || undefined;
-            }
-            catch {
-                // sqlite3 CLI not available or query failed — not critical
-            }
-        }
-        const info = {
-            name: db.name,
-            size_mb: (stat.size / 1e6).toFixed(1),
-            wal_mb: walMb,
-            modified: stat.mtime.toISOString(),
-        };
-        if (schemaVersion !== undefined)
-            info.schema_version = schemaVersion;
-        results.push(info);
-    }
-    return results;
-}
-// ============================================================================
-// Section: daemon (audit + delegation journal)
-// ============================================================================
-async function getDaemon(limit) {
-    const results = [];
-    // Daemon audit log — restart loops, crashes, startup events
-    const auditPath = path.join(ARIA_HOME, "arions/ARIA/daemon/audit.jsonl");
-    const auditEntries = await tailJsonl(auditPath, limit);
-    if (auditEntries.length > 0) {
-        results.push({ source: "daemon/audit", entries: auditEntries });
-    }
-    // Delegation journal — worker spawn/complete/fail
-    const delegationPath = path.join(ARIA_HOME, "arions/ARIA/delegation-journal.jsonl");
-    const delegationEntries = await tailJsonl(delegationPath, limit);
-    if (delegationEntries.length > 0) {
-        results.push({ source: "delegation-journal", entries: delegationEntries });
-    }
-    return results;
-}
-// ============================================================================
-// Section: network (identity, peers, tunnels, TLS, diagnostics)
-// ============================================================================
-async function getNetwork(limit) {
-    // Node identity from network/config.json
-    let nodeId = null;
-    let displayName = null;
-    let listenPort = null;
-    let externalEndpoint = null;
-    try {
-        const raw = await fs.readFile(path.join(ARIA_HOME, "network/config.json"), "utf-8");
-        const cfg = JSON.parse(raw);
-        nodeId = cfg.nodeId ?? null;
-        displayName = cfg.localDisplayNameSnapshot ?? null;
-        listenPort = cfg.listenPort ?? null;
-        if (cfg.externalEndpoint) {
-            externalEndpoint = `${cfg.externalEndpoint.address}:${cfg.externalEndpoint.port}`;
-        }
-        // Never expose private keys — only the fact we have them
-    }
-    catch {
-        /* config may not exist */
-    }
-    // Peers from network/state.db (using sqlite3 CLI to avoid locking)
-    const peers = [];
-    let peerCount = 0;
-    try {
-        const { execFileSync } = await import("node:child_process");
-        const out = execFileSync("sqlite3", [
-            path.join(ARIA_HOME, "network/state.db"),
-            "-json",
-            `SELECT nodeId, displayName, status, lastSeen FROM network_peers ORDER BY lastSeen DESC LIMIT ${limit};`,
-        ], { timeout: 1000, encoding: "utf-8" }).trim();
-        if (out) {
-            const rows = JSON.parse(out);
-            for (const row of rows) {
-                peers.push({
-                    node_id: row.nodeId ?? "",
-                    name: row.displayName ?? "",
-                    status: row.status ?? "unknown",
-                    last_seen: row.lastSeen ? new Date(row.lastSeen).toISOString() : null,
-                });
-            }
-        }
-        const countOut = execFileSync("sqlite3", [path.join(ARIA_HOME, "network/state.db"), "SELECT COUNT(*) FROM network_peers;"], { timeout: 1000, encoding: "utf-8" }).trim();
-        peerCount = parseInt(countOut, 10) || 0;
-    }
-    catch {
-        /* sqlite3 CLI not available or query failed */
-    }
-    // TLS state
-    let tlsCertsPresent = false;
-    let trustedCas = 0;
-    try {
-        await fs.access(path.join(ARIA_HOME, "network/tls/server.pem"));
-        tlsCertsPresent = true;
-    }
-    catch {
-        /* no TLS certs */
-    }
-    try {
-        const cas = await fs.readdir(path.join(ARIA_HOME, "network/trusted-cas"));
-        trustedCas = cas.filter((f) => f.endsWith(".pem")).length;
-    }
-    catch {
-        /* dir may not exist */
-    }
-    // Recent tunnel events (connection attempts, handshakes, failures)
-    const tunnelEvents = await tailJsonl(path.join(ARIA_HOME, "audit/wireguard-secure-tunnel.jsonl"), limit);
-    // Recent diagnostics (disconnects, reconnects, errors)
-    const diagnostics = await tailJsonl(path.join(ARIA_HOME, "audit/wireguard-diagnostics.jsonl"), limit);
-    return {
-        node_id: nodeId,
-        display_name: displayName,
-        listen_port: listenPort,
-        external_endpoint: externalEndpoint,
-        peer_count: peerCount,
-        peers,
-        tls_certs_present: tlsCertsPresent,
-        trusted_cas: trustedCas,
-        recent_tunnel_events: tunnelEvents,
-        recent_diagnostics: diagnostics,
-    };
-}
-// ============================================================================
-// Main Executor
-// ============================================================================
-export async function executeSelfDiagnose(input, ctx) {
-    if (ctx.abortSignal?.aborted)
-        return fail("Operation cancelled");
-    const startMs = Date.now();
-    const limit = input.limit ?? 10;
-    const since = input.since ? new Date(input.since) : new Date(Date.now() - 3600_000);
-    const focus = input.focus?.toLowerCase();
-    const requested = input.sections ?? ALL_SECTIONS;
-    const sectionsToRun = requested.filter((s) => ALL_SECTIONS.includes(s));
-    const sectionFns = {
-        runtime: () => getRuntime(ctx),
-        errors: () => getErrors(since, focus, limit),
-        crashes: () => getCrashes(limit),
-        databases: () => getDatabases(),
-        daemon: () => getDaemon(limit),
-        network: () => getNetwork(limit),
-    };
-    const results = {};
-    const errors = [];
-    const returned = [];
-    const withTimeout = (fn, name) => Promise.race([
-        fn().then((r) => {
-            returned.push(name);
-            return r;
-        }),
-        new Promise((_, reject) => setTimeout(() => reject(new Error(`${name} timed out`)), 2000)),
-    ]).catch((err) => {
-        errors.push(`${name}: ${err.message}`);
-        return null;
-    });
-    await Promise.all(sectionsToRun.map(async (name) => {
-        const fn = sectionFns[name];
-        if (fn)
-            results[name] = await withTimeout(fn, name);
-    }));
-    const elapsed = Date.now() - startMs;
-    results._meta = {
-        sections_requested: sectionsToRun,
-        sections_returned: returned,
-        elapsed_ms: elapsed,
-        errors,
-    };
-    const msg = `Diagnostics: ${returned.length}/${sectionsToRun.length} sections in ${elapsed}ms` +
-        (errors.length > 0 ? ` (${errors.length} errors)` : "");
-    return success(msg, results);
-}

package/dist/executors/session-history.js

@@ -1,283 +0,0 @@
-/**
- * @aria/tools - Session History tool executor
- *
- * Implementation of session history operations for ARIA tool system.
- * Provides list, search, get, current, stats, delete, and set_title actions
- * against the SessionHistory SQLite database.
- */
-import * as os from "node:os";
-import * as path from "node:path";
-import { success, fail, getErrorMessage } from "./utils.js";
-// ============================================================================
-// Helpers
-// ============================================================================
-/** Max content length per message in 'get' output to prevent context blowout */
-const MAX_MESSAGE_CONTENT_LENGTH = 2000;
-/**
- * Cached fallback SessionHistory instance — created once per process via
- * dynamic import of @aria/cli's SessionHistory class.  This avoids a hard
- * package dependency (tools → cli) while still giving the tool access to
- * the real SQLite history DB when ctx.sessionHistory isn't wired through.
- */
-/** Cached fallback SessionHistory — resolved once per process via dynamic import. */
-let _fallbackSessionHistory;
-let _fallbackPromise = null;
-async function resolveFallbackSessionHistory() {
-    if (_fallbackSessionHistory !== undefined)
-        return _fallbackSessionHistory;
-    if (_fallbackPromise)
-        return _fallbackPromise;
-    _fallbackPromise = (async () => {
-        try {
-            // Dynamic import of @aria/cli (optionalDependency, ESM-only).
-            // Using a variable prevents TS from resolving the specifier statically
-            // and from downleveling to require() in CJS output.
-            const _specifier = "@aria-cli/cli";
-            const mod = (await import(_specifier));
-            const SessionHistory = mod.SessionHistory;
-            const ariaHome = process.env.ARIA_HOME ?? path.join(os.homedir(), ".aria");
-            // Determine active arion from config or default to "ARIA"
-            let arionName = "ARIA";
-            try {
-                const { readFileSync, existsSync } = await import("node:fs");
-                const configPath = path.join(ariaHome, "config.json");
-                if (existsSync(configPath)) {
-                    const raw = JSON.parse(readFileSync(configPath, "utf-8"));
-                    if (raw.activeArion)
-                        arionName = raw.activeArion;
-                }
-            }
-            catch {
-                // Ignore config read errors
-            }
-            const dbPath = SessionHistory.resolvePerArionPath(ariaHome, arionName);
-            _fallbackSessionHistory = new SessionHistory(dbPath);
-            return _fallbackSessionHistory;
-        }
-        catch {
-            // @aria/cli not available (e.g. isolated worker) — no fallback
-            _fallbackSessionHistory = null;
-            return null;
-        }
-    })();
-    return _fallbackPromise;
-}
-/**
- * Get the SessionHistoryRef — from ToolContext if wired, otherwise create
- * a fallback instance by dynamically importing @aria/cli's SessionHistory.
- */
-export async function getSessionHistory(ctx) {
-    if (ctx.sessionHistory)
-        return ctx.sessionHistory;
-    return resolveFallbackSessionHistory();
-}
-function formatSessions(sessions) {
-    return sessions.map((s) => ({
-        id: s.id,
-        title: s.title,
-        arion: s.arion,
-        model: s.model,
-        messageCount: s.messageCount,
-        updatedAt: s.updatedAt.toISOString(),
-        completedAt: s.completedAt?.toISOString(),
-        preview: s.preview,
-    }));
-}
-function truncateContent(content, max) {
-    if (content.length <= max)
-        return content;
-    return content.slice(0, max - 3) + "...";
-}
-function resolveSessionId(sh, rawId) {
-    // Try exact match first (full UUID), then prefix
-    if (rawId.length === 36) {
-        const session = sh.getSession(rawId);
-        return session ? rawId : null;
-    }
-    return sh.findSessionByPrefix(rawId);
-}
-// ============================================================================
-// Main Executor
-// ============================================================================
-/**
- * Execute a session_history action.
- */
-export async function executeSessionHistory(input, ctx) {
-    if (ctx.abortSignal?.aborted)
-        return fail("Operation cancelled");
-    if (!input.action) {
-        return fail("action is required. Valid actions: list, search, get, current, stats, delete, set_title");
-    }
-    const sh = await getSessionHistory(ctx);
-    if (!sh) {
-        return fail("Session history is not available in this context");
-    }
-    try {
-        switch (input.action) {
-            case "list":
-                return executeList(input, sh);
-            case "search":
-                return executeSearch(input, sh);
-            case "get":
-                return executeGet(input, sh);
-            case "current":
-                return executeCurrent(ctx, sh);
-            case "stats":
-                return executeStats(sh);
-            case "delete":
-                return executeDelete(input, sh);
-            case "set_title":
-                return executeSetTitle(input, sh);
-            default:
-                return fail(`Unknown action "${input.action}". Valid actions: list, search, get, current, stats, delete, set_title`);
-        }
-    }
-    catch (err) {
-        return fail(getErrorMessage(err));
-    }
-}
-// ============================================================================
-// Action Implementations
-// ============================================================================
-function executeList(input, sh) {
-    const limit = input.limit ?? 20;
-    const offset = input.offset ?? 0;
-    const sessions = sh.listSessions(limit, offset);
-    const formatted = formatSessions(sessions);
-    const output = {
-        sessions: formatted,
-        total: formatted.length,
-        limit,
-        offset,
-    };
-    if (formatted.length === 0) {
-        return success("No sessions found", output);
-    }
-    const summaryLines = formatted.map((s) => `• ${s.id.slice(0, 8)}… | ${s.title || "(untitled)"} | ${s.messageCount} msgs | ${s.arion} | ${s.updatedAt.slice(0, 10)}`);
-    return success(`Found ${formatted.length} session(s):\n${summaryLines.join("\n")}`, output);
-}
-function executeSearch(input, sh) {
-    if (!input.query || input.query.trim() === "") {
-        return fail("query is required for 'search' action");
-    }
-    const limit = input.limit ?? 20;
-    const offset = input.offset ?? 0;
-    const sessions = sh.searchSessionsFts(input.query, limit, offset);
-    const formatted = formatSessions(sessions);
-    const output = {
-        sessions: formatted,
-        total: formatted.length,
-        limit,
-        offset,
-    };
-    if (formatted.length === 0) {
-        return success(`No sessions found matching "${input.query}"`, output);
-    }
-    const summaryLines = formatted.map((s) => `• ${s.id.slice(0, 8)}… | ${s.title || "(untitled)"} | ${s.messageCount} msgs | ${s.arion} | ${s.updatedAt.slice(0, 10)}`);
-    return success(`Found ${formatted.length} session(s) matching "${input.query}":\n${summaryLines.join("\n")}`, output);
-}
-function executeGet(input, sh) {
-    if (!input.sessionId || input.sessionId.trim() === "") {
-        return fail("sessionId is required for 'get' action");
-    }
-    const resolvedId = resolveSessionId(sh, input.sessionId);
-    if (!resolvedId) {
-        return fail(`Session not found for ID/prefix "${input.sessionId}"`);
-    }
-    const session = sh.getSession(resolvedId);
-    if (!session) {
-        return fail(`Session ${resolvedId} not found`);
-    }
-    const messageLimit = input.messageLimit ?? 50;
-    // Take the last N messages to avoid context blowout
-    const messagesSlice = session.messages.slice(-messageLimit);
-    const formattedMessages = messagesSlice.map((m) => ({
-        role: m.role,
-        content: truncateContent(m.content, MAX_MESSAGE_CONTENT_LENGTH),
-        createdAt: m.createdAt.toISOString(),
-        toolCallId: m.toolCallId,
-    }));
-    // Also fetch metrics if available (getRunMetrics may not exist on all impls)
-    let metrics;
-    try {
-        const rawMetrics = sh.getRunMetrics?.(resolvedId) ?? [];
-        metrics =
-            rawMetrics.length > 0
-                ? rawMetrics.map((rm) => ({
-                    turnCount: rm.turnCount,
-                    inputTokens: rm.inputTokens,
-                    outputTokens: rm.outputTokens,
-                    estimatedCost: rm.estimatedCost,
-                    wallTimeMs: rm.wallTimeMs,
-                }))
-                : undefined;
-    }
-    catch {
-        // Non-critical — metrics may not be available
-    }
-    const output = {
-        id: session.id,
-        arion: session.arion,
-        model: session.model,
-        messageCount: session.messages.length,
-        messages: formattedMessages,
-        metrics,
-    };
-    const truncNote = session.messages.length > messageLimit
-        ? ` (showing last ${messageLimit} of ${session.messages.length})`
-        : "";
-    return success(`Session ${session.id.slice(0, 8)}… | ${session.arion} | ${session.model} | ${session.messages.length} messages${truncNote}`, output);
-}
-function executeCurrent(ctx, sh) {
-    if (!ctx.currentSessionId) {
-        return fail("No current session ID available");
-    }
-    const output = {
-        sessionId: ctx.currentSessionId,
-    };
-    // Try to get session details if available
-    const session = sh.getSession(ctx.currentSessionId);
-    if (session) {
-        return success(`Current session: ${session.id.slice(0, 8)}… | ${session.arion} | ${session.model} | ${session.messages.length} messages`, {
-            ...output,
-            arion: session.arion,
-            model: session.model,
-            messageCount: session.messages.length,
-        });
-    }
-    return success(`Current session: ${ctx.currentSessionId}`, output);
-}
-function executeStats(sh) {
-    const totalSessions = sh.getSessionCount?.() ?? 0;
-    const incompleteSessions = (sh.getIncompleteSessions?.(1000) ?? []).length;
-    const output = {
-        totalSessions,
-        incompleteSessions,
-    };
-    return success(`Session stats: ${totalSessions} total, ${incompleteSessions} incomplete, ${totalSessions - incompleteSessions} completed`, output);
-}
-function executeDelete(input, sh) {
-    if (!input.sessionId || input.sessionId.trim() === "") {
-        return fail("sessionId is required for 'delete' action");
-    }
-    const resolvedId = resolveSessionId(sh, input.sessionId);
-    if (!resolvedId) {
-        return fail(`Session not found for ID/prefix "${input.sessionId}"`);
-    }
-    sh.deleteSession(resolvedId);
-    return success(`Deleted session ${resolvedId}`);
-}
-function executeSetTitle(input, sh) {
-    if (!input.sessionId || input.sessionId.trim() === "") {
-        return fail("sessionId is required for 'set_title' action");
-    }
-    if (!input.title || input.title.trim() === "") {
-        return fail("title is required for 'set_title' action");
-    }
-    const resolvedId = resolveSessionId(sh, input.sessionId);
-    if (!resolvedId) {
-        return fail(`Session not found for ID/prefix "${input.sessionId}"`);
-    }
-    sh.setSessionTitle(resolvedId, input.title);
-    return success(`Set title of session ${resolvedId.slice(0, 8)}… to "${input.title}"`);
-}