minionsai 0.1.11 → 0.1.13

package/dist/server/server/workers/{hermes_routines.py → hermes_scheduled_tasks.py}

@@ -1,4 +1,4 @@
-"""Routine operations for the Hermes worker.
+"""Scheduled task operations for the Hermes worker.
 
 Wraps Hermes's `cron.jobs` / `cron.scheduler` modules with input validation,
 shape normalization, and a background ticker thread.
@@ -18,8 +18,8 @@ from hermes_worker_utils import (
 )
 
 
-_ROUTINES_TICKER_STARTED = False
-_ROUTINES_TICKER_LOCK = threading.Lock()
+_SCHEDULED_TASKS_TICKER_STARTED = False
+_SCHEDULED_TASKS_TICKER_LOCK = threading.Lock()
 
 
 def _ensure_imports() -> None:
@@ -31,7 +31,7 @@ def _ensure_imports() -> None:
     hermes_worker._ensure_imports()
 
 
-def _normalize_routine(job: dict[str, Any] | None) -> dict[str, Any] | None:
+def _normalize_scheduled_task(job: dict[str, Any] | None) -> dict[str, Any] | None:
     if not isinstance(job, dict):
         return None
 
@@ -136,27 +136,27 @@ def _build_update_dict(request: dict[str, Any]) -> dict[str, Any]:
         updates["context_from"] = request.get("contextFrom") or None
 
     if not updates:
-        raise WorkerError("No routine updates were provided.", code="bad_request")
+        raise WorkerError("No scheduled task updates were provided.", code="bad_request")
     return updates
 
 
-def list_routines(include_disabled: bool = False) -> dict[str, Any]:
+def list_scheduled_tasks(include_disabled: bool = False) -> dict[str, Any]:
     _ensure_imports()
     from cron.jobs import list_jobs
 
-    jobs = [_normalize_routine(job) for job in list_jobs(include_disabled=include_disabled)]
-    return {"jobs": [job for job in jobs if job is not None]}
+    jobs = [_normalize_scheduled_task(job) for job in list_jobs(include_disabled=include_disabled)]
+    return {"scheduledTasks": [job for job in jobs if job is not None]}
 
 
-def get_routine(job_id: Any) -> dict[str, Any]:
+def get_scheduled_task(job_id: Any) -> dict[str, Any]:
     _ensure_imports()
     from cron.jobs import get_job
 
-    job = _normalize_routine(get_job(_validate_path_segment(job_id, "Routine ID")))
-    return {"job": job}
+    job = _normalize_scheduled_task(get_job(_validate_path_segment(job_id, "Scheduled task ID")))
+    return {"scheduledTask": job}
 
 
-def create_routine(request: dict[str, Any]) -> dict[str, Any]:
+def create_scheduled_task(request: dict[str, Any]) -> dict[str, Any]:
     _ensure_imports()
     from cron.jobs import create_job
 
@@ -176,45 +176,45 @@ def create_routine(request: dict[str, Any]) -> dict[str, Any]:
         )
     except ValueError as exc:
         raise WorkerError(str(exc), code="bad_request") from exc
-    return {"job": _normalize_routine(job)}
+    return {"scheduledTask": _normalize_scheduled_task(job)}
 
 
-def update_routine(request: dict[str, Any]) -> dict[str, Any]:
+def update_scheduled_task(request: dict[str, Any]) -> dict[str, Any]:
     _ensure_imports()
     from cron.jobs import update_job
 
-    job_id = _validate_path_segment(request.get("jobId"), "Routine ID")
+    job_id = _validate_path_segment(request.get("scheduledTaskId"), "Scheduled task ID")
     try:
-        job = _normalize_routine(update_job(job_id, _build_update_dict(request)))
+        job = _normalize_scheduled_task(update_job(job_id, _build_update_dict(request)))
     except ValueError as exc:
         raise WorkerError(str(exc), code="bad_request") from exc
-    return {"job": job}
+    return {"scheduledTask": job}
 
 
-def pause_routine(job_id: Any, reason: Any = None) -> dict[str, Any]:
+def pause_scheduled_task(job_id: Any, reason: Any = None) -> dict[str, Any]:
     _ensure_imports()
     from cron.jobs import pause_job
 
-    routine_id = _validate_path_segment(job_id, "Routine ID")
-    return {"job": _normalize_routine(pause_job(routine_id, reason=string_or_none(reason)))}
+    scheduled_task_id = _validate_path_segment(job_id, "Scheduled task ID")
+    return {"scheduledTask": _normalize_scheduled_task(pause_job(scheduled_task_id, reason=string_or_none(reason)))}
 
 
-def resume_routine(job_id: Any) -> dict[str, Any]:
+def resume_scheduled_task(job_id: Any) -> dict[str, Any]:
     _ensure_imports()
     from cron.jobs import resume_job
 
-    return {"job": _normalize_routine(resume_job(_validate_path_segment(job_id, "Routine ID")))}
+    return {"scheduledTask": _normalize_scheduled_task(resume_job(_validate_path_segment(job_id, "Scheduled task ID")))}
 
 
-def trigger_routine(job_id: Any) -> dict[str, Any]:
+def trigger_scheduled_task(job_id: Any) -> dict[str, Any]:
     _ensure_imports()
     from cron.jobs import trigger_job
 
-    routine_id = _validate_path_segment(job_id, "Routine ID")
-    job = _normalize_routine(trigger_job(routine_id))
+    scheduled_task_id = _validate_path_segment(job_id, "Scheduled task ID")
+    job = _normalize_scheduled_task(trigger_job(scheduled_task_id))
     if job is not None:
         _kick_immediate_tick()
-    return {"job": job}
+    return {"scheduledTask": job}
 
 
 def _kick_immediate_tick() -> None:
@@ -227,43 +227,43 @@ def _kick_immediate_tick() -> None:
     """
     def _run() -> None:
         try:
-            tick_routines()
+            tick_scheduled_tasks()
         except Exception as exc:  # noqa: BLE001 — log and swallow, this is best-effort
-            print(f"[hermes-worker] immediate routine tick failed: {exc}", file=sys.stderr, flush=True)
+            print(f"[hermes-worker] immediate scheduled task tick failed: {exc}", file=sys.stderr, flush=True)
 
-    threading.Thread(target=_run, name="hermes-routines-trigger", daemon=True).start()
+    threading.Thread(target=_run, name="hermes-scheduled-tasks-trigger", daemon=True).start()
 
 
-def remove_routine(job_id: Any) -> dict[str, Any]:
+def remove_scheduled_task(job_id: Any) -> dict[str, Any]:
     _ensure_imports()
     from cron.jobs import remove_job
 
-    return {"ok": bool(remove_job(_validate_path_segment(job_id, "Routine ID")))}
+    return {"ok": bool(remove_job(_validate_path_segment(job_id, "Scheduled task ID")))}
 
 
-def tick_routines() -> int:
+def tick_scheduled_tasks() -> int:
     _ensure_imports()
     from cron.scheduler import tick
 
     return int(tick(verbose=False) or 0)
 
 
-def _routines_ticker_loop() -> None:
+def _scheduled_tasks_ticker_loop() -> None:
     while True:
         try:
-            executed = tick_routines()
+            executed = tick_scheduled_tasks()
             if executed:
-                print(f"[hermes-worker] routine tick executed {executed} job(s)", file=sys.stderr, flush=True)
+                print(f"[hermes-worker] scheduled task tick executed {executed} job(s)", file=sys.stderr, flush=True)
         except Exception as exc:
-            print(f"[hermes-worker] routine tick failed: {exc}", file=sys.stderr, flush=True)
+            print(f"[hermes-worker] scheduled task tick failed: {exc}", file=sys.stderr, flush=True)
         time.sleep(60)
 
 
-def start_routine_ticker() -> None:
-    global _ROUTINES_TICKER_STARTED
-    with _ROUTINES_TICKER_LOCK:
-        if _ROUTINES_TICKER_STARTED:
+def start_scheduled_task_ticker() -> None:
+    global _SCHEDULED_TASKS_TICKER_STARTED
+    with _SCHEDULED_TASKS_TICKER_LOCK:
+        if _SCHEDULED_TASKS_TICKER_STARTED:
             return
-        thread = threading.Thread(target=_routines_ticker_loop, name="hermes-routines-ticker", daemon=True)
+        thread = threading.Thread(target=_scheduled_tasks_ticker_loop, name="hermes-scheduled-tasks-ticker", daemon=True)
         thread.start()
-        _ROUTINES_TICKER_STARTED = True
+        _SCHEDULED_TASKS_TICKER_STARTED = True

package/dist/server/server/workers/hermes_worker.py

@@ -8,7 +8,6 @@ import dataclasses
 import inspect
 import json
 import os
-import re
 import sys
 import threading
 import time
@@ -32,23 +31,25 @@ from hermes_sessions import (
     project_session_messages,
     project_session_metadata,
 )
-from hermes_routines import (
-    create_routine,
-    get_routine,
-    list_routines,
-    pause_routine,
-    remove_routine,
-    resume_routine,
-    start_routine_ticker,
-    tick_routines,
-    trigger_routine,
-    update_routine,
+from hermes_scheduled_tasks import (
+    create_scheduled_task,
+    get_scheduled_task,
+    list_scheduled_tasks,
+    pause_scheduled_task,
+    remove_scheduled_task,
+    resume_scheduled_task,
+    start_scheduled_task_ticker,
+    tick_scheduled_tasks,
+    trigger_scheduled_task,
+    update_scheduled_task,
 )
 
 PROTOCOL_OUT = sys.stdout
 PROTOCOL_LOCK = threading.Lock()
+# Keep in sync with MINIONS_GOAL_MAX_TURNS in shared/types.ts.
+MINIONS_GOAL_MAX_TURNS = 20
 
-# Cap on concurrent AIAgent.run_conversation calls (chat + judge).
+# Cap on concurrent AIAgent.run_conversation calls.
 AGENT_RUN_LIMIT = int(os.environ.get("HERMES_AGENT_RUN_LIMIT", "10"))
 AGENT_SEMAPHORE = threading.BoundedSemaphore(AGENT_RUN_LIMIT)
 ACTIVE_TASKS: dict[str, str] = {}
@@ -1022,6 +1023,94 @@ def _warm_agent() -> None:
     _load_config()
 
 
+def _goal_manager(session_id: str) -> Any:
+    _ensure_imports()
+    if not session_id:
+        raise WorkerError("Session ID is required.", code="bad_request")
+    from hermes_cli.goals import GoalManager
+
+    return GoalManager(session_id=session_id, default_max_turns=MINIONS_GOAL_MAX_TURNS)
+
+
+def _project_goal_state(state: Any) -> dict[str, Any] | None:
+    if not state:
+        return None
+    return {
+        "goal": str(getattr(state, "goal", "") or ""),
+        "status": str(getattr(state, "status", "") or "active"),
+        "turnsUsed": int(getattr(state, "turns_used", 0) or 0),
+        "maxTurns": int(getattr(state, "max_turns", 0) or 0),
+        "lastReason": string_or_none(getattr(state, "last_reason", None)),
+        "pausedReason": string_or_none(getattr(state, "paused_reason", None)),
+    }
+
+
+def _project_goal_decision(decision: dict[str, Any], state: Any) -> dict[str, Any]:
+    return {
+        "status": string_or_none(decision.get("status")),
+        "shouldContinue": bool(decision.get("should_continue")),
+        "continuationPrompt": string_or_none(decision.get("continuation_prompt")),
+        "verdict": string_or_none(decision.get("verdict")) or "inactive",
+        "reason": string_or_none(decision.get("reason")) or "",
+        "message": string_or_none(decision.get("message")) or "",
+        "state": _project_goal_state(state),
+    }
+
+
+def _goal_mgr_from_request(request: dict[str, Any]) -> Any:
+    return _goal_manager(string_or_none(request.get("sessionId")) or "")
+
+
+def _goal_status(request: dict[str, Any]) -> dict[str, Any]:
+    mgr = _goal_mgr_from_request(request)
+    return {"goal": _project_goal_state(mgr.state)}
+
+
+def _goal_set(request: dict[str, Any]) -> dict[str, Any]:
+    goal = string_or_none(request.get("goal")) or ""
+    if not goal.strip():
+        raise WorkerError("Goal text is required.", code="bad_request")
+
+    mgr = _goal_mgr_from_request(request)
+    raw_max_turns = request.get("maxTurns")
+    if raw_max_turns is None:
+        state = mgr.set(goal)
+    else:
+        try:
+            max_turns = int(raw_max_turns)
+        except (TypeError, ValueError) as exc:
+            raise WorkerError("maxTurns must be a positive integer.", code="bad_request") from exc
+        if max_turns <= 0:
+            raise WorkerError("maxTurns must be a positive integer.", code="bad_request")
+        state = mgr.set(goal, max_turns=max_turns)
+    return {"goal": _project_goal_state(state)}
+
+
+def _goal_pause(request: dict[str, Any]) -> dict[str, Any]:
+    reason = string_or_none(request.get("reason")) or "user-paused"
+    mgr = _goal_mgr_from_request(request)
+    return {"goal": _project_goal_state(mgr.pause(reason))}
+
+
+def _goal_resume(request: dict[str, Any]) -> dict[str, Any]:
+    mgr = _goal_mgr_from_request(request)
+    return {"goal": _project_goal_state(mgr.resume())}
+
+
+def _goal_clear(request: dict[str, Any]) -> dict[str, Any]:
+    mgr = _goal_mgr_from_request(request)
+    had_goal = bool(mgr.has_goal())
+    mgr.clear()
+    return {"cleared": had_goal}
+
+
+def _goal_evaluate(request: dict[str, Any]) -> dict[str, Any]:
+    response_text = string_or_none(request.get("responseText")) or ""
+    mgr = _goal_mgr_from_request(request)
+    decision = mgr.evaluate_after_turn(response_text)
+    return _project_goal_decision(decision, mgr.state)
+
+
 def _run_chat(request_id: str, request: dict[str, Any]) -> None:
     settings = request.get("settings") if isinstance(request.get("settings"), dict) else {}
     requested_model = string_or_none(settings.get("model"))
@@ -1205,7 +1294,18 @@ def _submit_background_agent_request(
     *,
     name_prefix: str,
     handler: Callable[[dict[str, Any]], dict[str, Any]],
+    task_key: str | None = None,
 ) -> None:
+    if task_key and not _try_mark_task_active(task_key, request_id):
+        _send_error(
+            request_id,
+            WorkerError(
+                "This task is already running. Wait for the current operation to finish, then retry.",
+                code="task_busy",
+            ),
+        )
+        return
+
     def runner() -> None:
         acquired = False
         try:
@@ -1217,6 +1317,8 @@ def _submit_background_agent_request(
         finally:
             if acquired:
                 AGENT_SEMAPHORE.release()
+            if task_key:
+                _clear_task_active(task_key, request_id)
 
     threading.Thread(
         target=runner,
@@ -1291,50 +1393,6 @@ def _run_compress(request: dict[str, Any]) -> dict[str, Any]:
     }
 
 
-def _judge_completion(request: dict[str, Any]) -> dict[str, Any]:
-    """Evaluate whether the agent's response indicates task completion."""
-    task_title = string_or_none(request.get("taskTitle")) or ""
-    task_description = string_or_none(request.get("taskDescription")) or ""
-    response_text = string_or_none(request.get("responseText")) or ""
-
-    if not response_text:
-        return {"done": False, "reason": "empty response"}
-
-    response_text = truncate_with_ellipsis(response_text, 4000)
-
-    task_context = task_title
-    if task_description:
-        task_context += f"\n{task_description}"
-
-    judge_system = (
-        "You are a task completion judge. "
-        "Respond ONLY with a JSON object, nothing else. "
-        "Do not use any tools."
-    )
-
-    judge_prompt = (
-        f"Task:\n{task_context}\n\n"
-        f"Agent's most recent response:\n{response_text}\n\n"
-        'Has the agent completed the task? Respond with: {"done": true/false, "reason": "one sentence"}\n'
-        "- done=true ONLY when the response clearly delivers the final result or confirms completion\n"
-        "- done=false for: questions, partial progress, clarification requests, errors, or ongoing work"
-    )
-
-    text = _run_one_shot_agent("judge", judge_system, judge_prompt)
-    json_match = re.search(r"\{[^{}]*\}", text)
-    if json_match:
-        try:
-            parsed = json.loads(json_match.group())
-            return {
-                "done": bool(parsed.get("done", False)),
-                "reason": str(parsed.get("reason", "")),
-            }
-        except (json.JSONDecodeError, ValueError):
-            pass
-
-    return {"done": False, "reason": "unparseable response"}
-
-
 def _clean_generated_title(raw: str) -> str:
     """Sanitize the LLM's title output: strip quotes, trailing punctuation, cap length."""
     stripped = raw.strip()
@@ -1417,34 +1475,50 @@ def _handle_request(request: dict[str, Any]) -> None:
             _result(request_id, _set_defaults(request))
         elif request_type == "models.list":
             _result(request_id, _list_models())
-        elif request_type == "routines.jobs.list":
-            _result(request_id, list_routines(bool(request.get("includeDisabled"))))
-        elif request_type == "routines.jobs.get":
-            _result(request_id, get_routine(request.get("jobId")))
-        elif request_type == "routines.jobs.create":
-            _result(request_id, create_routine(request))
-        elif request_type == "routines.jobs.update":
-            _result(request_id, update_routine(request))
-        elif request_type == "routines.jobs.pause":
-            _result(request_id, pause_routine(request.get("jobId"), request.get("reason")))
-        elif request_type == "routines.jobs.resume":
-            _result(request_id, resume_routine(request.get("jobId")))
-        elif request_type == "routines.jobs.run":
-            _result(request_id, trigger_routine(request.get("jobId")))
-        elif request_type == "routines.jobs.remove":
-            _result(request_id, remove_routine(request.get("jobId")))
-        elif request_type == "routines.tick":
-            _result(request_id, {"executed": tick_routines()})
+        elif request_type == "scheduledTasks.list":
+            _result(request_id, list_scheduled_tasks(bool(request.get("includeDisabled"))))
+        elif request_type == "scheduledTasks.get":
+            _result(request_id, get_scheduled_task(request.get("scheduledTaskId")))
+        elif request_type == "scheduledTasks.create":
+            _result(request_id, create_scheduled_task(request))
+        elif request_type == "scheduledTasks.update":
+            _result(request_id, update_scheduled_task(request))
+        elif request_type == "scheduledTasks.pause":
+            _result(request_id, pause_scheduled_task(request.get("scheduledTaskId"), request.get("reason")))
+        elif request_type == "scheduledTasks.resume":
+            _result(request_id, resume_scheduled_task(request.get("scheduledTaskId")))
+        elif request_type == "scheduledTasks.run":
+            _result(request_id, trigger_scheduled_task(request.get("scheduledTaskId")))
+        elif request_type == "scheduledTasks.remove":
+            _result(request_id, remove_scheduled_task(request.get("scheduledTaskId")))
+        elif request_type == "scheduledTasks.tick":
+            _result(request_id, {"executed": tick_scheduled_tasks()})
         elif request_type == "session.messages.get":
             _result(request_id, project_session_messages(request.get("sessionId"), request.get("taskId")))
         elif request_type == "session.get":
             _result(request_id, project_session_metadata(request.get("sessionId")))
+        elif request_type == "goal.status":
+            _result(request_id, _goal_status(request))
+        elif request_type == "goal.set":
+            _result(request_id, _goal_set(request))
+        elif request_type == "goal.pause":
+            _result(request_id, _goal_pause(request))
+        elif request_type == "goal.resume":
+            _result(request_id, _goal_resume(request))
+        elif request_type == "goal.clear":
+            _result(request_id, _goal_clear(request))
+        elif request_type == "goal.evaluate":
+            _submit_background_agent_request(request_id, request, name_prefix="goal", handler=_goal_evaluate)
         elif request_type == "chat":
             _submit_chat_request(request_id, request)
         elif request_type == "session.compress":
-            _submit_background_agent_request(request_id, request, name_prefix="compress", handler=_run_compress)
-        elif request_type == "judge.completion":
-            _submit_background_agent_request(request_id, request, name_prefix="judge", handler=_judge_completion)
+            _submit_background_agent_request(
+                request_id,
+                request,
+                name_prefix="compress",
+                handler=_run_compress,
+                task_key=_task_key_for(request),
+            )
         elif request_type == "title.generate":
             _submit_background_agent_request(request_id, request, name_prefix="title", handler=_generate_title)
         else:
@@ -1503,7 +1577,7 @@ def main() -> int:
         return _self_test()
 
     sys.stdout = sys.stderr
-    start_routine_ticker()
+    start_scheduled_task_ticker()
     try:
         _run_loop()
     except KeyboardInterrupt:

package/dist/server/server/workers/hermes_worker_utils.py

@@ -1,7 +1,7 @@
 """Shared utilities for the Hermes worker and its submodules.
 
 Kept intentionally small: just the error type and pure helpers that are used
-across `hermes_worker.py`, `hermes_sessions.py`, and `hermes_routines.py`.
+across `hermes_worker.py`, `hermes_sessions.py`, and `hermes_scheduled_tasks.py`.
 """
 
 from __future__ import annotations

package/dist/server/shared/types.d.ts

@@ -6,9 +6,13 @@ export interface AppVersion {
     name: string;
     version: string;
 }
+export declare const CHAT_RUN_MODES: readonly ["task", "goal"];
+export type ChatRunMode = (typeof CHAT_RUN_MODES)[number];
+export declare const MINIONS_GOAL_MAX_TURNS = 20;
 export interface AgentRunSettings {
     model?: string | null;
     reasoningEffort?: ReasoningEffort | null;
+    mode?: ChatRunMode;
 }
 export interface Task {
     id: string;
@@ -38,13 +42,16 @@ export interface ToolProgressEvent {
     duration?: number;
     label?: string;
 }
-export type LiveChatRunStatus = 'streaming' | 'done' | 'error';
+export type TaskRunKind = 'chat' | 'goal' | 'compact';
+export type LiveChatRunStatus = 'streaming' | 'compacting' | 'done' | 'error';
 export interface TaskRunState {
     taskId: string;
     runId: string;
+    kind: TaskRunKind;
     status: LiveChatRunStatus;
     startedAt: number;
     updatedAt: number;
+    goal?: GoalStateSnapshot | null;
 }
 export type BoardEvent = {
     type: 'task_created';
@@ -68,11 +75,13 @@ export type LiveChatMessage = TaskMessage & {
 export interface LiveChatRun {
     taskId: string;
     runId: string;
+    kind: TaskRunKind;
     sessionId: string;
     status: LiveChatRunStatus;
     startedAt: number;
     updatedAt: number;
     messages: LiveChatMessage[];
+    goal?: GoalStateSnapshot | null;
     context?: ContextUsage | null;
     error?: string;
 }
@@ -87,6 +96,23 @@ export interface CompactResult {
     compressedMessageCount: number;
     context?: ContextUsage | null;
 }
+export interface GoalStateSnapshot {
+    goal: string;
+    status: 'active' | 'paused' | 'done' | 'cleared';
+    turnsUsed: number;
+    maxTurns: number;
+    lastReason?: string | null;
+    pausedReason?: string | null;
+}
+export interface GoalDecision {
+    status: GoalStateSnapshot['status'] | null;
+    shouldContinue: boolean;
+    continuationPrompt?: string | null;
+    verdict: 'done' | 'continue' | 'skipped' | 'inactive';
+    reason: string;
+    message: string;
+    state?: GoalStateSnapshot | null;
+}
 export interface SessionMetadata {
     id: string;
     input_tokens: number;
@@ -134,14 +160,14 @@ export interface TaskAgentSettings {
         reasoningEffort: ReasoningEffort | null;
     };
 }
-export interface RoutineOrigin {
+export interface ScheduledTaskOrigin {
     platform?: string | null;
     chat_id?: string | null;
     chat_name?: string | null;
     thread_id?: string | null;
     [key: string]: unknown;
 }
-export interface Routine {
+export interface ScheduledTask {
     id: string;
     name: string;
     prompt: string | null;
@@ -151,38 +177,38 @@ export interface Routine {
     state: string | null;
     nextRunAt: string | null;
     lastRunAt: string | null;
-    lastStatus: RoutineStatus | null;
+    lastStatus: ScheduledTaskStatus | null;
     lastError: string | null;
     lastDeliveryError: string | null;
     model: string | null;
     provider: string | null;
     baseUrl: string | null;
     deliver: string | null;
-    origin: RoutineOrigin | null;
-    repeat: RoutineRepeat | null;
+    origin: ScheduledTaskOrigin | null;
+    repeat: ScheduledTaskRepeat | null;
     contextFrom: string[];
     skills: string[];
     workdir: string | null;
     createdAt: string | null;
 }
-export type RoutineStatus = 'ok' | 'error' | 'unknown';
-export interface RoutineRepeat {
+export type ScheduledTaskStatus = 'ok' | 'error' | 'unknown';
+export interface ScheduledTaskRepeat {
     times: number | null;
     completed: number;
 }
-export interface RoutineRun {
+export interface ScheduledTaskRun {
     id: string;
-    jobId: string;
+    scheduledTaskId: string;
     ranAt: string | null;
     path: string;
-    status: RoutineStatus;
+    status: ScheduledTaskStatus;
     preview: string;
 }
-export interface RoutineRunContent {
+export interface ScheduledTaskRunContent {
     body: string;
-    status: RoutineStatus;
+    status: ScheduledTaskStatus;
 }
-export interface RoutineInput {
+export interface ScheduledTaskInput {
     name?: string;
     prompt: string;
     schedule: string;

package/dist/server/shared/types.js

@@ -1,2 +1,4 @@
 export const TASK_STATUSES = ['in_progress', 'in_review', 'done'];
 export const REASONING_EFFORTS = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh'];
+export const CHAT_RUN_MODES = ['task', 'goal'];
+export const MINIONS_GOAL_MAX_TURNS = 20;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minionsai",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Mission Control for Hermes Agent — a Kanban board for autonomous agent tasks",
   "license": "MIT",
   "type": "module",
@@ -50,6 +50,7 @@
     "react-dom": "^19.0.0",
     "react-router": "^7.14.2",
     "react-router-dom": "^7.14.2",
+    "sonner": "^2.0.7",
     "streamdown": "^2.4.0",
     "uuid": "^11.0.5",
     "zustand": "^5.0.12"