@bike4mind/cli 0.2.20-feat-web-fetch-tool.18049 → 0.2.20-feat-cli-smart-stream-logging.18065

package/bin/bike4mind-cli.mjs

@@ -36,6 +36,11 @@ const argv = await yargs(hideBin(process.argv))
     description: 'Show debug logs in console',
     default: false,
   })
+  .option('debug-stream', {
+    type: 'boolean',
+    description: 'Ultra-verbose: log every SSE event (for debugging stream parser)',
+    default: false,
+  })
   .option('no-project-config', {
     type: 'boolean',
     description: 'Disable loading project-specific configuration (.bike4mind/)',
@@ -94,6 +99,11 @@ if (argv.verbose) {
   process.env.B4M_VERBOSE = '1';
   process.env.LOG_LEVEL = 'debug'; // Enable debug logs in core packages
 }
+if (argv['debug-stream']) {
+  process.env.B4M_DEBUG_STREAM = '1';
+  process.env.B4M_VERBOSE = '1'; // Ultra-verbose implies verbose
+  process.env.LOG_LEVEL = 'debug';
+}
 if (argv['no-project-config']) {
   process.env.B4M_NO_PROJECT_CONFIG = '1';
 }

package/dist/{artifactExtractor-HVF42WXK.js → artifactExtractor-4EVH663R.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   CurationArtifactType
-} from "./chunk-T5NXFTZC.js";
+} from "./chunk-DTPBHKQL.js";
 
 // ../../b4m-core/packages/services/dist/src/notebookCurationService/artifactExtractor.js
 var ARTIFACT_TAG_REGEX = /<artifact\s+(.*?)>([\s\S]*?)<\/artifact>/gi;

package/dist/{chunk-V2UQMO2S.js → chunk-AKCBPXLX.js}

@@ -7,11 +7,11 @@ import {
   getSettingsMap,
   getSettingsValue,
   secureParameters
-} from "./chunk-VAFY6X3M.js";
+} from "./chunk-EP4OGIQI.js";
 import {
   KnowledgeType,
   SupportedFabFileMimeTypes
-} from "./chunk-T5NXFTZC.js";
+} from "./chunk-DTPBHKQL.js";
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/create.js
 import { z } from "zod";

package/dist/{chunk-T5NXFTZC.js → chunk-DTPBHKQL.js}

@@ -209,7 +209,6 @@ var b4mLLMTools = z3.enum([
   "edit_image",
   "weather_info",
   "web_search",
-  "web_fetch",
   "math_evaluate",
   "mermaid_chart",
   "current_datetime",
@@ -4667,8 +4666,66 @@ function formatPageList(pagesResponse, siteUrl) {
     results
   };
 }
+function formatPageRestrictions(restrictionsResponse, pageId) {
+  if (!restrictionsResponse || typeof restrictionsResponse !== "object" || restrictionsResponse.error) {
+    return {
+      pageId,
+      hasRestrictions: false,
+      restrictions: []
+    };
+  }
+  const restrictions = [];
+  const operationsMap = {};
+  if (Array.isArray(restrictionsResponse.results)) {
+    for (const item of restrictionsResponse.results) {
+      if (item.operation && item.restrictions) {
+        operationsMap[item.operation] = item;
+      }
+    }
+  } else {
+    for (const operation of RESTRICTION_OPERATIONS) {
+      if (restrictionsResponse[operation]) {
+        operationsMap[operation] = restrictionsResponse[operation];
+      }
+    }
+  }
+  for (const [operation, opData] of Object.entries(operationsMap)) {
+    if (!opData?.restrictions)
+      continue;
+    const subjects = [];
+    const users = opData.restrictions.user?.results || opData.restrictions.user || [];
+    for (const user of users) {
+      subjects.push({
+        type: "user",
+        identifier: user.accountId || user.username || user.key,
+        displayName: user.displayName || user.publicName
+      });
+    }
+    const groups = opData.restrictions.group?.results || opData.restrictions.group || [];
+    for (const group of groups) {
+      subjects.push({
+        type: "group",
+        identifier: group.name || group.id,
+        displayName: group.name
+      });
+    }
+    if (subjects.length > 0) {
+      restrictions.push({
+        operation,
+        subjects
+      });
+    }
+  }
+  return {
+    pageId,
+    hasRestrictions: restrictions.length > 0,
+    restrictions
+  };
+}
 
 // ../../b4m-core/packages/common/dist/src/confluence/api.js
+var RESTRICTION_OPERATIONS = ["read", "update"];
+var RESTRICTION_SUBJECT_TYPES = ["user", "group"];
 var ConfluenceApi = class {
   config;
   constructor(config) {
@@ -4735,11 +4792,15 @@ var ConfluenceApi = class {
     if (response.status === 204) {
       return void 0;
     }
+    const responseText = await response.text();
+    if (!responseText || responseText.trim() === "") {
+      return void 0;
+    }
     const contentType = response.headers.get("content-type") || "";
     if (contentType.includes("application/json")) {
-      return await response.json();
+      return JSON.parse(responseText);
     }
-    return await response.text();
+    return responseText;
   }
   /**
    * Make v1 API request
@@ -4942,6 +5003,17 @@ var ConfluenceApi = class {
     }
     return formatSpaceResponse(results[0], this.config.siteUrl);
   }
+  /**
+   * Get details about a specific Confluence space by ID (v2 API)
+   */
+  async getSpaceById(params) {
+    const { spaceId } = params;
+    if (!spaceId) {
+      throw new Error("spaceId is required to fetch space details.");
+    }
+    const space = await this.get(`/spaces/${spaceId}`);
+    return formatSpaceResponse(space, this.config.siteUrl);
+  }
   /**
    * Get child pages for a given page
    */
@@ -5177,6 +5249,161 @@ var ConfluenceApi = class {
       throw error;
     }
   }
+  // ============================================================================
+  // Page Restrictions API (v1)
+  // ============================================================================
+  /**
+   * Validate that a user exists by account ID
+   * @throws Error if user does not exist
+   */
+  async validateUserExists(accountId) {
+    try {
+      const user = await this.getV1("/user", { accountId });
+      if (!user || user.error) {
+        throw new Error(`User with account ID "${accountId}" not found.`);
+      }
+      return {
+        accountId: user.accountId,
+        displayName: user.displayName || user.publicName || accountId
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("not found")) {
+        throw error;
+      }
+      throw new Error(`User with account ID "${accountId}" not found or access denied.`);
+    }
+  }
+  /**
+   * Validate that a group exists by name
+   * @throws Error if group does not exist
+   */
+  async validateGroupExists(groupName) {
+    try {
+      const group = await this.getV1(`/group/${encodeURIComponent(groupName)}`);
+      if (!group || group.error) {
+        throw new Error(`Group "${groupName}" not found.`);
+      }
+      return { name: group.name || groupName };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("not found")) {
+        throw error;
+      }
+      throw new Error(`Group "${groupName}" not found or access denied.`);
+    }
+  }
+  /**
+   * Get current restrictions for a Confluence page
+   */
+  async getPageRestrictions(params) {
+    const { pageId } = params;
+    if (!pageId) {
+      throw new Error("pageId is required to get page restrictions.");
+    }
+    const result = await this.getV1(`/content/${pageId}/restriction`, {
+      expand: "restrictions.user,restrictions.group"
+    });
+    return formatPageRestrictions(result, pageId);
+  }
+  /**
+   * Add a restriction to a Confluence page
+   * Validates that the user/group exists before applying the restriction.
+   * Automatically includes the current user in restrictions to prevent self-lockout.
+   */
+  async addPageRestriction(params) {
+    const { pageId, operation, restrictionType, subject, skipValidation = false } = params;
+    if (!pageId || !operation || !restrictionType || !subject) {
+      throw new Error("pageId, operation, restrictionType, and subject are required to add a page restriction.");
+    }
+    let subjectDisplayName;
+    if (!skipValidation) {
+      if (restrictionType === "user") {
+        const userInfo = await this.validateUserExists(subject);
+        subjectDisplayName = userInfo.displayName;
+      } else {
+        const groupInfo = await this.validateGroupExists(subject);
+        subjectDisplayName = groupInfo.name;
+      }
+    }
+    const currentUser = await this.getCurrentUser();
+    const currentUserAccountId = currentUser.accountId;
+    if (!currentUserAccountId) {
+      throw new Error("Unable to determine current user account ID. Cannot add restrictions safely.");
+    }
+    const userList = [];
+    userList.push({ accountId: currentUserAccountId });
+    if (restrictionType === "user" && subject !== currentUserAccountId) {
+      userList.push({ accountId: subject });
+    }
+    const restrictionPayload = [
+      {
+        operation,
+        restrictions: {
+          user: userList,
+          ...restrictionType === "group" ? { group: [{ name: subject }] } : {}
+        }
+      }
+    ];
+    await this.postV1(`/content/${pageId}/restriction`, restrictionPayload);
+    return {
+      success: true,
+      pageId,
+      operation,
+      restrictionType,
+      subject,
+      subjectDisplayName
+    };
+  }
+  /**
+   * Remove a restriction from a Confluence page
+   * First checks if the restriction exists to avoid 404 errors
+   */
+  async removePageRestriction(params) {
+    const { pageId, operation, restrictionType, subject } = params;
+    if (!pageId || !operation || !restrictionType || !subject) {
+      throw new Error("pageId, operation, restrictionType, and subject are required to remove a page restriction.");
+    }
+    const currentRestrictions = await this.getPageRestrictions({ pageId });
+    const operationRestriction = currentRestrictions.restrictions.find((r) => r.operation === operation);
+    if (!operationRestriction) {
+      return {
+        success: true,
+        pageId,
+        operation,
+        restrictionType,
+        subject,
+        skipped: true,
+        message: `No ${operation} restrictions exist on this page.`
+      };
+    }
+    const subjectExists = operationRestriction.subjects.some((s) => s.type === restrictionType && s.identifier === subject);
+    if (!subjectExists) {
+      return {
+        success: true,
+        pageId,
+        operation,
+        restrictionType,
+        subject,
+        skipped: true,
+        message: `Restriction for ${restrictionType} "${subject}" on ${operation} operation does not exist.`
+      };
+    }
+    let deletePath;
+    let deleteQuery;
+    if (restrictionType === "user") {
+      deletePath = `/content/${pageId}/restriction/byOperation/${operation}/user`;
+      deleteQuery = { accountId: subject };
+    } else {
+      deletePath = `/content/${pageId}/restriction/byOperation/${operation}/group/${encodeURIComponent(subject)}`;
+    }
+    await this.request("DELETE", deletePath, { query: deleteQuery, useV1: true });
+    return {
+      success: true,
+      pageId,
+      operation,
+      restrictionType,
+      subject
+    };
+  }
 };
 
 // ../../b4m-core/packages/common/dist/src/jira/format.js
@@ -6836,6 +7063,8 @@ export {
   extractSnippetMeta,
   searchSchema,
   LinkedInApi,
+  RESTRICTION_OPERATIONS,
+  RESTRICTION_SUBJECT_TYPES,
   ConfluenceApi,
   formatIssueResponse,
   formatProjectResponse,

package/dist/{chunk-VAFY6X3M.js → chunk-EP4OGIQI.js}

@@ -13,7 +13,7 @@ import {
   dayjsConfig_default,
   extractSnippetMeta,
   settingsMap
-} from "./chunk-T5NXFTZC.js";
+} from "./chunk-DTPBHKQL.js";
 import {
   Logger
 } from "./chunk-OCYRD7D6.js";
@@ -205,7 +205,8 @@ function obfuscateApiKey(apiKey) {
 }
 
 // ../../b4m-core/packages/utils/dist/src/llm/anthropicBackend.js
-import { Anthropic } from "@anthropic-ai/sdk";
+import { Anthropic, RateLimitError } from "@anthropic-ai/sdk";
+import { CloudWatchClient, PutMetricDataCommand, StandardUnit } from "@aws-sdk/client-cloudwatch";
 
 // ../../b4m-core/packages/utils/dist/src/llm/backend.js
 var DEFAULT_MAX_TOOL_CALLS = 10;
@@ -1952,9 +1953,44 @@ var AnthropicBackend = class {
   isThinkingEnabled = false;
   // Track if thinking is enabled for current request
   constructor(apiKey, logger) {
-    this._api = new Anthropic({ apiKey });
+    this._api = new Anthropic({ apiKey, maxRetries: 5 });
     this.logger = logger ?? new Logger();
   }
+  /**
+   * Emit a CloudWatch metric when a rate limit error occurs.
+   * This helps monitor and alert on Anthropic API rate limiting issues.
+   */
+  async emitRateLimitMetric(model) {
+    try {
+      const client = new CloudWatchClient({
+        region: process.env.AWS_REGION || "us-east-2"
+      });
+      const command = new PutMetricDataCommand({
+        Namespace: "Lumina5/AnthropicAPI",
+        MetricData: [
+          {
+            MetricName: "RateLimitError",
+            Value: 1,
+            Unit: StandardUnit.Count,
+            Timestamp: /* @__PURE__ */ new Date(),
+            Dimensions: [
+              { Name: "Model", Value: model },
+              // SEED_STAGE_NAME is set via DEFAULT_LAMBDA_ENVIRONMENT in infra/constants.ts
+              // and maps to $app.stage. The alarm in infra/alarms.ts filters by Stage dimension.
+              // Fallback to 'local' for non-Lambda contexts (local dev, tests).
+              { Name: "Stage", Value: process.env.SEED_STAGE_NAME || "local" }
+            ]
+          }
+        ]
+      });
+      await client.send(command);
+      this.logger.info("[AnthropicBackend] Emitted RateLimitError metric to CloudWatch", { model });
+    } catch (metricsError) {
+      this.logger.warn("[AnthropicBackend] Failed to emit CloudWatch metric", {
+        error: metricsError instanceof Error ? metricsError.message : String(metricsError)
+      });
+    }
+  }
   /**
    * Get thinking blocks from the last assistant content.
    * Filters to only include thinking/redacted_thinking blocks.
@@ -2368,6 +2404,13 @@ var AnthropicBackend = class {
             }
             const hasToolsToExecute = func.some((f) => f && f.name);
             if (!hasToolsToExecute) {
+              if (options.tools && options.tools.length > 0) {
+                const mcpToolCount = options.tools.filter((t) => t._isMcpTool).length;
+                const hasContent = collectedContent.some((c) => c?.type === "text" && c?.text?.trim());
+                if (!hasContent && mcpToolCount > 0) {
+                  this.logger.warn(`\u26A0\uFE0F [AnthropicBackend] Model returned empty content with ${mcpToolCount} MCP tools available. Total tools: ${options.tools.length}. This may indicate tool overload or model confusion.`);
+                }
+              }
               await cb([], { toolsUsed });
             }
             resolve();
@@ -2523,7 +2566,17 @@ var AnthropicBackend = class {
         }
       }
     } catch (error) {
-      this.logger.debug("Error in complete:", error);
+      if (error instanceof RateLimitError) {
+        this.logger.error("[AnthropicBackend] Rate limit error after all retries exhausted", {
+          model,
+          status: error.status,
+          message: error.message
+        });
+        this.emitRateLimitMetric(model).catch(() => {
+        });
+      } else {
+        this.logger.debug("Error in complete:", error);
+      }
       throw error;
     }
   }

package/dist/{chunk-NAZHGW73.js → chunk-RRYX2K7W.js}

@@ -6,12 +6,12 @@ import {
   getSettingsByNames,
   obfuscateApiKey,
   secureParameters
-} from "./chunk-VAFY6X3M.js";
+} from "./chunk-EP4OGIQI.js";
 import {
   ApiKeyType,
   MementoTier,
   isSupportedEmbeddingModel
-} from "./chunk-T5NXFTZC.js";
+} from "./chunk-DTPBHKQL.js";
 
 // ../../b4m-core/packages/services/dist/src/apiKeyService/get.js
 import { z } from "zod";

package/dist/{chunk-W5U65OA2.js → chunk-XWI42ILN.js}

@@ -2,7 +2,7 @@
 import {
   BadRequestError,
   secureParameters
-} from "./chunk-VAFY6X3M.js";
+} from "./chunk-EP4OGIQI.js";
 import {
   CompletionApiUsageTransaction,
   GenericCreditDeductTransaction,
@@ -11,7 +11,7 @@ import {
   RealtimeVoiceUsageTransaction,
   TextGenerationUsageTransaction,
   TransferCreditTransaction
-} from "./chunk-T5NXFTZC.js";
+} from "./chunk-DTPBHKQL.js";
 
 // ../../b4m-core/packages/services/dist/src/creditService/subtractCredits.js
 import { z } from "zod";

package/dist/{create-2H5YR4KE.js → create-KAKBAGES.js}

@@ -2,9 +2,9 @@
 import {
   createFabFile,
   createFabFileSchema
-} from "./chunk-V2UQMO2S.js";
-import "./chunk-VAFY6X3M.js";
-import "./chunk-T5NXFTZC.js";
+} from "./chunk-AKCBPXLX.js";
+import "./chunk-EP4OGIQI.js";
+import "./chunk-DTPBHKQL.js";
 import "./chunk-OCYRD7D6.js";
 export {
   createFabFile,

package/dist/index.js

@@ -4,12 +4,12 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-NAZHGW73.js";
+} from "./chunk-RRYX2K7W.js";
 import {
   ConfigStore
 } from "./chunk-VFQF2JIT.js";
-import "./chunk-W5U65OA2.js";
-import "./chunk-V2UQMO2S.js";
+import "./chunk-XWI42ILN.js";
+import "./chunk-AKCBPXLX.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -21,7 +21,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-VAFY6X3M.js";
+} from "./chunk-EP4OGIQI.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -75,7 +75,7 @@ import {
   XAI_IMAGE_MODELS,
   b4mLLMTools,
   getMcpProviderMetadata
-} from "./chunk-T5NXFTZC.js";
+} from "./chunk-DTPBHKQL.js";
 import {
   Logger
 } from "./chunk-OCYRD7D6.js";
@@ -5608,7 +5608,7 @@ var webSearchTool = {
     },
     toolSchema: {
       name: "web_search",
-      description: "Search the web using Google Search API to FIND pages about a topic. Use this when you need to find URLs or search for information. DO NOT use this if the user provides a specific URL - use web_fetch instead to read the full content.",
+      description: "Search the web using Google Search API",
       parameters: {
         type: "object",
         properties: {
@@ -5629,109 +5629,6 @@ var webSearchTool = {
   })
 };
 
-// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/webfetch/index.js
-import FirecrawlApp2 from "@mendable/firecrawl-js";
-async function firecrawlFetch(adapters, url) {
-  const urlPattern = /^https?:\/\/.+/i;
-  if (!urlPattern.test(url)) {
-    throw new Error(`Invalid URL format: ${url}. URL must start with http:// or https://`);
-  }
-  const apiKeySetting = await adapters.db.adminSettings.findBySettingName("FirecrawlApiKey");
-  if (!apiKeySetting?.settingValue) {
-    console.error("\u274C WebFetch Tool: Firecrawl API key not configured");
-    throw new Error("Firecrawl API key not configured");
-  }
-  const app = new FirecrawlApp2({ apiKey: apiKeySetting.settingValue });
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 6e4);
-  try {
-    console.log("\u{1F4E5} WebFetch Tool: Scraping URL with Firecrawl...");
-    const result = await app.scrapeUrl(url, {
-      formats: ["markdown"],
-      actions: [
-        {
-          type: "wait",
-          milliseconds: 1e3
-          // Wait for JavaScript to execute
-        }
-      ]
-    });
-    clearTimeout(timeoutId);
-    if (!result || result.error) {
-      const errorMessage = result?.error || "Unknown error";
-      console.error("\u274C WebFetch Tool: Firecrawl error:", errorMessage);
-      throw new Error(`Failed to fetch content from URL: ${errorMessage}`);
-    }
-    if (!("markdown" in result) || !result.markdown) {
-      console.error("\u274C WebFetch Tool: No markdown content returned");
-      throw new Error("No content could be extracted from the URL");
-    }
-    const markdown = result.markdown.slice(0, 5e4);
-    console.log(`\u{1F4C4} WebFetch Tool: Extracted ${markdown.length} characters of content`);
-    return {
-      markdown,
-      title: result.metadata?.title
-    };
-  } catch (error) {
-    clearTimeout(timeoutId);
-    throw error;
-  }
-}
-var webFetchTool = {
-  name: "web_fetch",
-  implementation: (context) => ({
-    toolFn: async (value) => {
-      const params = value;
-      console.log("\u{1F310} WebFetch Tool: Starting fetch for URL:", params.url);
-      try {
-        await context.statusUpdate({}, `Fetching content from ${params.url}...`);
-        const result = await firecrawlFetch({ db: context.db }, params.url);
-        const citable = {
-          id: params.url,
-          type: "web_url",
-          title: result.title || params.url,
-          url: params.url,
-          description: result.markdown.slice(0, 200) + (result.markdown.length > 200 ? "..." : ""),
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          status: "complete",
-          metadata: {
-            sourceSystem: "web_fetch",
-            contentLength: result.markdown.length
-          }
-        };
-        await context.statusUpdate({
-          promptMeta: {
-            citables: [citable]
-          }
-        }, "WebFetch completed successfully");
-        console.log(`\u{1F4DA} WebFetch Tool: Stored citable source for ${params.url}`);
-        return result.markdown;
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        console.error("\u274C WebFetch Tool: Error during fetch:", error);
-        await context.statusUpdate({}, `WebFetch failed: ${errorMessage}`);
-        context.logger.error("WebFetch error:", error);
-        throw error;
-      }
-    },
-    toolSchema: {
-      name: "web_fetch",
-      description: 'Fetches and reads the FULL CONTENT of a specific URL that the user provides. Use this when the user gives you a direct URL link (e.g., "fetch https://example.com", "read this article https://...", "summarize the content at https://..."). This tool downloads the entire page content and converts it to markdown for you to read. You can then answer questions, summarize, or extract information from the content yourself. DO NOT use web_search when the user provides a specific URL - always use web_fetch instead.',
-      parameters: {
-        type: "object",
-        properties: {
-          url: {
-            type: "string",
-            format: "uri",
-            description: "The URL to fetch content from (must be http or https)"
-          }
-        },
-        required: ["url"]
-      }
-    }
-  })
-};
-
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/math/index.js
 import { create as create6, all } from "mathjs";
 var math = create6(all, {
@@ -9631,7 +9528,6 @@ var tools = {
   image_generation: imageGenerationTool,
   edit_image: imageEditTool,
   web_search: webSearchTool,
-  web_fetch: webFetchTool,
   math_evaluate: mathTool,
   mermaid_chart: mermaidChartTool,
   current_datetime: currentDateTimeTool,
@@ -10247,14 +10143,14 @@ var ServerToolExecutor = class {
       const errorMessage = err?.response?.data?.error || err?.message || "Unknown error";
       const status = err?.response?.status || "unknown";
       logger.error(`[ServerToolExecutor] Request failed for ${toolName}: ${errorMessage} (status: ${status})`);
-      logger.debug(`[ServerToolExecutor] Full error: ${JSON.stringify(err, null, 2)}`);
+      logger.error(`[ServerToolExecutor] Full error: ${JSON.stringify(err, null, 2)}`);
       return `Error executing ${toolName}: ${errorMessage}`;
     }
   }
 };
 
 // src/llm/ToolRouter.ts
-var SERVER_TOOLS = ["weather_info", "web_search", "web_fetch"];
+var SERVER_TOOLS = ["weather_info", "web_search"];
 var LOCAL_TOOLS = [
   "file_read",
   "create_file",
@@ -10723,8 +10619,7 @@ function generateCliTools(userId, llm, model, permissionManager, showPermissionP
     // Server-side tools (executed via /api/ai/v1/tools Lambda)
     // Routed by ToolRouter to use B4M company API keys
     weather_info: {},
-    web_search: {},
-    web_fetch: {}
+    web_search: {}
     // Disable web-only tools
     // blog_publish: undefined,
     // blog_edit: undefined,
@@ -11615,6 +11510,169 @@ var MessageBuilder = class {
 // src/llm/ServerLlmBackend.ts
 import { createParser } from "eventsource-parser";
 import { isAxiosError } from "axios";
+
+// src/utils/StreamLogger.ts
+var StreamLogger = class _StreamLogger {
+  constructor(logger2, context, verbose = false, ultraVerbose = false) {
+    // State tracking
+    this.startEventNum = 0;
+    this.currentEventNum = 0;
+    this.lastLoggedLength = 0;
+    this.totalLength = 0;
+    this.lastLogTime = 0;
+    this.streamStartTime = 0;
+    this.lastPreview = "";
+    this.logger = logger2;
+    this.context = context;
+    this.verbose = verbose;
+    this.ultraVerbose = ultraVerbose;
+  }
+  static {
+    // Configuration thresholds
+    this.CHAR_THRESHOLD = 200;
+  }
+  static {
+    this.TIME_THRESHOLD_MS = 500;
+  }
+  static {
+    this.PREVIEW_LENGTH = 30;
+  }
+  static {
+    this.MAX_FULL_TEXT_LENGTH = 1e4;
+  }
+  /**
+   * Called when stream starts
+   */
+  streamStart() {
+    this.streamStartTime = Date.now();
+    this.lastLogTime = this.streamStartTime;
+    this.startEventNum = 0;
+    this.currentEventNum = 0;
+    this.lastLoggedLength = 0;
+    this.totalLength = 0;
+    this.lastPreview = "";
+    this.logger.debug(`[${this.context}] Stream started`);
+  }
+  /**
+   * Called on each SSE event
+   */
+  onEvent(eventNum, eventData) {
+    this.currentEventNum = eventNum;
+    if (this.ultraVerbose) {
+      this.logger.debug(`[${this.context}] SSE event #${eventNum}, data: ${eventData.substring(0, 100)}`);
+    }
+  }
+  /**
+   * Called when content is accumulated
+   */
+  onContent(eventNum, textChunk, totalAccumulated) {
+    this.currentEventNum = eventNum;
+    this.totalLength = totalAccumulated.length;
+    const rawPreview = totalAccumulated.slice(-_StreamLogger.PREVIEW_LENGTH);
+    this.lastPreview = this.sanitizePreview(rawPreview);
+    if (this.ultraVerbose) {
+      this.logger.debug(`[${this.context}] Content event #${eventNum}, chunk: "${textChunk}"`);
+      this.logger.debug(`[${this.context}] Accumulated text length: ${this.totalLength}`);
+      return;
+    }
+    if (!this.verbose) {
+      return;
+    }
+    const charsDelta = this.totalLength - this.lastLoggedLength;
+    const timeDelta = Date.now() - this.lastLogTime;
+    if (charsDelta >= _StreamLogger.CHAR_THRESHOLD || timeDelta >= _StreamLogger.TIME_THRESHOLD_MS) {
+      this.flushBatch();
+    }
+  }
+  /**
+   * Called for non-content events (tool_use, errors, etc.)
+   * These are always logged immediately (critical events)
+   */
+  onCriticalEvent(eventNum, eventType, description) {
+    this.currentEventNum = eventNum;
+    if (this.verbose && !this.ultraVerbose) {
+      const charsDelta = this.totalLength - this.lastLoggedLength;
+      if (charsDelta > 0) {
+        this.flushBatch();
+      }
+    }
+    this.logger.debug(`[${this.context}] ${eventType} event #${eventNum}: ${description}`);
+  }
+  /**
+   * Called when stream completes
+   */
+  streamComplete(totalText) {
+    if (this.verbose && !this.ultraVerbose) {
+      const charsDelta = this.totalLength - this.lastLoggedLength;
+      if (charsDelta > 0) {
+        this.flushBatch();
+      }
+    }
+    const totalTime = Date.now() - this.streamStartTime;
+    this.logger.debug(
+      `[${this.context}] Stream complete: ${this.currentEventNum} events, ${this.totalLength} chars, ${(totalTime / 1e3).toFixed(2)}s`
+    );
+    if (totalText.length > _StreamLogger.MAX_FULL_TEXT_LENGTH) {
+      const truncated = totalText.substring(0, _StreamLogger.MAX_FULL_TEXT_LENGTH);
+      this.logger.debug(
+        `[${this.context}] Full text (truncated to ${_StreamLogger.MAX_FULL_TEXT_LENGTH} chars):
+${truncated}
+... [+${totalText.length - _StreamLogger.MAX_FULL_TEXT_LENGTH} more chars]`
+      );
+    } else if (totalText.length > 0) {
+      this.logger.debug(`[${this.context}] Full text:
+${totalText}`);
+    }
+  }
+  /**
+   * Called when stream fails
+   */
+  streamError(error) {
+    if (this.verbose && !this.ultraVerbose) {
+      const charsDelta = this.totalLength - this.lastLoggedLength;
+      if (charsDelta > 0) {
+        this.flushBatch();
+      }
+    }
+    this.logger.error(`[${this.context}] Stream error:`, error);
+  }
+  /**
+   * Flush the current batch to console
+   */
+  flushBatch() {
+    const charsDelta = this.totalLength - this.lastLoggedLength;
+    const timeDelta = Date.now() - this.lastLogTime;
+    const eventRange = this.startEventNum === this.currentEventNum ? `#${this.currentEventNum}` : `#${this.startEventNum}-${this.currentEventNum}`;
+    const preview = this.lastPreview.length > 0 ? ` "...${this.lastPreview}"` : "";
+    this.logger.debug(
+      `[${this.context}] Streaming... events ${eventRange}, ${this.totalLength} chars (+${charsDelta}, ${(timeDelta / 1e3).toFixed(1)}s)${preview}`
+    );
+    this.lastLoggedLength = this.totalLength;
+    this.lastLogTime = Date.now();
+    this.startEventNum = this.currentEventNum + 1;
+  }
+  /**
+   * Sanitize preview text for single-line display
+   * Replaces newlines and control characters with spaces
+   */
+  sanitizePreview(text) {
+    return text.replace(/[\r\n\t]/g, " ").replace(/\s+/g, " ");
+  }
+  /**
+   * Reset state for new stream
+   */
+  reset() {
+    this.startEventNum = 0;
+    this.currentEventNum = 0;
+    this.lastLoggedLength = 0;
+    this.totalLength = 0;
+    this.lastLogTime = 0;
+    this.streamStartTime = 0;
+    this.lastPreview = "";
+  }
+};
+
+// src/llm/ServerLlmBackend.ts
 function stripThinkingBlocks(text) {
   return text.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
 }
@@ -11639,6 +11697,10 @@ var ServerLlmBackend = class {
         logger.debug("[ServerLlmBackend] Making streaming request...");
         const response = await this.makeStreamingRequest(model, messages, options);
         logger.debug("[ServerLlmBackend] Got response, setting up SSE parser");
+        const isVerbose = process.env.B4M_VERBOSE === "1";
+        const isUltraVerbose = process.env.B4M_DEBUG_STREAM === "1";
+        const streamLogger = new StreamLogger(logger, "ServerLlmBackend", isVerbose, isUltraVerbose);
+        streamLogger.streamStart();
         let eventCount = 0;
         let accumulatedText = "";
         let lastUsageInfo = {};
@@ -11648,12 +11710,13 @@ var ServerLlmBackend = class {
         const parser = createParser({
           onEvent: (event) => {
             eventCount++;
-            logger.debug(`[ServerLlmBackend] SSE event #${eventCount}, data: ${event.data?.substring(0, 100)}`);
+            streamLogger.onEvent(eventCount, event.data || "");
             const data = event.data;
             if (data === "[DONE]") {
               receivedDone = true;
-              logger.debug(`[ServerLlmBackend] Received [DONE], accumulated text length: ${accumulatedText.length}`);
+              streamLogger.onCriticalEvent(eventCount, "[DONE]", `accumulated text length: ${accumulatedText.length}`);
               const cleanedText = stripThinkingBlocks(accumulatedText);
+              streamLogger.streamComplete(accumulatedText);
               if (toolsUsed.length > 0) {
                 const info = {
                   toolsUsed,
@@ -11682,9 +11745,8 @@ var ServerLlmBackend = class {
             }
             try {
               const parsed = JSON.parse(data);
-              logger.debug(`[ServerLlmBackend] Parsed event type: ${parsed.type}`);
               if (parsed.type === "error") {
-                logger.error("[ServerLlmBackend] Error event:", parsed);
+                streamLogger.onCriticalEvent(eventCount, "ERROR", parsed.message || "Server error");
                 reject(new Error(parsed.message || "Server error"));
                 return;
               }
@@ -11697,9 +11759,9 @@ var ServerLlmBackend = class {
                     outputTokens: parsed.usage.outputTokens
                   };
                 }
-                logger.debug(`[ServerLlmBackend] Accumulated text length: ${accumulatedText.length}`);
+                streamLogger.onContent(eventCount, textChunk, accumulatedText);
               } else if (parsed.type === "tool_use") {
-                logger.debug(`[ServerLlmBackend] Tool use event, tools: ${parsed.tools?.length}`);
+                streamLogger.onCriticalEvent(eventCount, "TOOL_USE", `tools: ${parsed.tools?.length}`);
                 if (parsed.tools && parsed.tools.length > 0) {
                   for (const tool of parsed.tools) {
                     logger.debug(`TOOL REQUEST: ${tool.name}`);
@@ -11720,7 +11782,7 @@ var ServerLlmBackend = class {
                 }
                 if (parsed.thinking && parsed.thinking.length > 0) {
                   thinkingBlocks = parsed.thinking;
-                  logger.debug(`[ServerLlmBackend] Received ${thinkingBlocks.length} thinking blocks`);
+                  streamLogger.onCriticalEvent(eventCount, "THINKING", `${thinkingBlocks.length} thinking blocks`);
                 }
                 if (parsed.usage) {
                   lastUsageInfo = {
@@ -11730,7 +11792,7 @@ var ServerLlmBackend = class {
                 }
               }
             } catch (parseError) {
-              logger.error("[ServerLlmBackend] Failed to parse SSE event:", parseError);
+              streamLogger.streamError(parseError);
             }
           }
         });
@@ -12078,7 +12140,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.20-feat-web-fetch-tool.18049+39c7dfb4d",
+  version: "0.2.20-feat-cli-smart-stream-logging.18065+d52838015",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -12185,10 +12247,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.44.1-feat-web-fetch-tool.18049+39c7dfb4d",
-    "@bike4mind/mcp": "1.24.1-feat-web-fetch-tool.18049+39c7dfb4d",
-    "@bike4mind/services": "2.42.1-feat-web-fetch-tool.18049+39c7dfb4d",
-    "@bike4mind/utils": "2.2.2-feat-web-fetch-tool.18049+39c7dfb4d",
+    "@bike4mind/common": "2.44.1-feat-cli-smart-stream-logging.18065+d52838015",
+    "@bike4mind/mcp": "1.24.1-feat-cli-smart-stream-logging.18065+d52838015",
+    "@bike4mind/services": "2.42.1-feat-cli-smart-stream-logging.18065+d52838015",
+    "@bike4mind/utils": "2.2.2-feat-cli-smart-stream-logging.18065+d52838015",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -12205,7 +12267,7 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.0"
   },
-  gitHead: "39c7dfb4d069a6ad381f141879508e07c8f94368"
+  gitHead: "d5283801593920282f1b31c29b56dea473919327"
 };
 
 // src/config/constants.ts

package/dist/{llmMarkdownGenerator-UU65W336.js → llmMarkdownGenerator-CSIFMRI3.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   CurationArtifactType
-} from "./chunk-T5NXFTZC.js";
+} from "./chunk-DTPBHKQL.js";
 
 // ../../b4m-core/packages/services/dist/src/notebookCurationService/llmMarkdownGenerator.js
 var DEFAULT_OPTIONS = {

package/dist/{markdownGenerator-EUNRHSE3.js → markdownGenerator-5L737COC.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   CurationArtifactType
-} from "./chunk-T5NXFTZC.js";
+} from "./chunk-DTPBHKQL.js";
 
 // ../../b4m-core/packages/services/dist/src/notebookCurationService/markdownGenerator.js
 var DEFAULT_OPTIONS = {

package/dist/{mementoService-TBB3M45P.js → mementoService-7OF7S4V3.js}

@@ -2,9 +2,9 @@
 import {
   findMostSimilarMemento,
   getRelevantMementos
-} from "./chunk-NAZHGW73.js";
-import "./chunk-VAFY6X3M.js";
-import "./chunk-T5NXFTZC.js";
+} from "./chunk-RRYX2K7W.js";
+import "./chunk-EP4OGIQI.js";
+import "./chunk-DTPBHKQL.js";
 import "./chunk-OCYRD7D6.js";
 export {
   findMostSimilarMemento,

package/dist/{src-MLAUU67W.js → src-TO27QQZM.js}

@@ -129,8 +129,8 @@ import {
   validateMermaidSyntax,
   warmUpSettingsCache,
   withRetry
-} from "./chunk-VAFY6X3M.js";
-import "./chunk-T5NXFTZC.js";
+} from "./chunk-EP4OGIQI.js";
+import "./chunk-DTPBHKQL.js";
 import {
   Logger,
   NotificationDeduplicator,

package/dist/{src-FQOHXWN2.js → src-ZECC33CL.js}

@@ -160,6 +160,8 @@ import {
   QuestResourceSchema,
   QuestSchema,
   QuestStatusSchema,
+  RESTRICTION_OPERATIONS,
+  RESTRICTION_SUBJECT_TYPES,
   RapidReplyFallbackBehaviors,
   RapidReplyResponseStylesCommon,
   RapidReplySettingsSchema,
@@ -306,7 +308,7 @@ import {
   validateReactArtifactV2,
   validateSvgArtifactV2,
   wikiMarkupToAdf
-} from "./chunk-T5NXFTZC.js";
+} from "./chunk-DTPBHKQL.js";
 export {
   ALL_IMAGE_MODELS,
   ALL_IMAGE_SIZES,
@@ -468,6 +470,8 @@ export {
   QuestResourceSchema,
   QuestSchema,
   QuestStatusSchema,
+  RESTRICTION_OPERATIONS,
+  RESTRICTION_SUBJECT_TYPES,
   RapidReplyFallbackBehaviors,
   RapidReplyResponseStylesCommon,
   RapidReplySettingsSchema,

package/dist/{subtractCredits-OKODPLEC.js → subtractCredits-MGHZAPOE.js}

@@ -2,9 +2,9 @@
 import {
   SubtractCreditsSchema,
   subtractCredits
-} from "./chunk-W5U65OA2.js";
-import "./chunk-VAFY6X3M.js";
-import "./chunk-T5NXFTZC.js";
+} from "./chunk-XWI42ILN.js";
+import "./chunk-EP4OGIQI.js";
+import "./chunk-DTPBHKQL.js";
 import "./chunk-OCYRD7D6.js";
 export {
   SubtractCreditsSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bike4mind/cli",
-  "version": "0.2.20-feat-web-fetch-tool.18049+39c7dfb4d",
+  "version": "0.2.20-feat-cli-smart-stream-logging.18065+d52838015",
   "type": "module",
   "description": "Interactive CLI tool for Bike4Mind with ReAct agents",
   "license": "UNLICENSED",
@@ -107,10 +107,10 @@
   },
   "devDependencies": {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.44.1-feat-web-fetch-tool.18049+39c7dfb4d",
-    "@bike4mind/mcp": "1.24.1-feat-web-fetch-tool.18049+39c7dfb4d",
-    "@bike4mind/services": "2.42.1-feat-web-fetch-tool.18049+39c7dfb4d",
-    "@bike4mind/utils": "2.2.2-feat-web-fetch-tool.18049+39c7dfb4d",
+    "@bike4mind/common": "2.44.1-feat-cli-smart-stream-logging.18065+d52838015",
+    "@bike4mind/mcp": "1.24.1-feat-cli-smart-stream-logging.18065+d52838015",
+    "@bike4mind/services": "2.42.1-feat-cli-smart-stream-logging.18065+d52838015",
+    "@bike4mind/utils": "2.2.2-feat-cli-smart-stream-logging.18065+d52838015",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -127,5 +127,5 @@
   "optionalDependencies": {
     "@vscode/ripgrep": "^1.17.0"
   },
-  "gitHead": "39c7dfb4d069a6ad381f141879508e07c8f94368"
+  "gitHead": "d5283801593920282f1b31c29b56dea473919327"
 }