comisai 1.0.15 → 1.0.17

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

@@ -12,7 +12,9 @@
 import { execFile, spawn } from "node:child_process";
 import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, openSync } from "node:fs";
 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 { success, error, info, warn } from "../output/format.js";
@@ -23,6 +25,63 @@ const PID_FILE = safePath(COMIS_DIR, "daemon.pid");
 const LOG_FILE = safePath(COMIS_DIR, "daemon.log");
 /** Max time to wait for daemon gateway to become ready (ms). */
 const READY_TIMEOUT_MS = 15_000;
+// ---------- Log formatting ----------
+const PINO_LEVELS = {
+    10: { label: "TRACE", color: chalk.gray },
+    20: { label: "DEBUG", color: chalk.gray },
+    30: { label: "INFO", color: chalk.cyan },
+    40: { label: "WARN", color: chalk.yellow },
+    50: { label: "ERROR", color: chalk.red },
+    60: { label: "FATAL", color: chalk.bgRed.white },
+};
+const PINO_META_KEYS = new Set([
+    "level", "time", "pid", "hostname", "name", "msg", "module",
+    "levelValue", "instanceId",
+]);
+function formatPinoLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{"))
+        return line;
+    let record;
+    try {
+        record = JSON.parse(trimmed);
+    }
+    catch {
+        return line;
+    }
+    if (typeof record["level"] !== "number" && typeof record["level"] !== "string")
+        return line;
+    const levelNum = typeof record["level"] === "number"
+        ? record["level"]
+        : ({ trace: 10, debug: 20, info: 30, warn: 40, error: 50, fatal: 60 }[record["level"]] ?? 30);
+    const levelInfo = PINO_LEVELS[levelNum] ?? { label: String(record["level"]), color: chalk.white };
+    const time = record["time"]
+        ? new Date(record["time"]).toLocaleTimeString()
+        : "";
+    const mod = record["module"] ? `[${record["module"]}]` : "";
+    const msg = record["msg"] ?? "";
+    const extra = {};
+    for (const [k, v] of Object.entries(record)) {
+        if (!PINO_META_KEYS.has(k))
+            extra[k] = v;
+    }
+    const extraStr = Object.keys(extra).length > 0
+        ? chalk.gray(` ${JSON.stringify(extra)}`)
+        : "";
+    return `${chalk.dim(time)} ${levelInfo.color(levelInfo.label.padEnd(5))} ${chalk.blue(mod)} ${msg}${extraStr}`;
+}
+function formatLogOutput(raw) {
+    return raw
+        .split("\n")
+        .map((line) => (line.trim() ? formatPinoLine(line) : line))
+        .join("\n");
+}
+function pipeFormatted(child) {
+    if (!child.stdout)
+        return;
+    const rl = createInterface({ input: child.stdout });
+    rl.on("line", (line) => console.log(formatPinoLine(line)));
+}
 /** Interval between readiness polls (ms). */
 const READY_POLL_MS = 500;
 /**
@@ -533,40 +592,48 @@ async function handleDaemonLogs(options) {
     }
 }
 async function streamSystemdLogs(scope, options) {
-    const jArgs = ["--unit=comis", "--no-pager", `-n${options.lines}`];
+    const jArgs = ["--unit=comis", "--no-pager", `-n${options.lines}`, "--output=cat"];
     if (scope === "systemd-user")
         jArgs.push("--user");
     if (options.follow)
         jArgs.push("--follow");
     if (options.follow) {
-        const child = spawn("journalctl", jArgs, { stdio: "inherit" });
-        child.on("error", (err) => {
-            error(`Failed to read logs: ${err.message}`);
-            process.exit(1);
-        });
+        if (options.raw) {
+            const child = spawn("journalctl", jArgs, { stdio: "inherit" });
+            child.on("error", (err) => {
+                error(`Failed to read logs: ${err.message}`);
+                process.exit(1);
+            });
+        }
+        else {
+            const child = spawn("journalctl", jArgs, { stdio: ["ignore", "pipe", "inherit"] });
+            child.on("error", (err) => {
+                error(`Failed to read logs: ${err.message}`);
+                process.exit(1);
+            });
+            pipeFormatted(child);
+        }
         return;
     }
-    // Try journalctl directly first (works when user is in systemd-journal group),
-    // then fall back to sudo for system-scope journals.
-    try {
-        const { stdout } = await exec("journalctl", jArgs, { timeout: 10_000 });
+    const printOutput = (stdout) => {
         if (stdout.trim()) {
-            console.log(stdout);
+            console.log(options.raw ? stdout : formatLogOutput(stdout));
         }
         else {
             info("No logs found");
         }
+    };
+    // Try journalctl directly first (works when user is in systemd-journal group),
+    // then fall back to sudo for system-scope journals.
+    try {
+        const { stdout } = await exec("journalctl", jArgs, { timeout: 10_000 });
+        printOutput(stdout);
     }
     catch {
         // eslint-disable-next-line no-restricted-syntax -- CLI bootstrap before SecretManager
         if (scope === "systemd" && process.getuid?.() !== 0) {
             const { stdout } = await exec("sudo", ["journalctl", ...jArgs], { timeout: 10_000 });
-            if (stdout.trim()) {
-                console.log(stdout);
-            }
-            else {
-                info("No logs found");
-            }
+            printOutput(stdout);
         }
         else {
             throw new Error("Failed to read journal logs");
@@ -577,11 +644,21 @@ function streamPm2Logs(options) {
     const args = ["logs", "comis", "--lines", options.lines];
     if (!options.follow)
         args.push("--nostream");
-    const child = spawn("pm2", args, { stdio: "inherit" });
-    child.on("error", (err) => {
-        error(`Failed to read logs: ${err.message}`);
-        process.exit(1);
-    });
+    if (options.raw) {
+        const child = spawn("pm2", args, { stdio: "inherit" });
+        child.on("error", (err) => {
+            error(`Failed to read logs: ${err.message}`);
+            process.exit(1);
+        });
+    }
+    else {
+        const child = spawn("pm2", args, { stdio: ["ignore", "pipe", "inherit"] });
+        child.on("error", (err) => {
+            error(`Failed to read logs: ${err.message}`);
+            process.exit(1);
+        });
+        pipeFormatted(child);
+    }
 }
 async function streamDirectLogs(options) {
     // eslint-disable-next-line no-restricted-syntax -- CLI bootstrap before SecretManager
@@ -594,16 +671,26 @@ async function streamDirectLogs(options) {
     const args = ["-n", options.lines, logPath];
     if (options.follow) {
         args.unshift("-f");
-        const child = spawn("tail", args, { stdio: "inherit" });
-        child.on("error", (err) => {
-            error(`Failed to read logs: ${err.message}`);
-            process.exit(1);
-        });
+        if (options.raw) {
+            const child = spawn("tail", args, { stdio: "inherit" });
+            child.on("error", (err) => {
+                error(`Failed to read logs: ${err.message}`);
+                process.exit(1);
+            });
+        }
+        else {
+            const child = spawn("tail", args, { stdio: ["ignore", "pipe", "inherit"] });
+            child.on("error", (err) => {
+                error(`Failed to read logs: ${err.message}`);
+                process.exit(1);
+            });
+            pipeFormatted(child);
+        }
         return;
     }
     const { stdout } = await exec("tail", args, { timeout: 5_000 });
     if (stdout.trim()) {
-        console.log(stdout);
+        console.log(options.raw ? stdout : formatLogOutput(stdout));
     }
     else {
         info("No logs found");
@@ -634,5 +721,6 @@ export function registerDaemonCommand(program) {
         .description("Show daemon logs")
         .option("-f, --follow", "Follow log output")
         .option("-n, --lines <n>", "Number of lines to show", "50")
+        .option("--raw", "Show raw JSON output without formatting")
         .action(handleDaemonLogs);
 }

package/node_modules/@comis/cli/dist/wizard/non-interactive.js

@@ -230,6 +230,7 @@ export function buildNonInteractiveState(opts) {
         authMethod: gatewayAuth,
         ...(gatewayToken !== undefined && { token: gatewayToken }),
         ...(gatewayPassword !== undefined && { password: gatewayPassword }),
+        webEnabled: true,
     };
     // Data directory
     const dataDir = opts.dataDir ?? safePath(homedir(), ".comis", "data");

package/node_modules/@comis/cli/dist/wizard/steps/01-detect-existing.js

@@ -68,12 +68,16 @@ function extractStateFromConfig(raw, envRecord = {}) {
             bindMode = "custom";
             customIp = host;
         }
+        // Recover gateway.web.enabled (default true) when reloading existing config
+        const webRaw = gatewayRaw["web"];
+        const webEnabled = webRaw && typeof webRaw["enabled"] === "boolean" ? webRaw["enabled"] : true;
         if (port !== undefined) {
             gateway = {
                 port,
                 bindMode,
                 ...(customIp !== undefined && { customIp }),
                 authMethod: "token",
+                webEnabled,
             };
         }
     }

package/node_modules/@comis/cli/dist/wizard/steps/07-gateway.js

@@ -91,6 +91,14 @@ export const gatewayStep = {
                 },
             });
         }
+        // 5b. Web dashboard prompt
+        const webEnabled = await prompter.confirm({
+            message: "Enable web dashboard? (served at /app/ on the gateway port)",
+            initialValue: state.gateway?.webEnabled ?? true,
+        });
+        if (webEnabled && bindMode === "loopback") {
+            prompter.log.info("Dashboard will bind to 127.0.0.1 only. For remote access, SSH-tunnel: `ssh -L 4766:localhost:4766 user@host`.");
+        }
         // 6. Build config and update state
         const config = {
             port,
@@ -99,6 +107,7 @@ export const gatewayStep = {
             authMethod: authMethod,
             ...(token !== undefined && { token }),
             ...(password !== undefined && { password }),
+            webEnabled,
         };
         return updateState(state, { gateway: config });
     },

package/node_modules/@comis/cli/dist/wizard/steps/10-write-config.js

@@ -96,6 +96,8 @@ function buildConfigObject(state) {
         else if (state.gateway.authMethod === "password") {
             gatewayConfig.password = "${COMIS_GATEWAY_PASSWORD}";
         }
+        // Web dashboard -- default true; wizard always sets this explicitly
+        gatewayConfig.web = { enabled: state.gateway.webEnabled };
         config.gateway = gatewayConfig;
     }
     // Channels section

package/node_modules/@comis/cli/dist/wizard/steps/12-finish.js

@@ -54,6 +54,9 @@ function buildGatewayInfo(state) {
             host = "127.0.0.1";
     }
     const wsLine = `  WebSocket:  ${brand(`ws://${host}:${state.gateway.port}/ws`)}`;
+    const dashboardLine = state.gateway.webEnabled
+        ? `  Dashboard:  ${brand(`http://${host}:${state.gateway.port}/app/`)}`
+        : undefined;
     let authLine;
     if (state.gateway.authMethod === "password") {
         authLine = "  Auth:       Password auth (in ~/.comis/.env)";
@@ -64,8 +67,8 @@ function buildGatewayInfo(state) {
             : "see file";
         authLine = `  Token:      ${tokenPreview} (in ~/.comis/.env)`;
     }
-    const webLine = `  Web App:    ${brand(`http://${host}:${state.gateway.port}`)}`;
-    return `${wsLine}\n${webLine}\n${authLine}`;
+    const lines = [wsLine, dashboardLine, authLine].filter((l) => l !== undefined);
+    return lines.join("\n");
 }
 // ---------- Step Implementation ----------
 export const finishStep = {

package/node_modules/@comis/cli/dist/wizard/types.d.ts

@@ -65,6 +65,7 @@ export type GatewayConfig = {
     authMethod: "token" | "password";
     token?: string;
     password?: string;
+    webEnabled: boolean;
 };
 /** Auth method for providers that support both API keys and OAuth tokens. */
 export type AuthMethod = "apikey" | "oauth";

package/node_modules/@comis/cli/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@comis/cli",
   "private": true,
-  "version": "1.0.15",
+  "version": "1.0.17",
   "author": "Moshe Anconina",
   "license": "Apache-2.0",
   "description": "Command-line interface for the Comis AI agent platform",

package/node_modules/@comis/core/dist/config/schema-agent.d.ts

@@ -737,6 +737,10 @@ export declare const AgentConfigSchema: z.ZodObject<{
         "multi-zone": "multi-zone";
         single: "single";
     }>>;
+    /** Advanced cache optimization options for interactive sessions. */
+    advancedCacheOptimization: z.ZodDefault<z.ZodObject<{
+        enableRecentZonePromotion: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
     /** Gemini explicit cache configuration (CachedContent lifecycle). */
     geminiCache: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
@@ -1102,6 +1106,9 @@ export declare const PerAgentConfigSchema: z.ZodObject<{
         "multi-zone": "multi-zone";
         single: "single";
     }>>;
+    advancedCacheOptimization: z.ZodDefault<z.ZodObject<{
+        enableRecentZonePromotion: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
     geminiCache: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         maxActiveCaches: z.ZodDefault<z.ZodNumber>;
@@ -1773,6 +1780,9 @@ export declare const AgentsMapSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
         "multi-zone": "multi-zone";
         single: "single";
     }>>;
+    advancedCacheOptimization: z.ZodDefault<z.ZodObject<{
+        enableRecentZonePromotion: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
     geminiCache: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         maxActiveCaches: z.ZodDefault<z.ZodNumber>;

package/node_modules/@comis/core/dist/config/schema-agent.js

@@ -574,6 +574,14 @@ export const AgentConfigSchema = z.strictObject({
      *  'auto' resolves to 'single' for direct Anthropic and 'multi-zone' for Bedrock/Vertex.
      *  'multi-zone' places breakpoints across system, tools, and messages. */
     cacheBreakpointStrategy: z.enum(["auto", "multi-zone", "single"]).default("single"),
+    /** Advanced cache optimization options for interactive sessions. */
+    advancedCacheOptimization: z.object({
+        /** When true, the recent-zone message breakpoint may be promoted from
+         *  "short" (5m) to "long" (1h) TTL when observed inter-turn gaps
+         *  consistently exceed 5 minutes. Prevents repeated cache rewrite costs
+         *  in slow-cadence channels like Telegram. Default: true. */
+        enableRecentZonePromotion: z.boolean().default(true),
+    }).default(() => ({ enableRecentZonePromotion: true })),
     /** Gemini explicit cache configuration (CachedContent lifecycle). */
     geminiCache: GeminiCacheConfigSchema.default(() => GeminiCacheConfigSchema.parse({})),
     /** When true, only content inside <final> blocks reaches users (streaming + non-streaming). Default: false. */

package/node_modules/@comis/core/dist/config/schema-gateway.d.ts

@@ -29,9 +29,9 @@ export declare const GatewayTokenSchema: z.ZodObject<{
     /** The secret value (min 32 chars; resolved at runtime if omitted; string or SecretRef) */
     secret: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         source: z.ZodEnum<{
+            env: "env";
             file: "file";
             exec: "exec";
-            env: "env";
         }>;
         provider: z.ZodString;
         id: z.ZodString;
@@ -48,6 +48,15 @@ export declare const GatewayRateLimitSchema: z.ZodObject<{
     /** Maximum requests per window (default: 100) */
     maxRequests: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>;
+/**
+ * Web dashboard configuration. Controls whether the @comis/web SPA is mounted
+ * at /app/* alongside the gateway, sharing the same host/port/auth. When
+ * disabled, the daemon skips /app/*, /api, SSE, and the `/` -> `/app/` redirect.
+ */
+export declare const GatewayWebConfigSchema: z.ZodObject<{
+    /** Enable the web dashboard SPA (default: true) */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
 /**
  * Gateway server configuration schema.
  *
@@ -79,9 +88,9 @@ export declare const GatewayConfigSchema: z.ZodObject<{
         /** The secret value (min 32 chars; resolved at runtime if omitted; string or SecretRef) */
         secret: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             source: z.ZodEnum<{
+                env: "env";
                 file: "file";
                 exec: "exec";
-                env: "env";
             }>;
             provider: z.ZodString;
             id: z.ZodString;
@@ -96,6 +105,11 @@ export declare const GatewayConfigSchema: z.ZodObject<{
         /** Maximum requests per window (default: 100) */
         maxRequests: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>;
+    /** Web dashboard (mounted at /app/*, shares gateway host/port/auth) */
+    web: z.ZodDefault<z.ZodObject<{
+        /** Enable the web dashboard SPA (default: true) */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
     /** Maximum JSON-RPC batch size (default: 50) */
     maxBatchSize: z.ZodDefault<z.ZodNumber>;
     /** WebSocket heartbeat interval in milliseconds (default: 30000) */
@@ -122,3 +136,4 @@ export type GatewayConfig = z.infer<typeof GatewayConfigSchema>;
 export type GatewayTlsConfig = z.infer<typeof GatewayTlsConfigSchema>;
 export type GatewayToken = z.infer<typeof GatewayTokenSchema>;
 export type GatewayRateLimit = z.infer<typeof GatewayRateLimitSchema>;
+export type GatewayWebConfig = z.infer<typeof GatewayWebConfigSchema>;

package/node_modules/@comis/core/dist/config/schema-gateway.js

@@ -42,6 +42,15 @@ export const GatewayRateLimitSchema = z.strictObject({
     /** Maximum requests per window (default: 100) */
     maxRequests: z.number().int().positive().default(100),
 });
+/**
+ * Web dashboard configuration. Controls whether the @comis/web SPA is mounted
+ * at /app/* alongside the gateway, sharing the same host/port/auth. When
+ * disabled, the daemon skips /app/*, /api, SSE, and the `/` -> `/app/` redirect.
+ */
+export const GatewayWebConfigSchema = z.strictObject({
+    /** Enable the web dashboard SPA (default: true) */
+    enabled: z.boolean().default(true),
+});
 /**
  * Gateway server configuration schema.
  *
@@ -61,6 +70,8 @@ export const GatewayConfigSchema = z.strictObject({
     tokens: z.array(GatewayTokenSchema).default([]),
     /** Rate limiting settings */
     rateLimit: GatewayRateLimitSchema.default(() => GatewayRateLimitSchema.parse({})),
+    /** Web dashboard (mounted at /app/*, shares gateway host/port/auth) */
+    web: GatewayWebConfigSchema.default(() => GatewayWebConfigSchema.parse({})),
     /** Maximum JSON-RPC batch size (default: 50) */
     maxBatchSize: z.number().int().positive().default(50),
     /** WebSocket heartbeat interval in milliseconds (default: 30000) */

package/node_modules/@comis/core/dist/config/schema-skills.d.ts

@@ -23,7 +23,14 @@ export declare const PromptSkillsConfigSchema: z.ZodObject<{
  * per-deployment without a rebuild.
  */
 declare const ToolDiscoverySchema: z.ZodObject<{
-    /** Minimum BM25 score to consider a match (BM25-only mode). Default 0.8. */
+    /** Minimum BM25 score as FRACTION OF TOP MATCH (0..1). Default 0.8.
+     *  As of 2026-04-23, BM25 scores are normalized to [0, 1] before this floor
+     *  applies, matching the semantics of minHybridScore. A value of 0.8 means
+     *  "return only tools scoring >= 80% of the top match". Values > 1.0 fail
+     *  validation at config load (stale raw-score overrides would produce zero
+     *  matches under the new normalized semantics; fail-fast surfaces the
+     *  error immediately per AGENTS.md §3.4). See design §5.6:
+     *  .planning/design/discover-tools-bm25-fallback-fix.md */
     minBm25Score: z.ZodDefault<z.ZodNumber>;
     /** Minimum combined score (0..1 normalized) for hybrid mode. Default 0.35. */
     minHybridScore: z.ZodDefault<z.ZodNumber>;
@@ -115,7 +122,14 @@ export declare const SkillsConfigSchema: z.ZodObject<{
     }, z.core.$strict>>;
     /** discover_tools score-floor thresholds (BM25 + hybrid). */
     toolDiscovery: z.ZodDefault<z.ZodObject<{
-        /** Minimum BM25 score to consider a match (BM25-only mode). Default 0.8. */
+        /** Minimum BM25 score as FRACTION OF TOP MATCH (0..1). Default 0.8.
+         *  As of 2026-04-23, BM25 scores are normalized to [0, 1] before this floor
+         *  applies, matching the semantics of minHybridScore. A value of 0.8 means
+         *  "return only tools scoring >= 80% of the top match". Values > 1.0 fail
+         *  validation at config load (stale raw-score overrides would produce zero
+         *  matches under the new normalized semantics; fail-fast surfaces the
+         *  error immediately per AGENTS.md §3.4). See design §5.6:
+         *  .planning/design/discover-tools-bm25-fallback-fix.md */
         minBm25Score: z.ZodDefault<z.ZodNumber>;
         /** Minimum combined score (0..1 normalized) for hybrid mode. Default 0.35. */
         minHybridScore: z.ZodDefault<z.ZodNumber>;

package/node_modules/@comis/core/dist/config/schema-skills.js

@@ -93,8 +93,15 @@ const ExecSandboxSchema = z.strictObject({
  * per-deployment without a rebuild.
  */
 const ToolDiscoverySchema = z.strictObject({
-    /** Minimum BM25 score to consider a match (BM25-only mode). Default 0.8. */
-    minBm25Score: z.number().min(0).default(0.8),
+    /** Minimum BM25 score as FRACTION OF TOP MATCH (0..1). Default 0.8.
+     *  As of 2026-04-23, BM25 scores are normalized to [0, 1] before this floor
+     *  applies, matching the semantics of minHybridScore. A value of 0.8 means
+     *  "return only tools scoring >= 80% of the top match". Values > 1.0 fail
+     *  validation at config load (stale raw-score overrides would produce zero
+     *  matches under the new normalized semantics; fail-fast surfaces the
+     *  error immediately per AGENTS.md §3.4). See design §5.6:
+     *  .planning/design/discover-tools-bm25-fallback-fix.md */
+    minBm25Score: z.number().min(0).max(1).default(0.8),
     /** Minimum combined score (0..1 normalized) for hybrid mode. Default 0.35. */
     minHybridScore: z.number().min(0).max(1).default(0.35),
 });