morpheus-cli 0.4.15 → 0.5.0

package/dist/runtime/oracle.js

@@ -1,23 +1,116 @@
-import { HumanMessage, SystemMessage } from "@langchain/core/messages";
+import { HumanMessage, SystemMessage, AIMessage, ToolMessage } from "@langchain/core/messages";
 import { ProviderFactory } from "./providers/factory.js";
-import { Construtor } from "./tools/factory.js";
 import { ConfigManager } from "../config/manager.js";
 import { ProviderError } from "./errors.js";
 import { DisplayManager } from "./display.js";
 import { SQLiteChatMessageHistory } from "./memory/sqlite.js";
 import { SatiMemoryMiddleware } from "./memory/sati/index.js";
 import { Apoc } from "./apoc.js";
+import { TaskRequestContext } from "./tasks/context.js";
+import { TaskRepository } from "./tasks/repository.js";
+import { Neo } from "./neo.js";
+import { NeoDelegateTool } from "./tools/neo-tool.js";
+import { ApocDelegateTool } from "./tools/apoc-tool.js";
+import { TaskQueryTool } from "./tools/task-query-tool.js";
 export class Oracle {
     provider;
     config;
     history;
     display = DisplayManager.getInstance();
+    taskRepository = TaskRepository.getInstance();
     databasePath;
     satiMiddleware = SatiMemoryMiddleware.getInstance();
     constructor(config, overrides) {
         this.config = config || ConfigManager.getInstance().get();
         this.databasePath = overrides?.databasePath;
     }
+    buildDelegationFailureResponse() {
+        return "Task enqueue could not be confirmed in the database. No task was created. Please retry.";
+    }
+    looksLikeSyntheticDelegationAck(text) {
+        const raw = (text || "").trim();
+        if (!raw)
+            return false;
+        // Detect the structured ack format that Oracle itself generates.
+        // LLMs can learn to reproduce this format from conversation history without calling any tool.
+        const hasAckTaskLine = /Task\s+`[0-9a-fA-F]{8}-[0-9a-fA-F]{4}/i.test(raw);
+        const hasAckAgentLine = /Agent:\s*`(APOC|NEO|apoc|neo)/i.test(raw);
+        const hasAckStatusLine = /Status:\s*`(QUEUED|PENDING|RUNNING|COMPLETED|FAILED)/i.test(raw);
+        if (hasAckTaskLine && hasAckAgentLine && hasAckStatusLine)
+            return true;
+        const hasCreationClaim = /(as\s+tarefas?\s+foram\s+criadas|tarefa\s+criada|nova\s+tarefa\s+criada|deleguei|delegado|delegada|tasks?\s+created|task\s+created|queued\s+for|agendei|agendado|agendada|foi\s+agendad)/i.test(raw);
+        if (!hasCreationClaim)
+            return false;
+        const hasAgentMention = /\b(apoc|neo|trinit)\b/i.test(raw);
+        const hasUuid = /\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}\b/.test(raw);
+        const hasAgentListLine = /(?:\*|-)?.{0,8}(apoc|neo|trinit)\s*[:：]/i.test(raw);
+        return hasCreationClaim && (hasAgentMention || hasUuid || hasAgentListLine);
+    }
+    buildDelegationAck(acks) {
+        const truncate = (s, max = 72) => s.length > max ? s.slice(0, max).trimEnd() + '…' : s;
+        if (acks.length === 1) {
+            const { task_id, agent } = acks[0];
+            const task = this.taskRepository.getTaskById(task_id);
+            const taskLine = task?.input ? `\n${truncate(task.input)}` : '';
+            return `✅\ Task \`${task_id.toUpperCase()}\`\nAgent: \`${agent.toUpperCase()}\`\nStatus: \`QUEUED\`${taskLine}`;
+        }
+        const lines = acks.map((a) => {
+            const task = this.taskRepository.getTaskById(a.task_id);
+            const label = task?.input ? ` — ${truncate(task.input, 50)}` : '';
+            return `• ${a.agent.toUpperCase()}: \`${a.task_id}\`${label}`;
+        }).join('\n');
+        return `Tasks:\n${lines}\n\nRunning...`;
+    }
+    buildDelegationAckResult(acks) {
+        return { content: this.buildDelegationAck(acks) };
+    }
+    extractDelegationAcksFromMessages(messages) {
+        const acks = [];
+        const regex = /Task\s+([0-9a-fA-F-]{36})\s+(?:queued|already queued)\s+for\s+(Apoc|Neo|apoc|neo)\s+execution/i;
+        for (const msg of messages) {
+            if (!(msg instanceof ToolMessage))
+                continue;
+            const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+            const match = regex.exec(content);
+            if (!match)
+                continue;
+            acks.push({ task_id: match[1], agent: match[2].toLowerCase() });
+        }
+        return acks;
+    }
+    validateDelegationAcks(acks, requestMessage) {
+        const deduped = new Map();
+        for (const ack of acks) {
+            deduped.set(`${ack.agent}:${ack.task_id}`, { task_id: ack.task_id, agent: ack.agent });
+        }
+        const valid = [];
+        for (const ack of deduped.values()) {
+            const task = this.taskRepository.getTaskById(ack.task_id);
+            if (!task) {
+                this.display.log(`Discarded delegation ack with unknown task id: ${ack.task_id}`, { source: "Oracle", level: "warning", meta: { requestMessage, agent: ack.agent } });
+                continue;
+            }
+            if (task.agent !== ack.agent) {
+                this.display.log(`Discarded delegation ack with agent mismatch for task ${ack.task_id}: ack=${ack.agent}, db=${task.agent}`, { source: "Oracle", level: "warning", meta: { requestMessage } });
+                continue;
+            }
+            valid.push(ack);
+        }
+        return valid;
+    }
+    hasDelegationToolCall(messages) {
+        for (const msg of messages) {
+            if (!(msg instanceof AIMessage))
+                continue;
+            const toolCalls = msg.tool_calls ?? [];
+            if (!Array.isArray(toolCalls))
+                continue;
+            if (toolCalls.some((tc) => tc?.name === "apoc_delegate" || tc?.name === "neo_delegate")) {
+                return true;
+            }
+        }
+        return false;
+    }
     async initialize() {
         if (!this.config.llm) {
             throw new Error("LLM configuration missing in config object.");
@@ -29,8 +122,10 @@ export class Oracle {
         // Note: API Key validation is delegated to ProviderFactory or the Provider itself 
         // to allow for Environment Variable fallback supported by LangChain.
         try {
-            const tools = await Construtor.create();
-            this.provider = await ProviderFactory.create(this.config.llm, tools);
+            // Refresh Neo tool catalog so neo_delegate description contains runtime tools list.
+            // Fail-open: Oracle can still initialize even if catalog refresh fails.
+            await Neo.refreshDelegateCatalog().catch(() => { });
+            this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool]);
             if (!this.provider) {
                 throw new Error("Provider factory returned undefined");
             }
@@ -50,7 +145,7 @@ export class Oracle {
             throw new ProviderError(this.config.llm.provider || 'unknown', err, "Oracle initialization failed");
         }
     }
-    async chat(message, extraUsage, isTelephonist) {
+    async chat(message, extraUsage, isTelephonist, taskContext) {
         if (!this.provider) {
             throw new Error("Oracle not initialized. Call initialize() first.");
         }
@@ -70,194 +165,54 @@ export class Oracle {
                 userMessage.usage_metadata = extraUsage;
             }
             const systemMessage = new SystemMessage(`
-You are  ${this.config.agent.name}, ${this.config.agent.personality}, the Oracle.
-
-Your role is to orchestrate tools, MCPs, and language models to accurately fulfill the Architect’s request.
-
-You are an operator, not a guesser.
-Accuracy, verification, and task completion are more important than speed.
-
---------------------------------------------------
-CORE OPERATING PRINCIPLES
---------------------------------------------------
-
-1. TOOL EVALUATION FIRST
-
-Before generating any final answer, evaluate whether an available tool or MCP can provide a more accurate, up-to-date, or authoritative result.
-
-If a tool can provide the answer, you MUST call the tool.
-
-Never generate speculative values when a tool can verify them.
-
-
-2. ACTIVE INTENT TRACKING (CRITICAL)
-
-You must always maintain the current active user intent until it is fully resolved.
-
-If you ask a clarification question, the original intent remains ACTIVE.
-
-When the user responds to a clarification, you MUST:
-
-- Combine the new information with the original request
-- Resume the same task
-- Continue the tool evaluation process
-- Complete the original objective
-
-You MUST NOT:
-- Treat clarification answers as new unrelated requests
-- Drop the original task
-- Change subject unexpectedly
-
-Clarifications are part of the same execution chain.
-
-
-3. NO HISTORICAL ASSUMPTIONS FOR DYNAMIC DATA
-
-If the user asks something that:
-
-- may change over time
-- depends on system state
-- depends on filesystem
-- depends on external APIs
-- was previously asked in the conversation
-
-You MUST NOT reuse previous outputs as final truth.
-
-You MUST:
-- Re-evaluate available tools
-- Re-execute relevant tools
-- Provide a fresh result
-
-Repeated queries require fresh verification.
-
-
-4. HISTORY IS CONTEXT, NOT SOURCE OF TRUTH
-
-Conversation history provides context, not verified data.
-
-Never assume:
-- System state
-- File contents
-- Database values
-- API responses
-
-based only on previous messages.
-
-
-5. TASK RESOLUTION LOOP
-
-You must operate in this loop:
-
-- Identify intent
-- Determine missing information (if any)
-- Ask clarification ONLY if necessary
-- When clarification is received, resume original task
-- Evaluate tools
-- Execute tools if applicable
-- Deliver verified answer
-
-Do not break this loop.
-
-
-6. TOOL PRIORITY OVER LANGUAGE GUESSING
-
-If a tool can compute, fetch, inspect, or verify something, prefer tool usage.
-
-Never hallucinate values retrievable via tools.
-
---------------------------------------------------
-DELEGATION DECISION PROTOCOL
---------------------------------------------------
-
-Before responding, classify the request into one of the following categories:
-
-CATEGORY A — Execution / System / External State
-If the request involves:
-- Filesystem access
-- Code execution
-- Git operations
-- Package management
-- Process inspection
-- Networking
-- Environment state
-- Browser automation
-- Web navigation
-- Web research
-- Fact verification
-- Current or time-sensitive data
-
-You MUST delegate to the appropriate tool (e.g., apoc_delegate).
-
-CATEGORY B — Factual Question Requiring Verification
-If the question involves:
-- Rankings
-- Results
-- Versions
-- News
-- Public figures
-- Statistics
-- Events
-- Anything that may have changed over time
-
-You MUST delegate to Apoc for verification.
-
-CATEGORY C — Pure Reasoning / Conceptual
-If the request can be fully answered through reasoning alone without external validation,
-you may answer directly without delegating.
-
-If uncertainty exists about whether verification is required,
-DELEGATE.
-
---------------------------------------------------
-APOC DELEGATION STANDARD
---------------------------------------------------
-
-When delegating to Apoc:
-
-- Provide a clear objective.
-- Specify verification requirements if factual.
-- Define expected output structure if needed.
-- Pass relevant context from the conversation.
-- Never send vague tasks.
-
-Weak delegation example (forbidden):
-"Search who won the championship."
-
-Correct delegation example:
-"Find who won the 2023 NBA Championship. Verify using at least 3 reliable sources. Provide URLs and confidence level."
-
---------------------------------------------------
-UNCERTAINTY RULE
---------------------------------------------------
-
-If the answer cannot be produced with high confidence without external verification,
-you MUST delegate.
-
-Never fabricate certainty.
-Never simulate tool results.
-When in doubt, delegate.
-
-
-7. FINAL ANSWER POLICY
-
-Provide a natural language answer only if:
-
-- No tool is relevant
-- Tools are unavailable
-- The request is purely conceptual
-
-Otherwise, use tools first.
-
---------------------------------------------------
-
-You are a deterministic orchestration layer.
-You do not drift.
-You do not abandon tasks.
-You do not speculate when verification is possible.
-
-You maintain intent until resolution.
-
-      `);
+You are ${this.config.agent.name}, ${this.config.agent.personality}, the Oracle.
+
+You are an orchestrator and task router.
+
+
+Rules:
+1. For conversation-only requests (greetings, conceptual explanation, memory follow-up, statements of fact, sharing personal information), answer directly. DO NOT create tasks or delegate for simple statements like "I have two cats" or "My name is John". Sati will automatically memorize facts in the background ( **ALWAYS** use SATI Memories to review or retrieve these facts if needed).
+**NEVER** Create data, use SATI memories to response on informal conversation or say that dont know abaout the awsor if the answer is in the memories. Always use the memories as source of truth for user facts, preferences, stable context and informal conversation. Use tools only for execution, verification or when external/system state is required.*
+2. For requests that require execution, verification, external/system state, or non-trivial operations, evaluate the available tools and choose the best one.
+3. For task status/check questions (for example: "consultou?", "status da task", "andamento"), use task_query directly and do not delegate.
+4. Prefer delegation tools when execution should be asynchronous, and return the task acknowledgement clearly.
+5. If the user asked for multiple independent actions in the same message, enqueue one delegated task per action. Each task must be atomic (single objective).
+6. If the user asked for a single action, do not create additional delegated tasks.
+7. Never fabricate execution results for delegated tasks.
+8. Keep responses concise and objective.
+9. Avoid duplicate delegations to the same tool or agent.
+10. After enqueuing all required delegated tasks for the current message, stop calling tools and return a concise acknowledgement.
+11. If a delegation is rejected as "not atomic", immediately split into smaller delegations and retry.
+
+Delegation quality:
+- Write delegation input in the same language requested by the user.
+- Include clear objective and constraints.
+- Include OS-aware guidance for network checks when relevant.
+- Use Sati memories only as context to complement the task, never as source of truth for dynamic data.
+- Use Sati memories to fill missing stable context fields (for example: city, timezone, language, currency, preferred units).
+- If Sati memory is conflicting or uncertain for a required field, ask one short clarification before delegating.
+- When completing missing fields from Sati, include explicit assumptions in delegation context using the format: "Assumption from Sati: key=value".
+- Never infer sensitive data from Sati memories (credentials, legal identifiers, health details, financial account data).
+- When assumptions were used, mention them briefly in the user-facing response and allow correction.
+- break the request into multiple delegations if it contains multiple independent actions.
+- Set a single task per delegation tool call. Do not combine multiple actions into one delegation, as it complicates execution and error handling.
+- If user requested N independent actions, produce N delegated tasks (or direct answers), each one singular and tool-scoped.
+- If use a delegation dont use the sati or messages history to answer directly in the same response. Just response with the delegations.
+Example 1:
+ask: "Tell me my account balance and do a ping on google.com"
+good:
+- delegate to "neo_delegate" with task "Check account balance using morpheus analytics MCP and return the result."
+- delegate to "apoc_delegate" with task "Ping google.com using the network diagnostics MCP and return reachability status. Use '-n' flag for Windows and '-c' for Linux/macOS."
+bad:
+- delegate to "neo_delegate" with task "Check account balance using morpheus analytics MCP and ping google.com using the network diagnostics MCP, then return both results." (combines two independent actions into one delegation, which is not atomic and complicates execution and error handling)
+
+Example 2:
+ask: "I have two cats" or "My name is John"
+good:
+- Answer directly acknowledging the fact. Do NOT delegate.
+bad:
+- delegate to "neo_delegate" or "apoc_delegate" to save the fact. (Sati handles this automatically in the background)
+`);
             // Load existing history from database in reverse order (most recent first)
             let previousMessages = await this.history.getMessages();
             previousMessages = previousMessages.reverse();
@@ -277,7 +232,15 @@ You maintain intent until resolution.
                 systemMessage
             ];
             if (memoryMessage) {
-                messages.push(memoryMessage);
+                // messages.push(memoryMessage);
+                systemMessage.content += `
+
+## Retrieved SATI Memory:
+${memoryMessage.content} 
+
+This memory may be relevant to the user's request.
+Use this to complemento the informal conversatrion.
+Use it to inform your response and tool selection (if needed), but do not assume it is 100% accurate or complete. Always validate against current inputs and tools.`;
             }
             messages.push(...previousMessages);
             messages.push(userMessage);
@@ -286,7 +249,19 @@ You maintain intent until resolution.
                 ? this.history.currentSessionId
                 : undefined;
             Apoc.setSessionId(currentSessionId);
-            const response = await this.provider.invoke({ messages });
+            Neo.setSessionId(currentSessionId);
+            const invokeContext = {
+                origin_channel: taskContext?.origin_channel ?? "api",
+                session_id: taskContext?.session_id ?? currentSessionId ?? "default",
+                origin_message_id: taskContext?.origin_message_id,
+                origin_user_id: taskContext?.origin_user_id,
+            };
+            let contextDelegationAcks = [];
+            const response = await TaskRequestContext.run(invokeContext, async () => {
+                const agentResponse = await this.provider.invoke({ messages });
+                contextDelegationAcks = TaskRequestContext.getDelegationAcks();
+                return agentResponse;
+            });
             // Identify new messages generated during the interaction
             // The `messages` array passed to invoke had length `messages.length`
             // The `response.messages` contains the full state.
@@ -301,14 +276,77 @@ You maintain intent until resolution.
                     model: this.config.llm.model
                 };
             }
-            // Persist user message + all generated messages in a single transaction
-            await this.history.addMessages([userMessage, ...newGeneratedMessages]);
+            let responseContent;
+            const toolDelegationAcks = this.extractDelegationAcksFromMessages(newGeneratedMessages);
+            const hadDelegationToolCall = this.hasDelegationToolCall(newGeneratedMessages);
+            const mergedDelegationAcks = [
+                ...contextDelegationAcks.map((ack) => ({ task_id: ack.task_id, agent: ack.agent })),
+                ...toolDelegationAcks,
+            ];
+            const validDelegationAcks = this.validateDelegationAcks(mergedDelegationAcks, message);
+            if (mergedDelegationAcks.length > 0) {
+                this.display.log(`Delegation trace: context=${contextDelegationAcks.length}, tool_messages=${toolDelegationAcks.length}, valid=${validDelegationAcks.length}`, { source: "Oracle", level: "info" });
+            }
+            const delegatedThisTurn = validDelegationAcks.length > 0;
+            let blockedSyntheticDelegationAck = false;
+            if (delegatedThisTurn) {
+                const ackResult = this.buildDelegationAckResult(validDelegationAcks);
+                responseContent = ackResult.content;
+                const ackMessage = new AIMessage(responseContent);
+                ackMessage.provider_metadata = {
+                    provider: this.config.llm.provider,
+                    model: this.config.llm.model,
+                };
+                if (ackResult.usage_metadata) {
+                    ackMessage.usage_metadata = ackResult.usage_metadata;
+                }
+                // Persist with addMessage so ack-provider usage is tracked per message row.
+                await this.history.addMessage(userMessage);
+                await this.history.addMessage(ackMessage);
+            }
+            else if (mergedDelegationAcks.length > 0 || hadDelegationToolCall) {
+                this.display.log(`Delegation attempted but no valid task id was confirmed (context=${contextDelegationAcks.length}, tool_messages=${toolDelegationAcks.length}, had_tool_call=${hadDelegationToolCall}).`, { source: "Oracle", level: "error" });
+                // Delegation was attempted but no valid task id could be confirmed in DB.
+                responseContent = this.buildDelegationFailureResponse();
+                const failureMessage = new AIMessage(responseContent);
+                failureMessage.provider_metadata = {
+                    provider: this.config.llm.provider,
+                    model: this.config.llm.model,
+                };
+                await this.history.addMessages([userMessage, failureMessage]);
+            }
+            else {
+                const lastMessage = response.messages[response.messages.length - 1];
+                responseContent = (typeof lastMessage.content === 'string') ? lastMessage.content : JSON.stringify(lastMessage.content);
+                if (this.looksLikeSyntheticDelegationAck(responseContent)) {
+                    blockedSyntheticDelegationAck = true;
+                    this.display.log("Blocked synthetic delegation acknowledgement without validated task creation.", { source: "Oracle", level: "error", meta: { preview: responseContent.slice(0, 200) } });
+                    const usage = lastMessage.usage_metadata
+                        ?? lastMessage.response_metadata?.usage
+                        ?? lastMessage.response_metadata?.tokenUsage
+                        ?? lastMessage.usage;
+                    responseContent = this.buildDelegationFailureResponse();
+                    const failureMessage = new AIMessage(responseContent);
+                    failureMessage.provider_metadata = {
+                        provider: this.config.llm.provider,
+                        model: this.config.llm.model,
+                    };
+                    if (usage) {
+                        failureMessage.usage_metadata = usage;
+                    }
+                    await this.history.addMessages([userMessage, failureMessage]);
+                }
+                else {
+                    // Persist user message + all generated messages in a single transaction
+                    await this.history.addMessages([userMessage, ...newGeneratedMessages]);
+                }
+            }
             this.display.log('Response generated.', { source: 'Oracle' });
-            const lastMessage = response.messages[response.messages.length - 1];
-            const responseContent = (typeof lastMessage.content === 'string') ? lastMessage.content : JSON.stringify(lastMessage.content);
-            // Sati Middleware: Evaluation (Fire and forget)
-            this.satiMiddleware.afterAgent(responseContent, [...previousMessages, userMessage], currentSessionId)
-                .catch((e) => this.display.log(`Sati memory evaluation failed: ${e.message}`, { source: 'Sati' }));
+            // Sati Middleware: skip memory evaluation for delegation-only acknowledgements.
+            if (!delegatedThisTurn && !blockedSyntheticDelegationAck) {
+                this.satiMiddleware.afterAgent(responseContent, [...previousMessages, userMessage], currentSessionId)
+                    .catch((e) => this.display.log(`Sati memory evaluation failed: ${e.message}`, { source: 'Sati' }));
+            }
             return responseContent;
         }
         catch (err) {
@@ -401,8 +439,9 @@ You maintain intent until resolution.
         if (!this.provider) {
             throw new Error("Oracle not initialized. Call initialize() first.");
         }
-        const tools = await Construtor.create();
-        this.provider = await ProviderFactory.create(this.config.llm, tools);
-        this.display.log(`MCP tools reloaded (${tools.length} tools)`, { source: 'Oracle' });
+        await Neo.refreshDelegateCatalog().catch(() => { });
+        this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool]);
+        await Neo.getInstance().reload();
+        this.display.log(`Oracle and Neo tools reloaded`, { source: 'Oracle' });
     }
 }

package/dist/runtime/providers/factory.js

@@ -5,7 +5,6 @@ import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
 import { ProviderError } from "../errors.js";
 import { createAgent, createMiddleware } from "langchain";
 import { DisplayManager } from "../display.js";
-import { ConfigQueryTool, ConfigUpdateTool, DiagnosticTool, MessageCountTool, TokenUsageTool, ProviderModelUsageTool, ApocDelegateTool } from "../tools/index.js";
 export class ProviderFactory {
     static buildMonitoringMiddleware() {
         const display = DisplayManager.getInstance();
@@ -103,17 +102,7 @@ export class ProviderFactory {
         try {
             const model = ProviderFactory.buildModel(config);
             const middleware = ProviderFactory.buildMonitoringMiddleware();
-            const toolsForAgent = [
-                ...tools,
-                ConfigQueryTool,
-                ConfigUpdateTool,
-                DiagnosticTool,
-                MessageCountTool,
-                TokenUsageTool,
-                ProviderModelUsageTool,
-                ApocDelegateTool
-            ];
-            return createAgent({ model, tools: toolsForAgent, middleware: [middleware] });
+            return createAgent({ model, tools, middleware: [middleware] });
         }
         catch (error) {
             ProviderFactory.handleProviderError(config, error);

package/dist/runtime/tasks/context.js

@@ -0,0 +1,53 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+const storage = new AsyncLocalStorage();
+export class TaskRequestContext {
+    static MAX_DELEGATIONS_PER_TURN = 6;
+    static run(ctx, fn) {
+        return storage.run({ ...ctx }, fn);
+    }
+    static get() {
+        return storage.getStore();
+    }
+    static getDelegationAck() {
+        const acks = storage.getStore()?.delegation_acks ?? [];
+        return acks[0];
+    }
+    static setDelegationAck(ack) {
+        const current = storage.getStore();
+        if (!current)
+            return;
+        if (!current.delegation_acks) {
+            current.delegation_acks = [];
+        }
+        current.delegation_acks.push(ack);
+    }
+    static getDelegationAcks() {
+        return storage.getStore()?.delegation_acks ?? [];
+    }
+    static canEnqueueDelegation() {
+        return this.getDelegationAcks().length < this.MAX_DELEGATIONS_PER_TURN;
+    }
+    static findDuplicateDelegation(agent, task) {
+        const acks = this.getDelegationAcks();
+        if (acks.length === 0)
+            return undefined;
+        const normalized = this.normalizeTask(task);
+        for (const ack of acks) {
+            if (ack.agent !== agent) {
+                continue;
+            }
+            const existing = this.normalizeTask(ack.task);
+            if (existing === normalized) {
+                return ack;
+            }
+        }
+        return undefined;
+    }
+    static normalizeTask(task) {
+        return task
+            .toLowerCase()
+            .replace(/[^\p{L}\p{N}\s]/gu, " ")
+            .replace(/\s+/g, " ")
+            .trim();
+    }
+}