codemini-cli 0.4.1 → 0.4.2

package/src/core/reflect-skill.js

@@ -0,0 +1,178 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getProjectSkillsDir, getSkillsDir } from './paths.js';
+import { createChatCompletion } from './provider/index.js';
+
+const REFLECT_TIMEOUT_MS = 45000;
+
+function slugifySkillName(value) {
+  const slug = String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9\u4e00-\u9fa5]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return slug || 'reflected-success-workflow';
+}
+
+function escapeFrontmatter(value) {
+  return String(value || '').replace(/\r?\n/g, ' ').replace(/"/g, '\\"').trim();
+}
+
+function hasFrontmatter(content) {
+  return /^---\r?\n[\s\S]*?\r?\n---\r?\n/.test(String(content || '').trimStart());
+}
+
+function renderSkillContent({ name, description, content }) {
+  const body = String(content || '').trim() || [
+    '## Workflow',
+    '',
+    '1. Recreate the successful chain from the recent task.',
+    '2. Preserve the key decision that made it work.',
+    '3. Verify with the narrowest relevant check.',
+    '',
+    '## Boundaries',
+    '',
+    'Use this only when the current task matches the preserved workflow.'
+  ].join('\n');
+  if (hasFrontmatter(body)) return `${body.trim()}\n`;
+  return [
+    '---',
+    `name: ${name}`,
+    `description: ${escapeFrontmatter(description) || `Use when this reflected workflow applies.`}`,
+    '---',
+    '',
+    body
+  ].join('\n').trimEnd() + '\n';
+}
+
+export function normalizeReflectDraft(raw = {}) {
+  const name = slugifySkillName(raw.name || raw.skillName || raw.title);
+  const description = String(raw.description || raw.summary || `Use when the ${name} workflow applies.`).trim();
+  const confidence = Math.min(1, Math.max(0, Number(raw.confidence ?? 0.75)));
+  return {
+    id: Number(raw.id || 1),
+    name,
+    description,
+    confidence,
+    content: renderSkillContent({ name, description, content: raw.content || raw.markdown || raw.body })
+  };
+}
+
+export function buildReflectTargetPath({ scope = 'project', name, workspaceRoot = process.cwd() } = {}) {
+  const safeName = slugifySkillName(name);
+  const baseDir = String(scope || '').toLowerCase() === 'global'
+    ? getSkillsDir()
+    : getProjectSkillsDir(workspaceRoot);
+  return path.join(baseDir, safeName, 'SKILL.md');
+}
+
+export function parseReflectScope(args = []) {
+  let scope = 'project';
+  const requestParts = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = String(args[index] || '');
+    if (arg === '--scope') {
+      const next = String(args[index + 1] || '').toLowerCase();
+      if (next === 'global' || next === 'project') {
+        scope = next;
+        index += 1;
+      }
+      continue;
+    }
+    if (arg.startsWith('--scope=')) {
+      const value = arg.slice('--scope='.length).toLowerCase();
+      if (value === 'global' || value === 'project') scope = value;
+      continue;
+    }
+    requestParts.push(arg);
+  }
+  return { scope, request: requestParts.join(' ').trim() };
+}
+
+function parseModelDrafts(text) {
+  const raw = String(text || '').trim();
+  if (!raw) return [];
+  const unfenced = raw.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/i, '').trim();
+  try {
+    const parsed = JSON.parse(unfenced);
+    if (Array.isArray(parsed?.candidates)) return parsed.candidates.map((item, index) => normalizeReflectDraft({ id: index + 1, ...item }));
+    if (Array.isArray(parsed)) return parsed.map((item, index) => normalizeReflectDraft({ id: index + 1, ...item }));
+    if (parsed && typeof parsed === 'object') return [normalizeReflectDraft(parsed)];
+  } catch {
+    // Fall back to wrapping plain markdown below.
+  }
+  return [normalizeReflectDraft({
+    name: 'reflected-success-workflow',
+    description: 'Use when the reflected successful workflow applies.',
+    content: raw
+  })];
+}
+
+function recentContext(session, limit = 10) {
+  const messages = Array.isArray(session?.messages) ? session.messages : [];
+  return messages
+    .slice(-limit)
+    .map((message) => `${message.role}: ${String(message.content || '').slice(0, 1200)}`)
+    .join('\n\n');
+}
+
+export async function buildReflectSkillDraft({
+  request = '',
+  scope = 'project',
+  session,
+  config = {},
+  model,
+  systemPrompt = '',
+  previousDraft = null,
+  feedback = ''
+} = {}) {
+  const mode = String(request || '').trim() ? 'directed' : 'exploratory';
+  const prompt = [
+    'Create a reusable Codex/CodeMini SKILL.md draft from a successful workflow.',
+    `Mode: ${mode}`,
+    `Target scope: ${scope}`,
+    request ? `User reflection request:\n${request}` : 'No explicit request was supplied. Be conservative and return no candidates if the recent context does not show a reusable success pattern.',
+    previousDraft ? `Existing draft to revise:\n${previousDraft.content || ''}` : '',
+    feedback ? `User edit feedback:\n${feedback}` : '',
+    'Recent session context:',
+    recentContext(session),
+    'Return valid JSON only, no markdown fences.',
+    'Shape: {"candidates":[{"name":"kebab-case-name","description":"when to use this skill","confidence":0.0,"content":"full SKILL.md body or markdown body"}]}',
+    'The content must include trigger conditions, workflow/toolchain, key decisions, pitfalls, verification, and boundaries.',
+    'Do not write memory or inbox content. This is only a skill draft.'
+  ].filter(Boolean).join('\n\n');
+
+  const result = await createChatCompletion({
+    sdkProvider: config?.sdk?.provider,
+    baseUrl: config?.gateway?.base_url,
+    apiKey: config?.gateway?.api_key,
+    model: model || config?.model?.name,
+    messages: [
+      { role: 'system', content: systemPrompt || 'You draft concise, reusable coding workflow skills.' },
+      { role: 'user', content: prompt }
+    ],
+    temperature: 0,
+    timeoutMs: REFLECT_TIMEOUT_MS
+  });
+
+  return parseModelDrafts(result?.text || '');
+}
+
+export function attachReflectTargets({ candidates = [], scope = 'project', workspaceRoot = process.cwd() } = {}) {
+  return candidates.map((candidate, index) => {
+    const draft = normalizeReflectDraft({ id: index + 1, ...candidate });
+    return {
+      ...draft,
+      targetPath: buildReflectTargetPath({ scope, name: draft.name, workspaceRoot })
+    };
+  });
+}
+
+export async function writeReflectSkillDraft({ draft, scope = 'project', workspaceRoot = process.cwd() } = {}) {
+  const normalized = normalizeReflectDraft(draft);
+  const filePath = buildReflectTargetPath({ scope, name: normalized.name, workspaceRoot });
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, normalized.content, 'utf8');
+  return { filePath, draft: normalized };
+}
+

package/src/core/tool-result-store.js

@@ -0,0 +1,206 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { BoundedCache } from './bounded-cache.js';
+import { trimInline } from './string-utils.js';
+
+const TOOL_RESULT_DISK_THRESHOLD = 6000;
+const PREVIEW_SIZE_BYTES = 2000;
+const TOOL_RESULTS_SUBDIR = 'tool-results';
+
+let currentResultDir = null;
+let resultDirReady = false;
+
+const storedResults = new BoundedCache({
+  maxSize: 64,
+  ttlMs: 30 * 60 * 1000,
+  onEvict(_key, value) {
+    if (value?.filePath) {
+      fs.unlink(value.filePath).catch(() => {});
+    }
+  }
+});
+
+const readCache = new BoundedCache({ maxSize: 128, ttlMs: 10 * 60 * 1000 });
+
+function generatePreview(content) {
+  if (content.length <= PREVIEW_SIZE_BYTES) {
+    return { preview: content, hasMore: false };
+  }
+  const truncated = content.slice(0, PREVIEW_SIZE_BYTES);
+  const lastNewline = truncated.lastIndexOf('\n');
+  const cutPoint = lastNewline > PREVIEW_SIZE_BYTES * 0.5 ? lastNewline : PREVIEW_SIZE_BYTES;
+  return { preview: content.slice(0, cutPoint), hasMore: true };
+}
+
+function formatFileSize(chars) {
+  if (chars < 1024) return `${chars} B`;
+  return `${(chars / 1024).toFixed(1)} KB`;
+}
+
+export function setResultDir(dir) {
+  currentResultDir = dir ? path.join(dir, TOOL_RESULTS_SUBDIR) : null;
+  resultDirReady = false;
+}
+
+async function ensureResultDir() {
+  if (!currentResultDir) return false;
+  if (!resultDirReady) {
+    await fs.mkdir(currentResultDir, { recursive: true });
+    resultDirReady = true;
+  }
+  return true;
+}
+
+export async function storeResultIfNeeded(callId, formattedContent, rawResult) {
+  if (formattedContent.length <= TOOL_RESULT_DISK_THRESHOLD) {
+    return formattedContent;
+  }
+  try {
+    const ready = await ensureResultDir();
+    const dir = ready ? currentResultDir : path.join(os.tmpdir(), 'codemini-results');
+    if (!resultDirReady && dir === currentResultDir) {
+      await fs.mkdir(dir, { recursive: true });
+    } else if (!resultDirReady) {
+      await fs.mkdir(dir, { recursive: true });
+    }
+    const filePath = path.join(dir, `${callId}.txt`);
+    const payload = typeof rawResult === 'string' ? rawResult : JSON.stringify(rawResult, null, 2);
+    await fs.writeFile(filePath, payload, 'utf-8');
+    const summary = summarizeToolResult(rawResult);
+    const { preview, hasMore } = generatePreview(payload);
+    storedResults.set(callId, { filePath, summary });
+
+    return `<persisted-output>
+Output too large (${formatFileSize(payload.length)}). Full output saved to: ${filePath}
+
+Preview (first ${formatFileSize(PREVIEW_SIZE_BYTES)}):
+${preview}${hasMore ? '\n...' : ''}
+
+Summary: ${summary}
+</persisted-output>`;
+  } catch {
+    return formattedContent;
+  }
+}
+
+export function clearResultStore() {
+  const files = [];
+  for (const [, val] of storedResults.entries()) {
+    files.push(val.filePath);
+  }
+  storedResults.clear();
+  readCache.clear();
+  return Promise.allSettled(files.map((filePath) => fs.unlink(filePath).catch(() => {})));
+}
+
+export function checkReadDedup(filePath, startLine, endLine, mtimeMs) {
+  const key = `${filePath}:${startLine || 0}:${endLine || 0}:${mtimeMs}`;
+  if (readCache.has(key)) {
+    return true;
+  }
+  readCache.set(key, true);
+  return false;
+}
+
+export function summarizeToolResult(result) {
+  if (result === null || result === undefined) return 'no output';
+  if (typeof result === 'string') {
+    const oneLine = result.replace(/\s+/g, ' ').trim();
+    return oneLine.length > 90 ? `${oneLine.slice(0, 87)}...` : oneLine || 'empty string';
+  }
+  if (typeof result === 'object') {
+    const obj = result;
+    if (Array.isArray(obj)) return `array(${obj.length})`;
+    if ('deleted' in obj && 'path' in obj) {
+      const kind = trimInline(obj.type || 'item', 16);
+      const target = trimInline(obj.path || '', 96);
+      if (obj.deleted) return target ? `deleted ${kind} ${target}` : `deleted ${kind}`;
+      if (obj.cancelled) return target ? `cancelled delete ${target}` : 'cancelled delete';
+    }
+    if ('path' in obj && 'action' in obj) {
+      const p = String(obj.path || '');
+      const action = String(obj.action || 'write');
+      const line = Number(obj.changed_line || 1);
+      const suffix =
+        action === 'delete'
+          ? 'deleted'
+          : action === 'create'
+            ? 'created'
+            : action === 'patch'
+              ? 'patched'
+              : action === 'replace_block' || action === 'replace_text'
+                ? 'edited'
+                : action === 'append'
+                  ? 'appended'
+                  : 'updated';
+      return p ? `${suffix} ${p}${line > 0 ? ` @L${line}` : ''}` : suffix;
+    }
+    if ('path' in obj && 'phase' in obj) {
+      const phase = String(obj.phase || '');
+      const p = String(obj.path || '');
+      const total = Number(obj.total_lines);
+      const start =
+        Number(obj.suggested_start_line || obj.start_line) > 0
+          ? Number(obj.suggested_start_line || obj.start_line)
+          : 1;
+      const end =
+        Number(obj.suggested_end_line || obj.end_line) >= start
+          ? Number(obj.suggested_end_line || obj.end_line)
+          : start;
+      const rangeText = start > 0 && end >= start ? ` lines ${start}-${end}` : '';
+      const totalText = total > 0 ? ` of ${total}` : '';
+      const enclosingText = obj.enclosing_symbol ? ` in ${obj.enclosing_symbol}` : '';
+      const errorText = obj.error ? ` (${trimInline(obj.error, 64)})` : '';
+      const truncatedText = obj.truncated ? ' [truncated]' : '';
+      return phase === 'metadata'
+        ? `metadata for ${p}${rangeText}${totalText}${errorText}`
+        : `content from ${p}${rangeText}${totalText}${enclosingText}${truncatedText}`;
+    }
+    if ('stdout' in obj || 'stderr' in obj || 'code' in obj) {
+      const stdout = trimInline(obj.stdout || '', 96);
+      const stderr = trimInline(obj.stderr || '', 96);
+      const command = trimInline(obj.command || '', 72);
+      const lead = command ? `${command} -> ` : '';
+      if (stdout) return `${lead}exit ${obj.code ?? 0}\nstdout: ${stdout}`;
+      if (stderr) return `${lead}exit ${obj.code ?? 0}\nstderr: ${stderr}`;
+      return `${lead}exit ${obj.code ?? 0}`;
+    }
+    if ('task_id' in obj && 'startup_confirmed' in obj) {
+      const status = trimInline(obj.status || 'unknown', 32);
+      const taskId = trimInline(obj.task_id || '', 24);
+      const source = trimInline(obj.startup_source || '', 24);
+      const outputFile = trimInline(obj.output_file || '', 72);
+      const output = Array.isArray(obj.recent_output) ? trimInline(obj.recent_output.slice(-1)[0] || '', 96) : '';
+      return `${taskId || 'task'} ${status}${source ? ` (${source})` : ''}${outputFile ? ` -> ${outputFile}` : ''}${output ? `\n${output}` : ''}`;
+    }
+    if ('tasks' in obj && Array.isArray(obj.tasks)) {
+      const count = obj.tasks.length;
+      const first = obj.tasks[0];
+      const lead = first?.task_id ? `${trimInline(first.task_id, 24)} ${trimInline(first.status || 'unknown', 24)}` : '';
+      return `tasks(${count})${lead ? `\n${lead}` : ''}`;
+    }
+    if ('files' in obj && Array.isArray(obj.files)) {
+      return `patched ${obj.files.length} file(s)`;
+    }
+    if ('diff' in obj && 'new_hash' in obj && 'path' in obj) {
+      const p = String(obj.path || '');
+      return p ? `diff preview for ${p}` : 'diff preview';
+    }
+    if ('created' in obj && Array.isArray(obj.created)) {
+      return `created ${obj.created.length} task(s)`;
+    }
+    if ('tasks' in obj && Array.isArray(obj.tasks)) {
+      return `${obj.tasks.length} task(s)`;
+    }
+    if ('newTodos' in obj && Array.isArray(obj.newTodos)) {
+      return obj.newTodos.length > 0 ? `updated ${obj.newTodos.length} todo item(s)` : 'cleared todo list';
+    }
+    if ('newPlan' in obj) {
+      return obj.newPlan ? `updated plan state (${String(obj.newPlan.status || 'draft')})` : 'cleared plan state';
+    }
+    const keys = Object.keys(obj);
+    return keys.length > 0 ? `keys: ${keys.slice(0, 5).join(',')}` : 'object';
+  }
+  return String(result);
+}

package/src/core/tools.js

@@ -15,7 +15,7 @@ import {
 import { evaluateCommandPolicy } from './command-policy.js';
 import { findEnclosingSymbol, queryAst, readAstNode, resolveAstTarget } from './ast.js';
 import { initializeProjectIndex, queryProjectIndex, refreshIndexedFile } from './project-index.js';
-import { checkReadDedup } from './agent-loop.js';
+import { checkReadDedup } from './tool-result-store.js';
 import { TOOL_SKIP_DIRS as SKIP_DIRS, TEXT_EXTENSIONS, CODE_WRITE_GUARD_EXTENSIONS, LANGUAGE_FILE_TYPES } from './constants.js';
 import { sha256Prefixed as sha256, sha256 as sha256Hash } from './crypto-utils.js';
 import { forgetMemory, listMemories, rememberMemory, searchMemories, captureToInbox } from './memory-store.js';
@@ -172,6 +172,55 @@ function collectPageLinks($, pageUrl, maxLinks = 20) {
   return links;
 }
 
+function extractPageContent(cheerio, html, pageUrl, { maxLinks, status = null, contentType = '', fetchMode = 'static' } = {}) {
+  const $ = cheerio.load(html);
+  $('script, style, noscript').remove();
+  const bodyText = $('body').text() || $.root().text();
+  const text = String(bodyText || '').replace(/[^\S\n]+/g, ' ').replace(/\n{3,}/g, '\n\n').trim();
+  const title = trimPreview($('title').first().text(), 240);
+  const description = extractHtmlMeta($, 'description') || extractHtmlMeta($, 'og:description');
+  const links = collectPageLinks($, pageUrl, maxLinks);
+
+  return {
+    final_url: pageUrl,
+    title,
+    description,
+    text,
+    links,
+    metadata: {
+      status,
+      fetched_at: new Date().toISOString(),
+      content_type: contentType,
+      fetch_mode: fetchMode,
+      lang: String($('html').attr('lang') || '').trim()
+    }
+  };
+}
+
+function shouldTryBrowserRender(html, text) {
+  if (String(text || '').trim().length >= 120) return false;
+  return /<script\b/i.test(html) ||
+    /id=["']__(?:next|nuxt)["']/i.test(html) ||
+    /data-reactroot|ng-version|window\.__/i.test(html);
+}
+
+function playwrightInstallHint() {
+  return 'For JavaScript-rendered pages, install Playwright for richer web_fetch results: npm install -g playwright && playwright install chromium';
+}
+
+async function loadOptionalPlaywright() {
+  try {
+    return await import('playwright');
+  } catch (error) {
+    const code = String(error?.code || '');
+    const message = String(error?.message || '');
+    if (code === 'ERR_MODULE_NOT_FOUND' || /Cannot find package 'playwright'|Cannot find module 'playwright'/i.test(message)) {
+      return null;
+    }
+    throw error;
+  }
+}
+
 async function buildPlaywrightLaunchEnv() {
   const localLibDir = path.join(
     process.env.HOME || '',
@@ -204,44 +253,85 @@ async function webFetchPage(args = {}) {
     ? String(normalizedArgs.wait_until).trim()
     : 'domcontentloaded';
 
-  const [{ chromium }, cheerio] = await Promise.all([import('playwright'), import('cheerio')]);
+  const cheerio = await import('cheerio');
+  let staticResult = null;
+  let staticHtml = '';
+  let staticError = null;
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    let response;
+    try {
+      response = await fetch(url, {
+        redirect: 'follow',
+        signal: controller.signal,
+        headers: {
+          'user-agent': 'CodeMiniCLI/0.4 web_fetch'
+        }
+      });
+    } finally {
+      clearTimeout(timeout);
+    }
+    staticHtml = await response.text();
+    staticResult = {
+      url,
+      ...extractPageContent(cheerio, staticHtml, response.url || url, {
+        maxLinks,
+        status: response.status,
+        contentType: response.headers.get('content-type') || '',
+        fetchMode: 'static'
+      })
+    };
+    if (!shouldTryBrowserRender(staticHtml, staticResult.text)) {
+      return staticResult;
+    }
+  } catch (error) {
+    staticError = error;
+  }
 
-  // Crawlee is intentionally disabled for now so single-page reads stay lightweight.
-  // If we later need multi-URL crawl orchestration, retries, or request queues, we can re-enable it here.
+  const playwright = await loadOptionalPlaywright();
+  if (!playwright) {
+    if (staticResult) {
+      return {
+        ...staticResult,
+        warnings: [playwrightInstallHint()]
+      };
+    }
+    throw new Error(`web_fetch failed and browser rendering is unavailable. ${playwrightInstallHint()}. Static fetch error: ${staticError?.message || staticError}`);
+  }
 
-  const browser = await chromium.launch({
-    headless: true,
-    env: await buildPlaywrightLaunchEnv()
-  });
+  let browser;
   try {
+    browser = await playwright.chromium.launch({
+      headless: true,
+      env: await buildPlaywrightLaunchEnv()
+    });
     const page = await browser.newPage();
     const response = await page.goto(url, { waitUntil, timeout: timeoutMs });
     const finalUrl = page.url();
     const html = await page.content();
-    const $ = cheerio.load(html);
-    const bodyText = $('body').text() || $.root().text();
-    const text = String(bodyText || '').replace(/[^\S\n]+/g, ' ').replace(/\n{3,}/g, '\n\n').trim();
-    const title = trimPreview($('title').first().text() || (await page.title()), 240);
-    const description = extractHtmlMeta($, 'description') || extractHtmlMeta($, 'og:description');
-    const links = collectPageLinks($, finalUrl, maxLinks);
-
-    return {
+    const rendered = {
       url,
-      final_url: finalUrl,
-      title,
-      description,
-      text,
-      links,
-      metadata: {
+      ...extractPageContent(cheerio, html, finalUrl, {
+        maxLinks,
         status: response?.status?.() ?? null,
-        fetched_at: new Date().toISOString(),
-        content_type: response?.headers?.()['content-type'] || '',
-        wait_until: waitUntil,
-        lang: String($('html').attr('lang') || '').trim()
-      }
+        contentType: response?.headers?.()['content-type'] || '',
+        fetchMode: 'browser'
+      })
     };
+    rendered.metadata.wait_until = waitUntil;
+    rendered.title = rendered.title || trimPreview(await page.title(), 240);
+    return rendered;
+  } catch (error) {
+    if (staticResult) {
+      return {
+        ...staticResult,
+        warnings: [`Browser rendering fallback failed: ${error?.message || error}`]
+      };
+    }
+    throw error;
   } finally {
-    await browser.close();
+    if (browser) await browser.close();
   }
 }
 
@@ -2036,7 +2126,7 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       function: {
         name: 'web_fetch',
         description:
-          'Fetch and read a live web page. Uses Playwright to render the page, Cheerio to extract structured content, and Crawlee request handling to normalize the fetch flow. Use this for direct URL reads, not for keyword search.',
+          'Fetch and read a live web page. Uses a lightweight fetch + Cheerio reader by default, then falls back to optional Playwright browser rendering for JavaScript-heavy pages when Playwright is installed. Use this for direct URL reads, not for keyword search.',
         parameters: {
           type: 'object',
           properties: {
@@ -2140,7 +2230,7 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       function: {
         name: 'dream_consolidate',
         description:
-          'Run a dream loop consolidation pass over inbox entries. Reads recent inbox items, deduplicates, evaluates lifecycle progression (observed → candidate → operational/longterm), promotes stable patterns into persistent memory, archives expired items, and writes an audit report. Use during off-hours or explicit maintenance.',
+          'Run a dream loop pass over inbox entries and existing memory buckets. Reads recent inbox items, deduplicates, evaluates lifecycle progression (observed → candidate → operational/longterm), promotes stable patterns into persistent memory, then uses LLM maintenance to merge/summarize/clean stale user/global/project memories when their bucket changed since the last maintenance marker. Writes an audit report. Use during off-hours or explicit maintenance.',
         parameters: {
           type: 'object',
           properties: {
@@ -2742,6 +2832,12 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       if (result.title) lines.push(`title: ${result.title}`);
       if (result.description) lines.push(`description: ${trimPreview(result.description, 200)}`);
       if (result.metadata?.status) lines.push(`status: ${result.metadata.status}`);
+      if (result.metadata?.fetch_mode) lines.push(`mode: ${result.metadata.fetch_mode}`);
+      if (Array.isArray(result.warnings)) {
+        for (const warning of result.warnings.slice(0, 3)) {
+          if (warning) lines.push(`warning: ${warning}`);
+        }
+      }
       if (Array.isArray(result.links) && result.links.length > 0) {
         lines.push(`links: ${result.links.slice(0, 5).map((item) => item.href).join(', ')}`);
       }