minionsai 0.1.11 → 0.1.13

package/dist/server/server/routes/chat.js

@@ -2,16 +2,28 @@ import { Router } from 'express';
 import { contextFromTask, getTask, updateTask, touchTask, recordAgentResponse } from '../db/queries.js';
 import { adapter } from '../app.js';
 import { broadcast, initSSE } from '../events.js';
-import { applyEvent, broadcast as broadcastLive, finishRun, getRun, getRunContext, getRunStatus, sendSnapshot, startRun, subscribe, } from '../live-chat.js';
+import { appendSystemMessage, appendUserMessage, applyEvent, broadcast as broadcastLive, finishRun, getRun, getRunContext, getRunStatus, sendSnapshot, startAssistantMessage, startCompactionRun, startGoalRun, startRun, subscribe, updateRunGoal, updateRunContext, updateRunStatus, } from '../live-chat.js';
 import { taskRunSettings, parseRunSettingsBody } from '../agent-settings.js';
 import { TASK_AGENT_SYSTEM_PROMPT } from '../prompts/task-agent.js';
-import { toErrorMessage } from '../errors.js';
+import { isRecord, toErrorMessage } from '../errors.js';
+import { CHAT_RUN_MODES, MINIONS_GOAL_MAX_TURNS } from '../../shared/types.js';
 export const chatRouter = Router();
 function hasNoSession(task) {
     if (task.last_agent_response_at !== null)
         return false;
     return getRunStatus(task.id)?.status !== 'streaming';
 }
+function isTaskRunActive(status) {
+    return status?.status === 'streaming' || status?.status === 'compacting';
+}
+function completeTaskRun(taskId, runId, status, ttlMs, options) {
+    const updated = updateRunStatus(taskId, status, options);
+    if (updated) {
+        broadcast({ type: 'task_run_updated', run: updated });
+        broadcastRunSnapshot(taskId);
+    }
+    finishRun(taskId, ttlMs, runId);
+}
 chatRouter.get('/:id/messages', async (req, res) => {
     const task = getTask(req.params.id);
     if (!task)
@@ -44,31 +56,46 @@ chatRouter.get('/:id/session', async (req, res) => {
 });
 const DONE_SNAPSHOT_TTL_MS = 30_000;
 const ERROR_SNAPSHOT_TTL_MS = 24 * 60 * 60_000;
-async function judgeTaskCompletion(task, responseText, responseAt) {
-    if (!responseText.trim() || task.status !== 'in_progress')
-        return;
-    try {
-        const result = await adapter.judgeCompletion(task.title, task.description, responseText);
-        if (result.done) {
-            const current = getTask(task.id);
-            if (!current ||
-                current.status !== 'in_progress' ||
-                current.last_agent_response_at !== responseAt) {
-                return;
-            }
-            const updated = updateTask(task.id, { status: 'in_review' });
-            if (updated)
-                broadcast({ type: 'task_updated', task: updated });
-        }
+function parseChatRunMode(body) {
+    const record = isRecord(body) ? body : {};
+    const settings = isRecord(record.settings) ? record.settings : {};
+    const mode = settings.mode ?? record.mode ?? 'task';
+    if (CHAT_RUN_MODES.includes(mode))
+        return mode;
+    throw new Error(`mode must be one of: ${CHAT_RUN_MODES.join(', ')}`);
+}
+function broadcastRunSnapshot(taskId) {
+    const liveRun = getRun(taskId);
+    if (liveRun)
+        broadcastLive(taskId, { type: 'snapshot', run: liveRun });
+}
+function recordCompletedAgentRun(taskId, context) {
+    const updated = recordAgentResponse(taskId, Date.now(), context);
+    if (updated && updated.status === 'in_progress') {
+        return updateTask(taskId, { status: 'in_review' });
     }
-    catch {
-        // Judge failure is non-critical — leave task as-is
+    return updated;
+}
+function settleRun(taskId, runId, context) {
+    const status = getRunStatus(taskId);
+    if (status)
+        broadcast({ type: 'task_run_updated', run: status });
+    if (status?.status === 'done') {
+        const updated = recordCompletedAgentRun(taskId, context);
+        if (updated)
+            broadcast({ type: 'task_updated', task: updated });
     }
+    else {
+        touchTask(taskId);
+    }
+    const ttl = status?.status === 'error' ? ERROR_SNAPSHOT_TTL_MS : DONE_SNAPSHOT_TTL_MS;
+    finishRun(taskId, ttl, runId);
 }
-async function consumeChatRun(runTask, sessionId, content, runId) {
+async function streamChatTurn(runTask, sessionId, content, options) {
     let sawDone = false;
     let doneContext;
     let responseText = '';
+    let hadError = false;
     try {
         const stream = adapter.chatStream(sessionId, content, {
             systemMessage: TASK_AGENT_SYSTEM_PROMPT,
@@ -76,44 +103,111 @@ async function consumeChatRun(runTask, sessionId, content, runId) {
             task: { id: runTask.id, title: runTask.title },
         });
         for await (const event of stream) {
-            if (event.type === 'text_delta' && responseText.length < 4200)
-                responseText += event.content ?? '';
+            if (options.captureResponseText && event.type === 'text_delta' && event.content) {
+                responseText += event.content;
+            }
             if (event.type === 'done') {
                 sawDone = true;
                 doneContext = event.context;
+                if (!options.completeOnDone) {
+                    updateRunContext(runTask.id, event.context, event.sessionId);
+                    continue;
+                }
+            }
+            if (event.type === 'error') {
+                hadError = true;
             }
             applyEvent(runTask.id, event);
             broadcastLive(runTask.id, event);
         }
     }
     catch (error) {
+        hadError = true;
         const event = { type: 'error', error: toErrorMessage(error, 'Hermes chat stream failed') };
         applyEvent(runTask.id, event);
         broadcastLive(runTask.id, event);
     }
-    finally {
-        const currentRun = getRunStatus(runTask.id);
-        if (!sawDone && currentRun?.status === 'streaming') {
-            const event = { type: 'done', sessionId };
+    const finalRun = getRunStatus(runTask.id);
+    if (!sawDone && !hadError && finalRun?.status === 'streaming') {
+        if (options.completeOnDone) {
+            const event = { type: 'done', sessionId, context: doneContext };
             sawDone = true;
             applyEvent(runTask.id, event);
             broadcastLive(runTask.id, event);
         }
-        const finishedRun = getRunStatus(runTask.id);
-        if (finishedRun)
-            broadcast({ type: 'task_run_updated', run: finishedRun });
-        if (sawDone && finishedRun?.status === 'done') {
-            const responseAt = Date.now();
-            const updated = recordAgentResponse(runTask.id, responseAt, doneContext ?? null);
-            if (updated)
-                broadcast({ type: 'task_updated', task: updated });
-            void judgeTaskCompletion(runTask, responseText, responseAt);
-        }
         else {
-            touchTask(runTask.id);
+            hadError = true;
+            const event = { type: 'error', error: 'Hermes chat stream ended before completion' };
+            applyEvent(runTask.id, event);
+            broadcastLive(runTask.id, event);
         }
-        const ttl = finishedRun?.status === 'error' ? ERROR_SNAPSHOT_TTL_MS : DONE_SNAPSHOT_TTL_MS;
-        finishRun(runTask.id, ttl, runId);
+    }
+    return { responseText, sawDone, context: doneContext, hadError };
+}
+async function consumeChatRun(runTask, sessionId, content, runId) {
+    const result = await streamChatTurn(runTask, sessionId, content, { completeOnDone: true });
+    try {
+        settleRun(runTask.id, runId, result.context ?? null);
+    }
+    catch {
+        finishRun(runTask.id, ERROR_SNAPSHOT_TTL_MS, runId);
+    }
+}
+async function consumeGoalRun(runTask, sessionId, initialContent, runId) {
+    let finalContext;
+    let hadError = false;
+    let turnContent = initialContent;
+    let turnCount = 0;
+    try {
+        while (turnContent) {
+            if (++turnCount > MINIONS_GOAL_MAX_TURNS) {
+                appendSystemMessage(runTask.id, 'Goal turn limit reached');
+                broadcastRunSnapshot(runTask.id);
+                break;
+            }
+            appendUserMessage(runTask.id, turnContent);
+            startAssistantMessage(runTask.id);
+            const turn = await streamChatTurn(runTask, sessionId, turnContent, {
+                completeOnDone: false,
+                captureResponseText: true,
+            });
+            if (turn.context !== undefined)
+                finalContext = turn.context;
+            const currentRun = getRunStatus(runTask.id);
+            if (turn.hadError || currentRun?.status === 'error') {
+                hadError = true;
+                break;
+            }
+            const decision = await adapter.evaluateGoal(sessionId, turn.responseText);
+            let shouldBroadcastSnapshot = false;
+            if (decision.state) {
+                const goalRun = updateRunGoal(runTask.id, decision.state);
+                if (goalRun)
+                    broadcast({ type: 'task_run_updated', run: goalRun });
+                shouldBroadcastSnapshot = true;
+            }
+            if (decision.message) {
+                appendSystemMessage(runTask.id, decision.message);
+                shouldBroadcastSnapshot = true;
+            }
+            if (shouldBroadcastSnapshot)
+                broadcastRunSnapshot(runTask.id);
+            if (!decision.shouldContinue)
+                break;
+            turnContent = decision.continuationPrompt?.trim() ? decision.continuationPrompt : null;
+        }
+    }
+    catch (error) {
+        hadError = true;
+        const event = { type: 'error', error: toErrorMessage(error, 'Hermes goal loop failed') };
+        applyEvent(runTask.id, event);
+        broadcastLive(runTask.id, event);
+    }
+    finally {
+        if (!hadError && getRunStatus(runTask.id)?.status === 'streaming') {
+            updateRunStatus(runTask.id, 'done', { context: finalContext ?? null });
+        }
+        settleRun(runTask.id, runId, finalContext ?? null);
     }
 }
 chatRouter.post('/:id/messages', async (req, res) => {
@@ -125,14 +219,16 @@ chatRouter.post('/:id/messages', async (req, res) => {
         return res.status(400).json({ error: 'content is required' });
     }
     let runSettings;
+    let mode;
     try {
         runSettings = parseRunSettingsBody(req.body);
+        mode = parseChatRunMode(req.body);
     }
     catch (error) {
         return res.status(400).json({ error: toErrorMessage(error, 'Invalid run settings') });
     }
     const activeRun = getRunStatus(task.id);
-    if (activeRun?.status === 'streaming') {
+    if (isTaskRunActive(activeRun)) {
         return res.status(409).json({ error: 'This task already has a message in progress' });
     }
     let runTask = task;
@@ -157,24 +253,43 @@ chatRouter.post('/:id/messages', async (req, res) => {
         broadcast({ type: 'task_updated', task: updated });
     }
     const sessionId = runTask.id;
-    const run = startRun(runTask.id, sessionId, content);
-    const startedRun = getRunStatus(runTask.id);
-    if (startedRun)
-        broadcast({ type: 'task_run_updated', run: startedRun });
-    broadcastLive(runTask.id, { type: 'snapshot', run });
-    void consumeChatRun(runTask, sessionId, content, run.runId);
-    res.status(202).json({ runId: run.runId });
+    if (mode === 'goal') {
+        let goalState;
+        try {
+            goalState = await adapter.setGoal(sessionId, content);
+        }
+        catch (error) {
+            return res.status(503).json({ error: toErrorMessage(error, 'Could not set Hermes goal') });
+        }
+        const { snapshot, state } = startGoalRun(runTask.id, sessionId, goalState);
+        broadcast({ type: 'task_run_updated', run: state });
+        broadcastLive(runTask.id, { type: 'snapshot', run: snapshot });
+        void consumeGoalRun(runTask, sessionId, content, snapshot.runId);
+        return res.status(202).json({ runId: snapshot.runId });
+    }
+    const { snapshot, state } = startRun(runTask.id, sessionId, content);
+    broadcast({ type: 'task_run_updated', run: state });
+    broadcastLive(runTask.id, { type: 'snapshot', run: snapshot });
+    void consumeChatRun(runTask, sessionId, content, snapshot.runId);
+    res.status(202).json({ runId: snapshot.runId });
 });
 chatRouter.post('/:id/compact', async (req, res) => {
     const task = getTask(req.params.id);
     if (!task)
         return res.status(404).json({ error: 'Task not found' });
     const activeRun = getRunStatus(task.id);
-    if (activeRun?.status === 'streaming') {
-        return res.status(409).json({ error: 'Cannot compact while a message is streaming' });
+    if (isTaskRunActive(activeRun)) {
+        return res.status(409).json({
+            error: activeRun?.status === 'compacting'
+                ? 'This task is already compacting'
+                : 'Cannot compact while a message is streaming',
+        });
     }
     const focusTopic = typeof req.body?.focusTopic === 'string' ? req.body.focusTopic.trim() || null : null;
     const currentTokens = task.last_context_used_tokens ?? undefined;
+    const { snapshot, state } = startCompactionRun(task.id, task.id);
+    broadcast({ type: 'task_run_updated', run: state });
+    broadcastLive(task.id, { type: 'snapshot', run: snapshot });
     try {
         const result = await adapter.compressSession(task.id, {
             focusTopic,
@@ -187,10 +302,13 @@ chatRouter.post('/:id/compact', async (req, res) => {
             if (updated)
                 broadcast({ type: 'task_updated', task: updated });
         }
+        completeTaskRun(task.id, snapshot.runId, 'done', DONE_SNAPSHOT_TTL_MS, { context: result.context });
         res.json(result);
     }
     catch (error) {
-        res.status(503).json({ error: toErrorMessage(error, 'Compaction failed') });
+        const message = toErrorMessage(error, 'Compaction failed');
+        completeTaskRun(task.id, snapshot.runId, 'error', ERROR_SNAPSHOT_TTL_MS, { error: message });
+        res.status(503).json({ error: message });
     }
 });
 chatRouter.get('/:id/live', (req, res) => {

package/dist/server/server/routes/{routines.d.ts → scheduled-tasks.d.ts}

@@ -1,3 +1,3 @@
 import { Router } from 'express';
 import type { HermesWorkerAdapter } from '../adapters/hermes-worker.js';
-export declare function createRoutinesRouter(adapter: HermesWorkerAdapter): Router;
+export declare function createScheduledTasksRouter(adapter: HermesWorkerAdapter): Router;

package/dist/server/server/routes/{routines.js → scheduled-tasks.js}

@@ -1,7 +1,7 @@
 import { Router } from 'express';
 import { errorCode, isRecord, toErrorMessage } from '../errors.js';
-import { listRoutineRuns, getRoutineRunContent } from '../routines/runs.js';
-const ROUTINE_INPUT_FIELDS = [
+import { listScheduledTaskRuns, getScheduledTaskRunContent } from '../scheduled-tasks/runs.js';
+const SCHEDULED_TASK_INPUT_FIELDS = [
     'name',
     'prompt',
     'schedule',
@@ -17,11 +17,11 @@ const ROUTINE_INPUT_FIELDS = [
 function hasText(value) {
     return typeof value === 'string' && value.trim().length > 0;
 }
-function routineInputFromBody(body) {
+function scheduledTaskInputFromBody(body) {
     if (!isRecord(body))
         return {};
     const input = {};
-    for (const field of ROUTINE_INPUT_FIELDS) {
+    for (const field of SCHEDULED_TASK_INPUT_FIELDS) {
         if (Object.prototype.hasOwnProperty.call(body, field)) {
             Object.assign(input, { [field]: body[field] });
         }
@@ -37,48 +37,48 @@ function workerStatus(error) {
     return 503;
 }
 function workerErrorFallback(error) {
-    return workerStatus(error) === 400 ? 'Invalid routine' : 'Hermes routines worker unavailable';
+    return workerStatus(error) === 400 ? 'Invalid scheduled task' : 'Hermes scheduled tasks worker unavailable';
 }
-export function createRoutinesRouter(adapter) {
+export function createScheduledTasksRouter(adapter) {
     const router = Router();
-    router.get('/jobs', async (req, res) => {
+    router.get('/', async (req, res) => {
         try {
             const includeDisabled = req.query.includeDisabled === 'true';
-            const jobs = await adapter.listRoutines(includeDisabled);
-            res.json({ jobs });
+            const scheduledTasks = await adapter.listScheduledTasks(includeDisabled);
+            res.json({ scheduledTasks });
         }
         catch (error) {
-            res.status(503).json({ error: toErrorMessage(error, 'Hermes routines worker unavailable') });
+            res.status(503).json({ error: toErrorMessage(error, 'Hermes scheduled tasks worker unavailable') });
         }
     });
-    router.get('/jobs/:jobId', async (req, res) => {
+    router.get('/:id', async (req, res) => {
         try {
-            const job = await adapter.getRoutine(req.params.jobId);
-            if (!job)
-                return res.status(404).json({ error: 'Routine not found' });
-            res.json({ job });
+            const scheduledTask = await adapter.getScheduledTask(req.params.id);
+            if (!scheduledTask)
+                return res.status(404).json({ error: 'Scheduled task not found' });
+            res.json({ scheduledTask });
         }
         catch (error) {
-            res.status(503).json({ error: toErrorMessage(error, 'Hermes routines worker unavailable') });
+            res.status(503).json({ error: toErrorMessage(error, 'Hermes scheduled tasks worker unavailable') });
         }
     });
-    router.post('/jobs', async (req, res) => {
-        const input = routineInputFromBody(req.body);
+    router.post('/', async (req, res) => {
+        const input = scheduledTaskInputFromBody(req.body);
         if (!hasText(input.prompt))
             return res.status(400).json({ error: 'prompt is required' });
         if (!hasText(input.schedule))
             return res.status(400).json({ error: 'schedule is required' });
         try {
-            const job = await adapter.createRoutine(input);
-            res.json({ job });
+            const scheduledTask = await adapter.createScheduledTask(input);
+            res.json({ scheduledTask });
         }
         catch (error) {
             const status = workerStatus(error);
             res.status(status).json({ error: toErrorMessage(error, workerErrorFallback(error)) });
         }
     });
-    router.patch('/jobs/:jobId', async (req, res) => {
-        const updates = routineInputFromBody(req.body);
+    router.patch('/:id', async (req, res) => {
+        const updates = scheduledTaskInputFromBody(req.body);
         if ('prompt' in updates && !hasText(updates.prompt)) {
             return res.status(400).json({ error: 'prompt cannot be empty' });
         }
@@ -86,69 +86,69 @@ export function createRoutinesRouter(adapter) {
             return res.status(400).json({ error: 'schedule cannot be empty' });
         }
         try {
-            const job = await adapter.updateRoutine(req.params.jobId, updates);
-            if (!job)
-                return res.status(404).json({ error: 'Routine not found' });
-            res.json({ job });
+            const scheduledTask = await adapter.updateScheduledTask(req.params.id, updates);
+            if (!scheduledTask)
+                return res.status(404).json({ error: 'Scheduled task not found' });
+            res.json({ scheduledTask });
         }
         catch (error) {
             const status = workerStatus(error);
             res.status(status).json({ error: toErrorMessage(error, workerErrorFallback(error)) });
         }
     });
-    router.get('/jobs/:jobId/runs', async (req, res) => {
+    router.get('/:id/runs', async (req, res) => {
         try {
             const rawLimit = Array.isArray(req.query.limit) ? req.query.limit[0] : req.query.limit;
             const limit = rawLimit ? Number.parseInt(String(rawLimit), 10) : 20;
-            const runs = await listRoutineRuns(req.params.jobId, Number.isFinite(limit) ? limit : 20);
+            const runs = await listScheduledTaskRuns(req.params.id, Number.isFinite(limit) ? limit : 20);
             res.json({ runs });
         }
         catch (error) {
-            res.status(500).json({ error: toErrorMessage(error, 'Failed to list routine runs') });
+            res.status(500).json({ error: toErrorMessage(error, 'Failed to list scheduled task runs') });
         }
     });
-    router.get('/jobs/:jobId/runs/:runId/content', async (req, res) => {
+    router.get('/:id/runs/:runId/content', async (req, res) => {
         try {
-            const content = await getRoutineRunContent(req.params.jobId, req.params.runId);
+            const content = await getScheduledTaskRunContent(req.params.id, req.params.runId);
             if (!content)
-                return res.status(404).json({ error: 'Routine run output not found' });
+                return res.status(404).json({ error: 'Scheduled task run output not found' });
             res.json({ content });
         }
         catch (error) {
-            res.status(500).json({ error: toErrorMessage(error, 'Failed to read routine run') });
+            res.status(500).json({ error: toErrorMessage(error, 'Failed to read scheduled task run') });
         }
     });
-    async function jobActionHandler(res, jobId, action) {
+    async function scheduledTaskActionHandler(res, id, action) {
         try {
-            const job = await action(jobId);
-            if (!job)
-                return res.status(404).json({ error: 'Routine not found' });
-            res.json({ job });
+            const scheduledTask = await action(id);
+            if (!scheduledTask)
+                return res.status(404).json({ error: 'Scheduled task not found' });
+            res.json({ scheduledTask });
         }
         catch (error) {
-            res.status(503).json({ error: toErrorMessage(error, 'Hermes routines worker unavailable') });
+            res.status(503).json({ error: toErrorMessage(error, 'Hermes scheduled tasks worker unavailable') });
         }
     }
-    router.post('/jobs/:jobId/pause', (req, res) => {
+    router.post('/:id/pause', (req, res) => {
         const rawReason = req.body?.reason;
         const reason = typeof rawReason === 'string' && rawReason.trim() ? rawReason.trim() : undefined;
-        jobActionHandler(res, req.params.jobId, (jobId) => adapter.pauseRoutine(jobId, reason));
+        scheduledTaskActionHandler(res, req.params.id, (id) => adapter.pauseScheduledTask(id, reason));
     });
-    router.post('/jobs/:jobId/resume', (req, res) => {
-        jobActionHandler(res, req.params.jobId, (jobId) => adapter.resumeRoutine(jobId));
+    router.post('/:id/resume', (req, res) => {
+        scheduledTaskActionHandler(res, req.params.id, (id) => adapter.resumeScheduledTask(id));
     });
-    router.post('/jobs/:jobId/run', (req, res) => {
-        jobActionHandler(res, req.params.jobId, (jobId) => adapter.runRoutine(jobId));
+    router.post('/:id/run', (req, res) => {
+        scheduledTaskActionHandler(res, req.params.id, (id) => adapter.runScheduledTask(id));
     });
-    router.delete('/jobs/:jobId', async (req, res) => {
+    router.delete('/:id', async (req, res) => {
         try {
-            const removed = await adapter.removeRoutine(req.params.jobId);
+            const removed = await adapter.removeScheduledTask(req.params.id);
             if (!removed)
-                return res.status(404).json({ error: 'Routine not found' });
+                return res.status(404).json({ error: 'Scheduled task not found' });
             res.json({ ok: true });
         }
         catch (error) {
-            res.status(503).json({ error: toErrorMessage(error, 'Hermes routines worker unavailable') });
+            res.status(503).json({ error: toErrorMessage(error, 'Hermes scheduled tasks worker unavailable') });
         }
     });
     return router;

package/dist/server/server/scheduled-tasks/runs.d.ts

@@ -0,0 +1,3 @@
+import type { ScheduledTaskRun, ScheduledTaskRunContent } from '../../shared/types.js';
+export declare function listScheduledTaskRuns(scheduledTaskId: string, limit?: number): Promise<ScheduledTaskRun[]>;
+export declare function getScheduledTaskRunContent(scheduledTaskId: string, runId: string): Promise<ScheduledTaskRunContent | null>;

package/dist/server/server/{routines → scheduled-tasks}/runs.js

@@ -53,10 +53,10 @@ async function readHead(path, maxBytes = 8192) {
         await fh.close();
     }
 }
-export async function listRoutineRuns(jobId, limit = 20) {
-    if (!isValidSegment(jobId))
+export async function listScheduledTaskRuns(scheduledTaskId, limit = 20) {
+    if (!isValidSegment(scheduledTaskId))
         return [];
-    const dir = join(resolveOutputDir(), jobId);
+    const dir = join(resolveOutputDir(), scheduledTaskId);
     const safeLimit = Math.max(1, Math.min(limit, 100));
     let names;
     try {
@@ -75,13 +75,13 @@ export async function listRoutineRuns(jobId, limit = 20) {
             head = await readHead(path);
         }
         catch { }
-        return { id: stem, jobId, ranAt: parseTimestamp(stem), path, status: detectStatus(head), preview: buildPreview(head) };
+        return { id: stem, scheduledTaskId, ranAt: parseTimestamp(stem), path, status: detectStatus(head), preview: buildPreview(head) };
     }));
 }
-export async function getRoutineRunContent(jobId, runId) {
-    if (!isValidSegment(jobId) || !isValidSegment(runId))
+export async function getScheduledTaskRunContent(scheduledTaskId, runId) {
+    if (!isValidSegment(scheduledTaskId) || !isValidSegment(runId))
         return null;
-    const path = join(resolveOutputDir(), jobId, `${runId}.md`);
+    const path = join(resolveOutputDir(), scheduledTaskId, `${runId}.md`);
     let content;
     try {
         content = await readFile(path, 'utf8');