@rubytech/taskmaster 1.0.4 → 1.0.6

package/README.md

@@ -14,7 +14,7 @@ taskmaster provision
 Or one command on a fresh device:
 
 ```bash
-curl -fsSL https://taskmaster.bot/install.sh | bash
+curl -fsSL https://taskmaster.bot/install.sh | sudo bash
 ```
 
 After install, open the setup wizard in your browser:

package/dist/agents/system-prompt.js

@@ -122,7 +122,7 @@ export function buildAgentSystemPrompt(params) {
         browser: "Control web browser",
         canvas: "Present/eval/snapshot the Canvas",
         nodes: "List/describe/notify/camera/screen on paired nodes",
-        cron: "Manage cron jobs and wake events (use for reminders; when scheduling a reminder, write the systemEvent text as something that will read like a reminder when it fires, and mention that it is a reminder depending on the time gap between setting and firing; include recent context in reminder text if appropriate)",
+        cron: "Manage scheduled events and wake events (use for reminders; when scheduling a reminder, write the systemEvent text as something that will read like a reminder when it fires, and mention that it is a reminder depending on the time gap between setting and firing; include recent context in reminder text if appropriate)",
         message: "Send messages and channel actions",
         gateway: "Restart, apply config, or run updates on the running Taskmaster process",
         agents_list: "List agent ids allowed for sessions_spawn",
@@ -263,7 +263,7 @@ export function buildAgentSystemPrompt(params) {
                 "- browser: control Taskmaster's dedicated browser",
                 "- canvas: present/eval/snapshot the Canvas",
                 "- nodes: list/describe/notify/camera/screen on paired nodes",
-                "- cron: manage cron jobs and wake events (use for reminders; when scheduling a reminder, write the systemEvent text as something that will read like a reminder when it fires, and mention that it is a reminder depending on the time gap between setting and firing; include recent context in reminder text if appropriate)",
+                "- cron: manage scheduled events and wake events (use for reminders; when scheduling a reminder, write the systemEvent text as something that will read like a reminder when it fires, and mention that it is a reminder depending on the time gap between setting and firing; include recent context in reminder text if appropriate)",
                 "- sessions_list: list sessions",
                 "- sessions_history: fetch session history",
                 "- sessions_send: send to another session",

package/dist/agents/tool-display.json

@@ -145,7 +145,7 @@
         },
         "cron": {
             "emoji": "⏰",
-            "title": "Cron",
+            "title": "Events",
             "actions": {
                 "status": { "label": "status" },
                 "list": { "label": "list" },

package/dist/agents/tools/cron-tool.js

@@ -113,21 +113,21 @@ async function buildReminderContextLines(params) {
 }
 export function createCronTool(opts) {
     return {
-        label: "Cron",
+        label: "Events",
         name: "cron",
-        description: `Manage Gateway cron jobs (status/list/add/update/remove/run/runs) and send wake events.
+        description: `Manage scheduled events (status/list/add/update/remove/run/runs) and send wake events.
 
 ACTIONS:
-- status: Check cron scheduler status
-- list: List jobs (use includeDisabled:true to include disabled)
-- add: Create job (requires job object, see schema below)
-- update: Modify job (requires jobId + patch object)
-- remove: Delete job (requires jobId)
-- run: Trigger job immediately (requires jobId)
-- runs: Get job run history (requires jobId)
+- status: Check event scheduler status
+- list: List events (use includeDisabled:true to include disabled). Returns all events for your account.
+- add: Create event (requires job object, see schema below)
+- update: Modify event (requires jobId + patch object)
+- remove: Delete event (requires jobId)
+- run: Trigger event immediately (requires jobId)
+- runs: Get event run history (requires jobId)
 - wake: Send wake event (requires text, optional mode)
 
-JOB SCHEMA (for add action):
+EVENT SCHEMA (for add action):
 {
   "name": "string (optional)",
   "schedule": { ... },      // Required: when to run
@@ -158,7 +158,7 @@ WAKE MODES (for wake action):
 - "next-heartbeat" (default): Wake on next heartbeat
 - "now": Wake immediately
 
-Use jobId as the canonical identifier; id is accepted for compatibility. Use contextMessages (0-10) to add previous messages as context to the job text.`,
+Use jobId as the canonical identifier; id is accepted for compatibility. Use contextMessages (0-10) to add previous messages as context to the event text.`,
         parameters: CronToolSchema,
         execute: async (_toolCallId, args) => {
             const params = args;
@@ -171,10 +171,15 @@ Use jobId as the canonical identifier; id is accepted for compatibility. Use con
             switch (action) {
                 case "status":
                     return jsonResult(await callGatewayTool("cron.status", gatewayOpts, {}));
-                case "list":
-                    return jsonResult(await callGatewayTool("cron.list", gatewayOpts, {
+                case "list": {
+                    const listParams = {
                         includeDisabled: Boolean(params.includeDisabled),
-                    }));
+                    };
+                    const accountId = opts?.agentAccountId;
+                    if (accountId)
+                        listParams.accountId = accountId;
+                    return jsonResult(await callGatewayTool("cron.list", gatewayOpts, listParams));
+                }
                 case "add": {
                     if (!params.job || typeof params.job !== "object") {
                         throw new Error("job required");

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.4",
-  "commit": "a317fdb599ad59d1366f5d5352244c8dff8f44a8",
-  "builtAt": "2026-02-14T19:55:48.406Z"
+  "version": "1.0.6",
+  "commit": "f50bf4225d9f628ae369ac7b6d520687095a688d",
+  "builtAt": "2026-02-15T08:03:07.343Z"
 }

package/dist/cli/provision-seed.js

@@ -87,7 +87,11 @@ export function buildDefaultAgentList(workspaceRoot) {
                     ],
                 },
                 write: {
-                    include: ["memory/users/{peer}/**", "memory/groups/{peer}/**"],
+                    include: [
+                        "memory/users/{peer}/**",
+                        "memory/groups/{peer}/**",
+                        "memory/shared/events/**",
+                    ],
                 },
             },
         },

package/dist/config/version.js

@@ -13,11 +13,21 @@ export function parseTaskmasterVersion(raw) {
         revision: revision ? Number.parseInt(revision, 10) : 0,
     };
 }
+/**
+ * Date-based versions (e.g. 2026.1.25) have major >= 2000.
+ * Semver versions (e.g. 1.0.4) have major < 100.
+ * Comparing across formats is meaningless — return null.
+ */
+function isDateVersion(v) {
+    return v.major >= 2000;
+}
 export function compareTaskmasterVersions(a, b) {
     const parsedA = parseTaskmasterVersion(a);
     const parsedB = parseTaskmasterVersion(b);
     if (!parsedA || !parsedB)
         return null;
+    if (isDateVersion(parsedA) !== isDateVersion(parsedB))
+        return null;
     if (parsedA.major !== parsedB.major)
         return parsedA.major < parsedB.major ? -1 : 1;
     if (parsedA.minor !== parsedB.minor)

package/dist/filler/config.js

@@ -0,0 +1,69 @@
+/**
+ * Filler configuration resolution.
+ */
+/** Default filler configuration values. */
+export const FILLER_DEFAULTS = {
+    enabled: false,
+    channels: [
+        "whatsapp",
+        "telegram",
+        "discord",
+        "slack",
+        "signal",
+        "googlechat",
+        "imessage",
+        "webchat",
+    ],
+    maxWaitMs: 3000,
+    model: "claude-3-haiku-20240307",
+    maxWords: 15,
+};
+/** Resolve filler config with defaults applied. */
+export function resolveFillerConfig(cfg) {
+    return {
+        ...FILLER_DEFAULTS,
+        ...cfg?.filler,
+        // Ensure channels array is always present
+        channels: cfg?.filler?.channels ?? FILLER_DEFAULTS.channels,
+    };
+}
+/**
+ * Resolve whether filler is enabled, checking session and agent-level config.
+ *
+ * Priority:
+ * 1. Session override (from /filler command)
+ * 2. Per-agent config (agents.list[].fillerEnabled)
+ * 3. Agent defaults (agents.defaults.fillerEnabled)
+ * 4. Global filler config (filler.enabled)
+ * 5. Default (false)
+ */
+export function resolveFillerEnabled(params) {
+    const { cfg, agentId, sessionFillerEnabled } = params;
+    // Session-level override takes precedence (from /filler command)
+    if (sessionFillerEnabled !== undefined) {
+        return sessionFillerEnabled;
+    }
+    // Check per-agent config
+    if (agentId && cfg?.agents?.list) {
+        const agentConfig = cfg.agents.list.find((a) => a.id === agentId);
+        if (agentConfig?.fillerEnabled !== undefined) {
+            return agentConfig.fillerEnabled;
+        }
+    }
+    // Check agent defaults
+    if (cfg?.agents?.defaults?.fillerEnabled !== undefined) {
+        return cfg.agents.defaults.fillerEnabled;
+    }
+    // Fall back to global filler config
+    return cfg?.filler?.enabled ?? FILLER_DEFAULTS.enabled;
+}
+/** Check if filler is enabled for a specific channel. */
+export function isFillerEnabledForChannel(params) {
+    const { cfg, channel } = params;
+    if (!resolveFillerEnabled(params))
+        return false;
+    if (!channel)
+        return false;
+    const fillerConfig = resolveFillerConfig(cfg);
+    return fillerConfig.channels.includes(channel);
+}

package/dist/filler/generator.js

@@ -0,0 +1,237 @@
+/**
+ * Filler message generation using a lightweight model (Haiku).
+ *
+ * Uses pi-ai complete() for OAuth-compatible inference.
+ */
+import path from "node:path";
+import { complete } from "@mariozechner/pi-ai";
+import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+import { getApiKeyForModel, requireApiKey } from "../agents/model-auth.js";
+import { ensureTaskmasterModelsJson } from "../agents/models-config.js";
+const FILLER_SYSTEM_PROMPT = `You generate a brief, first-person filler while processing a request. Output ONLY the filler text.
+
+Rules:
+1. For trivial messages (greetings, "yes", "ok", "thanks", single-word replies), output: SKIP
+2. Always use first person ("I'll...", "I need to...", "I'm...")
+3. Match the filler to what you're doing (shown in thinking)
+4. Keep it short (2-6 words) and casual
+5. Vary your responses every time
+
+Quick acknowledgments (no lookup needed):
+- "one moment please", "just a moment", "one sec", "OK", "sure thing", "got it"
+
+When looking something up / searching:
+- "I need to look that up", "I'll check on that", "I need to search for that", "I'm looking into it"
+
+When checking / verifying:
+- "I'll check", "I'm checking now", "I need to verify that"
+
+When thinking / working out:
+- "hmm", "I'm thinking", "I need to work this out"
+
+IMPORTANT: Vary every response. Never repeat the same phrase twice in a row.`;
+const TOOL_PROGRESS_SYSTEM_PROMPT = `You generate a brief, first-person progress update while a tool is running. Output ONLY the progress text.
+
+Rules:
+1. Always use first person ("I'm...", "Just...", "Let me...")
+2. Be specific about what you're doing based on the tool and its arguments
+3. Keep it short (3-8 words) and natural
+4. Sound like a human assistant giving a quick status update
+
+Examples:
+- exec with "git status" → "Just checking the git status"
+- exec with "npm install" → "Installing the dependencies"
+- memory_search with query "invoice" → "Searching my notes for invoices"
+- read with path "/config.json" → "Reading the config file"
+- web_search with query "weather" → "Looking up the weather"
+
+Output ONLY the progress message, nothing else.`;
+/** Token returned when filler should not be sent. */
+export const FILLER_SKIP_TOKEN = "SKIP";
+/**
+ * Generate a filler message using pi-ai complete().
+ *
+ * Works with both API keys and OAuth tokens.
+ */
+export async function generateFiller(params) {
+    const { userMessage, thinking, model: modelId, maxWords, timeoutMs = 3000, abortSignal, cfg, agentDir, } = params;
+    // Check if already aborted before starting
+    if (abortSignal?.aborted) {
+        return { ok: false, error: new Error("Filler generation aborted") };
+    }
+    try {
+        // Set up model discovery with auth
+        await ensureTaskmasterModelsJson(cfg, agentDir);
+        const authStorage = agentDir
+            ? new AuthStorage(path.join(agentDir, "auth.json"))
+            : new AuthStorage();
+        const modelRegistry = agentDir
+            ? new ModelRegistry(authStorage, path.join(agentDir, "models.json"))
+            : new ModelRegistry(authStorage);
+        // Find Haiku model
+        const model = modelRegistry.find("anthropic", modelId);
+        if (!model) {
+            return { ok: false, error: new Error(`Filler model not found: anthropic/${modelId}`) };
+        }
+        // Resolve and set API key
+        const apiKeyInfo = await getApiKeyForModel({
+            model,
+            cfg,
+            agentDir,
+        });
+        const apiKey = requireApiKey(apiKeyInfo, model.provider);
+        authStorage.setRuntimeApiKey(model.provider, apiKey);
+        // Truncate thinking if too long (keep last 400 chars for context)
+        const truncatedThinking = thinking
+            ? thinking.length > 400
+                ? `...${thinking.slice(-400)}`
+                : thinking
+            : "";
+        // Build the prompt with both user message and thinking
+        let prompt = `User's message: "${userMessage}"`;
+        if (truncatedThinking) {
+            prompt += `\n\nAssistant's thinking so far:\n---\n${truncatedThinking}\n---`;
+        }
+        prompt += `\n\nGenerate a brief filler (max ${maxWords} words) that fits what the assistant is doing:`;
+        // console.log(`[filler] === FILLER GENERATION ===`);
+        // console.log(`[filler] User message: "${userMessage}"`);
+        // console.log(
+        //   `[filler] Thinking (${truncatedThinking.length} chars): "${truncatedThinking.slice(0, 100)}..."`,
+        // );
+        // Build context with system prompt and user message
+        const context = {
+            systemPrompt: FILLER_SYSTEM_PROMPT,
+            messages: [
+                {
+                    role: "user",
+                    content: prompt,
+                    timestamp: Date.now(),
+                },
+            ],
+        };
+        // Create timeout promise
+        const timeoutPromise = new Promise((_, reject) => {
+            const timer = setTimeout(() => reject(new Error("Filler generation timeout")), timeoutMs);
+            abortSignal?.addEventListener("abort", () => {
+                clearTimeout(timer);
+                reject(new Error("Filler generation aborted"));
+            });
+        });
+        // Race completion against timeout
+        const message = (await Promise.race([
+            complete(model, context, {
+                apiKey,
+                maxTokens: 50,
+                temperature: 0.9, // Higher temperature for variety
+            }),
+            timeoutPromise,
+        ]));
+        // Extract text from response
+        const content = message.content?.[0];
+        if (!content || content.type !== "text" || !content.text) {
+            return { ok: false, skip: true };
+        }
+        const text = content.text.trim();
+        // console.log(`[filler] Generated output: "${text}"`);
+        // Check for SKIP token
+        if (text.toUpperCase() === FILLER_SKIP_TOKEN) {
+            // logVerbose(`[filler] Skipping (model returned SKIP)`);
+            return { ok: false, skip: true };
+        }
+        // Don't truncate - mid-sentence cuts look bad. The prompt already
+        // instructs Haiku to keep it brief (2-6 words).
+        return { ok: true, text };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        // logVerbose(`Filler generation failed: ${error.message}`);
+        return { ok: false, error };
+    }
+}
+/**
+ * Generate a tool progress message using Haiku.
+ */
+export async function generateToolProgress(params) {
+    const { toolName, args, model: modelId, timeoutMs = 2000, cfg, agentDir } = params;
+    try {
+        // Set up model discovery with auth
+        await ensureTaskmasterModelsJson(cfg, agentDir);
+        const authStorage = agentDir
+            ? new AuthStorage(path.join(agentDir, "auth.json"))
+            : new AuthStorage();
+        const modelRegistry = agentDir
+            ? new ModelRegistry(authStorage, path.join(agentDir, "models.json"))
+            : new ModelRegistry(authStorage);
+        // Find Haiku model
+        const model = modelRegistry.find("anthropic", modelId);
+        if (!model) {
+            return { ok: false, error: new Error(`Filler model not found: anthropic/${modelId}`) };
+        }
+        // Resolve and set API key
+        const apiKeyInfo = await getApiKeyForModel({
+            model,
+            cfg,
+            agentDir,
+        });
+        const apiKey = requireApiKey(apiKeyInfo, model.provider);
+        authStorage.setRuntimeApiKey(model.provider, apiKey);
+        // Build prompt with tool info
+        let prompt = `Tool: ${toolName}`;
+        if (args && Object.keys(args).length > 0) {
+            // Include relevant args, truncating long values
+            const relevantArgs = {};
+            for (const [key, value] of Object.entries(args)) {
+                if (typeof value === "string" && value.length > 100) {
+                    relevantArgs[key] = value.slice(0, 100) + "...";
+                }
+                else if (typeof value === "string" ||
+                    typeof value === "number" ||
+                    typeof value === "boolean") {
+                    relevantArgs[key] = value;
+                }
+            }
+            if (Object.keys(relevantArgs).length > 0) {
+                prompt += `\nArguments: ${JSON.stringify(relevantArgs)}`;
+            }
+        }
+        prompt += "\n\nGenerate a brief progress update:";
+        // console.log(`[filler] === TOOL PROGRESS GENERATION ===`);
+        // console.log(`[filler] Tool: ${toolName}, args: ${JSON.stringify(args ?? {}).slice(0, 100)}`);
+        const context = {
+            systemPrompt: TOOL_PROGRESS_SYSTEM_PROMPT,
+            messages: [
+                {
+                    role: "user",
+                    content: prompt,
+                    timestamp: Date.now(),
+                },
+            ],
+        };
+        // Create timeout promise
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => reject(new Error("Tool progress generation timeout")), timeoutMs);
+        });
+        // Race completion against timeout
+        const message = (await Promise.race([
+            complete(model, context, {
+                apiKey,
+                maxTokens: 30,
+                temperature: 0.7,
+            }),
+            timeoutPromise,
+        ]));
+        // Extract text from response
+        const content = message.content?.[0];
+        if (!content || content.type !== "text" || !content.text) {
+            return { ok: false, skip: true };
+        }
+        const text = content.text.trim();
+        // console.log(`[filler] Tool progress: "${text}"`);
+        return { ok: true, text };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        console.warn(`[filler] Tool progress generation failed: ${error.message}`);
+        return { ok: false, error };
+    }
+}

package/dist/filler/index.js

@@ -0,0 +1,8 @@
+/**
+ * Filler message system - reduces perceived latency by emitting brief
+ * acknowledgments while the main AI response generates.
+ */
+export * from "./types.js";
+export { FILLER_DEFAULTS, resolveFillerConfig, resolveFillerEnabled, isFillerEnabledForChannel, } from "./config.js";
+export { createFillerTrigger } from "./trigger.js";
+export { generateFiller, FILLER_SKIP_TOKEN } from "./generator.js";

package/dist/filler/trigger.js

@@ -0,0 +1,163 @@
+/**
+ * Filler trigger: generates and delivers a brief acknowledgment message
+ * while the main AI response is being generated.
+ *
+ * Waits briefly for initial thinking to accumulate, then generates a
+ * context-aware filler using both the user message and model's thinking.
+ *
+ * Also sends progress updates during tool calls (throttled).
+ */
+import { isFillerEnabledForChannel, resolveFillerConfig } from "./config.js";
+import { generateFiller, generateToolProgress } from "./generator.js";
+/** How long to wait for thinking before generating filler (ms) */
+const THINKING_WAIT_MS = 350;
+/** Minimum time between tool progress updates (ms) */
+const TOOL_PROGRESS_THROTTLE_MS = 8000;
+/**
+ * Check if a tool should trigger a progress update.
+ * Messaging tools are skipped since they're the final output.
+ */
+function shouldSkipToolProgress(toolName) {
+    const normalized = toolName.toLowerCase().trim();
+    return (normalized === "message" ||
+        normalized === "send" ||
+        normalized === "send_message" ||
+        normalized === "sessions_send");
+}
+/**
+ * Create a filler trigger for an agent run.
+ *
+ * Returns null if filler is disabled or not enabled for this channel.
+ * Waits briefly for thinking to accumulate before generating filler.
+ */
+export function createFillerTrigger(params) {
+    const config = resolveFillerConfig(params.cfg);
+    // Check if filler is enabled for this channel (respects session and per-agent config)
+    if (!isFillerEnabledForChannel({
+        cfg: params.cfg,
+        agentId: params.agentId,
+        channel: params.channel,
+        sessionFillerEnabled: params.sessionFillerEnabled,
+    })) {
+        return null;
+    }
+    // console.log(`[filler] waiting for thinking (${THINKING_WAIT_MS}ms) for run ${params.runId}`);
+    let cancelled = false;
+    let fillerSent = false;
+    const abortController = new AbortController();
+    const thinkingChunks = [];
+    let generatePromise = null;
+    let lastProgressAt = 0;
+    // Collect thinking chunks
+    const feedThinking = (text) => {
+        if (cancelled || fillerSent || !text)
+            return;
+        thinkingChunks.push(text);
+    };
+    // Send progress update for tool calls (throttled, uses Haiku to generate)
+    const feedToolCall = (toolName, args) => {
+        if (cancelled)
+            return;
+        // Skip messaging tools (they're the final output)
+        if (shouldSkipToolProgress(toolName)) {
+            // console.log(`[filler] skipping progress for tool ${toolName}`);
+            return;
+        }
+        // Throttle progress updates
+        const now = Date.now();
+        if (now - lastProgressAt < TOOL_PROGRESS_THROTTLE_MS) {
+            // console.log(`[filler] throttled tool progress for ${toolName}`);
+            return;
+        }
+        lastProgressAt = now;
+        // console.log(`[filler] generating tool progress for ${toolName}`);
+        // Generate and send progress update via Haiku
+        void generateToolProgress({
+            toolName,
+            args,
+            model: config.model,
+            timeoutMs: 2000,
+            cfg: params.cfg,
+            agentDir: params.agentDir,
+        })
+            .then((result) => {
+            if (cancelled) {
+                // console.log(`[filler] cancelled, discarding tool progress`);
+                return;
+            }
+            if (result.ok) {
+                // console.log(`[filler] sending tool progress: "${result.text}" (${toolName})`);
+                return params.onFiller(result.text);
+            }
+        })
+            .catch((err) => {
+            console.warn(`[filler] tool progress failed: ${err instanceof Error ? err.message : String(err)}`);
+        });
+    };
+    // Start generation after brief delay to collect thinking
+    const thinkingTimer = setTimeout(() => {
+        if (cancelled)
+            return;
+        generatePromise = startGeneration();
+    }, THINKING_WAIT_MS);
+    async function startGeneration() {
+        if (cancelled)
+            return;
+        const thinking = thinkingChunks.join("").trim();
+        // console.log(`[filler] generating with ${thinking.length} chars of thinking`);
+        try {
+            const result = await generateFiller({
+                userMessage: params.userMessage || "",
+                thinking: thinking || undefined,
+                model: config.model,
+                maxWords: config.maxWords,
+                timeoutMs: config.maxWaitMs,
+                abortSignal: abortController.signal,
+                cfg: params.cfg,
+                agentDir: params.agentDir,
+            });
+            if (cancelled) {
+                // console.log(`[filler] cancelled during generation, discarding`);
+                return;
+            }
+            if (result.ok) {
+                fillerSent = true;
+                // console.log(`[filler] delivering: "${result.text}"`);
+                await params.onFiller(result.text);
+            }
+            else if ("skip" in result && result.skip) {
+                // console.log(`[filler] model returned SKIP`);
+            }
+            else if ("error" in result) {
+                console.warn(`[filler] generation error: ${result.error.message}`);
+            }
+        }
+        catch (err) {
+            // Fail silently - filler is non-critical
+            console.warn(`[filler] error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    const cancel = () => {
+        if (cancelled)
+            return;
+        cancelled = true;
+        clearTimeout(thinkingTimer);
+        abortController.abort();
+        console.warn(`[filler] cancelled for run ${params.runId}`);
+    };
+    const flush = async () => {
+        clearTimeout(thinkingTimer);
+        if (!generatePromise && !cancelled && !fillerSent) {
+            generatePromise = startGeneration();
+        }
+        if (generatePromise) {
+            await generatePromise;
+        }
+    };
+    return {
+        feedThinking,
+        feedToolCall,
+        cancel,
+        flush,
+    };
+}

package/dist/filler/types.js

@@ -0,0 +1,7 @@
+/**
+ * Filler message generation types.
+ *
+ * The filler system emits brief acknowledgments while the main AI response
+ * is generating, reducing perceived latency for channels like WhatsApp.
+ */
+export {};

package/dist/gateway/protocol/schema/cron.js

@@ -66,6 +66,7 @@ export const CronJobStateSchema = Type.Object({
 export const CronJobSchema = Type.Object({
     id: NonEmptyString,
     agentId: Type.Optional(NonEmptyString),
+    accountId: Type.Optional(NonEmptyString),
     name: NonEmptyString,
     description: Type.Optional(Type.String()),
     enabled: Type.Boolean(),
@@ -82,11 +83,13 @@ export const CronJobSchema = Type.Object({
 export const CronListParamsSchema = Type.Object({
     includeDisabled: Type.Optional(Type.Boolean()),
     agentIds: Type.Optional(Type.Array(Type.String())),
+    accountId: Type.Optional(Type.String()),
 }, { additionalProperties: false });
 export const CronStatusParamsSchema = Type.Object({}, { additionalProperties: false });
 export const CronAddParamsSchema = Type.Object({
     name: NonEmptyString,
     agentId: Type.Optional(Type.Union([NonEmptyString, Type.Null()])),
+    accountId: Type.Optional(Type.Union([NonEmptyString, Type.Null()])),
     description: Type.Optional(Type.String()),
     enabled: Type.Optional(Type.Boolean()),
     deleteAfterRun: Type.Optional(Type.Boolean()),
@@ -99,6 +102,7 @@ export const CronAddParamsSchema = Type.Object({
 export const CronJobPatchSchema = Type.Object({
     name: Type.Optional(NonEmptyString),
     agentId: Type.Optional(Type.Union([NonEmptyString, Type.Null()])),
+    accountId: Type.Optional(Type.Union([NonEmptyString, Type.Null()])),
     description: Type.Optional(Type.String()),
     enabled: Type.Optional(Type.Boolean()),
     deleteAfterRun: Type.Optional(Type.Boolean()),