comisai 1.0.37 → 1.0.41

package/node_modules/@comis/cli/dist/commands/config.js

@@ -8,13 +8,19 @@
  *
  * @module
  */
+import * as fs from "node:fs";
 import * as os from "node:os";
 import chalk from "chalk";
-import { loadConfigFile, validateConfig, deepMerge, loadEnvFile } from "@comis/core";
-import { withClient } from "../client/rpc-client.js";
+import { parseDocument } from "yaml";
+import { loadConfigFile, validateConfig, deepMerge, loadEnvFile, ConfigReadContract, ConfigPatchContract, ConfigHistoryContract, ConfigDiffContract, ConfigRollbackContract, } from "@comis/core";
+import { callTyped, withClient } from "../client/rpc-client.js";
 import { success, error, info, warn, json } from "../output/format.js";
 import { withSpinner } from "../output/spinner.js";
 import { renderTable, renderKeyValue } from "../output/table.js";
+import { applyToDocument, atomicWriteFile, computeMutationPlan, discoverSkills, isDaemonRunning, readMcpServers, renderInspectHuman, renderInspectJson, writeBackup, pruneOldBackups, } from "../sync-tooling/index.js";
+import { runToolingFill, } from "../tooling-fill/index.js";
+import * as readline from "node:readline/promises";
+import { formatDate, readHintKeysForInspect, resolveEnvRefs, truncate, } from "./config-parsers.js";
 /** Default config paths to check (matching daemon defaults). */
 const DEFAULT_CONFIG_PATHS = [
     os.homedir() + "/.comis/config.yaml",
@@ -22,32 +28,14 @@ const DEFAULT_CONFIG_PATHS = [
     "/etc/comis/config.yaml",
     "/etc/comis/config.local.yaml",
 ];
-/** Pattern matching `${VAR_NAME}` env var references. */
-const ENV_REF_RE = /\$\{([A-Z_][A-Z0-9_]*)\}/g;
 /**
- * Deep-walk an object and resolve `${VAR}` references using process.env.
- * Mutates in place for efficiency since the input is a transient merge result.
+ * Default config path for `sync-tooling` — single path, not the merged
+ * 4-path list used by `validate`. Hardcoded to `~/.comis/config.yaml` so
+ * the no-flag invocation is safe by construction — operator-supplied
+ * `--config` is operator-trusted; the default is not operator-derived
+ * and therefore not subject to traversal concerns.
  */
-function resolveEnvRefs(obj) {
-    for (const [key, value] of Object.entries(obj)) {
-        if (typeof value === "string" && value.includes("${")) {
-            obj[key] = value.replace(ENV_REF_RE, (match, varName) => {
-                // eslint-disable-next-line no-restricted-syntax -- CLI bootstrap before SecretManager
-                return process.env[varName] ?? match;
-            });
-        }
-        else if (value && typeof value === "object" && !Array.isArray(value)) {
-            resolveEnvRefs(value);
-        }
-        else if (Array.isArray(value)) {
-            for (const item of value) {
-                if (item && typeof item === "object") {
-                    resolveEnvRefs(item);
-                }
-            }
-        }
-    }
-}
+const SYNC_TOOLING_DEFAULT_CONFIG = os.homedir() + "/.comis/config.yaml";
 /**
  * Register the `config` subcommand group on the program.
  *
@@ -121,7 +109,7 @@ export function registerConfigCommand(program) {
         .action(async (section, options) => {
         try {
             const result = await withSpinner("Reading config...", () => withClient(async (client) => {
-                return await client.call("config.read", { section });
+                return await callTyped(client, ConfigReadContract, section ? { section } : {});
             }));
             if (options.format === "json") {
                 json(result);
@@ -175,7 +163,18 @@ export function registerConfigCommand(program) {
         }
         try {
             await withClient(async (client) => {
-                return await client.call("config.patch", { section, key, value });
+                // ConfigPatchContract.request.value accepts the wire-observable
+                // primitive | record | array-of-record union (loose record).
+                // The `value` here is JSON-parsed from the CLI arg (or raw string
+                // fallback) — already in the allowed shape. callTyped's contract
+                // input type widens to z.input, which for the union is
+                // `string | number | boolean | Record<string, unknown> | Array<Record<string, unknown>>`
+                // — cast through unknown to satisfy TS narrowing.
+                return await callTyped(client, ConfigPatchContract, {
+                    section,
+                    key,
+                    value: value,
+                });
             });
             success(`Set ${dotPath} = ${JSON.stringify(value)}`);
             warn("Daemon is restarting to apply changes...");
@@ -196,7 +195,7 @@ export function registerConfigCommand(program) {
         try {
             const limit = parseInt(options.limit, 10);
             const result = await withSpinner("Fetching config history...", () => withClient(async (client) => {
-                return (await client.call("config.history", { limit }));
+                return await callTyped(client, ConfigHistoryContract, { limit });
             }));
             // Handle graceful degradation when git is unavailable
             if (result.entries.length === 0 && result.error) {
@@ -213,7 +212,7 @@ export function registerConfigCommand(program) {
             }
             renderTable(["SHA", "Date", "Message"], result.entries.map((entry) => [
                 entry.sha.slice(0, 7),
-                formatDate(entry.date),
+                formatDate(entry.timestamp),
                 truncate(entry.message, 60),
             ]));
         }
@@ -230,7 +229,7 @@ export function registerConfigCommand(program) {
         .action(async (sha) => {
         try {
             const result = await withSpinner("Computing diff...", () => withClient(async (client) => {
-                return (await client.call("config.diff", { sha }));
+                return await callTyped(client, ConfigDiffContract, sha ? { sha } : {});
             }));
             if (result.error) {
                 warn(result.error);
@@ -291,7 +290,7 @@ export function registerConfigCommand(program) {
         }
         try {
             await withClient(async (client) => {
-                return await client.call("config.rollback", { sha });
+                return await callTyped(client, ConfigRollbackContract, { sha });
             });
             success(`Config rolled back to ${sha.slice(0, 7)}`);
             warn("Daemon is restarting...");
@@ -302,27 +301,284 @@ export function registerConfigCommand(program) {
             process.exit(1);
         }
     });
-}
-/**
- * Truncate a string to a maximum length with ellipsis.
- */
-function truncate(str, maxLength) {
-    const oneLine = str.replace(/\n/g, " ");
-    if (oneLine.length <= maxLength)
-        return oneLine;
-    return oneLine.slice(0, maxLength - 3) + "...";
-}
-/**
- * Format an ISO date string for display.
- */
-function formatDate(dateStr) {
-    try {
-        const d = new Date(dateStr);
-        if (isNaN(d.getTime()))
-            return dateStr;
-        return d.toLocaleString();
-    }
-    catch {
-        return dateStr;
-    }
+    // --- config sync-tooling --------------------------------------------------
+    // Operator UX for materializing the `tooling:` block from discovered MCPs
+    // and skills. Three modes:
+    //   1. inspect (default)   — print diff, exit 0, never touch the file
+    //   2. --write             — backup + append-only mutation + atomic write
+    //   3. --write --overwrite — backup + regenerate the entire managed block
+    //
+    // Wiring boundary: this callback is the orchestrator. All discovery,
+    // AST mutation, fs I/O, and daemon probing live in
+    // `packages/cli/src/sync-tooling/*`.
+    config
+        .command("sync-tooling")
+        .description("Discover MCPs/skills and sync the tooling: config block")
+        .option("--write", "Apply changes to config.yaml (default: inspect-only)")
+        .option("--overwrite", "Regenerate the entire tooling block (requires --write)")
+        .option("--format <format>", "Inspect-mode output format (human|json)", "human")
+        // --config is operator-supplied and operator-trusted. The default is
+        // hardcoded so the no-flag invocation is safe by construction.
+        .option("-c, --config <path>", "Config file path", SYNC_TOOLING_DEFAULT_CONFIG)
+        .action(async (options) => {
+        const configPath = options.config ?? SYNC_TOOLING_DEFAULT_CONFIG;
+        const homeDir = os.homedir();
+        const isWrite = options.write === true;
+        const isOverwrite = options.overwrite === true;
+        const fmt = options.format ?? "human";
+        // --overwrite requires --write — usage error before any I/O.
+        if (isOverwrite && !isWrite) {
+            error("--overwrite requires --write");
+            process.exit(1);
+            return;
+        }
+        if (fmt !== "human" && fmt !== "json") {
+            error(`--format must be 'human' or 'json' (got: ${fmt})`);
+            process.exit(1);
+            return;
+        }
+        // Daemon-active guard fires for write paths only. Inspect mode is
+        // read-only so the daemon's restart-required `tooling.*`
+        // configuration is unaffected.
+        if (isWrite) {
+            const running = await isDaemonRunning();
+            if (running) {
+                error("daemon is running — stop it before running sync-tooling --write (tooling.* is restart-required)");
+                process.exit(1);
+                return;
+            }
+        }
+        // Two views of the source file:
+        //   (1) loadConfigFile → JS shape for discover.ts (validates structure,
+        //       returns ok({}) on missing/empty file).
+        //   (2) parseDocument  → AST for generate.ts (preserves comments and
+        //       key order across mutations).
+        const loaded = loadConfigFile(configPath);
+        if (!loaded.ok) {
+            // FILE_NOT_FOUND is recoverable — init-when-absent path. Anything
+            // else (parse error, permission denied) → exit 3.
+            if (loaded.error.code !== "FILE_NOT_FOUND") {
+                error(`Failed to load ${configPath}: ${loaded.error.message}`);
+                process.exit(3);
+                return;
+            }
+        }
+        const configJs = loaded.ok ? loaded.value : {};
+        let rawYaml;
+        try {
+            rawYaml = fs.readFileSync(configPath, "utf-8");
+        }
+        catch {
+            // Init-when-absent: file does not exist on disk → start with empty
+            // content; parseDocument tolerates an empty string.
+            rawYaml = "";
+        }
+        let doc;
+        try {
+            doc = parseDocument(rawYaml);
+            if (doc.errors.length > 0) {
+                error(`Invalid YAML in ${configPath}: ${doc.errors.map((er) => er.message).join("; ")}`);
+                process.exit(3);
+                return;
+            }
+        }
+        catch (e) {
+            error(`Failed to parse ${configPath}: ${String(e)}`);
+            process.exit(3);
+            return;
+        }
+        // Discovery — both helpers are pure (no Result wrapper; they silent-skip
+        // malformed entries, see discover.ts JSDoc).
+        const mcps = readMcpServers(configJs);
+        const skills = discoverSkills(configJs, { homeDir });
+        const artifacts = { mcps, skills };
+        // Compute the read-only mutation plan against the current AST.
+        const plan = computeMutationPlan(doc, artifacts);
+        // "Nothing to sync" cases (write-path only — inspect mode always renders):
+        //  (a) Fresh config — operator has installed no MCPs/skills AND no tooling
+        //      block exists yet. Writing an empty skeleton would be churn.
+        //  (b) Plan is a no-op against an existing tooling block (no adds, no
+        //      removes, no skeleton needed).
+        // When discovery is empty BUT a tooling block exists with stale hints,
+        // the plan will report removes — that path must NOT short-circuit.
+        const isFreshAndEmpty = mcps.length === 0 && skills.length === 0 && plan.needsSkeleton;
+        const planIsNoop = plan.mcpAdds.length === 0 &&
+            plan.mcpRemoves.length === 0 &&
+            plan.skillAdds.length === 0 &&
+            plan.skillRemoves.length === 0 &&
+            !plan.needsSkeleton;
+        const nothingToDo = isFreshAndEmpty || planIsNoop;
+        if (nothingToDo && isWrite && !isOverwrite) {
+            info(isFreshAndEmpty
+                ? "(nothing to sync — no MCPs or skills discovered)"
+                : "(nothing to sync — config is already in sync)");
+            process.exit(0);
+            return;
+        }
+        // Build a "would-write" preview by cloning + applying without writing.
+        // Re-parse from rawYaml so we don't mutate the doc we may write later.
+        const previewDoc = parseDocument(rawYaml);
+        if (previewDoc.errors.length === 0) {
+            applyToDocument(previewDoc, artifacts, { overwrite: isOverwrite });
+        }
+        const wouldWrite = previewDoc.toString();
+        const inspectPayload = {
+            discovered: artifacts,
+            existing: {
+                tooling: doc.hasIn(["tooling"]) ? "present" : "absent",
+                mcpHintNames: readHintKeysForInspect(doc, [
+                    "tooling",
+                    "mcp",
+                    "capabilityHints",
+                ]),
+                skillHintNames: readHintKeysForInspect(doc, [
+                    "tooling",
+                    "skills",
+                    "capabilityHints",
+                ]),
+            },
+            diff: {
+                add: { mcps: plan.mcpAdds, skills: plan.skillAdds },
+                remove: { mcps: plan.mcpRemoves, skills: plan.skillRemoves },
+            },
+            wouldWrite,
+        };
+        // Inspect mode (no --write): render and exit 0 — config.yaml untouched.
+        if (!isWrite) {
+            if (fmt === "json") {
+                json(JSON.parse(renderInspectJson(inspectPayload)));
+            }
+            else {
+                // Use process.stdout.write so chalk-coded output renders without
+                // the format.ts indentation prefix (which is for one-liners).
+                process.stdout.write(renderInspectHuman(inspectPayload) + "\n");
+            }
+            process.exit(0);
+            return;
+        }
+        // --write path: backup-fail-fast → atomic write → summary lines.
+        const backup = writeBackup(configPath, homeDir);
+        if (!backup.ok) {
+            error(`Backup failed (${backup.error.code}): ${backup.error.path} — ${backup.error.cause}`);
+            process.exit(2);
+            return;
+        }
+        const counts = applyToDocument(doc, artifacts, { overwrite: isOverwrite });
+        const written = atomicWriteFile(configPath, doc.toString());
+        if (!written.ok) {
+            error(`Atomic write failed (${written.error.code}): ${written.error.cause}`);
+            process.exit(2);
+            return;
+        }
+        // Terse one-line summary so operators see the backup path.
+        const totalAdded = counts.mcpAdded + counts.skillAdded;
+        const totalRemoved = counts.mcpRemoved + counts.skillRemoved;
+        success(`tooling: +${totalAdded} hints, -${totalRemoved} hints (backup: ${backup.value.backupPath})`);
+        // Extra warning for overwrite (destructive of operator intent).
+        if (isOverwrite) {
+            warn(`⚠ overwrote ${configPath} — entire tooling: block regenerated. Backup: ${backup.value.backupPath}`);
+        }
+        // Housekeeping: keep the 5 most recent sync-tooling backups under
+        // ~/.comis/, drop older. Best-effort — backup pruning is never
+        // load-bearing, and the freshly-written backup counts toward the
+        // keep set.
+        const pruneRes = pruneOldBackups(homeDir, "sync-tooling", 5);
+        if (pruneRes.deleted > 0) {
+            info(`(pruned ${pruneRes.deleted} older sync-tooling backup(s))`);
+        }
+        process.exit(0);
+    });
+    // --- config tooling-fill --------------------------------------------------
+    // Operator UX for materializing the description + replacesPackages fields
+    // on tooling capability hints via the live Comis daemon. The orchestrator
+    // owns the full state machine; this callback is the composition root
+    // (AGENTS.md §2.4) — it builds the OrchestratorOpts bag, instantiates the
+    // readline-backed PromptIO, and routes the result's exitCode into
+    // process.exit.
+    //
+    // Wiring boundary: ALL discovery, AST mutation, fs I/O, daemon probing,
+    // supervisor calls, and LLM round-trips live in
+    // `packages/cli/src/tooling-fill/*`.
+    config
+        .command("tooling-fill [hint-name]")
+        .description("Fill description + replacesPackages on a tooling capability hint via the live agent")
+        .option("--all", "Fill every stub-valued hint")
+        .option("--force", "Overwrite operator-filled hints")
+        .option("--dry-run", "Print agent suggestion + diff; never stop daemon, never write file")
+        .option("--yes", "Skip values-confirmation prompt")
+        .option("--restart", "Authorize daemon-stop+start window")
+        .option("--allow-restart", "Alias for --restart")
+        .option("--no-restart", "Write file but skip daemon stop+start")
+        .option("--restart-cmd <cmd>", "Override supervisor with full stop+start command")
+        .option("--force-no-validate", "Skip package-name shape validation (escape hatch — loud warning)")
+        .option("-c, --config <path>", "Config file path", SYNC_TOOLING_DEFAULT_CONFIG)
+        .option("--agent <id>", "Agent ID for the LLM call (default: daemon's first agent)")
+        .option("--kind <kind>", "Disambiguate hint kind: mcp or skills (when both maps contain the same key)")
+        .action(async (hintName, options) => {
+        // Build readline-backed PromptIO. Even when not used (--yes
+        // --restart on a TTY), we still need to construct it so the
+        // orchestrator's PromptIO contract is satisfied. The interface
+        // is closed at action-callback exit via rl.close().
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const prompts = {
+            confirmValues: async (diff) => {
+                process.stdout.write(diff + "\n");
+                const ans = await rl.question("Apply these values? [y/N] ");
+                const norm = ans.trim().toLowerCase();
+                return norm === "y" || norm === "yes";
+            },
+            confirmRestart: async (s) => {
+                const ans = await rl.question(`Stop and restart daemon (${s.kind})? [y/N] `);
+                const norm = ans.trim().toLowerCase();
+                return norm === "y" || norm === "yes";
+            },
+        };
+        // --restart vs --no-restart vs unset — Commander convention:
+        //   --restart       → options.restart === true
+        //   --no-restart    → options.restart === false
+        //   neither         → options.restart === undefined
+        // --allow-restart is an alias: if either is set, treat as true.
+        // Explicit --no-restart + --allow-restart is a contradiction;
+        // refuse rather than silently letting the alias win.
+        if (options.allowRestart === true && options.restart === false) {
+            error("--allow-restart and --no-restart are mutually exclusive");
+            process.exit(1);
+            return;
+        }
+        const restartFlag = options.allowRestart === true
+            ? true
+            : options.restart === undefined
+                ? undefined
+                : options.restart;
+        const result = await runToolingFill({
+            hintName,
+            all: options.all === true,
+            force: options.force === true,
+            forceNoValidate: options.forceNoValidate === true,
+            dryRun: options.dryRun === true,
+            yes: options.yes === true,
+            restart: restartFlag,
+            restartCmd: options.restartCmd,
+            configPath: options.config ?? SYNC_TOOLING_DEFAULT_CONFIG,
+            homeDir: os.homedir(),
+            kindHint: options.kind === "mcp" || options.kind === "skills"
+                ? options.kind
+                : undefined,
+            agentId: options.agent,
+            isTty: process.stdout.isTTY === true,
+            prompts,
+            clock: () => new Date(),
+        });
+        rl.close();
+        if (result.exitCode === 0) {
+            success(result.summary);
+        }
+        else {
+            error(result.summary);
+        }
+        process.exit(result.exitCode);
+    });
 }

package/node_modules/@comis/cli/dist/commands/daemon.js

@@ -1,4 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
+// @allow-throw: CLI command entry point; throws caught by Commander.js error handler boundary per AGENTS.md §2.1 CLI user-facing flows exception.
 /**
  * Daemon control commands: start, stop, status, logs.
  *
@@ -15,8 +16,8 @@ import * as os from "node:os";
 import { createInterface } from "node:readline";
 import { promisify } from "node:util";
 import chalk from "chalk";
-import { safePath } from "@comis/core";
-import { withClient } from "../client/rpc-client.js";
+import { safePath, SystemPingContract, ConfigReadContract } from "@comis/core";
+import { withClient, callTyped } from "../client/rpc-client.js";
 import { success, error, info, warn } from "../output/format.js";
 import { renderKeyValue } from "../output/table.js";
 const exec = promisify(execFile);
@@ -325,7 +326,7 @@ async function handleDaemonStart() {
                 if (await isSystemdActive(manager)) {
                     // Verify the CLI can actually talk to the daemon
                     try {
-                        await withClient(async (client) => client.call("system.ping", {}));
+                        await withClient(async (client) => callTyped(client, SystemPingContract, {}));
                         success("Daemon is already running (systemd)");
                     }
                     catch {
@@ -445,8 +446,10 @@ async function stopDirectMode() {
  */
 async function tryRpcStatus() {
     try {
+        // ConfigReadContract.response is a loose record matching the daemon's
+        // return shape for `config.read`.
         const result = await withClient(async (client) => {
-            return (await client.call("config.get", {}));
+            return await callTyped(client, ConfigReadContract, {});
         });
         success("Daemon is running");
         const pairs = [];

package/node_modules/@comis/cli/dist/commands/init.js

@@ -1,4 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
+// @allow-throw: CLI command entry point; throws caught by Commander.js error handler boundary per AGENTS.md §2.1 CLI user-facing flows exception.
 /**
  * Init wizard command.
  *

package/node_modules/@comis/cli/dist/commands/memory.js

@@ -8,7 +8,8 @@
  * @module
  */
 import chalk from "chalk";
-import { withClient } from "../client/rpc-client.js";
+import { ContextSearchContract, ContextInspectContract, MemoryStatsContract, MemoryFlushContract, } from "@comis/core";
+import { callTyped, withClient } from "../client/rpc-client.js";
 import { success, error, info, warn, json } from "../output/format.js";
 import { withSpinner } from "../output/spinner.js";
 import { renderTable, renderKeyValue } from "../output/table.js";
@@ -32,10 +33,17 @@ export function registerMemoryCommand(program) {
             process.exit(1);
         }
         try {
+            // Routed via ContextSearchContract — the daemon exposes
+            // `memory.search_files` + `context.search` (no `memory.search`);
+            // ContextSearchContract is the closest semantic match (full-text
+            // search over message + summary content).
             const result = await withSpinner("Searching memory...", () => withClient(async (client) => {
-                return (await client.call("memory.search", { query, limit }));
+                return await callTyped(client, ContextSearchContract, {
+                    query,
+                    limit,
+                });
             }));
-            const results = result.results ?? [];
+            const results = (result.results ?? []);
             if (results.length === 0) {
                 info("No matching entries found");
                 return;
@@ -65,14 +73,20 @@ export function registerMemoryCommand(program) {
         .option("--format <format>", "Output format (detail|json)", "detail")
         .action(async (id, options) => {
         try {
+            // Routed via ContextInspectContract — there is no `memory.inspect`
+            // daemon handler. ContextInspectContract retrieves a single entry
+            // by id (the closest semantic match). The response is a loose
+            // record; we coerce to MemoryEntry shape for rendering.
             const result = await withSpinner("Fetching entry...", () => withClient(async (client) => {
-                return (await client.call("memory.inspect", { id }));
+                return await callTyped(client, ContextInspectContract, { id });
             }));
-            if (!result.entry) {
+            // ContextInspectContract returns the entry directly as a loose
+            // record (no `entry` wrapper). Treat empty record as "not found".
+            if (!result || Object.keys(result).length === 0) {
                 warn(`No entry found with ID: ${id}`);
                 return;
             }
-            const entry = result.entry;
+            const entry = result;
             if (options.format === "json") {
                 json(entry);
                 return;
@@ -112,10 +126,13 @@ export function registerMemoryCommand(program) {
         .option("--format <format>", "Output format (detail|json)", "detail")
         .action(async (options) => {
         try {
+            // Routed via MemoryStatsContract — the daemon's
+            // memory-statistics surface. Response is a loose record; the
+            // values matter, not the precise shape.
             const result = await withSpinner("Fetching memory stats...", () => withClient(async (client) => {
-                return (await client.call("memory.inspect", {}));
+                return await callTyped(client, MemoryStatsContract, {});
             }));
-            const stats = result.stats;
+            const stats = result;
             if (!stats || Object.keys(stats).length === 0) {
                 info("No memory statistics available");
                 return;
@@ -188,12 +205,16 @@ export function registerMemoryCommand(program) {
             }
         }
         try {
+            // Routed via MemoryFlushContract — the actual flush surface.
+            // The tenant filter maps to `tenant_id`; the generic
+            // `--filter key=value` flag is a no-op here (there is no
+            // `config.set` handler with section=memory).
             await withSpinner("Clearing memory entries...", () => withClient(async (client) => {
-                return await client.call("config.set", {
-                    section: "memory",
-                    key: "clear",
-                    value: params,
-                });
+                const flushParams = {};
+                if (typeof params.tenantId === "string") {
+                    flushParams.tenant_id = params.tenantId;
+                }
+                return await callTyped(client, MemoryFlushContract, flushParams);
             }));
             success("Memory entries cleared");
         }

package/node_modules/@comis/cli/dist/commands/models.js

@@ -12,8 +12,8 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import chalk from "chalk";
 import { parseDocument } from "yaml";
-import { createModelCatalog } from "@comis/agent";
-import { withClient } from "../client/rpc-client.js";
+import { createModelCatalog, ModelsListContract } from "@comis/core";
+import { withClient, callTyped } from "../client/rpc-client.js";
 import { success, error, info, json } from "../output/format.js";
 import { withSpinner } from "../output/spinner.js";
 import { renderTable } from "../output/table.js";
@@ -57,7 +57,7 @@ async function loadModels(provider) {
     // Try RPC first
     try {
         const result = await withClient(async (client) => {
-            return (await client.call("models.list", { provider }));
+            return (await callTyped(client, ModelsListContract, provider ? { provider } : {}));
         });
         if (Array.isArray(result)) {
             return result;

package/node_modules/@comis/cli/dist/commands/providers.js

@@ -13,10 +13,10 @@
  *
  * @module
  */
-import { getEnvApiKey } from "@mariozechner/pi-ai";
-import { withClient } from "../client/rpc-client.js";
+import { getEnvApiKey } from "@earendil-works/pi-ai";
+import { withClient, callTyped } from "../client/rpc-client.js";
 import { loadProvidersWithFallback } from "../client/provider-list.js";
-import { createModelCatalog } from "@comis/agent";
+import { createModelCatalog, ModelsListContract } from "@comis/core";
 import { error, info, json } from "../output/format.js";
 import { withSpinner } from "../output/spinner.js";
 import { renderTable } from "../output/table.js";
@@ -39,7 +39,7 @@ const KEYLESS_PROVIDERS = new Set(["ollama", "lm-studio"]);
 async function getModelCount(provider) {
     try {
         const result = await withClient(async (client) => {
-            return (await client.call("models.list", { provider }));
+            return (await callTyped(client, ModelsListContract, { provider }));
         });
         if (Array.isArray(result))
             return result.length;

package/node_modules/@comis/cli/dist/commands/reset.js

@@ -1,4 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
+// @allow-throw: CLI command entry point; throws caught by Commander.js error handler boundary per AGENTS.md §2.1 CLI user-facing flows exception.
 /**
  * Reset utility command: sessions, config, workspace.
  *
@@ -11,7 +12,8 @@
 import * as p from "@clack/prompts";
 import * as fs from "node:fs";
 import * as os from "node:os";
-import { withClient } from "../client/rpc-client.js";
+import { SessionListContract, SessionDeleteContract } from "@comis/core";
+import { callTyped, withClient } from "../client/rpc-client.js";
 import { success, error, info, warn } from "../output/format.js";
 import { withSpinner } from "../output/spinner.js";
 /** Valid reset targets. */
@@ -85,11 +87,15 @@ function isDaemonUnreachable(err) {
 async function resetSessions(dataDir) {
     try {
         await withSpinner("Clearing sessions via daemon...", () => withClient(async (client) => {
-            const result = await client.call("session.list");
+            // Typed RPC. The contract response is { sessions: SessionInfo[], total };
+            // iterate the typed array and delete each by sessionKey.
+            const result = await callTyped(client, SessionListContract, {});
             if (result.total === 0)
                 return;
             for (const session of result.sessions) {
-                await client.call("session.delete", { session_key: session.sessionKey });
+                await callTyped(client, SessionDeleteContract, {
+                    session_key: session.sessionKey,
+                });
             }
         }));
         success("All sessions deleted");