onbuzz 4.10.0 → 5.0.0

package/src/tools/__tests__/taskManagerTool.test.js

@@ -294,6 +294,17 @@ describe('TaskManagerTool', () => {
       expect(result.summary).toContain('No remaining tasks');
     });
 
+    test('no-tasks hint tells the agent to wrap up, not re-run completed work', async () => {
+      // Fixes D1: on the grace cycle the agent re-ran the finished task.
+      // The hint must steer to job-done + STOP and forbid redoing work.
+      const { tool, agent, context } = createTestSetup();
+      await tool.execute({ action: 'create', title: 'Only', priority: 'medium' }, context);
+      const result = await tool.execute({ action: 'complete', taskId: agent.taskList.tasks[0].id }, context);
+      expect(result.summary).toMatch(/job-done/);
+      expect(result.summary).toMatch(/STOP/);
+      expect(result.summary).toMatch(/do NOT repeat|re-run|already finished/i);
+    });
+
     test('errors when no taskId and no in-progress tasks', async () => {
       const { tool, context } = createTestSetup();
       const result = await tool.execute({ action: 'complete' }, context);

package/src/tools/composioTool.js

@@ -7,9 +7,11 @@
  * runtime works even if it's not installed — agents without the
  * `composio` capability never see this tool.
  *
- * Auth model: per-user. We map agentId → Composio userId. Composio
- * holds the OAuth tokens server-side and auto-refreshes them. Our
- * code never sees raw tokens.
+ * Auth model: shared account entity. All agents act as the Composio entity
+ * COMPOSIO_USER_ID (default "operator") — the same entity the human uses to
+ * connect apps via the UI/CLI — so agents can use those connections. Composio
+ * holds the OAuth tokens server-side and auto-refreshes them. Our code never
+ * sees raw tokens.
  *
  * API key: resolved by composioService.getClient() — first checks the
  * encrypted vault (where the web-ui's Integrations page saves it),
@@ -31,8 +33,9 @@ import { ComposioIndexer } from '../services/embeddings/indexers/composioIndexer
 import * as composioService from '../services/composioService.js';
 
 const SUPPORTED_ACTIONS = [
-  'list-toolkits',          // discover available integrations
-  'list-tools',             // for a specific toolkit, list its action slugs + schemas
+  'list-toolkits',          // discover available integrations (COMPACT: slug+name+category)
+  'list-tools',             // for a specific toolkit, list its action slugs (COMPACT: no schemas)
+  'get-action-schema',      // fetch ONE action's full input schema, on demand before execute
   'connect',                // generate a Connect Link URL for the user to OAuth into a toolkit
   'connection-status',      // check whether the current user has an active connection to a toolkit
   'execute',                // invoke a Composio action with arguments
@@ -40,6 +43,113 @@ const SUPPORTED_ACTIONS = [
   'backfill-actions-index', // (re)build the catalog vector index for find-action
 ];
 
+/**
+ * Cap on how many items a single discovery action returns to the agent.
+ * The catalog has ~1043 toolkits; an unprojected list-toolkits result was
+ * ~1 MB (and list-tools with full JSON schemas hit tens of MB), which
+ * overflowed the agent's context, triggered chunking, and trapped agents
+ * in a discovery loop that never reached the actual task. We cap + project
+ * so discovery stays a few KB. find-action (semantic top-K) is the
+ * preferred path; list-toolkits is the fallback browse.
+ */
+const DISCOVERY_MAX_ITEMS = 200;
+
+/**
+ * Composio entity (userId) that agents act as.
+ *
+ * Connections (Gmail/Slack/…) are established once by the human through the
+ * UI/CLI, which use the literal entity "operator" (see webServer.js
+ * OPERATOR_USER). Agents MUST act as that same shared entity to use those
+ * connections — otherwise Composio resolves a per-agent entity that has no
+ * connected account and `execute` fails with ConnectedAccountNotFound (and
+ * connection-status misleadingly reports connected:true because it doesn't
+ * strictly scope to the agent's id). Using the agentId as the Composio
+ * userId was exactly that bug. Overridable via COMPOSIO_USER_ID for installs
+ * that want a different shared entity.
+ */
+const COMPOSIO_USER_ID = process.env.COMPOSIO_USER_ID || 'operator';
+
+/**
+ * Process-wide dedup handle for the one-time background build of the semantic
+ * actions index. Holds the in-flight promise so concurrent find-action calls
+ * don't each kick off a build. Reset to null on failure so a later call can
+ * retry. See _maybeAutoBuildIndex.
+ */
+let _autoIndexBuild = null;
+/** Test-only: clear the auto-index dedup handle between cases. */
+export function __resetAutoIndexForTests() { _autoIndexBuild = null; }
+
+/**
+ * Project a full toolkit object down to the few fields an agent needs to
+ * pick a toolkit: slug (to call list-tools/connect/execute), name (human
+ * label), category (to disambiguate), and noAuth (whether a connection is
+ * even required). Drops description, logo, timestamps, counts, auth-scheme
+ * arrays — none of which the agent needs to ROUTE, and which together are
+ * ~95% of the bytes.
+ *
+ * @param {object} t  a _camelizeToolkit-shaped object
+ * @returns {object}  compact { slug, name, category?, noAuth? }
+ */
+export function compactToolkit(t) {
+  if (!t || typeof t !== 'object') return t;
+  const cats = t.meta?.categories;
+  const category = Array.isArray(cats) && cats.length
+    ? (cats[0]?.name || cats[0]?.id || null)
+    : null;
+  const out = { slug: t.slug, name: t.name };
+  if (category) out.category = category;
+  if (t.noAuth === true) out.noAuth = true;
+  return out;
+}
+
+/**
+ * Project a full tool/action object down to what an agent needs to DECIDE
+ * whether this is the action it wants: slug (to execute / fetch schema),
+ * displayName, and a clamped one-line description. Critically drops the
+ * full input/output JSON schemas (which the old shape duplicated THREE
+ * times as inputParameters/input/parameters). The agent fetches the schema
+ * for the ONE action it chose via get-action-schema right before execute.
+ *
+ * @param {object} t  a _camelizeTool-shaped object
+ * @returns {object}  compact { slug, displayName, description? }
+ */
+export function compactTool(t) {
+  if (!t || typeof t !== 'object') return t;
+  const out = { slug: t.slug, displayName: t.displayName || t.name };
+  if (typeof t.description === 'string' && t.description) {
+    out.description = t.description.length > 160
+      ? t.description.slice(0, 160) + '…'
+      : t.description;
+  }
+  return out;
+}
+
+/**
+ * Best-effort count of how many items an execute result returned, so the
+ * agent knows the full size of a list payload and summarises ALL of them
+ * (models otherwise under-read large outputs). Looks for the common
+ * list-bearing keys composio actions use; returns null when the output
+ * isn't a recognisable collection.
+ *
+ * @param {*} output  the upstream action output
+ * @returns {number|null}
+ */
+export function countItems(output) {
+  if (Array.isArray(output)) return output.length;
+  if (!output || typeof output !== 'object') return null;
+  const LIST_KEYS = ['messages', 'items', 'results', 'data', 'emails', 'records', 'entries', 'rows', 'files', 'events'];
+  for (const k of LIST_KEYS) {
+    if (Array.isArray(output[k])) return output[k].length;
+  }
+  // One level deeper (e.g. { response_data: { messages: [...] } }).
+  for (const v of Object.values(output)) {
+    if (v && typeof v === 'object' && !Array.isArray(v)) {
+      for (const k of LIST_KEYS) if (Array.isArray(v[k])) return v[k].length;
+    }
+  }
+  return null;
+}
+
 class ComposioTool extends BaseTool {
   constructor(config = {}, logger = null) {
     super(config, logger);
@@ -58,10 +168,40 @@ class ComposioTool extends BaseTool {
 
   getDescription() {
     return `
-Composio Tool: third-party integration hub. Connects agents to ~250 apps
+Composio Tool: third-party integration hub. Connects agents to ~1000 apps
 (Gmail, Slack, GitHub, Linear, Notion, Drive, Sheets, Calendar, etc.)
 via Composio's hosted OAuth and unified action API.
 
+### DISCOVERY DISCIPLINE (READ THIS FIRST)
+The catalog has ~1000 toolkits and tens of thousands of actions. DO NOT
+browse it blindly — that floods your context and stalls the task.
+
+The fast path is just TWO steps — take it whenever find-action gives you a
+confident hit:
+  1. **find-action** with a natural-language query ("read my gmail inbox",
+     "create a github issue"). It returns a small ranked list WITH each hit's
+     actionSlug + toolkitSlug + input schema. If the top hit is clearly the
+     right action, go STRAIGHT to step 2 — do not also call list-tools or
+     connection-status first.
+  2. **execute** { toolkitSlug, actionSlug, arguments }. If find-action
+     didn't include the schema, call **get-action-schema** once between 1
+     and 2. That's it.
+
+Only widen discovery when the fast path doesn't apply:
+  - **list-toolkits** — COMPACT browse (slug + name + category, first
+    ${DISCOVERY_MAX_ITEMS}). Use only when you don't yet know which app.
+  - **list-tools** <toolkitSlug> — a toolkit's action slugs + names (no
+    schemas). Use only when find-action's hits look wrong/empty.
+
+DON'T:
+  - Don't call the SAME discovery action twice with the same args — the
+    result is already in your context; re-issuing wastes a turn.
+  - Don't call **connection-status** preemptively. Just execute. Only check
+    connection-status if execute fails with a "not connected" error, then
+    use **connect** to get a Connect Link for the user.
+  - Connections are shared across all agents — if you (or the user) connected
+    an app once, it's already usable. Don't re-connect.
+
 USAGE (plural canonical — same shape as other tools):
 \`\`\`json
 {
@@ -115,8 +255,9 @@ Returns: { connected: true|false, status: "ACTIVE"|"INITIATED"|"FAILED", connect
 Returns: { success: true|false, output: <upstream result>, error? }
 
 NOTES:
-- Each agent is mapped to a distinct Composio userId (agentId is reused).
-  Tokens are isolated per-agent.
+- All agents act as one shared Composio account (the same identity you use to
+  connect apps in Settings → Integrations), so any app you connect once is
+  usable by every agent. You do NOT need to connect apps per-agent.
 - The org-level API key is resolved by composioService: encrypted vault
   first (saved via Settings → Integrations), then \`COMPOSIO_API_KEY\`
   env var as an operator fallback.
@@ -166,6 +307,10 @@ NOTES:
           if (!a.toolkitSlug) errors.push(`${tag}toolkitSlug is required for execute`);
           if (!a.actionSlug)  errors.push(`${tag}actionSlug is required for execute`);
           break;
+        case 'get-action-schema':
+          if (!a.toolkitSlug) errors.push(`${tag}toolkitSlug is required for get-action-schema`);
+          if (!a.actionSlug)  errors.push(`${tag}actionSlug is required for get-action-schema`);
+          break;
         case 'find-action':
           if (!a.query || typeof a.query !== 'string' || !a.query.trim()) {
             errors.push(`${tag}query is required for find-action`);
@@ -200,7 +345,7 @@ NOTES:
       return { success: false, error: 'composio requires `action` (singular) or `actions` (plural array).' };
     }
 
-    const userId = context.agentId || 'default-user';
+    const userId = COMPOSIO_USER_ID;
     const { client, error: sdkErr } = await this._loadSdk();
     if (sdkErr) {
       return {
@@ -279,7 +424,7 @@ NOTES:
     const topK = Number.isInteger(action.topK) && action.topK > 0 ? action.topK : 10;
     const hybrid = action.hybrid !== false;
     const toolkitSlug = typeof action.toolkitSlug === 'string' && action.toolkitSlug ? action.toolkitSlug : null;
-    const userId = context.agentId || 'default-user';
+    const userId = COMPOSIO_USER_ID;
 
     // Try the embedding path first. We DEGRADE GRACEFULLY: if embeddings
     // are missing, disabled, the index is empty, or search throws, we
@@ -336,7 +481,11 @@ NOTES:
       upgradeHint = 'Enable an embedding provider in Settings → Embeddings for semantic ranking.';
     } else if (fallbackCause === 'index-empty') {
       reason = 'Catalog index is empty.';
-      upgradeHint = 'Run `composio.backfill-actions-index` once to enable semantic ranking.';
+      upgradeHint = 'Building the semantic index now in the background; the next find-action will be sharper.';
+      // Self-heal: kick off a one-time background build of the index for the
+      // user's connected toolkits so subsequent calls (and future restarts —
+      // the store persists to disk) get semantic ranking. Non-blocking.
+      this._maybeAutoBuildIndex(userId);
     } else {
       // 'embedding-search-failed'
       reason = `Embedding search failed${embeddingErrorDetail ? ` (${embeddingErrorDetail})` : ''}.`;
@@ -378,15 +527,53 @@ NOTES:
     if (qTokens.length === 0) {
       return { success: true, action: 'find-action', mode: 'substring-fallback', query, topK, toolkitSlug, hits: [], message: 'No searchable tokens in query.' };
     }
-    const scoreText = (text) => {
-      const tTokens = tokenize(text);
+    // Synonym groups so intent survives the vocabulary gap between a user's
+    // phrasing and Composio's action names — e.g. "read my emails" should
+    // rank GMAIL_FETCH_EMAILS, not GMAIL_LIST_LABELS. Without this, pure
+    // token overlap gives both the same "gmail" hit and ties on noise.
+    const SYNONYM_GROUPS = [
+      ['read', 'fetch', 'get', 'list', 'retrieve', 'view', 'show', 'find', 'search'],
+      ['email', 'emails', 'mail', 'message', 'messages', 'inbox', 'gmail'],
+      ['send', 'create', 'compose', 'dispatch', 'post', 'draft'],
+      ['delete', 'remove', 'trash'],
+      ['update', 'modify', 'edit', 'change'],
+      ['label', 'labels', 'folder', 'category'],
+      ['event', 'events', 'calendar', 'meeting', 'meetings'],
+      ['file', 'files', 'document', 'documents', 'attachment', 'attachments'],
+      ['channel', 'channels', 'conversation', 'conversations'],
+      ['user', 'users', 'member', 'members', 'contact', 'contacts'],
+    ];
+    const synonymsFor = (token) => {
+      const out = new Set();
+      for (const g of SYNONYM_GROUPS) {
+        if (g.includes(token)) for (const w of g) if (w !== token) out.add(w);
+      }
+      return out;
+    };
+    const qSet = new Set(qTokens);
+    const synSet = new Set();
+    for (const q of qTokens) for (const sy of synonymsFor(q)) if (!qSet.has(sy)) synSet.add(sy);
+
+    // Score one text field by DISTINCT query-concept coverage — each query
+    // token (and each synonym) counts AT MOST ONCE per field. Summing raw
+    // occurrences let a keyword-dense description dominate (observed live:
+    // GMAIL_LIST_LABELS' verbose blurb outscored GMAIL_FETCH_EMAILS for
+    // "read my emails"). Coverage-based scoring neutralises verbosity so the
+    // action NAME (weighted 2× by the caller) is the deciding signal.
+    // `weight` lets callers rank a name match above a description match.
+    const scoreText = (text, weight = 1) => {
+      const present = new Set(tokenize(text));
+      if (present.size === 0) return 0;
       let s = 0;
-      for (const q of qTokens) {
-        for (const t of tTokens) {
-          if (t === q) s += 3;        // exact token match
-          else if (t.includes(q) || q.includes(t)) s += 1; // substring either way
+      for (const q of qSet) {
+        if (present.has(q)) { s += 3 * weight; continue; }    // exact query token
+        for (const t of present) {                            // loose substring either way
+          if (t.includes(q) || q.includes(t)) { s += 1 * weight; break; }
         }
       }
+      for (const sy of synSet) {                              // synonym of a query token
+        if (present.has(sy)) s += 2 * weight;
+      }
       return s;
     };
 
@@ -432,8 +619,9 @@ NOTES:
       const r = await composioService.listTools(tk.slug, userId);
       if (!r.success) continue;
       for (const tool of (r.tools || [])) {
-        const text = `${tool.slug || ''} ${tool.displayName || tool.name || ''} ${tool.description || ''}`;
-        const score = scoreText(text);
+        // Name match (slug + displayName) weighted 2×; description 1×.
+        const nameText = `${tool.slug || ''} ${tool.displayName || tool.name || ''}`;
+        const score = scoreText(nameText, 2) + scoreText(tool.description || '', 1);
         if (score > 0) {
           allHits.push({
             toolkitSlug:  tk.slug,
@@ -461,6 +649,62 @@ NOTES:
     };
   }
 
+  /**
+   * One-time, background build of the semantic actions index — scoped to the
+   * user's CONNECTED toolkits.
+   *
+   * find-action degrades to substring when the index is empty (which it is
+   * after a fresh install/restart until something builds it). This self-heals
+   * that: the first find-action that finds an empty index kicks off a build so
+   * subsequent calls get semantic ranking, and — because the vector store
+   * persists to disk — every future restart loads it for free.
+   *
+   * Why CONNECTED toolkits only, not the whole catalog: the full ~1000-toolkit
+   * catalog is tens of thousands of actions and takes ~an hour to embed —
+   * far too heavy to fire off a user's request. Connected toolkits are a
+   * handful, build in seconds, and are the only apps an agent can actually
+   * EXECUTE against anyway. Unconnected apps stay on substring, which is fine
+   * for "which app?" discovery.
+   *
+   * Deduped process-wide, fire-and-forget, never throws into the caller.
+   *
+   * @param {string} userId
+   * @private
+   */
+  _maybeAutoBuildIndex(userId) {
+    if (_autoIndexBuild) return _autoIndexBuild;       // already building / built this process
+    const indexer = this._getComposioIndexer();
+    if (!indexer || !indexer.isEnabled) return null;   // can't build without embeddings
+    _autoIndexBuild = (async () => {
+      const conns = await composioService.listConnections(userId);
+      const slugs = [...new Set((conns?.connections || [])
+        .map(c => c && c.toolkitSlug)
+        .filter(s => typeof s === 'string' && s))];
+      if (slugs.length === 0) {
+        // Nothing connected yet — let a later find-action retry once the
+        // user connects an app, rather than latching "done" forever.
+        this.logger?.info?.('[composio] no connected toolkits — skipping semantic index build');
+        _autoIndexBuild = null;
+        return { skipped: 'no-connections' };
+      }
+      this.logger?.info?.('[composio] building semantic actions index for connected toolkits (one-time)', { toolkits: slugs });
+      const fetcher = async (slug) => {
+        const r = await composioService.listTools(slug, userId);
+        return r.success ? (r.tools || []) : [];
+      };
+      const res = await indexer.indexCatalog(slugs.map(slug => ({ slug })), fetcher);
+      this.logger?.info?.('[composio] semantic actions index built', {
+        indexedActions: res?.indexedActions, toolkits: slugs.length,
+      });
+      return res;
+    })().catch((err) => {
+      this.logger?.warn?.('[composio] background index build failed; will retry on a later find-action', { error: err?.message });
+      _autoIndexBuild = null;                           // allow a later find-action to retry
+      return null;
+    });
+    return _autoIndexBuild;
+  }
+
   /**
    * Execute backfill-actions-index: walk every Composio toolkit, fetch
    * its actions, embed them all in batched calls, write the global
@@ -535,15 +779,80 @@ NOTES:
           // collapse to `[]` via the `|| []` fallback, which is how
           // agents saw "0 toolkits" even when integrations existed.
           const r = await composioService.listToolkits();
-          return r.success
-            ? { success: true, action: 'list-toolkits', toolkits: r.toolkits }
-            : { success: false, action: 'list-toolkits', error: r.error };
+          if (!r.success) {
+            return { success: false, action: 'list-toolkits', error: r.error };
+          }
+          // PROJECT to compact shape + cap. An unprojected catalog dump
+          // (~1043 toolkits, ~1 MB) overflows the agent's context and
+          // traps it in a discovery loop. Compact = slug/name/category,
+          // a few KB. If the catalog exceeds the cap we tell the agent to
+          // narrow via find-action rather than silently truncating blind.
+          const all = Array.isArray(r.toolkits) ? r.toolkits : [];
+          const capped = all.slice(0, DISCOVERY_MAX_ITEMS);
+          return {
+            success: true,
+            action: 'list-toolkits',
+            total: all.length,
+            returned: capped.length,
+            truncated: all.length > capped.length,
+            toolkits: capped.map(compactToolkit),
+            hint: all.length > capped.length
+              ? `Showing first ${capped.length} of ${all.length} toolkits. Prefer find-action with a query (e.g. "send gmail email") to locate the exact action instead of browsing the full catalog.`
+              : 'Use list-tools <toolkitSlug> for a toolkit\'s actions, or find-action with a query to jump straight to the action you need.',
+          };
         }
         case 'list-tools': {
           const r = await composioService.listTools(action.toolkitSlug, userId);
-          return r.success
-            ? { success: true, action: 'list-tools', toolkitSlug: action.toolkitSlug, tools: r.tools }
-            : { success: false, action: 'list-tools', toolkitSlug: action.toolkitSlug, error: r.error };
+          if (!r.success) {
+            return { success: false, action: 'list-tools', toolkitSlug: action.toolkitSlug, error: r.error };
+          }
+          // PROJECT to compact shape (no schemas) + cap. The full tool
+          // objects triple-duplicate the JSON input schema; a toolkit with
+          // many actions blew up to MBs. Compact = slug/displayName/desc.
+          // The agent fetches ONE action's schema via get-action-schema
+          // right before execute.
+          const allTools = Array.isArray(r.tools) ? r.tools : [];
+          const cappedTools = allTools.slice(0, DISCOVERY_MAX_ITEMS);
+          return {
+            success: true,
+            action: 'list-tools',
+            toolkitSlug: action.toolkitSlug,
+            total: allTools.length,
+            returned: cappedTools.length,
+            truncated: allTools.length > cappedTools.length,
+            tools: cappedTools.map(compactTool),
+            hint: 'Call get-action-schema { toolkitSlug, actionSlug } to fetch the chosen action\'s input schema before execute.',
+          };
+        }
+        case 'get-action-schema': {
+          // On-demand fetch of ONE action's full input schema. Lets the
+          // agent get exactly the schema it needs to build execute args,
+          // without ever pulling every action's schema (the old bloat).
+          const r = await composioService.listTools(action.toolkitSlug, userId);
+          if (!r.success) {
+            return { success: false, action: 'get-action-schema', toolkitSlug: action.toolkitSlug, error: r.error };
+          }
+          const match = (Array.isArray(r.tools) ? r.tools : [])
+            .find(t => t && t.slug === action.actionSlug);
+          if (!match) {
+            return {
+              success: false,
+              action: 'get-action-schema',
+              toolkitSlug: action.toolkitSlug,
+              actionSlug: action.actionSlug,
+              error: `Action "${action.actionSlug}" not found in toolkit "${action.toolkitSlug}". Use list-tools to see available action slugs.`,
+            };
+          }
+          return {
+            success: true,
+            action: 'get-action-schema',
+            toolkitSlug: action.toolkitSlug,
+            actionSlug: action.actionSlug,
+            displayName: match.displayName || match.name,
+            description: match.description,
+            inputParameters: match.inputParameters,
+            outputParameters: match.outputParameters,
+          };
         }
         case 'connect': {
           // composioService.connect maps the cryptic SDK error
@@ -587,16 +896,29 @@ NOTES:
           };
         }
         case 'execute': {
+          // `version: 'latest'` + dangerouslySkipVersionCheck: without a
+          // version, composio-core 0.6.x rejects manual execution with
+          // "Toolkit version not specified". We always run the toolkit's
+          // current version (the agent fetches the live schema via
+          // get-action-schema right before execute, so latest is correct).
           const result = await client.tools?.execute?.(action.actionSlug, {
             userId,
             arguments: action.arguments || {},
+            version: 'latest',
+            dangerouslySkipVersionCheck: true,
           });
+          const output = result?.data ?? result?.output ?? result;
           return {
             success: result?.successful !== false,
             action: 'execute',
             actionSlug: action.actionSlug,
             toolkitSlug: action.toolkitSlug,
-            output: result?.data ?? result?.output ?? result,
+            // Surface how many items the action returned. Models routinely
+            // under-read large list payloads and summarise only the first
+            // few (observed: agent summarised 3 of 5 fetched emails). An
+            // explicit count tells the agent exactly how many to cover.
+            ...(typeof countItems(output) === 'number' ? { itemCount: countItems(output) } : {}),
+            output,
             error: result?.error || null,
           };
         }

package/src/tools/taskManagerTool.js

@@ -635,9 +635,14 @@ Always use a detailed task description to provide context for the task, and leve
         this.logger?.debug(`TTL set to 1 for agent ${agentId} - no remaining tasks`);
       }
 
-      // When no actionable tasks remain, prompt the agent to decide next steps
+      // When no actionable tasks remain, prompt the agent to WRAP UP — not
+      // to re-start. Observed failure: after completing a one-shot request
+      // and delivering the answer, the agent used its grace cycle to re-run
+      // the whole task (re-fetched + re-summarised). The hint now makes the
+      // terminal action unambiguous: if the work is done and you've already
+      // answered, call job-done and STOP — do not redo completed work.
       const noTasksHint = pendingCount === 0
-        ? '\n\n[No remaining tasks] Have you fulfilled the user\'s request? If so, call job-done with a summary. Otherwise, update your task list to reflect what still needs to be done.'
+        ? '\n\n[No remaining tasks] All tasks are complete. If you have already delivered the answer to the user, call job-done with a brief summary and STOP — do NOT repeat or re-run work you have already finished. Only create a new task if there is genuinely NEW, unfinished work the user asked for.'
         : '';
 
       // Always include the full current task list in the response envelope

package/web-ui/build/index.html

@@ -6,8 +6,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Loxia Autopilot One</title>
     <meta name="description" content="AI Agents System - No-code/vibe-code/companion-coder platform" />
-    <script type="module" crossorigin src="/static/index-CMB6tjnk.js"></script>
-    <link rel="stylesheet" crossorigin href="/static/index-BdXFo8aC.css">
+    <script type="module" crossorigin src="/static/index-BgFqNh2p.js"></script>
+    <link rel="stylesheet" crossorigin href="/static/index-BoHnY9Pw.css">
   </head>
   <body>
     <div id="root"></div>

package/web-ui/build/static/1c-DRgYKojf.js

@@ -0,0 +1,2 @@
+import{g as f}from"./index-BgFqNh2p.js";import{r as s}from"./index-DF39mRfk.js";function i(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const c=Object.getOwnPropertyDescriptor(e,r);c&&Object.defineProperty(t,r,c.get?c:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var a=s();const p=f(a),l=i({__proto__:null,default:p},[a]);export{l as _};
+//# sourceMappingURL=1c-DRgYKojf.js.map

package/web-ui/build/static/1c-DRgYKojf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"1c-DRgYKojf.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/abap-BHq6UPHP.js

@@ -0,0 +1,2 @@
+import{g as s,r as f}from"./index-BgFqNh2p.js";function c(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var p=f();const i=s(p),b=c({__proto__:null,default:i},[p]);export{b as a};
+//# sourceMappingURL=abap-BHq6UPHP.js.map

package/web-ui/build/static/abap-BHq6UPHP.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abap-BHq6UPHP.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/abnf-6NpltExs.js

@@ -0,0 +1,2 @@
+import{g as s,a as c}from"./index-BgFqNh2p.js";function i(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var f=c();const p=s(f),b=i({__proto__:null,default:p},[f]);export{b as a};
+//# sourceMappingURL=abnf-6NpltExs.js.map

package/web-ui/build/static/abnf-6NpltExs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abnf-6NpltExs.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/abnf-DjSLvRKM.js

@@ -0,0 +1,2 @@
+import{g as s}from"./index-BgFqNh2p.js";import{a as i}from"./index-DF39mRfk.js";function c(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var f=i();const p=s(f),g=c({__proto__:null,default:p},[f]);export{g as a};
+//# sourceMappingURL=abnf-DjSLvRKM.js.map

package/web-ui/build/static/abnf-DjSLvRKM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abnf-DjSLvRKM.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/accesslog-Cz1NeVVu.js

@@ -0,0 +1,2 @@
+import{g as n}from"./index-BgFqNh2p.js";import{b as f}from"./index-DF39mRfk.js";function g(t,c){for(var o=0;o<c.length;o++){const e=c[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const s=Object.getOwnPropertyDescriptor(e,r);s&&Object.defineProperty(t,r,s.get?s:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var a=f();const l=n(a),u=g({__proto__:null,default:l},[a]);export{u as a};
+//# sourceMappingURL=accesslog-Cz1NeVVu.js.map

package/web-ui/build/static/accesslog-Cz1NeVVu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accesslog-Cz1NeVVu.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/actionscript-BTT6NgN6.js

@@ -0,0 +1,2 @@
+import{g as a}from"./index-BgFqNh2p.js";import{c as s}from"./index-DF39mRfk.js";function p(r,i){for(var o=0;o<i.length;o++){const t=i[o];if(typeof t!="string"&&!Array.isArray(t)){for(const e in t)if(e!=="default"&&!(e in r)){const c=Object.getOwnPropertyDescriptor(t,e);c&&Object.defineProperty(r,e,c.get?c:{enumerable:!0,get:()=>t[e]})}}}return Object.freeze(Object.defineProperty(r,Symbol.toStringTag,{value:"Module"}))}var n=s();const f=a(n),l=p({__proto__:null,default:f},[n]);export{l as a};
+//# sourceMappingURL=actionscript-BTT6NgN6.js.map

package/web-ui/build/static/actionscript-BTT6NgN6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actionscript-BTT6NgN6.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/actionscript-C1Li7fUv.js

@@ -0,0 +1,2 @@
+import{g as a,b as s}from"./index-BgFqNh2p.js";function p(r,i){for(var o=0;o<i.length;o++){const t=i[o];if(typeof t!="string"&&!Array.isArray(t)){for(const e in t)if(e!=="default"&&!(e in r)){const c=Object.getOwnPropertyDescriptor(t,e);c&&Object.defineProperty(r,e,c.get?c:{enumerable:!0,get:()=>t[e]})}}}return Object.freeze(Object.defineProperty(r,Symbol.toStringTag,{value:"Module"}))}var n=s();const f=a(n),g=p({__proto__:null,default:f},[n]);export{g as a};
+//# sourceMappingURL=actionscript-C1Li7fUv.js.map

package/web-ui/build/static/actionscript-C1Li7fUv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actionscript-C1Li7fUv.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/ada-2yP6rDa7.js

@@ -0,0 +1,2 @@
+import{g as f,c}from"./index-BgFqNh2p.js";function i(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var s=c();const p=f(s),d=i({__proto__:null,default:p},[s]);export{d as a};
+//# sourceMappingURL=ada-2yP6rDa7.js.map

package/web-ui/build/static/ada-2yP6rDa7.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ada-2yP6rDa7.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/ada-RBt265BZ.js

@@ -0,0 +1,2 @@
+import{g as s}from"./index-BgFqNh2p.js";import{d as i}from"./index-DF39mRfk.js";function c(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var f=i();const p=s(f),g=c({__proto__:null,default:p},[f]);export{g as a};
+//# sourceMappingURL=ada-RBt265BZ.js.map

package/web-ui/build/static/ada-RBt265BZ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ada-RBt265BZ.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/agda-CO3AGN_k.js

@@ -0,0 +1,2 @@
+import{g as f,d as g}from"./index-BgFqNh2p.js";function c(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var s=g();const i=f(s),p=c({__proto__:null,default:i},[s]);export{p as a};
+//# sourceMappingURL=agda-CO3AGN_k.js.map

package/web-ui/build/static/agda-CO3AGN_k.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agda-CO3AGN_k.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/al-B1PXE9sO.js

@@ -0,0 +1,2 @@
+import{g as f,e as l}from"./index-BgFqNh2p.js";function c(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var s=l();const i=f(s),u=c({__proto__:null,default:i},[s]);export{u as a};
+//# sourceMappingURL=al-B1PXE9sO.js.map

package/web-ui/build/static/al-B1PXE9sO.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"al-B1PXE9sO.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/angelscript-Cn8h1jFU.js

@@ -0,0 +1,2 @@
+import{g as i}from"./index-BgFqNh2p.js";import{e as c}from"./index-DF39mRfk.js";function p(t,a){for(var o=0;o<a.length;o++){const e=a[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const n=Object.getOwnPropertyDescriptor(e,r);n&&Object.defineProperty(t,r,n.get?n:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var s=c();const f=i(s),u=p({__proto__:null,default:f},[s]);export{u as a};
+//# sourceMappingURL=angelscript-Cn8h1jFU.js.map

package/web-ui/build/static/angelscript-Cn8h1jFU.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"angelscript-Cn8h1jFU.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}