@iaforged/context-code 1.2.8 → 1.2.10

package/dist/src/services/mcp/client.js

@@ -12,6 +12,7 @@ import memoize from 'lodash-es/memoize.js';
 import zipObject from 'lodash-es/zipObject.js';
 import pMap from 'p-map';
 import { getOriginalCwd, getSessionId } from '../../bootstrap/state.js';
+import { coreMcpRuntime, isCoreMcpEnabled } from '../../core/mcp/runtime.js';
 import { getOauthConfig } from '../../constants/oauth.js';
 import { PRODUCT_URL } from '../../constants/product.js';
 import { toolMatchesName, } from '../../Tool.js';
@@ -310,6 +311,12 @@ const IMAGE_MIME_TYPES = new Set([
 function getConnectionTimeoutMs() {
     return parseInt(process.env.MCP_TIMEOUT || '', 10) || 30000;
 }
+function syncCoreMcpServer(connection, extras) {
+    if (!isCoreMcpEnabled()) {
+        return;
+    }
+    coreMcpRuntime.upsertServer(connection, extras);
+}
 /**
  * Default timeout for individual MCP requests (auth, tool calls, etc.)
  */
@@ -1320,6 +1327,7 @@ export const fetchToolsForClient = memoizeWithLRU(async (client) => {
         return [];
     try {
         if (!client.capabilities?.tools) {
+            syncCoreMcpServer(client, { tools: [] });
             return [];
         }
         const result = (await client.client.request({ method: 'tools/list' }, ListToolsResultSchema));
@@ -1329,7 +1337,7 @@ export const fetchToolsForClient = memoizeWithLRU(async (client) => {
         const skipPrefix = client.config.type === 'sdk' &&
             isEnvTruthy(process.env.CLAUDE_AGENT_SDK_MCP_NO_PREFIX);
         // Convert MCP tools to our Tool format
-        return toolsToProcess
+        const mappedTools = toolsToProcess
             .map((tool) => {
             const fullyQualifiedName = buildMcpToolName(client.name, tool.name);
             return {
@@ -1523,6 +1531,8 @@ export const fetchToolsForClient = memoizeWithLRU(async (client) => {
             };
         })
             .filter(isIncludedMcpTool);
+        syncCoreMcpServer(client, { tools: mappedTools });
+        return mappedTools;
     }
     catch (error) {
         logMCPError(client.name, `Failed to fetch tools: ${errorMessage(error)}`);
@@ -1641,6 +1651,7 @@ export async function reconnectMcpServerImpl(name, config) {
         await clearServerCache(name, config);
         const client = await connectToServer(name, config);
         if (client.type !== 'connected') {
+            syncCoreMcpServer(client);
             return {
                 client,
                 tools: [],
@@ -1660,6 +1671,11 @@ export async function reconnectMcpServerImpl(name, config) {
             supportsResources ? fetchResourcesForClient(client) : Promise.resolve([]),
         ]);
         const commands = [...mcpCommands, ...mcpSkills];
+        syncCoreMcpServer(client, {
+            tools,
+            commands,
+            resources,
+        });
         // Check if we need to add resource tools
         const resourceTools = [];
         if (supportsResources) {
@@ -1770,6 +1786,7 @@ export async function getMcpToolsCommandsAndResources(onConnectionAttempt, mcpCo
             }
             const client = await connectToServer(name, config, serverStats);
             if (client.type !== 'connected') {
+                syncCoreMcpServer(client);
                 onConnectionAttempt({
                     client,
                     tools: client.type === 'needs-auth'
@@ -1796,6 +1813,11 @@ export async function getMcpToolsCommandsAndResources(onConnectionAttempt, mcpCo
                     : Promise.resolve([]),
             ]);
             const commands = [...mcpCommands, ...mcpSkills];
+            syncCoreMcpServer(client, {
+                tools,
+                commands,
+                resources,
+            });
             // If this server resources and we haven't added resource tools yet,
             // include our resource tools with this client's tools
             const resourceTools = [];
@@ -1819,6 +1841,7 @@ export async function getMcpToolsCommandsAndResources(onConnectionAttempt, mcpCo
                 tools: [],
                 commands: [],
             });
+            syncCoreMcpServer({ name, type: 'failed', config });
         }
     };
     // Process both groups concurrently, each with their own concurrency limits:
@@ -2473,6 +2496,9 @@ export async function setupSdkMcpClients(sdkMcpConfigs, sendMcpMessage) {
         if (result.status === 'fulfilled') {
             clients.push(result.value.client);
             tools.push(...result.value.tools);
+            syncCoreMcpServer(result.value.client, {
+                tools: result.value.tools,
+            });
         }
         // If rejected (unexpected), the error was already logged inside the promise
     }

package/dist/src/services/orchestration/execution/AgentTaskExecutor.js

@@ -137,27 +137,46 @@ function extractAnthropicOutput(payload) {
         .filter(Boolean)
         .join('\n') || null);
 }
-async function postJson(url, headers, body) {
-    const response = await fetch(url, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            ...headers,
-        },
-        body: JSON.stringify(body),
-    });
-    const text = await response.text();
-    const data = tryParseJson(text) ?? text;
-    if (!response.ok) {
-        return {
-            ok: false,
-            status: response.status,
-            error: typeof data === 'string'
-                ? data
-                : JSON.stringify(data),
-        };
+async function postJson(url, headers, body, retries = 3) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        if (attempt > 0) {
+            const delay = Math.pow(2, attempt) * 1000 + Math.random() * 1000;
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...headers,
+                },
+                body: JSON.stringify(body),
+            });
+            const text = await response.text();
+            const data = tryParseJson(text) ?? text;
+            if (!response.ok) {
+                lastError = {
+                    status: response.status,
+                    error: typeof data === 'string' ? data : JSON.stringify(data),
+                };
+                // Only retry on rate limits (429) or server errors (5xx)
+                if (response.status === 429 || response.status >= 500) {
+                    continue;
+                }
+                return { ok: false, ...lastError };
+            }
+            return { ok: true, data };
+        }
+        catch (e) {
+            lastError = {
+                status: 0,
+                error: e instanceof Error ? e.message : String(e),
+            };
+            continue;
+        }
     }
-    return { ok: true, data };
+    return { ok: false, ...lastError };
 }
 async function executeOpenAICompatible(input, model, baseUrl, credential) {
     const headers = {};

package/dist/src/services/orchestration/execution/OrchestrationExecutionRuntime.js

@@ -205,17 +205,17 @@ async function loadRunState(runId) {
     }
     const db = await getOrchestrationDatabase();
     const tasks = db
-        .prepare(`SELECT id, run_id, parent_task_id, scope_type, team_unit_id, assigned_agent_id, title, instructions, status, result_summary, created_at, finished_at
-       FROM orchestration_tasks
-       WHERE run_id = ?
+        .prepare(`SELECT id, run_id, parent_task_id, scope_type, team_unit_id, assigned_agent_id, title, instructions, status, result_summary, created_at, finished_at
+       FROM orchestration_tasks
+       WHERE run_id = ?
        ORDER BY created_at, id`)
         .all(requireText(runId, 'runId'))
         .map(rowToTask)
         .filter((task) => task !== null);
     const messages = db
-        .prepare(`SELECT id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
-       FROM orchestration_messages
-       WHERE run_id = ?
+        .prepare(`SELECT id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+       FROM orchestration_messages
+       WHERE run_id = ?
        ORDER BY created_at, id`)
         .all(requireText(runId, 'runId'))
         .map(rowToMessage)
@@ -225,8 +225,8 @@ async function loadRunState(runId) {
 async function loadTaskAndRunState(taskId) {
     const db = await getOrchestrationDatabase();
     const row = db
-        .prepare(`SELECT id, run_id, parent_task_id, scope_type, team_unit_id, assigned_agent_id, title, instructions, status, result_summary, created_at, finished_at
-       FROM orchestration_tasks
+        .prepare(`SELECT id, run_id, parent_task_id, scope_type, team_unit_id, assigned_agent_id, title, instructions, status, result_summary, created_at, finished_at
+       FROM orchestration_tasks
        WHERE id = ?`)
         .get(requireText(taskId, 'taskId'));
     const task = rowToTask(row);
@@ -242,8 +242,8 @@ async function loadTaskAndRunState(taskId) {
 async function updateTasksByRun(runId, transform) {
     const db = await getOrchestrationDatabase();
     const rows = db
-        .prepare(`SELECT id, run_id, parent_task_id, scope_type, team_unit_id, assigned_agent_id, title, instructions, status, result_summary, created_at, finished_at
-       FROM orchestration_tasks
+        .prepare(`SELECT id, run_id, parent_task_id, scope_type, team_unit_id, assigned_agent_id, title, instructions, status, result_summary, created_at, finished_at
+       FROM orchestration_tasks
        WHERE run_id = ?`)
         .all(requireText(runId, 'runId'))
         .map(rowToTask)
@@ -253,8 +253,8 @@ async function updateTasksByRun(runId, transform) {
         if (!patch) {
             continue;
         }
-        db.prepare(`UPDATE orchestration_tasks
-       SET status = ?, result_summary = ?, finished_at = ?
+        db.prepare(`UPDATE orchestration_tasks
+       SET status = ?, result_summary = ?, finished_at = ?
        WHERE id = ?`).run(patch.status ?? task.status, patch.result_summary ?? task.resultSummary ?? null, patch.finished_at ?? task.finishedAt ?? null, task.id);
     }
 }
@@ -271,8 +271,8 @@ async function writeRunTransition(runId, nextStatus, options) {
     const finishedAt = options?.finishedAt === undefined
         ? current.finishedAt
         : toNullableText(options.finishedAt);
-    db.prepare(`UPDATE orchestration_runs
-     SET status = ?, started_at = ?, finished_at = ?
+    db.prepare(`UPDATE orchestration_runs
+     SET status = ?, started_at = ?, finished_at = ?
      WHERE id = ?`).run(nextStatus, startedAt, finishedAt, runId);
 }
 async function writeTaskTransition(taskId, nextStatus, options) {
@@ -287,8 +287,8 @@ async function writeTaskTransition(taskId, nextStatus, options) {
             ? nowIso()
             : null
         : toNullableText(options.finishedAt);
-    db.prepare(`UPDATE orchestration_tasks
-     SET status = ?, result_summary = ?, finished_at = ?
+    db.prepare(`UPDATE orchestration_tasks
+     SET status = ?, result_summary = ?, finished_at = ?
      WHERE id = ?`).run(nextStatus, options?.resultSummary === undefined
         ? current.task.resultSummary
         : toNullableText(options.resultSummary), finishedAt, taskId);
@@ -407,20 +407,20 @@ export class OrchestrationExecutionRuntime {
         const changed = runState.run.status !== 'in_progress';
         await withOrchestrationTransaction(async (db) => {
             const startedAt = runState.run.startedAt ?? nowIso();
-            db.prepare(`UPDATE orchestration_runs
-         SET status = ?, started_at = ?, finished_at = NULL
+            db.prepare(`UPDATE orchestration_runs
+         SET status = ?, started_at = ?, finished_at = NULL
          WHERE id = ?`).run('in_progress', startedAt, runId);
             if (input.promotePendingTasks !== false) {
                 for (const task of runState.tasks) {
                     if (task.status === 'pending' || task.status === 'blocked') {
-                        db.prepare(`UPDATE orchestration_tasks
-               SET status = ?, finished_at = NULL
+                        db.prepare(`UPDATE orchestration_tasks
+               SET status = ?, finished_at = NULL
                WHERE id = ?`).run('ready', task.id);
                     }
                 }
             }
-            db.prepare(`INSERT INTO orchestration_messages (
-          id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+            db.prepare(`INSERT INTO orchestration_messages (
+          id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), runId, null, null, null, 'run.start', nowMessage('start', input.note), nowIso());
         });
         const refreshed = await loadRunState(runId);
@@ -452,20 +452,20 @@ export class OrchestrationExecutionRuntime {
         const changed = runState.run.status !== 'in_progress';
         await withOrchestrationTransaction(async (db) => {
             const startedAt = runState.run.startedAt ?? nowIso();
-            db.prepare(`UPDATE orchestration_runs
-         SET status = ?, started_at = ?, finished_at = NULL
+            db.prepare(`UPDATE orchestration_runs
+         SET status = ?, started_at = ?, finished_at = NULL
          WHERE id = ?`).run('in_progress', startedAt, runId);
             if (input.reactivateBlockedTasks !== false) {
                 for (const task of runState.tasks) {
                     if (task.status === 'blocked' || task.status === 'failed' || task.status === 'pending') {
-                        db.prepare(`UPDATE orchestration_tasks
-               SET status = ?, finished_at = NULL
+                        db.prepare(`UPDATE orchestration_tasks
+               SET status = ?, finished_at = NULL
                WHERE id = ?`).run('ready', task.id);
                     }
                 }
             }
-            db.prepare(`INSERT INTO orchestration_messages (
-          id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+            db.prepare(`INSERT INTO orchestration_messages (
+          id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), runId, null, null, null, 'run.resume', nowMessage('resume', input.note), nowIso());
         });
         const refreshed = await loadRunState(runId);
@@ -494,20 +494,20 @@ export class OrchestrationExecutionRuntime {
         const changed = runState.run.status !== 'cancelled';
         await withOrchestrationTransaction(async (db) => {
             const finishedAt = nowIso();
-            db.prepare(`UPDATE orchestration_runs
-         SET status = ?, finished_at = ?
+            db.prepare(`UPDATE orchestration_runs
+         SET status = ?, finished_at = ?
          WHERE id = ?`).run('cancelled', finishedAt, runId);
             if (input.blockOpenTasks !== false) {
                 for (const task of runState.tasks) {
                     if (task.status !== 'completed') {
-                        db.prepare(`UPDATE orchestration_tasks
-               SET status = ?, finished_at = ?
+                        db.prepare(`UPDATE orchestration_tasks
+               SET status = ?, finished_at = ?
                WHERE id = ?`).run('blocked', finishedAt, task.id);
                     }
                 }
             }
-            db.prepare(`INSERT INTO orchestration_messages (
-          id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+            db.prepare(`INSERT INTO orchestration_messages (
+          id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), runId, null, null, null, 'run.cancel', nowMessage('cancel', input.reason), nowIso());
         });
         const refreshed = await loadRunState(runId);
@@ -529,16 +529,16 @@ export class OrchestrationExecutionRuntime {
         const changed = current.status !== input.status;
         await withOrchestrationTransaction(async (db) => {
             validateRunTransition(current.status, input.status);
-            db.prepare(`UPDATE orchestration_runs
-         SET status = ?, started_at = ?, finished_at = ?
+            db.prepare(`UPDATE orchestration_runs
+         SET status = ?, started_at = ?, finished_at = ?
          WHERE id = ?`).run(input.status, input.startedAt === undefined
                 ? current.startedAt
                 : toNullableText(input.startedAt), input.finishedAt === undefined
                 ? current.finishedAt
                 : toNullableText(input.finishedAt), runId);
             if (input.note) {
-                db.prepare(`INSERT INTO orchestration_messages (
-            id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+                db.prepare(`INSERT INTO orchestration_messages (
+            id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), runId, null, null, null, 'run.transition', nowMessage('transition-run', input.note), nowIso());
             }
         });
@@ -561,8 +561,8 @@ export class OrchestrationExecutionRuntime {
         const changed = loaded.task.status !== input.status;
         await withOrchestrationTransaction(async (db) => {
             validateTaskTransition(loaded.task.status, input.status);
-            db.prepare(`UPDATE orchestration_tasks
-         SET status = ?, result_summary = ?, finished_at = ?
+            db.prepare(`UPDATE orchestration_tasks
+         SET status = ?, result_summary = ?, finished_at = ?
          WHERE id = ?`).run(input.status, input.resultSummary === undefined
                 ? loaded.task.resultSummary
                 : toNullableText(input.resultSummary), input.finishedAt === undefined
@@ -571,8 +571,8 @@ export class OrchestrationExecutionRuntime {
                     : null
                 : toNullableText(input.finishedAt), taskId);
             if (input.note) {
-                db.prepare(`INSERT INTO orchestration_messages (
-            id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+                db.prepare(`INSERT INTO orchestration_messages (
+            id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), loaded.run.id, taskId, null, null, 'task.transition', nowMessage('transition-task', input.note), nowIso());
             }
         });
@@ -654,6 +654,7 @@ export class OrchestrationExecutionRuntime {
                     domainName,
                     phase: 'blocked',
                     detail: 'sin agente asignado',
+                    output: summary,
                     progressPercent: Math.min(100, Math.round(((processedReadyTasks + 1) / totalReadyTasks) * 100)),
                 });
                 await writeTaskTransition(task.id, 'blocked', {
@@ -720,6 +721,7 @@ export class OrchestrationExecutionRuntime {
                     agentLabel: selectedAgentId,
                     phase: 'blocked',
                     detail: 'agente deshabilitado o inexistente',
+                    output: summary,
                     progressPercent: Math.min(100, Math.round(((processedReadyTasks + 1) / totalReadyTasks) * 100)),
                 });
                 await writeTaskTransition(task.id, 'blocked', {
@@ -786,6 +788,7 @@ export class OrchestrationExecutionRuntime {
                     agentLabel,
                     phase: 'blocked',
                     detail: 'workspace deshabilitado o inexistente',
+                    output: summary,
                     progressPercent: Math.min(100, Math.round(((processedReadyTasks + 1) / totalReadyTasks) * 100)),
                 });
                 await writeTaskTransition(task.id, 'blocked', {
@@ -841,11 +844,11 @@ export class OrchestrationExecutionRuntime {
                 continue;
             }
             await withOrchestrationTransaction(async (db) => {
-                db.prepare(`UPDATE orchestration_tasks
-           SET status = ?, assigned_agent_id = ?, finished_at = NULL
+                db.prepare(`UPDATE orchestration_tasks
+           SET status = ?, assigned_agent_id = ?, finished_at = NULL
            WHERE id = ?`).run('in_progress', selectedAgentId, task.id);
-                db.prepare(`INSERT INTO orchestration_messages (
-            id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+                db.prepare(`INSERT INTO orchestration_messages (
+            id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), runId, task.id, initial.run.globalOrchestratorAgentId, selectedAgentId, 'task.dispatch', `Equipo ${domainName}: tarea enviada a ${agent.name}.`, nowIso());
             });
             input.onProgress?.({
@@ -889,6 +892,7 @@ export class OrchestrationExecutionRuntime {
                 agentLabel,
                 phase: executionResult.status,
                 detail: executionResult.model ? `modelo ${executionResult.model}` : null,
+                output: executionResult.output || summary,
                 progressPercent: Math.min(100, Math.round(((processedReadyTasks + 1) / totalReadyTasks) * 100)),
             });
             await writeTaskTransition(task.id, nextTaskStatus, {
@@ -949,6 +953,9 @@ export class OrchestrationExecutionRuntime {
                 completedAt,
             });
             processedReadyTasks += 1;
+            if (processedReadyTasks < totalReadyTasks) {
+                await new Promise(resolve => setTimeout(resolve, 1000));
+            }
         }
         input.onProgress?.({
             runId,
@@ -1003,11 +1010,11 @@ export class OrchestrationExecutionRuntime {
             ? report.generatedAt
             : null;
         await withOrchestrationTransaction(async (db) => {
-            db.prepare(`UPDATE orchestration_runs
-         SET status = ?, finished_at = ?
+            db.prepare(`UPDATE orchestration_runs
+         SET status = ?, finished_at = ?
          WHERE id = ?`).run(report.status, finishedAt, runId);
-            db.prepare(`INSERT INTO orchestration_messages (
-          id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+            db.prepare(`INSERT INTO orchestration_messages (
+          id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), runId, null, null, state.run.globalOrchestratorAgentId, 'global.consolidated-report', report.summary, report.generatedAt);
         });
         await upsertOrchestrationRunReport({
@@ -1045,12 +1052,12 @@ export class OrchestrationExecutionRuntime {
         const db = await getOrchestrationDatabase();
         const id = randomUUID();
         const createdAt = nowIso();
-        db.prepare(`INSERT INTO orchestration_messages (
-        id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+        db.prepare(`INSERT INTO orchestration_messages (
+        id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, requireText(runId, 'runId'), toNullableText(taskId), toNullableText(fromAgentId), toNullableText(toAgentId), requireText(messageType, 'messageType'), requireText(content, 'content'), createdAt);
         const row = db
-            .prepare(`SELECT id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
-         FROM orchestration_messages
+            .prepare(`SELECT id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+         FROM orchestration_messages
          WHERE id = ?`)
             .get(id);
         const created = rowToMessage(row);
@@ -1073,11 +1080,11 @@ export class OrchestrationExecutionRuntime {
                     finished_at: finishedAt,
                     result_summary: task.resultSummary ?? null,
                 });
-            db.prepare(`INSERT INTO orchestration_messages (
-          id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
+            db.prepare(`INSERT INTO orchestration_messages (
+          id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), runId, null, null, null, 'run.block', nowMessage('cancel', reason), nowIso());
-            db.prepare(`UPDATE orchestration_runs
-         SET status = ?, finished_at = ?
+            db.prepare(`UPDATE orchestration_runs
+         SET status = ?, finished_at = ?
          WHERE id = ?`).run('cancelled', finishedAt, runId);
         });
         const refreshed = await loadRunState(runId);

package/dist/src/skills/bundled/loop.js

@@ -1,65 +1,65 @@
 import { CRON_CREATE_TOOL_NAME, CRON_DELETE_TOOL_NAME, DEFAULT_MAX_AGE_DAYS, isKairosCronEnabled, } from '../../tools/ScheduleCronTool/prompt.js';
 import { registerBundledSkill } from '../bundledSkills.js';
 const DEFAULT_INTERVAL = '10m';
-const USAGE_MESSAGE = `Usage: /loop [interval] <prompt>
-
-Run a prompt or slash command on a recurring interval.
-
-Intervals: Ns, Nm, Nh, Nd (e.g. 5m, 30m, 2h, 1d). Minimum granularity is 1 minute.
-If no interval is specified, defaults to ${DEFAULT_INTERVAL}.
-
-Examples:
-  /loop 5m /babysit-prs
-  /loop 30m check the deploy
-  /loop 1h /standup 1
-  /loop check the deploy          (defaults to ${DEFAULT_INTERVAL})
+const USAGE_MESSAGE = `Usage: /loop [interval] <prompt>
+
+Run a prompt or slash command on a recurring interval.
+
+Intervals: Ns, Nm, Nh, Nd (e.g. 5m, 30m, 2h, 1d). Minimum granularity is 1 minute.
+If no interval is specified, defaults to ${DEFAULT_INTERVAL}.
+
+Examples:
+  /loop 5m /babysit-prs
+  /loop 30m check the deploy
+  /loop 1h /standup 1
+  /loop check the deploy          (defaults to ${DEFAULT_INTERVAL})
   /loop check the deploy every 20m`;
 function buildPrompt(args) {
-    return `# /loop — schedule a recurring prompt
-
-Parse the input below into \`[interval] <prompt…>\` and schedule it with ${CRON_CREATE_TOOL_NAME}.
-
-## Parsing (in priority order)
-
-1. **Leading token**: if the first whitespace-delimited token matches \`^\\d+[smhd]$\` (e.g. \`5m\`, \`2h\`), that's the interval; the rest is the prompt.
-2. **Trailing "every" clause**: otherwise, if the input ends with \`every <N><unit>\` or \`every <N> <unit-word>\` (e.g. \`every 20m\`, \`every 5 minutes\`, \`every 2 hours\`), extract that as the interval and strip it from the prompt. Only match when what follows "every" is a time expression — \`check every PR\` has no interval.
-3. **Default**: otherwise, interval is \`${DEFAULT_INTERVAL}\` and the entire input is the prompt.
-
-If the resulting prompt is empty, show usage \`/loop [interval] <prompt>\` and stop — do not call ${CRON_CREATE_TOOL_NAME}.
-
-Examples:
-- \`5m /babysit-prs\` → interval \`5m\`, prompt \`/babysit-prs\` (rule 1)
-- \`check the deploy every 20m\` → interval \`20m\`, prompt \`check the deploy\` (rule 2)
-- \`run tests every 5 minutes\` → interval \`5m\`, prompt \`run tests\` (rule 2)
-- \`check the deploy\` → interval \`${DEFAULT_INTERVAL}\`, prompt \`check the deploy\` (rule 3)
-- \`check every PR\` → interval \`${DEFAULT_INTERVAL}\`, prompt \`check every PR\` (rule 3 — "every" not followed by time)
-- \`5m\` → empty prompt → show usage
-
-## Interval → cron
-
-Supported suffixes: \`s\` (seconds, rounded up to nearest minute, min 1), \`m\` (minutes), \`h\` (hours), \`d\` (days). Convert:
-
-| Interval pattern      | Cron expression     | Notes                                    |
-|-----------------------|---------------------|------------------------------------------|
-| \`Nm\` where N ≤ 59   | \`*/N * * * *\`     | every N minutes                          |
-| \`Nm\` where N ≥ 60   | \`0 */H * * *\`     | round to hours (H = N/60, must divide 24)|
-| \`Nh\` where N ≤ 23   | \`0 */N * * *\`     | every N hours                            |
-| \`Nd\`                | \`0 0 */N * *\`     | every N days at midnight local           |
-| \`Ns\`                | treat as \`ceil(N/60)m\` | cron minimum granularity is 1 minute  |
-
-**If the interval doesn't cleanly divide its unit** (e.g. \`7m\` → \`*/7 * * * *\` gives uneven gaps at :56→:00; \`90m\` → 1.5h which cron can't express), pick the nearest clean interval and tell the user what you rounded to before scheduling.
-
-## Action
-
-1. Call ${CRON_CREATE_TOOL_NAME} with:
-   - \`cron\`: the expression from the table above
-   - \`prompt\`: the parsed prompt from above, verbatim (slash commands are passed through unchanged)
-   - \`recurring\`: \`true\`
-2. Briefly confirm: what's scheduled, the cron expression, the human-readable cadence, that recurring tasks auto-expire after ${DEFAULT_MAX_AGE_DAYS} days, and that they can cancel sooner with ${CRON_DELETE_TOOL_NAME} (include the job ID).
-3. **Then immediately execute the parsed prompt now** — don't wait for the first cron fire. If it's a slash command, invoke it via the Skill tool; otherwise act on it directly.
-
-## Input
-
+    return `# /loop — schedule a recurring prompt
+
+Parse the input below into \`[interval] <prompt…>\` and schedule it with ${CRON_CREATE_TOOL_NAME}.
+
+## Parsing (in priority order)
+
+1. **Leading token**: if the first whitespace-delimited token matches \`^\\d+[smhd]$\` (e.g. \`5m\`, \`2h\`), that's the interval; the rest is the prompt.
+2. **Trailing "every" clause**: otherwise, if the input ends with \`every <N><unit>\` or \`every <N> <unit-word>\` (e.g. \`every 20m\`, \`every 5 minutes\`, \`every 2 hours\`), extract that as the interval and strip it from the prompt. Only match when what follows "every" is a time expression — \`check every PR\` has no interval.
+3. **Default**: otherwise, interval is \`${DEFAULT_INTERVAL}\` and the entire input is the prompt.
+
+If the resulting prompt is empty, show usage \`/loop [interval] <prompt>\` and stop — do not call ${CRON_CREATE_TOOL_NAME}.
+
+Examples:
+- \`5m /babysit-prs\` → interval \`5m\`, prompt \`/babysit-prs\` (rule 1)
+- \`check the deploy every 20m\` → interval \`20m\`, prompt \`check the deploy\` (rule 2)
+- \`run tests every 5 minutes\` → interval \`5m\`, prompt \`run tests\` (rule 2)
+- \`check the deploy\` → interval \`${DEFAULT_INTERVAL}\`, prompt \`check the deploy\` (rule 3)
+- \`check every PR\` → interval \`${DEFAULT_INTERVAL}\`, prompt \`check every PR\` (rule 3 — "every" not followed by time)
+- \`5m\` → empty prompt → show usage
+
+## Interval → cron
+
+Supported suffixes: \`s\` (seconds, rounded up to nearest minute, min 1), \`m\` (minutes), \`h\` (hours), \`d\` (days). Convert:
+
+| Interval pattern      | Cron expression     | Notes                                    |
+|-----------------------|---------------------|------------------------------------------|
+| \`Nm\` where N ≤ 59   | \`*/N * * * *\`     | every N minutes                          |
+| \`Nm\` where N ≥ 60   | \`0 */H * * *\`     | round to hours (H = N/60, must divide 24)|
+| \`Nh\` where N ≤ 23   | \`0 */N * * *\`     | every N hours                            |
+| \`Nd\`                | \`0 0 */N * *\`     | every N days at midnight local           |
+| \`Ns\`                | treat as \`ceil(N/60)m\` | cron minimum granularity is 1 minute  |
+
+**If the interval doesn't cleanly divide its unit** (e.g. \`7m\` → \`*/7 * * * *\` gives uneven gaps at :56→:00; \`90m\` → 1.5h which cron can't express), pick the nearest clean interval and tell the user what you rounded to before scheduling.
+
+## Action
+
+1. Call ${CRON_CREATE_TOOL_NAME} with:
+   - \`cron\`: the expression from the table above
+   - \`prompt\`: the parsed prompt from above, verbatim (slash commands are passed through unchanged)
+   - \`recurring\`: \`true\`
+2. Briefly confirm: what's scheduled, the cron expression, the human-readable cadence, that recurring tasks auto-expire after ${DEFAULT_MAX_AGE_DAYS} days, and that they can cancel sooner with ${CRON_DELETE_TOOL_NAME} (include the job ID).
+3. **Then immediately execute the parsed prompt now** — don't wait for the first cron fire. If it's a slash command, invoke it via the Skill tool; otherwise act on it directly.
+
+## Input
+
 ${args}`;
 }
 export function registerLoopSkill() {