@madh-io/alfred-ai 0.7.0 → 0.7.2

package/bundle/index.js

@@ -2035,6 +2035,29 @@ For complex tasks, work through multiple steps:
 - Documents: ${homeDir}/Documents
 - Desktop: ${homeDir}/Desktop
 - Downloads: ${homeDir}/Downloads`;
+        const serverTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        const effectiveTimezone = userProfile?.timezone || serverTimezone;
+        const now = /* @__PURE__ */ new Date();
+        const timeStr = now.toLocaleTimeString("en-GB", {
+          timeZone: effectiveTimezone,
+          hour: "2-digit",
+          minute: "2-digit"
+        });
+        const dateStr = now.toLocaleDateString("en-CA", { timeZone: effectiveTimezone });
+        const dayStr = now.toLocaleDateString("en-US", { timeZone: effectiveTimezone, weekday: "long" });
+        prompt += `
+
+## Current date & time`;
+        prompt += `
+- Timezone: ${effectiveTimezone}`;
+        prompt += `
+- Date: ${dateStr} (${dayStr})`;
+        prompt += `
+- Time: ${timeStr}`;
+        if (userProfile?.timezone && userProfile.timezone !== serverTimezone) {
+          prompt += `
+- Server timezone: ${serverTimezone}`;
+        }
         if (skills && skills.length > 0) {
           prompt += "\n\n## Available tools\n";
           for (const s of skills) {
@@ -2049,13 +2072,8 @@ For complex tasks, work through multiple steps:
 - Name: ${userProfile.displayName}`;
           }
           if (userProfile.timezone) {
-            const now = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-GB", {
-              timeZone: userProfile.timezone,
-              hour: "2-digit",
-              minute: "2-digit"
-            });
             prompt += `
-- Timezone: ${userProfile.timezone} (Current local time: ${now})`;
+- Timezone: ${userProfile.timezone}`;
           }
           if (userProfile.language) {
             prompt += `
@@ -2526,20 +2544,120 @@ var init_skill_registry = __esm({
 });
 
 // ../skills/dist/skill-sandbox.js
-var DEFAULT_TIMEOUT_MS, SkillSandbox;
+var DEFAULT_TIMEOUT_MS, INACTIVITY_THRESHOLD_MS, POLL_INTERVAL_MS, MAX_TOTAL_TIME_MS, SkillSandbox;
 var init_skill_sandbox = __esm({
   "../skills/dist/skill-sandbox.js"() {
     "use strict";
     DEFAULT_TIMEOUT_MS = 3e4;
+    INACTIVITY_THRESHOLD_MS = 12e4;
+    POLL_INTERVAL_MS = 1e4;
+    MAX_TOTAL_TIME_MS = 20 * 6e4;
     SkillSandbox = class {
       logger;
       constructor(logger) {
         this.logger = logger;
       }
-      async execute(skill, input2, context, timeoutMs) {
+      /**
+       * Execute a skill with timeout protection.
+       *
+       * If an ActivityTracker is provided, uses an inactivity-based timeout:
+       * the skill keeps running as long as the tracker receives pings.
+       * Only kills the skill when it goes silent for INACTIVITY_THRESHOLD_MS.
+       *
+       * Without a tracker, falls back to a simple hard timeout.
+       */
+      async execute(skill, input2, context, timeoutMs, tracker) {
         timeoutMs = timeoutMs ?? skill.metadata.timeoutMs ?? DEFAULT_TIMEOUT_MS;
         const { name } = skill.metadata;
         this.logger.info({ skill: name, input: input2 }, "Skill execution started");
+        if (tracker) {
+          return this.executeWithTracker(skill, input2, context, name, timeoutMs, tracker);
+        }
+        return this.executeWithHardTimeout(skill, input2, context, name, timeoutMs);
+      }
+      /**
+       * Activity-aware timeout: polls the tracker and only kills
+       * the skill when it has been inactive for too long.
+       */
+      async executeWithTracker(skill, input2, context, name, initialTimeoutMs, tracker) {
+        return new Promise((resolve) => {
+          let settled = false;
+          let pollTimer;
+          let safetyTimer;
+          let initialTimer;
+          const cleanup = () => {
+            if (pollTimer)
+              clearInterval(pollTimer);
+            if (safetyTimer)
+              clearTimeout(safetyTimer);
+            if (initialTimer)
+              clearTimeout(initialTimer);
+          };
+          const finish = (result) => {
+            if (settled)
+              return;
+            settled = true;
+            cleanup();
+            resolve(result);
+          };
+          skill.execute(input2, context).then((result) => {
+            this.logger.info({ skill: name, success: result.success }, "Skill execution completed");
+            finish(result);
+          }, (error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.error({ skill: name, error: message }, "Skill execution failed");
+            finish({ success: false, error: message });
+          });
+          initialTimer = setTimeout(() => {
+            if (settled)
+              return;
+            const idleMs = tracker.getIdleMs();
+            if (idleMs >= INACTIVITY_THRESHOLD_MS) {
+              const snapshot2 = tracker.getSnapshot();
+              this.logger.warn({ skill: name, idleMs, state: snapshot2.state, iteration: snapshot2.iteration }, "Agent inactive after initial timeout \u2014 aborting");
+              finish({
+                success: false,
+                error: `Skill "${name}" timed out \u2014 inactive for ${Math.round(idleMs / 1e3)}s (last state: ${snapshot2.state})`
+              });
+              return;
+            }
+            const snapshot = tracker.getSnapshot();
+            this.logger.info({ skill: name, idleMs, state: snapshot.state, iteration: snapshot.iteration, totalMs: snapshot.totalElapsedMs }, "Initial timeout reached but agent is active \u2014 extending");
+            pollTimer = setInterval(() => {
+              if (settled) {
+                cleanup();
+                return;
+              }
+              const currentIdleMs = tracker.getIdleMs();
+              const snap = tracker.getSnapshot();
+              if (currentIdleMs >= INACTIVITY_THRESHOLD_MS) {
+                this.logger.warn({ skill: name, idleMs: currentIdleMs, state: snap.state, iteration: snap.iteration, totalMs: snap.totalElapsedMs }, "Agent went inactive \u2014 aborting");
+                finish({
+                  success: false,
+                  error: `Skill "${name}" killed \u2014 inactive for ${Math.round(currentIdleMs / 1e3)}s (last state: ${snap.state})`
+                });
+              } else {
+                this.logger.debug({ skill: name, idleMs: currentIdleMs, state: snap.state, iteration: snap.iteration }, "Agent still active, continuing...");
+              }
+            }, POLL_INTERVAL_MS);
+          }, initialTimeoutMs);
+          safetyTimer = setTimeout(() => {
+            if (settled)
+              return;
+            const snap = tracker.getSnapshot();
+            this.logger.error({ skill: name, totalMs: snap.totalElapsedMs, state: snap.state, iteration: snap.iteration }, "Absolute time limit reached \u2014 force killing agent");
+            finish({
+              success: false,
+              error: `Skill "${name}" force-killed after ${Math.round(MAX_TOTAL_TIME_MS / 6e4)} minutes (safety limit)`
+            });
+          }, MAX_TOTAL_TIME_MS);
+        });
+      }
+      /**
+       * Simple hard timeout for skills that don't use a tracker.
+       * This is the legacy behavior.
+       */
+      async executeWithHardTimeout(skill, input2, context, name, timeoutMs) {
         try {
           const result = await Promise.race([
             skill.execute(input2, context),
@@ -2562,6 +2680,90 @@ var init_skill_sandbox = __esm({
   }
 });
 
+// ../skills/dist/activity-tracker.js
+var ActivityTracker;
+var init_activity_tracker = __esm({
+  "../skills/dist/activity-tracker.js"() {
+    "use strict";
+    ActivityTracker = class {
+      state = "starting";
+      iteration = 0;
+      maxIterations = 0;
+      currentTool;
+      lastPingAt;
+      startedAt;
+      history = [];
+      onProgress;
+      constructor(onProgress) {
+        this.startedAt = Date.now();
+        this.lastPingAt = Date.now();
+        this.onProgress = onProgress;
+      }
+      /**
+       * Called by the agent at every meaningful step.
+       * Resets the inactivity timer and reports status upward.
+       */
+      ping(state, meta) {
+        this.state = state;
+        this.lastPingAt = Date.now();
+        if (meta?.iteration !== void 0)
+          this.iteration = meta.iteration;
+        if (meta?.maxIterations !== void 0)
+          this.maxIterations = meta.maxIterations;
+        this.currentTool = meta?.tool;
+        this.history.push({
+          state,
+          tool: meta?.tool,
+          iteration: this.iteration,
+          timestamp: this.lastPingAt
+        });
+        if (this.onProgress) {
+          this.onProgress(this.formatStatus());
+        }
+      }
+      /** How long since last activity, in ms. */
+      getIdleMs() {
+        return Date.now() - this.lastPingAt;
+      }
+      /** Total elapsed time since agent started. */
+      getTotalElapsedMs() {
+        return Date.now() - this.startedAt;
+      }
+      /** Current human-readable status string. */
+      formatStatus() {
+        const iter = this.maxIterations > 0 ? ` (${this.iteration}/${this.maxIterations})` : "";
+        switch (this.state) {
+          case "starting":
+            return `Sub-agent starting...`;
+          case "llm_call":
+            return `Sub-agent thinking...${iter}`;
+          case "tool_call":
+            return this.currentTool ? `Sub-agent using ${this.currentTool}${iter}` : `Sub-agent using tool...${iter}`;
+          case "processing":
+            return `Sub-agent processing...${iter}`;
+          case "done":
+            return `Sub-agent done${iter}`;
+          default:
+            return `Sub-agent working...${iter}`;
+        }
+      }
+      /** Full snapshot for logging / debugging. */
+      getSnapshot() {
+        return {
+          state: this.state,
+          iteration: this.iteration,
+          maxIterations: this.maxIterations,
+          lastPingAt: this.lastPingAt,
+          idleMs: this.getIdleMs(),
+          currentTool: this.currentTool,
+          totalElapsedMs: this.getTotalElapsedMs(),
+          history: [...this.history]
+        };
+      }
+    };
+  }
+});
+
 // ../skills/dist/plugin-loader.js
 import fs3 from "node:fs";
 import path3 from "node:path";
@@ -2974,9 +3176,9 @@ var init_reminder = __esm({
       reminderRepo;
       metadata = {
         name: "reminder",
-        description: 'Set timed reminders that notify the user later. Use when the user says "remind me", "erinnere mich", or asks to be notified about something at a specific time.',
+        description: 'Set timed reminders that notify the user later. Use when the user says "remind me", "erinnere mich", or asks to be notified about something at a specific time. Prefer triggerAt (absolute time like "14:30" or "2026-02-28 09:00") over delayMinutes \u2014 it is more precise and avoids calculation errors.',
         riskLevel: "write",
-        version: "2.0.0",
+        version: "3.0.0",
         inputSchema: {
           type: "object",
           properties: {
@@ -2989,9 +3191,13 @@ var init_reminder = __esm({
               type: "string",
               description: "The reminder message (required for set)"
             },
+            triggerAt: {
+              type: "string",
+              description: 'Absolute time for the reminder. Accepts "HH:MM" for today or "YYYY-MM-DD HH:MM" for a specific date. Preferred over delayMinutes for time-specific reminders.'
+            },
             delayMinutes: {
               type: "number",
-              description: "Minutes until the reminder triggers (required for set)"
+              description: "Minutes until the reminder triggers. Use triggerAt instead when the user specifies a clock time."
             },
             reminderId: {
               type: "string",
@@ -3023,6 +3229,7 @@ var init_reminder = __esm({
       }
       setReminder(input2, context) {
         const message = input2.message;
+        const triggerAtStr = input2.triggerAt;
         const delayMinutes = input2.delayMinutes;
         if (!message || typeof message !== "string") {
           return {
@@ -3030,20 +3237,119 @@ var init_reminder = __esm({
             error: 'Missing required field "message" for set action'
           };
         }
-        if (delayMinutes === void 0 || typeof delayMinutes !== "number" || delayMinutes <= 0) {
+        let triggerAt;
+        if (triggerAtStr && typeof triggerAtStr === "string") {
+          const parsed = this.parseTriggerAt(triggerAtStr, context.timezone);
+          if (!parsed) {
+            return {
+              success: false,
+              error: `Could not parse triggerAt "${triggerAtStr}". Use "HH:MM" for today or "YYYY-MM-DD HH:MM" for a specific date.`
+            };
+          }
+          if (parsed.getTime() <= Date.now()) {
+            return {
+              success: false,
+              error: `The time "${triggerAtStr}" is in the past. Please specify a future time.`
+            };
+          }
+          triggerAt = parsed;
+        } else if (delayMinutes !== void 0 && typeof delayMinutes === "number" && delayMinutes > 0) {
+          triggerAt = new Date(Date.now() + delayMinutes * 60 * 1e3);
+        } else {
           return {
             success: false,
-            error: 'Missing or invalid "delayMinutes" for set action (must be a positive number)'
+            error: 'Provide either "triggerAt" (e.g. "14:30") or "delayMinutes" (positive number) for set action.'
           };
         }
-        const triggerAt = new Date(Date.now() + delayMinutes * 60 * 1e3);
         const entry = this.reminderRepo.create(context.userId, context.platform, context.chatId, message, triggerAt);
+        const delayMs = triggerAt.getTime() - Date.now();
+        const mins = Math.round(delayMs / 6e4);
+        const timeLabel = triggerAt.toLocaleTimeString("en-GB", {
+          hour: "2-digit",
+          minute: "2-digit",
+          ...context.timezone ? { timeZone: context.timezone } : {}
+        });
         return {
           success: true,
           data: { reminderId: entry.id, message, triggerAt: entry.triggerAt },
-          display: `Reminder set (${entry.id}): "${message}" in ${delayMinutes} minute(s)`
+          display: `Reminder set (${entry.id}): "${message}" at ${timeLabel} (in ${mins} min)`
         };
       }
+      /**
+       * Parse a trigger time string into a Date.
+       *
+       * Supported formats:
+       * - "HH:MM"            → today at that time in the given timezone
+       * - "YYYY-MM-DD HH:MM" → specific date+time
+       */
+      parseTriggerAt(str, timezone) {
+        const trimmed = str.trim();
+        const timeOnly = /^(\d{1,2}):(\d{2})$/.exec(trimmed);
+        if (timeOnly) {
+          const hours = parseInt(timeOnly[1], 10);
+          const minutes = parseInt(timeOnly[2], 10);
+          if (hours > 23 || minutes > 59)
+            return void 0;
+          return this.buildDateInTimezone(hours, minutes, void 0, timezone);
+        }
+        const dateTime = /^(\d{4})-(\d{2})-(\d{2})\s+(\d{1,2}):(\d{2})$/.exec(trimmed);
+        if (dateTime) {
+          const year = parseInt(dateTime[1], 10);
+          const month = parseInt(dateTime[2], 10) - 1;
+          const day = parseInt(dateTime[3], 10);
+          const hours = parseInt(dateTime[4], 10);
+          const minutes = parseInt(dateTime[5], 10);
+          if (hours > 23 || minutes > 59 || month > 11 || day > 31)
+            return void 0;
+          return this.buildDateInTimezone(hours, minutes, { year, month, day }, timezone);
+        }
+        return void 0;
+      }
+      /**
+       * Build a Date object for a given time in the user's timezone.
+       * Uses iterative offset correction to handle DST edge cases.
+       */
+      buildDateInTimezone(hours, minutes, date, timezone) {
+        if (!timezone) {
+          const d = date ? new Date(date.year, date.month, date.day, hours, minutes, 0, 0) : /* @__PURE__ */ new Date();
+          if (!date) {
+            d.setHours(hours, minutes, 0, 0);
+          }
+          return d;
+        }
+        const now = /* @__PURE__ */ new Date();
+        const refDate = date ? new Date(Date.UTC(date.year, date.month, date.day, hours, minutes, 0)) : new Date(Date.UTC(now.getFullYear(), now.getMonth(), now.getDate(), hours, minutes, 0));
+        const formatter = new Intl.DateTimeFormat("en-CA", {
+          timeZone: timezone,
+          year: "numeric",
+          month: "2-digit",
+          day: "2-digit",
+          hour: "2-digit",
+          minute: "2-digit",
+          second: "2-digit",
+          hour12: false
+        });
+        if (!date) {
+          const parts = formatter.formatToParts(now);
+          const tzYear = parseInt(parts.find((p) => p.type === "year").value, 10);
+          const tzMonth = parseInt(parts.find((p) => p.type === "month").value, 10) - 1;
+          const tzDay = parseInt(parts.find((p) => p.type === "day").value, 10);
+          let guess2 = new Date(Date.UTC(tzYear, tzMonth, tzDay, hours, minutes, 0));
+          const guessParts2 = formatter.formatToParts(guess2);
+          const guessHour2 = parseInt(guessParts2.find((p) => p.type === "hour").value, 10);
+          const guessMinute2 = parseInt(guessParts2.find((p) => p.type === "minute").value, 10);
+          const diffMinutes2 = (hours - guessHour2) * 60 + (minutes - guessMinute2);
+          guess2 = new Date(guess2.getTime() + diffMinutes2 * 6e4);
+          return guess2;
+        }
+        let guess = refDate;
+        const guessParts = formatter.formatToParts(guess);
+        const guessHour = parseInt(guessParts.find((p) => p.type === "hour").value, 10);
+        const guessMinute = parseInt(guessParts.find((p) => p.type === "minute").value, 10);
+        const diffMinutes = (hours - guessHour) * 60 + (minutes - guessMinute);
+        guess = new Date(guess.getTime() + diffMinutes * 6e4);
+        return guess;
+      }
       listReminders(context) {
         const reminders = this.reminderRepo.getByUser(context.userId);
         const reminderList = reminders.map((r) => ({
@@ -3576,12 +3882,15 @@ ${results.map((r) => `- ${r.key}: "${r.value}" (score: ${r.score.toFixed(2)})`).
 });
 
 // ../skills/dist/built-in/delegate.js
-var MAX_SUB_AGENT_ITERATIONS, DelegateSkill;
+var DEFAULT_MAX_ITERATIONS, MAX_ALLOWED_ITERATIONS, INITIAL_TIMEOUT_MS, DelegateSkill;
 var init_delegate = __esm({
   "../skills/dist/built-in/delegate.js"() {
     "use strict";
     init_skill();
-    MAX_SUB_AGENT_ITERATIONS = 5;
+    init_activity_tracker();
+    DEFAULT_MAX_ITERATIONS = 5;
+    MAX_ALLOWED_ITERATIONS = 15;
+    INITIAL_TIMEOUT_MS = 12e4;
     DelegateSkill = class extends Skill {
       llm;
       skillRegistry;
@@ -3589,11 +3898,10 @@ var init_delegate = __esm({
       securityManager;
       metadata = {
         name: "delegate",
-        description: 'Delegate a complex sub-task to an autonomous sub-agent that has full tool access. The sub-agent can use shell, web search, calculator, memory, email, and all other tools. Use when a task is independent enough to run in parallel or when it requires a focused, multi-step workflow (e.g. "research X and summarize", "find all TODO files and list them", "check the weather and draft a packing list"). The sub-agent runs up to 5 tool iterations autonomously.',
+        description: 'Delegate a complex sub-task to an autonomous sub-agent that has full tool access. The sub-agent can use shell, web search, calculator, memory, email, and all other tools. Use when a task is independent enough to run in parallel or when it requires a focused, multi-step workflow (e.g. "research X and summarize", "find all TODO files and list them", "check the weather and draft a packing list"). Control depth with max_iterations (default 5, max 15).',
         riskLevel: "write",
-        version: "2.0.0",
-        timeoutMs: 12e4,
-        // 2 minutes — delegate chains multiple LLM calls + tool executions
+        version: "3.0.0",
+        timeoutMs: INITIAL_TIMEOUT_MS,
         inputSchema: {
           type: "object",
           properties: {
@@ -3604,11 +3912,16 @@ var init_delegate = __esm({
             context: {
               type: "string",
               description: "Additional context the sub-agent needs (optional)"
+            },
+            max_iterations: {
+              type: "number",
+              description: "Max tool iterations (1-15). Use higher values for complex multi-step tasks. Default: 5."
             }
           },
           required: ["task"]
         }
       };
+      onProgress;
       constructor(llm, skillRegistry, skillSandbox, securityManager) {
         super();
         this.llm = llm;
@@ -3616,6 +3929,21 @@ var init_delegate = __esm({
         this.skillSandbox = skillSandbox;
         this.securityManager = securityManager;
       }
+      /**
+       * Set a progress callback before execution.
+       * The pipeline calls this so the user sees live status updates
+       * like "Sub-agent using web_search (2/5)".
+       */
+      setProgressCallback(cb) {
+        this.onProgress = cb;
+      }
+      /**
+       * Create an ActivityTracker for this execution.
+       * The sandbox uses this to decide whether to extend or kill.
+       */
+      createTracker() {
+        return new ActivityTracker(this.onProgress);
+      }
       async execute(input2, context) {
         const task = input2.task;
         const additionalContext = input2.context;
@@ -3625,6 +3953,10 @@ var init_delegate = __esm({
             error: 'Missing required field "task"'
           };
         }
+        const requestedIterations = input2.max_iterations;
+        const maxIterations = requestedIterations ? Math.max(1, Math.min(MAX_ALLOWED_ITERATIONS, Math.round(requestedIterations))) : DEFAULT_MAX_ITERATIONS;
+        const tracker = new ActivityTracker(this.onProgress);
+        tracker.ping("starting", { maxIterations });
         const tools = this.buildSubAgentTools();
         const systemPrompt = "You are a sub-agent of Alfred, a personal AI assistant. Complete the assigned task using the tools available to you. Work step by step: use tools to gather information, then synthesize a clear result. Be concise and return only the final answer when done.";
         let userContent = task;
@@ -3641,6 +3973,7 @@ Additional context: ${additionalContext}`;
           let totalInputTokens = 0;
           let totalOutputTokens = 0;
           while (true) {
+            tracker.ping("llm_call", { iteration, maxIterations });
             const response = await this.llm.complete({
               messages,
               system: systemPrompt,
@@ -3649,7 +3982,9 @@ Additional context: ${additionalContext}`;
             });
             totalInputTokens += response.usage.inputTokens;
             totalOutputTokens += response.usage.outputTokens;
-            if (!response.toolCalls || response.toolCalls.length === 0 || iteration >= MAX_SUB_AGENT_ITERATIONS) {
+            tracker.ping("processing", { iteration, maxIterations });
+            if (!response.toolCalls || response.toolCalls.length === 0 || iteration >= maxIterations) {
+              tracker.ping("done", { iteration, maxIterations });
               return {
                 success: true,
                 data: {
@@ -3676,6 +4011,7 @@ Additional context: ${additionalContext}`;
             messages.push({ role: "assistant", content: assistantContent });
             const toolResultBlocks = [];
             for (const toolCall of response.toolCalls) {
+              tracker.ping("tool_call", { iteration, maxIterations, tool: toolCall.name });
               const result = await this.executeSubAgentTool(toolCall, context);
               toolResultBlocks.push({
                 type: "tool_result",
@@ -5673,6 +6009,7 @@ var init_dist6 = __esm({
     init_skill();
     init_skill_registry();
     init_skill_sandbox();
+    init_activity_tracker();
     init_plugin_loader();
     init_calculator();
     init_system_info();
@@ -5746,6 +6083,9 @@ var init_message_pipeline = __esm({
       speechTranscriber;
       inboxPath;
       embeddingService;
+      /** Registry of currently running delegate agents, keyed by a unique agent ID. */
+      activeAgents = /* @__PURE__ */ new Map();
+      agentIdCounter = 0;
       constructor(options) {
         this.llm = options.llm;
         this.conversationManager = options.conversationManager;
@@ -5804,13 +6144,18 @@ var init_message_pipeline = __esm({
             }
           } catch {
           }
+          const resolvedTimezone = userProfile?.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone;
           const skillMetas = this.skillRegistry ? this.skillRegistry.getAll().map((s) => s.metadata) : void 0;
           const tools = skillMetas ? this.promptBuilder.buildTools(skillMetas) : void 0;
-          const system = this.promptBuilder.buildSystemPrompt({
+          let system = this.promptBuilder.buildSystemPrompt({
             memories,
             skills: skillMetas,
             userProfile
           });
+          const agentStatusBlock = this.buildActiveAgentStatus();
+          if (agentStatusBlock) {
+            system += "\n\n" + agentStatusBlock;
+          }
           const allMessages = this.promptBuilder.buildMessages(history);
           const userContent = await this.buildUserContent(message, onProgress);
           allMessages.push({ role: "user", content: userContent });
@@ -5854,8 +6199,9 @@ var init_message_pipeline = __esm({
                 chatId: message.chatId,
                 chatType: message.chatType,
                 platform: message.platform,
-                conversationId: conversation.id
-              });
+                conversationId: conversation.id,
+                timezone: resolvedTimezone
+              }, onProgress);
               toolResultBlocks.push({
                 type: "tool_result",
                 tool_use_id: toolCall.id,
@@ -5885,7 +6231,7 @@ var init_message_pipeline = __esm({
           throw error;
         }
       }
-      async executeToolCall(toolCall, context) {
+      async executeToolCall(toolCall, context, onProgress) {
         const skill = this.skillRegistry?.get(toolCall.name);
         if (!skill) {
           this.logger.warn({ tool: toolCall.name }, "Unknown skill requested");
@@ -5909,11 +6255,33 @@ var init_message_pipeline = __esm({
           }
         }
         if (this.skillSandbox) {
-          const result = await this.skillSandbox.execute(skill, toolCall.input, context);
-          return {
-            content: result.display ?? (result.success ? JSON.stringify(result.data) : result.error ?? "Unknown error"),
-            isError: !result.success
-          };
+          let tracker;
+          let agentId;
+          if (toolCall.name === "delegate" && "setProgressCallback" in skill && "createTracker" in skill) {
+            const delegateSkill = skill;
+            if (onProgress) {
+              delegateSkill.setProgressCallback(onProgress);
+            }
+            tracker = delegateSkill.createTracker();
+            agentId = `agent-${++this.agentIdCounter}`;
+            this.activeAgents.set(agentId, {
+              chatId: context.chatId,
+              task: String(toolCall.input.task ?? "").slice(0, 200),
+              tracker,
+              startedAt: Date.now()
+            });
+          }
+          try {
+            const result = await this.skillSandbox.execute(skill, toolCall.input, context, void 0, tracker);
+            return {
+              content: result.display ?? (result.success ? JSON.stringify(result.data) : result.error ?? "Unknown error"),
+              isError: !result.success
+            };
+          } finally {
+            if (agentId) {
+              this.activeAgents.delete(agentId);
+            }
+          }
         }
         try {
           const result = await skill.execute(toolCall.input, context);
@@ -5966,6 +6334,24 @@ var init_message_pipeline = __esm({
             return `Using ${toolName}...`;
         }
       }
+      /**
+       * Build a status block describing currently running delegate agents.
+       * Injected into the system prompt so the LLM can answer user questions
+       * like "What is the agent doing right now?".
+       */
+      buildActiveAgentStatus() {
+        if (this.activeAgents.size === 0)
+          return void 0;
+        const lines = ["## Currently running sub-agents"];
+        for (const [id, agent] of this.activeAgents) {
+          const snapshot = agent.tracker.getSnapshot();
+          const elapsedSec = Math.round(snapshot.totalElapsedMs / 1e3);
+          lines.push(`- **${id}**: "${agent.task}"`, `  Status: ${agent.tracker.formatStatus()}`, `  Running for ${elapsedSec}s | Last activity ${Math.round(snapshot.idleMs / 1e3)}s ago`);
+        }
+        lines.push("");
+        lines.push("If the user asks what you or the agent is doing, describe the above status in natural language.");
+        return lines.join("\n");
+      }
       /**
        * Trim messages to fit within the LLM's context window.
        * Keeps the system prompt, the latest user message, and as many

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@madh-io/alfred-ai",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Alfred — Personal AI Assistant across Telegram, Discord, WhatsApp, Matrix & Signal",
   "type": "module",
   "bin": {