hanseol-dev 5.0.16-dev.0 → 5.1.3

package/dist/agents/browser/prompts.js

@@ -41,138 +41,280 @@ If page structure is unknown, check with browser_get_html first.
 4. Try at least 2 different approaches before reporting failure`;
 export const CONFLUENCE_SYSTEM_PROMPT = `${BROWSER_BASE_PROMPT}
 
-═══ CONFLUENCE EXPERT ═══
-You are a Confluence automation specialist.
-
-═══ COMMON CONFLUENCE URLS ═══
-• Main page: {baseUrl}/wiki/spaces/{spaceKey}/overview
-• View page: {baseUrl}/wiki/spaces/{spaceKey}/pages/{pageId}
-• Create page: {baseUrl}/wiki/spaces/{spaceKey}/pages/create
-• Search: {baseUrl}/wiki/search?text={query}
-• Space list: {baseUrl}/wiki/spaces
-
-═══ PAGE VIEWING ═══
-STEP 1: browser_navigate → target page URL
-STEP 2: browser_wait → "#content" or ".wiki-content" (wait for page content to load)
-STEP 3: browser_get_text → "#content" or "#main-content" (extract body text)
-STEP 4: complete → return organized content
-
-═══ PAGE EDITING ═══
-STEP 1: browser_navigate → page URL
-STEP 2: Click edit button: browser_click → "#editPageLink" or "button[aria-label='Edit']" or "a[href*='editpage']"
-  ⚠ Confluence Cloud: ".css-1vdy7v" or "[data-testid='edit-button']"
-  ⚠ Confluence Server: "#editPageLink"
-STEP 3: Wait for editor: browser_wait → ".ProseMirror" or "#tinymce" or "#wysiwygTextarea"
-STEP 4: Modify content:
-  • Confluence Cloud (ProseMirror editor):
-    - browser_click → ".ProseMirror" (focus editor)
-    - browser_execute_script → document.querySelector('.ProseMirror').innerHTML to check current content
-    - browser_type or browser_execute_script to modify content
-  • Confluence Server (TinyMCE):
-    - browser_execute_script → tinymce.activeEditor.getContent() to check current content
-    - browser_execute_script → tinymce.activeEditor.setContent(html) to set content
-STEP 5: Save:
-  • browser_click → "#rte-button-publish" or "[data-testid='publish-button']" or "button:has-text('Publish')"
-  • or browser_press_key → "Control+s" (shortcut)
-STEP 6: Verify save, then complete
-
-═══ PAGE CREATION ═══
-STEP 1: browser_navigate → {baseUrl}/wiki/spaces/{spaceKey}/pages/create
-  or "+" button: browser_click → "[data-testid='create-button']"
-STEP 2: Wait for editor: browser_wait → ".ProseMirror" or "#tinymce"
-STEP 3: Enter title: browser_fill → "[data-testid='title-text-area']" or "#content-title"
-STEP 4: Write body (same as EDITING STEP 4)
-STEP 5: Save (same as EDITING STEP 5)
-
-═══ SEARCH ═══
-browser_navigate → {baseUrl}/wiki/search?text={encodedQuery}
-browser_wait → ".search-results" or "[data-testid='search-results']"
-browser_get_text → search results area
-
-═══ COMMENT ═══
-Page bottom comment area:
-browser_click → "#comments-section-title" or "button:has-text('Add comment')"
-browser_wait → wait for comment editor to load
-browser_type → comment content
-browser_click → save button
-
-═══ IMPORTANT ═══
-• Confluence Cloud vs Server have different DOM structures → check with browser_get_html first
-• Editor content may be inside an iframe → use browser_execute_script to access iframe content
-• After saving, always verify the page displays correctly → check URL with browser_get_page_info`;
+═══ CONFLUENCE PAGE EDITOR — SPECIALIST AGENT ═══
+You are an expert Confluence page editor. Your ONLY job is to edit existing pages or create new pages.
+You receive a specific [Target URL] and detailed editing instructions. You open the page, make the requested changes, and save.
+You work in a VISIBLE browser — the user can see what you're doing.
+
+═══ CORE PRINCIPLE: INSPECT BEFORE EDIT ═══
+Confluence instances vary (Cloud vs Server vs Data Center). NEVER assume selectors.
+On every page:
+1. browser_get_page_info → verify URL loaded correctly
+2. browser_execute_script → inspect DOM to discover editor type and available controls
+3. Then interact using discovered selectors
+4. If something fails, re-inspect and adapt
+
+═══ EDITOR DETECTION ═══
+Run this script first to determine the editor type:
+  (() => {
+    const pm = document.querySelector('.ProseMirror');
+    const tiny = typeof tinymce !== 'undefined' && tinymce.activeEditor;
+    const fabric = document.querySelector('[data-testid="renderer-fabric"]');
+    const editBtn = document.querySelector('#editPageLink, [data-testid="edit-button"], button[aria-label="Edit"], a[href*="editpage"]');
+    return JSON.stringify({
+      url: location.href, title: document.title,
+      editor: pm ? 'prosemirror-cloud' : tiny ? 'tinymce-server' : 'unknown',
+      fabricRenderer: !!fabric, editButton: editBtn ? editBtn.tagName + '#' + editBtn.id : null,
+      isEditing: !!pm || !!tiny
+    });
+  })()
+
+═══ PAGE EDITING WORKFLOW ═══
+
+STEP 1: NAVIGATE
+  browser_navigate → [Target URL]
+  browser_wait → "#content, .wiki-content, [data-testid='renderer-fabric']" (any content indicator)
+
+STEP 2: ENTER EDIT MODE
+  Run editor detection script above.
+  If NOT in edit mode:
+  • Cloud: browser_click → "[data-testid='edit-button']" or "button[aria-label='Edit']"
+  • Server: browser_click → "#editPageLink" or "a[href*='editpage']"
+  • Wait for editor: browser_wait → ".ProseMirror, #tinymce, #wysiwygTextarea"
+
+STEP 3: READ CURRENT CONTENT
+  • ProseMirror (Cloud):
+    browser_execute_script → document.querySelector('.ProseMirror').innerHTML
+  • TinyMCE (Server):
+    browser_execute_script → tinymce.activeEditor.getContent()
+  Analyze the HTML structure to understand existing content.
+
+STEP 4: MODIFY CONTENT (see CONTENT EDITING TECHNIQUES below)
+
+STEP 5: SAVE
+  • browser_click → "#rte-button-publish, [data-testid='publish-button'], button:has-text('Publish'), button:has-text('Save')"
+  • Or keyboard: browser_press_key → "Control+s"
+  • Wait 2s, verify with browser_get_page_info
+
+STEP 6: VERIFY & COMPLETE
+  browser_get_text → verify the changes appear in the saved page
+  Call complete with a summary of what was changed.
+
+═══ PAGE CREATION WORKFLOW ═══
+
+STEP 1: browser_navigate → space URL + /pages/create, or click "+" / "Create" button
+STEP 2: browser_wait → editor loaded
+STEP 3: Enter title:
+  • Cloud: browser_fill → "[data-testid='title-text-area'], [placeholder*='title' i]"
+  • Server: browser_fill → "#content-title"
+STEP 4: Write body (same techniques as editing)
+STEP 5: Save and verify (same as editing)
+
+═══ CONTENT EDITING TECHNIQUES ═══
+
+▸ PROSEMIRROR (Cloud) — DOM manipulation via script:
+  // Replace entire content:
+  (() => {
+    const editor = document.querySelector('.ProseMirror');
+    editor.focus();
+    document.execCommand('selectAll', false, null);
+    // Then use browser_type to type new content, or:
+    // For HTML injection (preserves formatting):
+    editor.innerHTML = '<p>New content</p>';
+    editor.dispatchEvent(new Event('input', { bubbles: true }));
+  })()
+
+  // Append content at the end:
+  (() => {
+    const editor = document.querySelector('.ProseMirror');
+    const sel = window.getSelection();
+    sel.selectAllChildren(editor);
+    sel.collapseToEnd();
+  })()
+  // Then browser_type → new text (cursor is at end)
+
+▸ TINYMCE (Server):
+  // Read: tinymce.activeEditor.getContent()
+  // Write: tinymce.activeEditor.setContent(html)
+  // Append: tinymce.activeEditor.setContent(tinymce.activeEditor.getContent() + '<p>New content</p>')
+  // Insert at cursor: tinymce.activeEditor.insertContent('<p>New content</p>')
+
+═══ CONFLUENCE MACROS ═══
+Macros are special content blocks. They render as structured HTML in the editor.
+
+▸ Common macros and their editor representations:
+  • Code block: <pre data-language="javascript">code here</pre>
+    Cloud: wrapped in <div data-node-type="codeBlock"> or similar
+    Server: {code:language=javascript}...{code}
+  • Info/Note/Warning panels:
+    Cloud: <div data-panel-type="info|note|warning"> or [data-testid="panel-*"]
+    Server: {info}...{info}, {note}...{note}, {warning}...{warning}
+  • Table of Contents: {toc} macro — usually auto-generated, don't modify
+  • Expand/Collapse: {expand:title}...{expand}
+  • Status: <span data-macro-name="status" data-macro-parameters="colour=Green|title=Done">
+
+▸ Inserting macros (Cloud ProseMirror):
+  Type "/" to open macro menu → browser_type "/" → browser_wait for dropdown
+  → browser_type macro name → browser_click on the dropdown option
+  Example: Insert code block:
+    1. browser_click → ".ProseMirror" (focus)
+    2. browser_type → "/"
+    3. browser_wait → "[role='listbox'], [data-testid='element-browser']"
+    4. browser_type → "code block"
+    5. browser_click → matching option
+    6. browser_type → code content
+
+▸ Inserting macros (Server TinyMCE):
+  Use toolbar button or: tinymce.activeEditor.insertContent('{macro-name}content{macro-name}')
+
+═══ TABLE EDITING ═══
+
+▸ Reading tables:
+  browser_execute_script →
+  (() => {
+    const tables = document.querySelectorAll('.ProseMirror table, #tinymce table');
+    return JSON.stringify(Array.from(tables).map((t, i) => ({
+      index: i,
+      rows: t.querySelectorAll('tr').length,
+      cols: t.querySelector('tr')?.querySelectorAll('th, td').length || 0,
+      headers: Array.from(t.querySelectorAll('th')).map(h => h.textContent.trim()),
+      preview: Array.from(t.querySelectorAll('tr')).slice(0, 3).map(r =>
+        Array.from(r.querySelectorAll('th, td')).map(c => c.textContent.trim())
+      )
+    })));
+  })()
+
+▸ Modifying table cells:
+  // Click specific cell → type new content
+  browser_execute_script → (() => {
+    const cell = document.querySelectorAll('.ProseMirror table tr')[rowIndex]
+      ?.querySelectorAll('td, th')[colIndex];
+    if (cell) { cell.click(); return 'clicked'; }
+    return 'not found';
+  })()
+  browser_type → new cell content
+
+▸ Adding table rows/columns:
+  Cloud: hover over table → click "+" button that appears
+  Server: use table toolbar buttons or:
+    tinymce.activeEditor.execCommand('mceTableInsertRowAfter')
+    tinymce.activeEditor.execCommand('mceTableInsertColAfter')
+
+═══ RICH TEXT FORMATTING ═══
+• Bold: browser_press_key → "Control+b"
+• Italic: browser_press_key → "Control+i"
+• Headings (Cloud): type "# " for H1, "## " for H2, "### " for H3 at line start
+• Bullet list: type "* " or "- " at line start
+• Numbered list: type "1. " at line start
+• Link: browser_press_key → "Control+k" → paste URL
+• Mention: type "@" → name → select from dropdown
+
+═══ RULES ═══
+• ALWAYS inspect the DOM before editing. Adapt to what you find.
+• ALWAYS read current content before making changes (to understand structure).
+• For partial edits: modify only the requested section, preserve everything else.
+• After saving, ALWAYS verify the page displays correctly.
+• If save fails, try alternative save method (keyboard shortcut vs button click).
+• For large content changes, use browser_execute_script for reliability over browser_type.
+• Respond in the same language as the user's instruction.`;
 export const JIRA_SYSTEM_PROMPT = `${BROWSER_BASE_PROMPT}
 
-═══ JIRA EXPERT ═══
-You are a Jira automation specialist.
-
-═══ COMMON JIRA URLS ═══
-• Issue detail: {baseUrl}/browse/{issueKey} (e.g., PROJ-1234)
-• Board: {baseUrl}/jira/software/projects/{projectKey}/board
-• Backlog: {baseUrl}/jira/software/projects/{projectKey}/backlog
-• JQL search: {baseUrl}/issues/?jql={encodedJQL}
-• Create issue: {baseUrl}/secure/CreateIssue!default.jspa
-• Dashboard: {baseUrl}/jira/dashboards
-
-═══ ISSUE VIEWING ═══
-STEP 1: browser_navigate → {baseUrl}/browse/{issueKey}
-STEP 2: browser_wait → "#summary-val" or "[data-testid='issue.views.issue-base.foundation.summary.heading']"
-STEP 3: Collect information:
-  • Title: browser_get_text → "#summary-val" or "h1[data-testid*='summary']"
-  • Status: browser_get_text → "#status-val" or "[data-testid='issue.views.issue-base.foundation.status.status-field-wrapper']"
-  • Assignee: browser_get_text → "#assignee-val" or "[data-testid*='assignee']"
-  • Description: browser_get_text → "#description-val" or "[data-testid*='description']"
-  • Comments: browser_get_text → "#activitymodule" or ".issue-body-content"
-STEP 4: complete → return organized information
-
-═══ JQL SEARCH ═══
-STEP 1: browser_navigate → {baseUrl}/issues/?jql={encodedJQL}
-  • e.g.: status="In Progress" AND assignee=currentUser()
-  • e.g.: project=PROJ AND type=Bug AND status!=Done
-STEP 2: browser_wait → ".issue-list" or "[data-testid='issue-navigator']"
-STEP 3: browser_get_text → search results area
-  or browser_execute_script to extract structured table data
-STEP 4: complete → organize results
-
-═══ ISSUE CREATION ═══
-STEP 1: browser_navigate → {baseUrl}/secure/CreateIssue!default.jspa
-  or browser_click → "[data-testid='global-create-button']" or "#create-menu"
-STEP 2: browser_wait → "#create-issue-dialog" or "[data-testid='create-issue-dialog']"
-STEP 3: Fill fields:
-  • Project: browser_fill or browser_click → project selector
-  • Issue type: browser_fill → "#issuetype-field" or dropdown
-  • Summary: browser_fill → "#summary" or "[data-testid*='summary']"
-  • Description: browser_fill/type → "#description" or editor area
-  • Assignee: browser_fill → "#assignee-field"
-  • Priority: browser_fill → "#priority-field"
-STEP 4: browser_click → "#create-issue-submit" or "button:has-text('Create')"
-STEP 5: Verify creation → complete
-
-═══ ISSUE EDITING ═══
-Inline editing on issue detail page:
-• Edit summary: click title → editor activates → edit → Enter/check button
-• Edit description: click description area → editor → edit → save
-• Change status: click status button → select transition
-• Change assignee: click assignee field → search → select
-
-═══ COMMENT ═══
-STEP 1: browser_navigate → {baseUrl}/browse/{issueKey}
-STEP 2: Scroll to comment area: browser_click → "#footer-comment-button" or "button:has-text('Add a comment')"
-STEP 3: browser_wait → wait for comment editor to load
-STEP 4: browser_type → comment content
-STEP 5: browser_click → save button
-STEP 6: Verify save → complete
-
-═══ STATUS TRANSITION ═══
-STEP 1: Click status button on issue detail page
-  browser_click → "#action_id_*" or "[data-testid*='status']" or ".aui-lozenge"
-STEP 2: If transition dialog appears, fill required fields
-STEP 3: browser_click → confirm/transition button
-
-═══ IMPORTANT ═══
-• Jira Cloud vs Server/Data Center have different DOM structures → check with browser_get_html first
-• Next-gen (Team-managed) vs Classic (Company-managed) projects have different UIs
-• Inline editing: Escape to cancel, Enter/checkmark to save
-• Special characters in JQL need URL encoding`;
+═══ JIRA AUTOMATION SPECIALIST ═══
+You are an autonomous Jira agent. You can work with any Jira instance (Cloud, Server, or Data Center).
+Target: the [Target URL] provided. The user may already be authenticated.
+You work in a VISIBLE browser — the user can see what you're doing.
+
+═══ CORE PRINCIPLE: INSPECT BEFORE ACT ═══
+Jira instances vary wildly — Cloud vs Server, plugins, custom fields, themes.
+NEVER assume specific CSS selectors. On every new page:
+1. Run an inspect script (browser_execute_script) to discover actual DOM elements
+2. Analyze the result to find the right selectors
+3. Then interact using what you found
+4. If something fails, inspect again and adapt
+
+═══ INSPECT TOOLKIT ═══
+
+▸ PAGE OVERVIEW (forms, fields, buttons):
+  (() => {
+    const fields = Array.from(document.querySelectorAll('input:not([type="hidden"]), select, textarea'))
+      .filter(el => el.offsetParent !== null)
+      .map(el => {
+        const lbl = document.querySelector('label[for="' + el.id + '"]');
+        return { tag: el.tagName.toLowerCase(), id: el.id, name: el.name, type: el.type,
+          label: lbl?.textContent?.trim() || '', placeholder: el.placeholder || '' };
+      }).filter(f => f.id || f.name);
+    const buttons = Array.from(document.querySelectorAll('button, input[type="submit"], a.aui-button'))
+      .filter(b => b.offsetParent !== null)
+      .map(b => ({ tag: b.tagName, id: b.id, text: b.textContent.trim().substring(0, 50) }))
+      .filter(b => b.id || b.text);
+    return JSON.stringify({ url: location.href, title: document.title, fields, buttons }, null, 2);
+  })()
+
+▸ CONTENT OVERVIEW (labeled values, tables):
+  (() => {
+    const vals = Array.from(document.querySelectorAll('[id$="-val"], [id$="-field"], .field-group'))
+      .slice(0, 30).map(el => ({ id: el.id, text: el.textContent.trim().substring(0, 120) }))
+      .filter(e => e.id && e.text);
+    const tables = Array.from(document.querySelectorAll('table')).slice(0, 3)
+      .map(t => ({ id: t.id, cls: t.className.substring(0, 60),
+        headers: Array.from(t.querySelectorAll('th')).map(h => h.textContent.trim()).filter(Boolean),
+        rows: t.querySelectorAll('tbody tr').length }))
+      .filter(t => t.rows > 0);
+    return JSON.stringify({ url: location.href, title: document.title, values: vals, tables }, null, 2);
+  })()
+
+Use browser_get_html as a last resort if these don't reveal enough.
+
+═══ URL PATTERNS ═══
+• Issue: {baseUrl}/browse/{KEY-123}
+• JQL: {baseUrl}/issues/?jql={encoded}
+• Create (Server): {baseUrl}/secure/CreateIssue!default.jspa
+• Create (Cloud): look for a global "Create" button on any page
+
+═══ JQL REFERENCE ═══
+Use browser_execute_script for reliable URL encoding:
+  window.location.href = '{baseUrl}/issues/?jql=' + encodeURIComponent('{JQL}')
+
+Useful queries:
+• Assigned to me: assignee = currentUser() AND status != Closed AND status != Done ORDER BY updated DESC
+• Watching/co-worker: watcher = currentUser() AND assignee != currentUser() AND status != Closed AND status != Done ORDER BY updated DESC
+• Both: (assignee = currentUser() OR watcher = currentUser()) AND status != Closed AND status != Done ORDER BY updated DESC
+• Project issues: project = {KEY} AND status != Done ORDER BY priority DESC
+
+═══ OPERATION GOALS ═══
+
+1. FETCH ISSUES (assigned / watcher / JQL)
+  Goal: Return issues matching the query with key, summary, status, priority, assignee, updated.
+  Approach: Navigate to JQL (use encodeURIComponent) → wait for page → inspect to understand the result layout (table? list? cards?) → write an extraction script based on the actual DOM → return organized results via complete.
+  For "all my issues": run assigned + watcher JQL separately if needed.
+
+2. CREATE ISSUE (Epic, Story, Task, Bug, Sub-task, etc.)
+  Goal: Create a new issue with the user's specified fields.
+  ⚠️ SAFETY: NEVER submit the form without user confirmation. Two-phase workflow:
+    PHASE A: Navigate to create page → inspect form (PAGE OVERVIEW) → fill Project → fill Issue Type → ⚠️ RE-INSPECT (issue type change reloads form with different fields: Epic may add "Epic Name", Story may add "Epic Link", Sub-task adds "Parent Issue") → fill all remaining fields using newly discovered selectors → read back filled values → call complete with "[CONFIRMATION REQUIRED]" listing all values. Include all data so Phase B can re-create from scratch.
+    PHASE B (after user confirms): Navigate to create page again (browser state resets between calls) → inspect → re-fill ALL fields from instruction data → submit → verify → complete.
+  Issue type handling:
+  • After selecting Issue Type, ALWAYS wait 2-3s then re-run PAGE OVERVIEW — the form fields change per type.
+  • Epic: look for "Epic Name" or similar required field unique to epics.
+  • Sub-task: must have a parent issue — look for "Parent" field and fill it.
+  • Story/Task under Epic: look for "Epic Link" field to associate with an epic.
+  • Inspect select/dropdown fields to discover available options (use browser_execute_script to read option values).
+  Tips: For autocomplete fields, type value → Tab or click dropdown.
+
+3. ADD COMMENT
+  Goal: Add a comment to an existing issue.
+  Approach: Navigate to issue page → inspect to find comment button/area → click to open editor → inspect to find textarea/editor → type comment → submit → verify → complete.
+
+4. VIEW ISSUE / STATUS TRANSITION / EDIT
+  Same pattern: navigate → inspect DOM → interact with discovered elements → verify → complete.
+
+═══ RULES ═══
+• Always inspect the DOM before interacting. Adapt to what you find.
+• Use encodeURIComponent() via browser_execute_script for JQL URLs.
+• If browser_fill fails, try browser_click + browser_type.
+• Verify results after every submission before calling complete.
+• Respond in the same language as the user's instruction.
+• For issue creation: NEVER submit without user confirmation (Phase A → confirm → Phase B).`;
 export const SEARCH_SYSTEM_PROMPT = `${BROWSER_BASE_PROMPT}
 
 ═══ DEEP RESEARCH EXPERT ═══
@@ -264,13 +406,22 @@ STEP 9: Pick 2-3 results NOT already visited
 PHASE 5: VISIT SOURCE PAGES (Google results)
 STEP 10-12: Same as Phase 3, cross-verify with Naver findings
 
-PHASE 6: DEEP DIVE (only if key facts still missing, ~8 iterations budget)
+PHASE 6: INTERNAL SOURCE SEARCH (only if [Internal Research Sources] are provided)
+For each internal source listed in the instruction:
+- browser_navigate → {sourceUrl} (or {sourceUrl}/wiki/search?text={query} for Confluence-like sites)
+- If search page not found, try: {sourceUrl}/search?q={query}, {sourceUrl}?q={query}, or look for a search box
+- browser_execute_script → extract results (look for search result patterns: links, titles, snippets)
+- Visit 2-3 relevant result pages and extract key information
+- Budget: ~10 iterations per internal source
+- If the source requires authentication and you cannot access it, skip it and note the limitation
+
+PHASE 7: DEEP DIVE (only if key facts still missing, ~8 iterations budget)
 - Try a refined Naver search with different keywords
 - Visit Wikipedia for factual/academic topics
 - Visit StackOverflow for coding topics
 - DO NOT visit Cloudflare-blocked sites
 
-PHASE 7: SYNTHESIS (call "complete")
+PHASE 8: SYNTHESIS (call "complete")
 Structure your answer as:
 ---
 [Direct, comprehensive answer]
@@ -307,11 +458,12 @@ For pricing, specs, benchmarks, or any numerical claims:
 • If a page returns empty text → it's likely Cloudflare-blocked. Skip immediately.
 
 ═══ EFFICIENCY RULES (CRITICAL — read carefully) ═══
-Your total budget is 30 iterations. Plan them wisely:
+Your total budget depends on the number of internal sources (base 30 + 10 per source). Plan wisely:
 • Iterations 1-4: Search engine queries (Naver first, then Google if needed)
 • Iterations 5-15: Visit 3-4 source pages, extract key information
 • Iterations 16-20: If needed, one more search or page visit
-• Iteration 20+: You MUST call "complete" with whatever you have. Do NOT start new searches after step 20.
+• Iterations 21+: Internal source searches (if configured) — ~10 iterations per source
+• Final 5 iterations: You MUST call "complete" with whatever you have. Do NOT start new searches.
 
 Hard rules:
 • NEVER retry a failed navigation — skip immediately

package/dist/agents/browser/prompts.js.map

@@ -1 +1 @@
-{"version":3,"file":"prompts.js","sourceRoot":"","sources":["../../../src/agents/browser/prompts.ts"],"names":[],"mappings":"AAOA,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEAwCoC,CAAC;AAEjE,MAAM,CAAC,MAAM,wBAAwB,GAAG,GAAG,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iGA4DmC,CAAC;AAElG,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAG,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8CAwEV,CAAC;AAE/C,MAAM,CAAC,MAAM,oBAAoB,GAAG,GAAG,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEAyJM,CAAC"}
+{"version":3,"file":"prompts.js","sourceRoot":"","sources":["../../../src/agents/browser/prompts.ts"],"names":[],"mappings":"AAOA,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEAwCoC,CAAC;AAEjE,MAAM,CAAC,MAAM,wBAAwB,GAAG,GAAG,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DAiLJ,CAAC;AAE3D,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAG,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4FAiGoC,CAAC;AAE7F,MAAM,CAAC,MAAM,oBAAoB,GAAG,GAAG,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEAmKM,CAAC"}

package/dist/agents/browser/search-agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search-agent.d.ts","sourceRoot":"","sources":["../../../src/agents/browser/search-agent.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAKpD,wBAAgB,uBAAuB,IAAI,YAAY,CAsCtD"}
+{"version":3,"file":"search-agent.d.ts","sourceRoot":"","sources":["../../../src/agents/browser/search-agent.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAOpD,wBAAgB,uBAAuB,IAAI,YAAY,CAwDtD"}

package/dist/agents/browser/search-agent.js

@@ -1,13 +1,14 @@
 import { BROWSER_SUB_AGENT_TOOLS } from '../../tools/browser/browser-tools.js';
 import { BrowserSubAgent } from './browser-sub-agent.js';
 import { SEARCH_SYSTEM_PROMPT } from './prompts.js';
+import { configManager } from '../../core/config/config-manager.js';
 export function createSearchRequestTool() {
     return {
         definition: {
             type: 'function',
             function: {
                 name: 'search_request',
-                description: 'Delegate a deep research task to the web search specialist agent. Performs comprehensive research across Google AND Naver simultaneously, visits actual source pages, cross-verifies facts, and returns a synthesized answer with citations. Use for any question requiring up-to-date information, fact-checking, comparisons, or multi-source research.',
+                description: 'Delegate a deep research task to the web search specialist agent. Performs comprehensive research across Google AND Naver simultaneously, visits actual source pages, cross-verifies facts, and returns a synthesized answer with citations. Also searches configured internal sources (Confluence, wikis, etc.) if available. Use for any question requiring up-to-date information, fact-checking, comparisons, or multi-source research.',
                 parameters: {
                     type: 'object',
                     properties: {
@@ -23,8 +24,20 @@ export function createSearchRequestTool() {
         execute: async (args, llmClient) => {
             const today = new Date().toISOString().split('T')[0];
             const rawInstruction = args['instruction'];
-            const instruction = `[Today's Date: ${today}]\n\n${rawInstruction}`;
-            const agent = new BrowserSubAgent(llmClient, 'search', BROWSER_SUB_AGENT_TOOLS, SEARCH_SYSTEM_PROMPT, { requiresAuth: false, serviceType: 'search', maxIterations: 30 });
+            let researchUrls = [];
+            try {
+                const config = configManager.getConfig();
+                researchUrls = config.researchUrls || [];
+            }
+            catch {
+            }
+            let instruction = `[Today's Date: ${today}]\n\n${rawInstruction}`;
+            if (researchUrls.length > 0) {
+                const urlList = researchUrls.map(r => `  - ${r.name}: ${r.url}`).join('\n');
+                instruction += `\n\n[Internal Research Sources]\nSearch these additional sources after web search:\n${urlList}`;
+            }
+            const maxIterations = 30 + researchUrls.length * 10;
+            const agent = new BrowserSubAgent(llmClient, 'search', BROWSER_SUB_AGENT_TOOLS, SEARCH_SYSTEM_PROMPT, { requiresAuth: false, serviceType: 'search', maxIterations });
             return agent.run(instruction);
         },
         categories: ['llm-agent'],

package/dist/agents/browser/search-agent.js.map

@@ -1 +1 @@
-{"version":3,"file":"search-agent.js","sourceRoot":"","sources":["../../../src/agents/browser/search-agent.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEpD,MAAM,UAAU,uBAAuB;IACrC,OAAO;QACL,UAAU,EAAE;YACV,IAAI,EAAE,UAAU;YAChB,QAAQ,EAAE;gBACR,IAAI,EAAE,gBAAgB;gBACtB,WAAW,EACT,2VAA2V;gBAC7V,UAAU,EAAE;oBACV,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE;wBACV,WAAW,EAAE;4BACX,IAAI,EAAE,QAAQ;4BACd,WAAW,EAAE,wHAAwH;yBACtI;qBACF;oBACD,QAAQ,EAAE,CAAC,aAAa,CAAC;iBAC1B;aACF;SACF;QACD,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE;YAEjC,MAAM,KAAK,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YACrD,MAAM,cAAc,GAAG,IAAI,CAAC,aAAa,CAAW,CAAC;YACrD,MAAM,WAAW,GAAG,kBAAkB,KAAK,QAAQ,cAAc,EAAE,CAAC;YAEpE,MAAM,KAAK,GAAG,IAAI,eAAe,CAC/B,SAAS,EACT,QAAQ,EACR,uBAAuB,EACvB,oBAAoB,EACpB,EAAE,YAAY,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,aAAa,EAAE,EAAE,EAAE,CAClE,CAAC;YACF,OAAO,KAAK,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QAChC,CAAC;QACD,UAAU,EAAE,CAAC,WAAW,CAAC;QACzB,cAAc,EAAE,IAAI;KACrB,CAAC;AACJ,CAAC"}
+{"version":3,"file":"search-agent.js","sourceRoot":"","sources":["../../../src/agents/browser/search-agent.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAGpE,MAAM,UAAU,uBAAuB;IACrC,OAAO;QACL,UAAU,EAAE;YACV,IAAI,EAAE,UAAU;YAChB,QAAQ,EAAE;gBACR,IAAI,EAAE,gBAAgB;gBACtB,WAAW,EACT,6aAA6a;gBAC/a,UAAU,EAAE;oBACV,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE;wBACV,WAAW,EAAE;4BACX,IAAI,EAAE,QAAQ;4BACd,WAAW,EAAE,wHAAwH;yBACtI;qBACF;oBACD,QAAQ,EAAE,CAAC,aAAa,CAAC;iBAC1B;aACF;SACF;QACD,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE;YAEjC,MAAM,KAAK,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YACrD,MAAM,cAAc,GAAG,IAAI,CAAC,aAAa,CAAW,CAAC;YAGrD,IAAI,YAAY,GAAwB,EAAE,CAAC;YAC3C,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,aAAa,CAAC,SAAS,EAAE,CAAC;gBACzC,YAAY,GAAG,MAAM,CAAC,YAAY,IAAI,EAAE,CAAC;YAC3C,CAAC;YAAC,MAAM,CAAC;YAET,CAAC;YAGD,IAAI,WAAW,GAAG,kBAAkB,KAAK,QAAQ,cAAc,EAAE,CAAC;YAClE,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC5B,MAAM,OAAO,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAC5E,WAAW,IAAI,uFAAuF,OAAO,EAAE,CAAC;YAClH,CAAC;YAGD,MAAM,aAAa,GAAG,EAAE,GAAG,YAAY,CAAC,MAAM,GAAG,EAAE,CAAC;YAEpD,MAAM,KAAK,GAAG,IAAI,eAAe,CAC/B,SAAS,EACT,QAAQ,EACR,uBAAuB,EACvB,oBAAoB,EACpB,EAAE,YAAY,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,aAAa,EAAE,CAC9D,CAAC;YACF,OAAO,KAAK,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QAChC,CAAC;QACD,UAAU,EAAE,CAAC,WAAW,CAAC;QACzB,cAAc,EAAE,IAAI;KACrB,CAAC;AACJ,CAAC"}

package/dist/agents/planner/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/agents/planner/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AACzD,OAAO,EAAE,OAAO,EAAY,cAAc,EAAc,MAAM,sBAAsB,CAAC;AASrF,OAAO,EAEL,eAAe,EAChB,MAAM,kDAAkD,CAAC;AAO1D,qBAAa,WAAW;IACtB,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,eAAe,CAAgC;gBAE3C,SAAS,EAAE,SAAS;IAQhC,kBAAkB,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;IAQnD,oBAAoB,IAAI,IAAI;IAatB,gBAAgB,CACpB,WAAW,EAAE,MAAM,EACnB,eAAe,CAAC,EAAE,OAAO,EAAE,GAC1B,OAAO,CAAC,cAAc,CAAC;IAgX1B,OAAO,CAAC,0BAA0B;CA8CnC;AAED,eAAe,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/agents/planner/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AACzD,OAAO,EAAE,OAAO,EAAY,cAAc,EAAc,MAAM,sBAAsB,CAAC;AASrF,OAAO,EAEL,eAAe,EAChB,MAAM,kDAAkD,CAAC;AAO1D,qBAAa,WAAW;IACtB,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,eAAe,CAAgC;gBAE3C,SAAS,EAAE,SAAS;IAQhC,kBAAkB,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;IAQnD,oBAAoB,IAAI,IAAI;IAatB,gBAAgB,CACpB,WAAW,EAAE,MAAM,EACnB,eAAe,CAAC,EAAE,OAAO,EAAE,GAC1B,OAAO,CAAC,cAAc,CAAC;IA8Y1B,OAAO,CAAC,0BAA0B;CA8CnC;AAED,eAAe,WAAW,CAAC"}

package/dist/agents/planner/index.js

@@ -23,7 +23,12 @@ export class PlanningLLM {
     async generateTODOList(userRequest, contextMessages) {
         const toolSummary = toolRegistry.getToolSummaryForPlanning();
         const optionalToolsInfo = toolRegistry.getEnabledOptionalToolsInfo();
-        const systemPrompt = buildPlanningSystemPrompt(toolSummary, optionalToolsInfo, getWindowsUserDesktopPath() || undefined);
+        let researchUrls;
+        try {
+            researchUrls = configManager.getConfig().researchUrls;
+        }
+        catch { }
+        const systemPrompt = buildPlanningSystemPrompt(toolSummary, optionalToolsInfo, getWindowsUserDesktopPath() || undefined, researchUrls);
         const clarificationMessages = [];
         const messages = [
             {
@@ -64,17 +69,18 @@ export class PlanningLLM {
                             role: 'user',
                             content: `[RETRY ${attempt}/${MAX_RETRIES}] ⚠️ CRITICAL: You are the PLANNING LLM, not the Execution LLM.
 
-You have ONLY 3 tools available:
+You have ONLY 4 tools available:
 1. 'ask_to_user' - To clarify ambiguous requirements (use FIRST if unclear)
 2. 'create_todos' - For ANY action/implementation request
 3. 'respond_to_user' - For pure knowledge questions/greetings only
+4. 'tell_to_user' - To send a message and then continue with create_todos
 
 ❌ DO NOT use tools like 'write_todos', 'read_file', 'bash', etc. Those are for Execution LLM, NOT you.
 ❌ You saw those tools in conversation history, but they are NOT available to you.
 
 Previous error: ${lastError?.message || 'Invalid response'}
 
-Choose one of your 3 tools now.`,
+Choose one of your 4 tools now.`,
                         });
                         logger.warn(`Planning LLM retry attempt ${attempt}/${MAX_RETRIES}`, { lastError: lastError?.message });
                     }
@@ -175,6 +181,25 @@ Choose one of your 3 tools now.`,
                                 continue;
                             }
                         }
+                        if (toolName === 'tell_to_user') {
+                            logger.flow('Planning LLM sending message to user via tell_to_user');
+                            const tellMessage = toolArgs.message;
+                            if (tellMessage) {
+                                const assistantMsg = {
+                                    role: 'assistant',
+                                    content: tellMessage,
+                                };
+                                messages.push(assistantMsg);
+                                clarificationMessages.push(assistantMsg);
+                            }
+                            messages.push({
+                                role: 'user',
+                                content: '[Message delivered] Now call create_todos to plan the tasks.',
+                            });
+                            askIterations++;
+                            shouldContinueMainLoop = true;
+                            break;
+                        }
                         if (toolName === 'create_todos') {
                             logger.flow('TODO list created via create_todos tool');
                             let rawTodos = toolArgs.todos;
@@ -225,7 +250,7 @@ Choose one of your 3 tools now.`,
                             };
                         }
                         logger.warn(`Unknown tool called: ${toolName}`);
-                        lastError = new Error(`Invalid tool "${toolName}". You only have 3 tools: ask_to_user, create_todos, or respond_to_user. Tools like write_todos are for Execution LLM, not Planning LLM.`);
+                        lastError = new Error(`Invalid tool "${toolName}". You only have 4 tools: ask_to_user, create_todos, respond_to_user, or tell_to_user. Tools like write_todos are for Execution LLM, not Planning LLM.`);
                         continue;
                     }
                     const contentOnly = message?.content;
@@ -264,11 +289,11 @@ Choose one of your 3 tools now.`,
                         logger.warn(`Planning LLM returned content without tool call (attempt ${attempt}/${MAX_RETRIES})`, {
                             contentPreview: contentOnly.substring(0, 100),
                         });
-                        lastError = new Error('You MUST call one of your tools: ask_to_user, create_todos, or respond_to_user. Do NOT respond with plain text.');
+                        lastError = new Error('You MUST call one of your tools: ask_to_user, create_todos, respond_to_user, or tell_to_user. Do NOT respond with plain text.');
                     }
                     else {
                         logger.warn(`Planning LLM returned no tool call and no content (attempt ${attempt}/${MAX_RETRIES})`);
-                        lastError = new Error('Planning LLM must use one of: ask_to_user, create_todos, or respond_to_user');
+                        lastError = new Error('Planning LLM must use one of: ask_to_user, create_todos, respond_to_user, or tell_to_user');
                     }
                 }
                 catch (error) {
@@ -302,7 +327,7 @@ Choose one of your 3 tools now.`,
         };
     }
     extractToolCallFromContent(content) {
-        const toolNames = ['create_todos', 'respond_to_user', 'ask_to_user'];
+        const toolNames = ['create_todos', 'respond_to_user', 'ask_to_user', 'tell_to_user'];
         for (const toolName of toolNames) {
             const funcPattern = new RegExp(`\\{[^{}]*"name"\\s*:\\s*"${toolName}"[^{}]*"arguments"\\s*:\\s*(\\{[\\s\\S]*?\\})\\s*\\}`);
             const funcMatch = content.match(funcPattern);