npm - minionsai - Versions diffs - 0.1.11 → 0.1.13 - Mend

minionsai 0.1.11 → 0.1.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (29) hide show

package/dist/server/client/dist/index.html CHANGED Viewed

@@ -8,8 +8,8 @@
     <script>
       (function(){var t=localStorage.getItem('theme');var d=t==='dark'||(!t||t==='system')&&window.matchMedia('(prefers-color-scheme: dark)').matches;if(d)document.documentElement.classList.add('dark')})();
     </script>
-    <script type="module" crossorigin src="/assets/index-C0fNYxd2.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-BdyoTQw9.css">
+    <script type="module" crossorigin src="/assets/index-o62nNllV.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BP1qiwyD.css">
   </head>
   <body class="bg-gray-50 text-gray-900 dark:bg-gray-950 dark:text-gray-100">
     <div id="root"></div>

package/dist/server/client/dist/sounds/done.mp3 ADDED Viewed

Binary file

package/dist/server/server/adapters/hermes-worker.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import type { AgentDefaults, AgentModelsResponse, CompactResult, Routine, RoutineInput, SessionMetadata, TaskMessage } from '../../shared/types.js';
+import type { AgentDefaults, AgentModelsResponse, CompactResult, GoalDecision, GoalStateSnapshot, ScheduledTask, ScheduledTaskInput, SessionMetadata, TaskMessage } from '../../shared/types.js';
 import type { AgentAdapter, AgentRunOptions, AgentRunSettings, StreamEvent } from './types.js';
 export declare class HermesWorkerAdapter implements AgentAdapter {
     private client;
@@ -19,19 +19,15 @@ export declare class HermesWorkerAdapter implements AgentAdapter {
         reasoningEffort?: string | null;
     }): Promise<AgentDefaults>;
     getModels(): Promise<AgentModelsResponse>;
-    listRoutines(includeDisabled?: boolean): Promise<Routine[]>;
-    getRoutine(jobId: string): Promise<Routine | null>;
-    createRoutine(input: RoutineInput): Promise<Routine>;
-    updateRoutine(jobId: string, updates: Partial<RoutineInput>): Promise<Routine | null>;
-    pauseRoutine(jobId: string, reason?: string): Promise<Routine | null>;
-    resumeRoutine(jobId: string): Promise<Routine | null>;
-    runRoutine(jobId: string): Promise<Routine | null>;
-    removeRoutine(jobId: string): Promise<boolean>;
-    tickRoutines(): Promise<number>;
-    judgeCompletion(taskTitle: string, taskDescription: string | null, responseText: string): Promise<{
-        done: boolean;
-        reason: string;
-    }>;
+    listScheduledTasks(includeDisabled?: boolean): Promise<ScheduledTask[]>;
+    getScheduledTask(scheduledTaskId: string): Promise<ScheduledTask | null>;
+    createScheduledTask(input: ScheduledTaskInput): Promise<ScheduledTask>;
+    updateScheduledTask(scheduledTaskId: string, updates: Partial<ScheduledTaskInput>): Promise<ScheduledTask | null>;
+    pauseScheduledTask(scheduledTaskId: string, reason?: string): Promise<ScheduledTask | null>;
+    resumeScheduledTask(scheduledTaskId: string): Promise<ScheduledTask | null>;
+    runScheduledTask(scheduledTaskId: string): Promise<ScheduledTask | null>;
+    removeScheduledTask(scheduledTaskId: string): Promise<boolean>;
+    tickScheduledTasks(): Promise<number>;
     generateTitle(description: string): Promise<{
         title: string;
     }>;
@@ -41,4 +37,12 @@ export declare class HermesWorkerAdapter implements AgentAdapter {
         systemMessage?: string;
         settings?: AgentRunSettings;
     }): Promise<CompactResult>;
+    getGoalStatus(sessionId: string): Promise<GoalStateSnapshot | null>;
+    setGoal(sessionId: string, goal: string, options?: {
+        maxTurns?: number | null;
+    }): Promise<GoalStateSnapshot>;
+    pauseGoal(sessionId: string, reason?: string): Promise<GoalStateSnapshot | null>;
+    resumeGoal(sessionId: string): Promise<GoalStateSnapshot | null>;
+    clearGoal(sessionId: string): Promise<boolean>;
+    evaluateGoal(sessionId: string, responseText: string): Promise<GoalDecision>;
 }

package/dist/server/server/adapters/hermes-worker.js CHANGED Viewed

@@ -441,76 +441,68 @@ export class HermesWorkerAdapter {
     async getModels() {
         return await this.client.request('models.list');
     }
-    async listRoutines(includeDisabled = false) {
+    async listScheduledTasks(includeDisabled = false) {
         const result = await this.client.request({
-            type: 'routines.jobs.list',
+            type: 'scheduledTasks.list',
             includeDisabled,
         });
-        return result.jobs;
+        return result.scheduledTasks;
     }
-    async getRoutine(jobId) {
+    async getScheduledTask(scheduledTaskId) {
         const result = await this.client.request({
-            type: 'routines.jobs.get',
-            jobId,
+            type: 'scheduledTasks.get',
+            scheduledTaskId,
         });
-        return result.job;
+        return result.scheduledTask;
     }
-    async createRoutine(input) {
+    async createScheduledTask(input) {
         const result = await this.client.request({
-            type: 'routines.jobs.create',
+            type: 'scheduledTasks.create',
             ...input,
         });
-        return result.job;
+        return result.scheduledTask;
     }
-    async updateRoutine(jobId, updates) {
+    async updateScheduledTask(scheduledTaskId, updates) {
         const result = await this.client.request({
-            type: 'routines.jobs.update',
-            jobId,
+            type: 'scheduledTasks.update',
+            scheduledTaskId,
             ...updates,
         });
-        return result.job;
+        return result.scheduledTask;
     }
-    async pauseRoutine(jobId, reason) {
+    async pauseScheduledTask(scheduledTaskId, reason) {
         const result = await this.client.request({
-            type: 'routines.jobs.pause',
-            jobId,
+            type: 'scheduledTasks.pause',
+            scheduledTaskId,
             reason,
         });
-        return result.job;
+        return result.scheduledTask;
     }
-    async resumeRoutine(jobId) {
+    async resumeScheduledTask(scheduledTaskId) {
         const result = await this.client.request({
-            type: 'routines.jobs.resume',
-            jobId,
+            type: 'scheduledTasks.resume',
+            scheduledTaskId,
         });
-        return result.job;
+        return result.scheduledTask;
     }
-    async runRoutine(jobId) {
+    async runScheduledTask(scheduledTaskId) {
         const result = await this.client.request({
-            type: 'routines.jobs.run',
-            jobId,
+            type: 'scheduledTasks.run',
+            scheduledTaskId,
         });
-        return result.job;
+        return result.scheduledTask;
     }
-    async removeRoutine(jobId) {
+    async removeScheduledTask(scheduledTaskId) {
         const result = await this.client.request({
-            type: 'routines.jobs.remove',
-            jobId,
+            type: 'scheduledTasks.remove',
+            scheduledTaskId,
         });
         return result.ok;
     }
-    async tickRoutines() {
-        const result = await this.client.request({ type: 'routines.tick' });
+    async tickScheduledTasks() {
+        const result = await this.client.request({ type: 'scheduledTasks.tick' });
         return result.executed;
     }
-    async judgeCompletion(taskTitle, taskDescription, responseText) {
-        return await this.client.request({
-            type: 'judge.completion',
-            taskTitle,
-            taskDescription,
-            responseText,
-        });
-    }
     async generateTitle(description) {
         return await this.client.request({
             type: 'title.generate',
@@ -527,4 +519,51 @@ export class HermesWorkerAdapter {
             settings: options?.settings,
         });
     }
+    async getGoalStatus(sessionId) {
+        const result = await this.client.request({
+            type: 'goal.status',
+            sessionId,
+        });
+        return result.goal;
+    }
+    async setGoal(sessionId, goal, options) {
+        const result = await this.client.request({
+            type: 'goal.set',
+            sessionId,
+            goal,
+            maxTurns: options?.maxTurns,
+        });
+        if (!result.goal)
+            throw new Error('Hermes did not return goal state');
+        return result.goal;
+    }
+    async pauseGoal(sessionId, reason) {
+        const result = await this.client.request({
+            type: 'goal.pause',
+            sessionId,
+            reason,
+        });
+        return result.goal;
+    }
+    async resumeGoal(sessionId) {
+        const result = await this.client.request({
+            type: 'goal.resume',
+            sessionId,
+        });
+        return result.goal;
+    }
+    async clearGoal(sessionId) {
+        const result = await this.client.request({
+            type: 'goal.clear',
+            sessionId,
+        });
+        return result.cleared;
+    }
+    async evaluateGoal(sessionId, responseText) {
+        return await this.client.request({
+            type: 'goal.evaluate',
+            sessionId,
+            responseText,
+        });
+    }
 }

package/dist/server/server/adapters/types.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import type { AgentRunSettings, CompactResult, ContextUsage, Routine, RoutineInput, SessionMetadata, TaskMessage } from '../../shared/types.js';
+import type { AgentRunSettings, CompactResult, ContextUsage, GoalDecision, GoalStateSnapshot, ScheduledTask, ScheduledTaskInput, SessionMetadata, TaskMessage } from '../../shared/types.js';
 export type { AgentRunSettings, ContextUsage };
 export interface AgentRunOptions {
     systemMessage?: string;
@@ -29,10 +29,6 @@ export interface AgentAdapter {
     healthCheck(): Promise<boolean>;
     getMessages(sessionId: string, taskId: string): Promise<TaskMessage[]>;
     getSessionMetadata(sessionId: string): Promise<SessionMetadata | null>;
-    judgeCompletion(taskTitle: string, taskDescription: string | null, responseText: string): Promise<{
-        done: boolean;
-        reason: string;
-    }>;
     generateTitle(description: string): Promise<{
         title: string;
     }>;
@@ -42,13 +38,21 @@ export interface AgentAdapter {
         systemMessage?: string;
         settings?: AgentRunSettings;
     }): Promise<CompactResult>;
-    listRoutines(includeDisabled?: boolean): Promise<Routine[]>;
-    getRoutine(jobId: string): Promise<Routine | null>;
-    createRoutine(input: RoutineInput): Promise<Routine>;
-    updateRoutine(jobId: string, updates: Partial<RoutineInput>): Promise<Routine | null>;
-    pauseRoutine(jobId: string, reason?: string): Promise<Routine | null>;
-    resumeRoutine(jobId: string): Promise<Routine | null>;
-    runRoutine(jobId: string): Promise<Routine | null>;
-    removeRoutine(jobId: string): Promise<boolean>;
-    tickRoutines(): Promise<number>;
+    getGoalStatus(sessionId: string): Promise<GoalStateSnapshot | null>;
+    setGoal(sessionId: string, goal: string, options?: {
+        maxTurns?: number | null;
+    }): Promise<GoalStateSnapshot>;
+    pauseGoal(sessionId: string, reason?: string): Promise<GoalStateSnapshot | null>;
+    resumeGoal(sessionId: string): Promise<GoalStateSnapshot | null>;
+    clearGoal(sessionId: string): Promise<boolean>;
+    evaluateGoal(sessionId: string, responseText: string): Promise<GoalDecision>;
+    listScheduledTasks(includeDisabled?: boolean): Promise<ScheduledTask[]>;
+    getScheduledTask(scheduledTaskId: string): Promise<ScheduledTask | null>;
+    createScheduledTask(input: ScheduledTaskInput): Promise<ScheduledTask>;
+    updateScheduledTask(scheduledTaskId: string, updates: Partial<ScheduledTaskInput>): Promise<ScheduledTask | null>;
+    pauseScheduledTask(scheduledTaskId: string, reason?: string): Promise<ScheduledTask | null>;
+    resumeScheduledTask(scheduledTaskId: string): Promise<ScheduledTask | null>;
+    runScheduledTask(scheduledTaskId: string): Promise<ScheduledTask | null>;
+    removeScheduledTask(scheduledTaskId: string): Promise<boolean>;
+    tickScheduledTasks(): Promise<number>;
 }

package/dist/server/server/adapters/worker-protocol.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import type { AgentDefaults, AgentModelsResponse, Routine, RoutineInput, SessionMetadata, TaskMessage, ContextUsage } from '../../shared/types.js';
+import type { AgentDefaults, AgentModelsResponse, GoalDecision, GoalStateSnapshot, ScheduledTask, ScheduledTaskInput, SessionMetadata, TaskMessage, ContextUsage } from '../../shared/types.js';
 import type { AgentRunSettings } from './types.js';
 export type WorkerRequest = {
     id: string;
@@ -17,39 +17,39 @@ export type WorkerRequest = {
     type: 'models.list';
 } | {
     id: string;
-    type: 'routines.jobs.list';
+    type: 'scheduledTasks.list';
     includeDisabled?: boolean;
 } | {
     id: string;
-    type: 'routines.jobs.get';
-    jobId: string;
+    type: 'scheduledTasks.get';
+    scheduledTaskId: string;
 } | {
     id: string;
-    type: 'routines.jobs.create';
-} & RoutineInput | {
+    type: 'scheduledTasks.create';
+} & ScheduledTaskInput | {
     id: string;
-    type: 'routines.jobs.update';
-    jobId: string;
-} & Partial<RoutineInput> | {
+    type: 'scheduledTasks.update';
+    scheduledTaskId: string;
+} & Partial<ScheduledTaskInput> | {
     id: string;
-    type: 'routines.jobs.pause';
-    jobId: string;
+    type: 'scheduledTasks.pause';
+    scheduledTaskId: string;
     reason?: string;
 } | {
     id: string;
-    type: 'routines.jobs.resume';
-    jobId: string;
+    type: 'scheduledTasks.resume';
+    scheduledTaskId: string;
 } | {
     id: string;
-    type: 'routines.jobs.run';
-    jobId: string;
+    type: 'scheduledTasks.run';
+    scheduledTaskId: string;
 } | {
     id: string;
-    type: 'routines.jobs.remove';
-    jobId: string;
+    type: 'scheduledTasks.remove';
+    scheduledTaskId: string;
 } | {
     id: string;
-    type: 'routines.tick';
+    type: 'scheduledTasks.tick';
 } | {
     id: string;
     type: 'session.messages.get';
@@ -59,6 +59,34 @@ export type WorkerRequest = {
     id: string;
     type: 'session.get';
     sessionId: string;
+} | {
+    id: string;
+    type: 'goal.status';
+    sessionId: string;
+} | {
+    id: string;
+    type: 'goal.set';
+    sessionId: string;
+    goal: string;
+    maxTurns?: number | null;
+} | {
+    id: string;
+    type: 'goal.pause';
+    sessionId: string;
+    reason?: string;
+} | {
+    id: string;
+    type: 'goal.resume';
+    sessionId: string;
+} | {
+    id: string;
+    type: 'goal.clear';
+    sessionId: string;
+} | {
+    id: string;
+    type: 'goal.evaluate';
+    sessionId: string;
+    responseText: string;
 } | {
     id: string;
     type: 'chat';
@@ -68,12 +96,6 @@ export type WorkerRequest = {
     settings: AgentRunSettings;
     taskId?: string;
     taskTitle?: string | null;
-} | {
-    id: string;
-    type: 'judge.completion';
-    taskTitle: string;
-    taskDescription?: string | null;
-    responseText: string;
 } | {
     id: string;
     type: 'title.generate';
@@ -97,9 +119,9 @@ export type WorkerResult = {
     agentDir?: string | null;
     python?: string | null;
 } | AgentDefaults | AgentModelsResponse | {
-    jobs: Routine[];
+    scheduledTasks: ScheduledTask[];
 } | {
-    job: Routine | null;
+    scheduledTask: ScheduledTask | null;
 } | {
     executed: number;
 } | {
@@ -107,9 +129,10 @@ export type WorkerResult = {
 } | {
     session: SessionMetadata | null;
 } | {
-    done: boolean;
-    reason: string;
+    goal: GoalStateSnapshot | null;
 } | {
+    cleared: boolean;
+} | GoalDecision | {
     title: string;
 } | {
     compressed: boolean;

package/dist/server/server/app.js CHANGED Viewed

@@ -3,7 +3,7 @@ import cors from 'cors';
 import { tasksRouter } from './routes/tasks.js';
 import { chatRouter } from './routes/chat.js';
 import { createAgentRouter, createTaskAgentSettingsRouter } from './routes/agent.js';
-import { createRoutinesRouter } from './routes/routines.js';
+import { createScheduledTasksRouter } from './routes/scheduled-tasks.js';
 import { skillsRouter } from './routes/skills.js';
 import { filesRouter } from './routes/files.js';
 import { HermesWorkerAdapter } from './adapters/hermes-worker.js';
@@ -31,7 +31,7 @@ app.use('/api/tasks', tasksRouter);
 app.use('/api/tasks', createTaskAgentSettingsRouter(adapter));
 app.use('/api/tasks', chatRouter);
 app.use('/api/agent', createAgentRouter(adapter));
-app.use('/api/routines', createRoutinesRouter(adapter));
+app.use('/api/scheduled-tasks', createScheduledTasksRouter(adapter));
 app.use('/api/skills', skillsRouter);
 app.use((error, _req, res, next) => {
     if (!res.headersSent && error && typeof error === 'object' && error.type === 'entity.too.large') {

package/dist/server/server/live-chat.d.ts CHANGED Viewed

@@ -1,16 +1,31 @@
 import type { Response } from 'express';
-import type { LiveChatRun, TaskRunState } from '../shared/types.js';
+import type { GoalStateSnapshot, LiveChatRun, LiveChatRunStatus, TaskRunState } from '../shared/types.js';
 import type { StreamEvent } from './adapters/types.js';
 export type LiveChatEvent = StreamEvent | {
     type: 'snapshot';
     run: LiveChatRun;
 };
-export declare function startRun(taskId: string, sessionId: string, userContent: string): LiveChatRun;
+export type RunStart = {
+    snapshot: LiveChatRun;
+    state: TaskRunState;
+};
+export declare function startRun(taskId: string, sessionId: string, userContent: string): RunStart;
+export declare function startGoalRun(taskId: string, sessionId: string, goal?: GoalStateSnapshot | null): RunStart;
+export declare function startCompactionRun(taskId: string, sessionId: string): RunStart;
+export declare function appendUserMessage(taskId: string, content: string): void;
+export declare function appendSystemMessage(taskId: string, content: string): void;
+export declare function startAssistantMessage(taskId: string): void;
+export declare function updateRunContext(taskId: string, context: LiveChatRun['context'], sessionId?: string): TaskRunState | undefined;
+export declare function updateRunGoal(taskId: string, goal: GoalStateSnapshot | null): TaskRunState | undefined;
 export declare function applyEvent(taskId: string, event: StreamEvent): void;
 export declare function getRun(taskId: string): LiveChatRun | undefined;
 export declare function getRunContext(taskId: string): LiveChatRun['context'] | undefined;
 export declare function getRunStatus(taskId: string): TaskRunState | undefined;
 export declare function getRunStatuses(): TaskRunState[];
+export declare function updateRunStatus(taskId: string, status: Extract<LiveChatRunStatus, 'done' | 'error'>, options?: {
+    context?: LiveChatRun['context'];
+    error?: string;
+}): TaskRunState | undefined;
 export declare function subscribe(taskId: string, res: Response): void;
 export declare function sendSnapshot(res: Response, run: LiveChatRun): void;
 export declare function broadcast(taskId: string, event: LiveChatEvent): void;

package/dist/server/server/live-chat.js CHANGED Viewed

@@ -11,6 +11,7 @@ function cloneRun(run) {
             ...message,
             tools: message.tools ? message.tools.map((tool) => ({ ...tool })) : undefined,
         })),
+        goal: run.goal ? { ...run.goal } : null,
         context: run.context ? { ...run.context } : null,
     };
 }
@@ -18,9 +19,11 @@ function runState(run) {
     return {
         taskId: run.taskId,
         runId: run.runId,
+        kind: run.kind,
         status: run.status,
         startedAt: run.startedAt,
         updatedAt: run.updatedAt,
+        goal: run.goal ? { ...run.goal } : null,
     };
 }
 function assistantMessage(run) {
@@ -87,40 +90,98 @@ function startKeepalive() {
         }
     }, KEEPALIVE_INTERVAL_MS);
 }
-export function startRun(taskId, sessionId, userContent) {
-    const expiryTimer = expiryTimers.get(taskId);
-    if (expiryTimer) {
-        clearTimeout(expiryTimer);
+function clearExpiry(taskId) {
+    const timer = expiryTimers.get(taskId);
+    if (timer) {
+        clearTimeout(timer);
         expiryTimers.delete(taskId);
     }
+}
+function storeRun(run) {
+    runs.set(run.taskId, run);
+    return { snapshot: cloneRun(run), state: runState(run) };
+}
+export function startRun(taskId, sessionId, userContent) {
+    clearExpiry(taskId);
     const now = Date.now();
-    const run = {
+    return storeRun({
         taskId,
         runId: uuid(),
+        kind: 'chat',
         sessionId,
         status: 'streaming',
         startedAt: now,
         updatedAt: now,
         messages: [
-            {
-                id: uuid(),
-                task_id: taskId,
-                role: 'user',
-                content: userContent,
-                created_at: now,
-            },
-            {
-                id: uuid(),
-                task_id: taskId,
-                role: 'assistant',
-                content: '',
-                created_at: now,
-                tools: [],
-            },
+            { id: uuid(), task_id: taskId, role: 'user', content: userContent, created_at: now },
+            { id: uuid(), task_id: taskId, role: 'assistant', content: '', created_at: now, tools: [] },
         ],
-    };
-    runs.set(taskId, run);
-    return cloneRun(run);
+    });
+}
+export function startGoalRun(taskId, sessionId, goal) {
+    clearExpiry(taskId);
+    const now = Date.now();
+    return storeRun({
+        taskId,
+        runId: uuid(),
+        kind: 'goal',
+        sessionId,
+        status: 'streaming',
+        startedAt: now,
+        updatedAt: now,
+        messages: [],
+        goal: goal ? { ...goal } : null,
+    });
+}
+export function startCompactionRun(taskId, sessionId) {
+    clearExpiry(taskId);
+    const now = Date.now();
+    return storeRun({
+        taskId,
+        runId: uuid(),
+        kind: 'compact',
+        sessionId,
+        status: 'compacting',
+        startedAt: now,
+        updatedAt: now,
+        messages: [],
+    });
+}
+function appendMessage(taskId, role, content, extra) {
+    const run = runs.get(taskId);
+    if (!run)
+        return;
+    const now = Date.now();
+    run.messages.push({ id: uuid(), task_id: taskId, role, content, created_at: now, ...extra });
+    run.updatedAt = now;
+}
+export function appendUserMessage(taskId, content) {
+    appendMessage(taskId, 'user', content);
+}
+export function appendSystemMessage(taskId, content) {
+    appendMessage(taskId, 'system', content);
+}
+export function startAssistantMessage(taskId) {
+    appendMessage(taskId, 'assistant', '', { tools: [] });
+}
+export function updateRunContext(taskId, context, sessionId) {
+    const run = runs.get(taskId);
+    if (!run)
+        return undefined;
+    if (sessionId)
+        run.sessionId = sessionId;
+    if (context !== undefined)
+        run.context = context;
+    run.updatedAt = Date.now();
+    return runState(run);
+}
+export function updateRunGoal(taskId, goal) {
+    const run = runs.get(taskId);
+    if (!run)
+        return undefined;
+    run.goal = goal ? { ...goal } : null;
+    run.updatedAt = Date.now();
+    return runState(run);
 }
 export function applyEvent(taskId, event) {
     const run = runs.get(taskId);
@@ -173,6 +234,18 @@ export function getRunStatus(taskId) {
 export function getRunStatuses() {
     return Array.from(runs.values()).map(runState);
 }
+export function updateRunStatus(taskId, status, options) {
+    const run = runs.get(taskId);
+    if (!run)
+        return undefined;
+    run.status = status;
+    run.updatedAt = Date.now();
+    if (options?.context !== undefined)
+        run.context = options.context;
+    if (options?.error)
+        run.error = options.error;
+    return runState(run);
+}
 export function subscribe(taskId, res) {
     let taskSubscribers = subscribers.get(taskId);
     if (!taskSubscribers) {
@@ -204,9 +277,7 @@ export function broadcast(taskId, event) {
 export function finishRun(taskId, ttlMs, runId) {
     if (!runs.has(taskId))
         return;
-    const expiryTimer = expiryTimers.get(taskId);
-    if (expiryTimer)
-        clearTimeout(expiryTimer);
+    clearExpiry(taskId);
     const timer = setTimeout(() => {
         if (runs.get(taskId)?.runId === runId)
             runs.delete(taskId);

package/dist/server/server/prompts/task-agent.d.ts CHANGED Viewed

	@@ -1 +1 @@
1	- export declare const TASK_AGENT_SYSTEM_PROMPT = "<task_agent>\n <role>\n You are an autonomous task agent. A user has given you a task to accomplish.\n </role>\n\n <responsibilities>\n <responsibility name=\"understand\">\n Read the task carefully. Identify anything unclear, ambiguous, or underspecified.\n </responsibility>\n <responsibility name=\"clarify\">\n Before doing work, make sure you fully understand what the user wants. Ask focused clarifying questions about scope, constraints, expected outcomes, edge cases, or anything else you are uncertain about. Do not assume when the uncertainty matters. The user is available to answer. Keep asking until you are confident you understand the task correctly.\n </responsibility>\n <responsibility name=\"execute\">\n Once you and the user are aligned, choose the best execution strategy. Do the work yourself in this session if it is straightforward. Create a child session if you need a dedicated sub-agent for complex sub-work. Set up a cron job when the work is recurring, periodic, ~~routine~~, or better handled as durable batches over time. You have full autonomy to use the tools and approach that best accomplish the task.\n </responsibility>\n </responsibilities>\n\n <guidelines>\n <guideline>Understand first, act second. Do not start executing until you are confident you know what the user wants.</guideline>\n <guideline>When clarifying, ask focused questions rather than a long wall of questions. A natural back-and-forth conversation is ideal.</guideline>\n <guideline>When the user asks for a cron job, schedule, ~~routine~~, recurring task, monitor, daily/weekly task, or similar repeated work, default to a Hermes cron job using the available cronjob tooling. Do not use Linux cron, systemd timers, or host OS schedulers unless the user explicitly asks for them.</guideline>\n <guideline>For lead generation, prospecting, and large list processing, prefer a small sample or validation run first. If the user wants more than a small one-off result, prefer a cron job with a self-contained prompt, sensible batch size, output/checkpoint location, and schedule.</guideline>\n <guideline>Keep the user informed of meaningful progress in your responses.</guideline>\n <guideline>You have project-specific skills under the \"minions\" category in your skills index. Before executing a task, check if any minions skill is relevant and load it \u2014 these encode proven workflows tailored to this system.</guideline>\n </guidelines>\n</task_agent>";
1	+ export declare const TASK_AGENT_SYSTEM_PROMPT = "<task_agent>\n <role>\n You are an autonomous task agent. A user has given you a task to accomplish.\n </role>\n\n <responsibilities>\n <responsibility name=\"understand\">\n Read the task carefully. Identify anything unclear, ambiguous, or underspecified.\n </responsibility>\n <responsibility name=\"clarify\">\n Before doing work, make sure you fully understand what the user wants. Ask focused clarifying questions about scope, constraints, expected outcomes, edge cases, or anything else you are uncertain about. Do not assume when the uncertainty matters. The user is available to answer. Keep asking until you are confident you understand the task correctly.\n </responsibility>\n <responsibility name=\"execute\">\n Once you and the user are aligned, choose the best execution strategy. Do the work yourself in this session if it is straightforward. Create a child session if you need a dedicated sub-agent for complex sub-work. Set up a cron job when the work is recurring, periodic, scheduled, or better handled as durable batches over time. You have full autonomy to use the tools and approach that best accomplish the task.\n </responsibility>\n </responsibilities>\n\n <guidelines>\n <guideline>Understand first, act second. Do not start executing until you are confident you know what the user wants.</guideline>\n <guideline>When clarifying, ask focused questions rather than a long wall of questions. A natural back-and-forth conversation is ideal.</guideline>\n <guideline>When the user asks for a cron job, schedule, scheduled task, recurring task, monitor, daily/weekly task, or similar repeated work, default to a Hermes cron job using the available cronjob tooling. Do not use Linux cron, systemd timers, or host OS schedulers unless the user explicitly asks for them.</guideline>\n <guideline>For lead generation, prospecting, and large list processing, prefer a small sample or validation run first. If the user wants more than a small one-off result, prefer a cron job with a self-contained prompt, sensible batch size, output/checkpoint location, and schedule.</guideline>\n <guideline>Keep the user informed of meaningful progress in your responses.</guideline>\n <guideline>You have project-specific skills under the \"minions\" category in your skills index. Before executing a task, check if any minions skill is relevant and load it \u2014 these encode proven workflows tailored to this system.</guideline>\n </guidelines>\n</task_agent>";

package/dist/server/server/prompts/task-agent.js CHANGED Viewed

@@ -11,14 +11,14 @@ export const TASK_AGENT_SYSTEM_PROMPT = `<task_agent>
       Before doing work, make sure you fully understand what the user wants. Ask focused clarifying questions about scope, constraints, expected outcomes, edge cases, or anything else you are uncertain about. Do not assume when the uncertainty matters. The user is available to answer. Keep asking until you are confident you understand the task correctly.
     </responsibility>
     <responsibility name="execute">
-      Once you and the user are aligned, choose the best execution strategy. Do the work yourself in this session if it is straightforward. Create a child session if you need a dedicated sub-agent for complex sub-work. Set up a cron job when the work is recurring, periodic, routine, or better handled as durable batches over time. You have full autonomy to use the tools and approach that best accomplish the task.
+      Once you and the user are aligned, choose the best execution strategy. Do the work yourself in this session if it is straightforward. Create a child session if you need a dedicated sub-agent for complex sub-work. Set up a cron job when the work is recurring, periodic, scheduled, or better handled as durable batches over time. You have full autonomy to use the tools and approach that best accomplish the task.
     </responsibility>
   </responsibilities>
   <guidelines>
     <guideline>Understand first, act second. Do not start executing until you are confident you know what the user wants.</guideline>
     <guideline>When clarifying, ask focused questions rather than a long wall of questions. A natural back-and-forth conversation is ideal.</guideline>
-    <guideline>When the user asks for a cron job, schedule, routine, recurring task, monitor, daily/weekly task, or similar repeated work, default to a Hermes cron job using the available cronjob tooling. Do not use Linux cron, systemd timers, or host OS schedulers unless the user explicitly asks for them.</guideline>
+    <guideline>When the user asks for a cron job, schedule, scheduled task, recurring task, monitor, daily/weekly task, or similar repeated work, default to a Hermes cron job using the available cronjob tooling. Do not use Linux cron, systemd timers, or host OS schedulers unless the user explicitly asks for them.</guideline>
     <guideline>For lead generation, prospecting, and large list processing, prefer a small sample or validation run first. If the user wants more than a small one-off result, prefer a cron job with a self-contained prompt, sensible batch size, output/checkpoint location, and schedule.</guideline>
     <guideline>Keep the user informed of meaningful progress in your responses.</guideline>
     <guideline>You have project-specific skills under the "minions" category in your skills index. Before executing a task, check if any minions skill is relevant and load it — these encode proven workflows tailored to this system.</guideline>