kimaki 0.25.0 → 0.26.0

package/dist/system-message.js

@@ -374,7 +374,8 @@ see --help for options like voice, speed, etc.
 
 ## requesting files from the user
 
-To ask the user to upload files from their device, use the \`kimaki_file_upload\` tool. This shows a native file picker dialog in Discord. The files are downloaded to the project's \`uploads/\` directory and the tool returns the local file paths.
+To ask the user to upload files from their device, use \`kimaki_file_upload\`. This shows a native file picker dialog in Discord. The files are downloaded to the project's \`uploads/\` directory and the tool returns the local file paths.
+You MUST call \`kimaki_file_upload\` LAST, after ALL text.
 
 ## archiving the current thread
 
@@ -492,6 +493,10 @@ Use \`--send-at\` to schedule a one-time or recurring task:
 kimaki send --channel ${channelId} --prompt 'Reminder: review open PRs' --send-at '2026-03-01T09:00:00Z' --agent <current_agent>${parentSessionArg}${userArg}
 kimaki send --channel ${channelId} --prompt 'Run weekly test suite and summarize failures' --send-at '0 9 * * 1' --agent <current_agent>${parentSessionArg}${userArg}
 
+Use \`--pre-run '<command>'\` to check whether a scheduled task should start. Kimaki runs the command in the project directory. Exit code 0 starts the session and appends stdout to the prompt. Any other exit code skips that occurrence. Command output is written to the Kimaki log.
+
+Scheduled tasks do not overlap by default. Add \`--allow-concurrency\` only when concurrent sessions from the same task are safe.
+
 **ALWAYS pass \`--user\` when scheduling a task.** Discord only shows a thread in the left sidebar to its members. Without \`--user\`, kimaki does not ensure anyone is a member, so the task can fire completely unnoticed if the user never joined the thread or already left it. This applies to \`--channel\` and \`--thread\` scheduling alike.
 
 ALL scheduling is in UTC. Dates must be UTC ISO format ending with \`Z\`. Cron expressions also fire in UTC (e.g. \`0 9 * * 1\` means 9:00 UTC every Monday).
@@ -501,6 +506,8 @@ When the user specifies a time without a timezone, ask them to confirm their tim
 - \`--notify-only\` to create a reminder thread without auto-starting a session
 - \`--worktree\` to create the scheduled thread as a worktree session (only if the user explicitly asks for a worktree)
 - \`--agent\` and \`--model\` to control scheduled session behavior
+- \`--pre-run\` to start only when a project command exits with code 0
+- \`--allow-concurrency\` to permit overlapping runs from the same task
 - \`--parent-session\` to pass this session as parent of the scheduled child
 - \`--user\` to add a specific user to the scheduled thread (always pass this)
 
@@ -534,7 +541,7 @@ Notification strategy:
 Manage scheduled tasks with:
 
 kimaki task list
-kimaki task edit <id> --prompt "new prompt" [--send-at "new schedule"] [--user "<discord-user-id>"] [--model "provider/model"] [--agent "<agent>"]
+kimaki task edit <id> --prompt "new prompt" [--send-at "new schedule"] [--pre-run "command"] [--allow-concurrency true|false] [--user "<discord-user-id>"] [--model "provider/model"] [--agent "<agent>"]
 kimaki task delete <id>
 
 \`kimaki task list\` prints \`userId\`, \`agent\`, and \`model\` columns. A \`-\` in \`userId\` means nobody is added to the thread when that task fires, so the user may never see it. Fix it with \`kimaki task edit <id> --user '<discord-user-id>'\` instead of deleting and recreating the task. Change model or agent in place with \`--model\` / \`--agent\` (empty string clears the override). Do not read SQLite or recreate the task just to swap model.
@@ -827,9 +834,16 @@ Only ask questions when the request is genuinely ambiguous with multiple valid a
 
 ## ending conversations with options
 
-The question tool must be called last, after all text parts. Always use it when you ask questions.
+You MUST write ALL user-visible text FIRST.
+You MUST call \`question\` LAST, after ALL text parts.
+NEVER call \`question\` before your text. Discord will hide the message.
+
+The same rule applies to \`kimaki_action_buttons\` and \`kimaki_file_upload\`.
+You MUST call them LAST, after ALL text.
+
+ALWAYS use \`question\` when you ask the user a question. Do not write a numbered list in plain text.
 
-IMPORTANT: Do NOT use the question tool to ask permission before doing work. Do the work first, then offer follow-ups.
+IMPORTANT: Do NOT use \`question\` to ask permission before doing work. Do the work first, then offer follow-ups.
 
 Examples:
 - After completing edits: offer "Commit changes?"

package/dist/system-message.test.js

@@ -24,6 +24,16 @@ describe('system-message', () => {
         expect(message).toContain('- failed commands');
         expect(message).toContain('<callout accent="#f59e0b">');
     });
+    test('requires interactive tools after all text, using exact tool names', () => {
+        const message = getOpencodeSystemMessage({
+            sessionId: 'ses_123',
+        });
+        expect(message).toContain('You MUST write ALL user-visible text FIRST');
+        expect(message).toContain('You MUST call `question` LAST');
+        expect(message).toContain('NEVER call `question` before your text');
+        expect(message).toContain('`kimaki_action_buttons`');
+        expect(message).toContain('`kimaki_file_upload`');
+    });
     test('persists and reads session system prompt for command path', async () => {
         const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-system-'));
         tempDirs.push(dataDir);
@@ -174,7 +184,8 @@ describe('system-message', () => {
 
       ## requesting files from the user
 
-      To ask the user to upload files from their device, use the \`kimaki_file_upload\` tool. This shows a native file picker dialog in Discord. The files are downloaded to the project's \`uploads/\` directory and the tool returns the local file paths.
+      To ask the user to upload files from their device, use \`kimaki_file_upload\`. This shows a native file picker dialog in Discord. The files are downloaded to the project's \`uploads/\` directory and the tool returns the local file paths.
+      You MUST call \`kimaki_file_upload\` LAST, after ALL text.
 
       ## archiving the current thread
 
@@ -295,6 +306,10 @@ describe('system-message', () => {
       kimaki send --channel chan_123 --prompt 'Reminder: review open PRs' --send-at '2026-03-01T09:00:00Z' --agent <current_agent> --parent-session ses_123 --user '<discord-user-id>'
       kimaki send --channel chan_123 --prompt 'Run weekly test suite and summarize failures' --send-at '0 9 * * 1' --agent <current_agent> --parent-session ses_123 --user '<discord-user-id>'
 
+      Use \`--pre-run '<command>'\` to check whether a scheduled task should start. Kimaki runs the command in the project directory. Exit code 0 starts the session and appends stdout to the prompt. Any other exit code skips that occurrence. Command output is written to the Kimaki log.
+
+      Scheduled tasks do not overlap by default. Add \`--allow-concurrency\` only when concurrent sessions from the same task are safe.
+
       **ALWAYS pass \`--user\` when scheduling a task.** Discord only shows a thread in the left sidebar to its members. Without \`--user\`, kimaki does not ensure anyone is a member, so the task can fire completely unnoticed if the user never joined the thread or already left it. This applies to \`--channel\` and \`--thread\` scheduling alike.
 
       ALL scheduling is in UTC. Dates must be UTC ISO format ending with \`Z\`. Cron expressions also fire in UTC (e.g. \`0 9 * * 1\` means 9:00 UTC every Monday).
@@ -304,6 +319,8 @@ describe('system-message', () => {
       - \`--notify-only\` to create a reminder thread without auto-starting a session
       - \`--worktree\` to create the scheduled thread as a worktree session (only if the user explicitly asks for a worktree)
       - \`--agent\` and \`--model\` to control scheduled session behavior
+      - \`--pre-run\` to start only when a project command exits with code 0
+      - \`--allow-concurrency\` to permit overlapping runs from the same task
       - \`--parent-session\` to pass this session as parent of the scheduled child
       - \`--user\` to add a specific user to the scheduled thread (always pass this)
 
@@ -337,7 +354,7 @@ describe('system-message', () => {
       Manage scheduled tasks with:
 
       kimaki task list
-      kimaki task edit <id> --prompt "new prompt" [--send-at "new schedule"] [--user "<discord-user-id>"] [--model "provider/model"] [--agent "<agent>"]
+      kimaki task edit <id> --prompt "new prompt" [--send-at "new schedule"] [--pre-run "command"] [--allow-concurrency true|false] [--user "<discord-user-id>"] [--model "provider/model"] [--agent "<agent>"]
       kimaki task delete <id>
 
       \`kimaki task list\` prints \`userId\`, \`agent\`, and \`model\` columns. A \`-\` in \`userId\` means nobody is added to the thread when that task fires, so the user may never see it. Fix it with \`kimaki task edit <id> --user '<discord-user-id>'\` instead of deleting and recreating the task. Change model or agent in place with \`--model\` / \`--agent\` (empty string clears the override). Do not read SQLite or recreate the task just to swap model.
@@ -782,9 +799,16 @@ describe('system-message', () => {
 
       ## ending conversations with options
 
-      The question tool must be called last, after all text parts. Always use it when you ask questions.
+      You MUST write ALL user-visible text FIRST.
+      You MUST call \`question\` LAST, after ALL text parts.
+      NEVER call \`question\` before your text. Discord will hide the message.
+
+      The same rule applies to \`kimaki_action_buttons\` and \`kimaki_file_upload\`.
+      You MUST call them LAST, after ALL text.
+
+      ALWAYS use \`question\` when you ask the user a question. Do not write a numbered list in plain text.
 
-      IMPORTANT: Do NOT use the question tool to ask permission before doing work. Do the work first, then offer follow-ups.
+      IMPORTANT: Do NOT use \`question\` to ask permission before doing work. Do the work first, then offer follow-ups.
 
       Examples:
       - After completing edits: offer "Commit changes?"

package/dist/task-runner.js

@@ -3,11 +3,15 @@ import { Routes } from 'discord.js';
 import { createDiscordRest } from './discord-urls.js';
 import { ensureThreadMember } from './discord-utils.js';
 import YAML from 'yaml';
-import { claimScheduledTaskRunning, getDuePlannedScheduledTasks, getScheduledTask, markScheduledTaskCronRescheduled, markScheduledTaskCronRetry, markScheduledTaskFailed, deleteScheduledTask, recoverStaleRunningScheduledTasks, } from './database.js';
+import { claimScheduledTaskRunning, createScheduledTaskRun, failScheduledTaskRun, finishScheduledTaskRun, getDuePlannedScheduledTasks, getScheduledTask, getActiveScheduledTaskRuns, markScheduledTaskCronRescheduled, markScheduledTaskCronRetry, markScheduledTaskFailed, deleteScheduledTask, recoverStaleRunningScheduledTasks, releaseScheduledTaskClaim, setScheduledTaskRunThread, } from './database.js';
+import { execAsync } from './exec-async.js';
+import { initializeOpencodeForDirectory } from './opencode.js';
 import { createLogger, formatErrorWithStack, LogPrefix } from './logger.js';
 import { notifyError } from './sentry.js';
-import { getNextCronRun, getPromptPreview, parseScheduledTaskPayload, } from './task-schedule.js';
+import { appendTaskCommandOutput, getNextCronRun, getPromptPreview, parseScheduledTaskPayload, } from './task-schedule.js';
 const taskLogger = createLogger(LogPrefix.TASK);
+const MAX_SCHEDULED_PROMPT_LENGTH = 1_900;
+const PENDING_RUN_TIMEOUT_MS = 120_000;
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
@@ -20,7 +24,7 @@ function parseMessageId(value) {
     }
     return value.id;
 }
-async function executeThreadScheduledTask({ rest, task, payload, }) {
+async function executeThreadScheduledTask({ rest, task, payload, prompt, runId, }) {
     const marker = {
         start: true,
         scheduledKind: task.schedule_kind,
@@ -28,6 +32,7 @@ async function executeThreadScheduledTask({ rest, task, payload, }) {
         // after execution, so the ID would be stale by the time the bot processes
         // the Discord event and tries to insert a session_start_sources row.
         ...(task.schedule_kind === 'cron' ? { scheduledTaskId: task.id } : {}),
+        ...(runId ? { scheduledTaskRunId: runId } : {}),
         ...(payload.agent ? { agent: payload.agent } : {}),
         ...(payload.model ? { model: payload.model } : {}),
         ...(payload.username ? { username: payload.username } : {}),
@@ -41,7 +46,7 @@ async function executeThreadScheduledTask({ rest, task, payload, }) {
     const embed = [{ color: 0x2b2d31, footer: { text: YAML.stringify(marker) } }];
     // Newline between prefix and prompt so leading /command detection can
     // find the command on its own line.
-    const prefixedPrompt = `» **kimaki-cli:**\n${payload.prompt}`;
+    const prefixedPrompt = `» **kimaki-cli:**\n${prompt}`;
     // Re-join the user before posting, so the message they get notified about is
     // in a thread they are already a member of. Works on archived threads too;
     // the post below auto-unarchives.
@@ -69,8 +74,9 @@ async function executeThreadScheduledTask({ rest, task, payload, }) {
     });
     if (postResult instanceof Error)
         return postResult;
+    return payload.threadId;
 }
-async function executeChannelScheduledTask({ rest, task, payload, }) {
+async function executeChannelScheduledTask({ rest, task, payload, prompt, runId, }) {
     const marker = payload.notifyOnly
         ? undefined
         : {
@@ -78,6 +84,7 @@ async function executeChannelScheduledTask({ rest, task, payload, }) {
             scheduledKind: task.schedule_kind,
             // Only include scheduledTaskId for cron tasks (see thread variant comment)
             ...(task.schedule_kind === 'cron' ? { scheduledTaskId: task.id } : {}),
+            ...(runId ? { scheduledTaskRunId: runId } : {}),
             ...(payload.worktreeName ? { worktree: payload.worktreeName } : {}),
             ...(payload.cwd ? { cwd: payload.cwd } : {}),
             ...(payload.agent ? { agent: payload.agent } : {}),
@@ -96,7 +103,7 @@ async function executeChannelScheduledTask({ rest, task, payload, }) {
     const starterResult = await rest
         .post(Routes.channelMessages(payload.channelId), {
         body: {
-            content: payload.prompt,
+            content: prompt,
             embeds,
         },
     })
@@ -113,7 +120,7 @@ async function executeChannelScheduledTask({ rest, task, payload, }) {
             cause: starterMessageId,
         });
     }
-    const threadName = (payload.name || getPromptPreview(payload.prompt)).slice(0, 100);
+    const threadName = (payload.name || getPromptPreview(prompt)).slice(0, 100);
     const threadResult = await rest
         .post(Routes.threads(payload.channelId, starterMessageId), {
         body: {
@@ -128,15 +135,14 @@ async function executeChannelScheduledTask({ rest, task, payload, }) {
     });
     if (threadResult instanceof Error)
         return threadResult;
-    if (!payload.userId) {
-        return;
-    }
     const threadIdResult = parseMessageId(threadResult);
     if (threadIdResult instanceof Error) {
         return new Error(`Invalid thread response for task ${task.id}`, {
             cause: threadIdResult,
         });
     }
+    if (!payload.userId)
+        return threadIdResult;
     const addMemberResult = await ensureThreadMember({
         rest,
         threadId: threadIdResult,
@@ -145,25 +151,111 @@ async function executeChannelScheduledTask({ rest, task, payload, }) {
     if (addMemberResult instanceof Error) {
         return new Error(`Failed to add user to scheduled thread for task ${task.id}`, { cause: addMemberResult });
     }
+    return threadIdResult;
+}
+export async function runTaskCommand({ task, payload, }) {
+    if (!payload.preRunCommand)
+        return { kind: 'run', prompt: payload.prompt };
+    if (!task.project_directory) {
+        return new Error(`Task ${task.id} has a pre-run command but no project directory`);
+    }
+    const command = payload.preRunCommand;
+    const result = await execAsync(command, { cwd: task.project_directory }).catch((error) => error instanceof Error ? error : new Error(String(error)));
+    const stdout = isRecord(result) && typeof result.stdout === 'string'
+        ? result.stdout
+        : '';
+    const stderr = isRecord(result) && typeof result.stderr === 'string'
+        ? result.stderr
+        : '';
+    const exitCode = result instanceof Error && isRecord(result)
+        ? result.code ?? 1
+        : 0;
+    if (stdout)
+        taskLogger.log(`[task-runner] task ${task.id} pre-run stdout:\n${stdout}`);
+    if (stderr)
+        taskLogger.log(`[task-runner] task ${task.id} pre-run stderr:\n${stderr}`);
+    taskLogger.log(`[task-runner] task ${task.id} pre-run exited with ${exitCode}`);
+    if (result instanceof Error)
+        return { kind: 'skip' };
+    const prompt = appendTaskCommandOutput({ prompt: payload.prompt, stdout });
+    if (prompt.length > MAX_SCHEDULED_PROMPT_LENGTH) {
+        return new Error(`Task ${task.id} prompt and pre-run stdout exceed ${MAX_SCHEDULED_PROMPT_LENGTH} characters`);
+    }
+    return { kind: 'run', prompt };
+}
+async function hasRunningSession(task) {
+    const runs = await getActiveScheduledTaskRuns(task.id);
+    if (runs.length === 0)
+        return false;
+    let active = false;
+    for (const run of runs) {
+        if (!run.session_id) {
+            if (Date.now() - run.started_at.getTime() < PENDING_RUN_TIMEOUT_MS) {
+                active = true;
+                continue;
+            }
+            await failScheduledTaskRun({
+                runId: run.id,
+                error: 'Timed out waiting for scheduled session to start',
+            });
+            continue;
+        }
+        if (!run.project_directory) {
+            active = true;
+            continue;
+        }
+        const getClient = await initializeOpencodeForDirectory(run.project_directory);
+        if (getClient instanceof Error)
+            return getClient;
+        const statusResponse = await getClient().session.status({
+            directory: run.project_directory,
+        }).catch((error) => new Error('Failed to check scheduled session status', {
+            cause: error,
+        }));
+        if (statusResponse instanceof Error)
+            return statusResponse;
+        if (statusResponse.error)
+            return new Error('Failed to check scheduled session status');
+        const status = statusResponse.data?.[run.session_id];
+        if (status && status.type !== 'idle') {
+            active = true;
+            continue;
+        }
+        if (!status && Date.now() - run.started_at.getTime() < PENDING_RUN_TIMEOUT_MS) {
+            active = true;
+            continue;
+        }
+        await finishScheduledTaskRun({ runId: run.id, status: 'completed' });
+    }
+    return active;
 }
-async function executeScheduledTask({ rest, task, }) {
+async function executeScheduledTask({ rest, task, runId, }) {
     const payloadResult = parseScheduledTaskPayload(task.payload_json);
     if (payloadResult instanceof Error) {
         return new Error(`Task ${task.id} has invalid payload`, {
             cause: payloadResult,
         });
     }
+    const commandResult = await runTaskCommand({ task, payload: payloadResult });
+    if (commandResult instanceof Error)
+        return commandResult;
+    if (commandResult.kind === 'skip')
+        return { kind: 'condition-not-met' };
     if (payloadResult.kind === 'thread') {
         return executeThreadScheduledTask({
             rest,
             task,
             payload: payloadResult,
+            prompt: commandResult.prompt,
+            runId,
         });
     }
     return executeChannelScheduledTask({
         rest,
         task,
         payload: payloadResult,
+        prompt: commandResult.prompt,
+        runId,
     });
 }
 async function finalizeSuccessfulTask({ task, completedAt, }) {
@@ -234,7 +326,32 @@ async function processDueTask({ rest, task, }) {
     if (!claimed) {
         return { kind: 'skipped' };
     }
-    const executeResult = await executeScheduledTask({ rest, task });
+    const payload = parseScheduledTaskPayload(task.payload_json);
+    if (payload instanceof Error) {
+        await finalizeFailedTask({ task, failedAt: new Date(), error: payload });
+        return { kind: 'failed', error: payload };
+    }
+    const activeSession = payload.allowConcurrency
+        ? false
+        : await hasRunningSession(task);
+    if (activeSession instanceof Error) {
+        await releaseScheduledTaskClaim(task.id);
+        taskLogger.warn(`[task-runner] could not check concurrency for task ${task.id}: ${formatErrorWithStack(activeSession)}`);
+        return { kind: 'failed', error: activeSession };
+    }
+    if (activeSession) {
+        if (task.schedule_kind === 'cron') {
+            await finalizeSuccessfulTask({ task, completedAt: new Date() });
+        }
+        else {
+            await releaseScheduledTaskClaim(task.id);
+        }
+        return { kind: 'concurrency-blocked' };
+    }
+    const runId = task.schedule_kind === 'cron'
+        ? await createScheduledTaskRun({ taskId: task.id, startedAt })
+        : undefined;
+    const executeResult = await executeScheduledTask({ rest, task, runId });
     const finishedAt = new Date();
     if (executeResult instanceof Error) {
         taskLogger.warn(`[task-runner] task ${task.id} failed: ${formatErrorWithStack(executeResult)}`);
@@ -243,8 +360,22 @@ async function processDueTask({ rest, task, }) {
             failedAt: finishedAt,
             error: executeResult,
         });
+        if (runId)
+            await failScheduledTaskRun({ runId, error: executeResult.message });
         return { kind: 'failed', error: executeResult };
     }
+    if (!(typeof executeResult === 'string' || executeResult === null)) {
+        if (runId)
+            await finishScheduledTaskRun({ runId, status: 'skipped' });
+        await finalizeSuccessfulTask({ task, completedAt: finishedAt });
+        return executeResult;
+    }
+    if (executeResult && runId) {
+        await setScheduledTaskRunThread({ runId, threadId: executeResult });
+    }
+    else if (runId) {
+        await finishScheduledTaskRun({ runId, status: 'completed' });
+    }
     await finalizeSuccessfulTask({ task, completedAt: finishedAt });
     return { kind: 'success' };
 }

package/dist/task-schedule.js

@@ -106,6 +106,12 @@ export function getNextCronRun({ cronExpr, timezone, from, }) {
 export function serializeScheduledTaskPayload(payload) {
     return JSON.stringify(payload);
 }
+export function appendTaskCommandOutput({ prompt, stdout, }) {
+    const output = stdout.trim();
+    if (!output)
+        return prompt;
+    return `${prompt}\n\n## Pre-run command output\n\n${output}`;
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
@@ -135,6 +141,8 @@ export function parseScheduledTaskPayload(payloadJson) {
         return new Error('Task payload must be an object');
     }
     const kind = asString(parsed.kind);
+    const preRunCommand = asString(parsed.preRunCommand);
+    const allowConcurrency = parsed.allowConcurrency === true;
     if (kind === 'thread') {
         const threadId = asString(parsed.threadId);
         const prompt = asString(parsed.prompt);
@@ -159,6 +167,8 @@ export function parseScheduledTaskPayload(payloadJson) {
             permissions,
             injectionGuardPatterns,
             parentSessionId,
+            preRunCommand,
+            allowConcurrency,
         };
     }
     if (kind === 'channel') {
@@ -194,6 +204,8 @@ export function parseScheduledTaskPayload(payloadJson) {
             permissions,
             injectionGuardPatterns,
             parentSessionId,
+            preRunCommand,
+            allowConcurrency,
         };
     }
     return new Error('Task payload has unknown kind');

package/dist/task-schedule.test.js

@@ -1,6 +1,12 @@
 // Tests for scheduled task date/cron parsing and UTC validation rules.
-import { describe, expect, test } from 'vitest';
-import { parseSendAtValue } from './task-schedule.js';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterAll, afterEach, describe, expect, test } from 'vitest';
+import { completeScheduledTaskRunsForSession, createScheduledTask, createScheduledTaskRun, getActiveScheduledTaskRuns, getScheduledTask, startScheduledTaskRunSession, } from './database.js';
+import { closeDb } from './db.js';
+import { runTaskCommand } from './task-runner.js';
+import { appendTaskCommandOutput, parseScheduledTaskPayload, parseSendAtValue, } from './task-schedule.js';
 describe('parseSendAtValue', () => {
     test('accepts UTC ISO date ending with Z', () => {
         const now = new Date('2026-02-22T13:00:00Z');
@@ -69,3 +75,144 @@ describe('parseSendAtValue', () => {
         expect(result.nextRunAt.toISOString()).toBe('2026-02-23T09:00:00.000Z');
     });
 });
+describe('scheduled task execution options', () => {
+    const tempDirectories = [];
+    afterEach(() => {
+        for (const directory of tempDirectories.splice(0)) {
+            fs.rmSync(directory, { recursive: true, force: true });
+        }
+    });
+    test('defaults old payloads to no command and no concurrency', () => {
+        const payload = parseScheduledTaskPayload(JSON.stringify({
+            kind: 'thread',
+            threadId: 'thread-1',
+            prompt: 'Handle support requests',
+        }));
+        expect(payload).toMatchInlineSnapshot(`
+      {
+        "agent": null,
+        "allowConcurrency": false,
+        "injectionGuardPatterns": null,
+        "kind": "thread",
+        "model": null,
+        "parentSessionId": null,
+        "permissions": null,
+        "preRunCommand": null,
+        "prompt": "Handle support requests",
+        "threadId": "thread-1",
+        "userId": null,
+        "username": null,
+      }
+    `);
+    });
+    test('adds command stdout to the prompt', () => {
+        expect(appendTaskCommandOutput({
+            prompt: 'Handle support requests',
+            stdout: '{"ticketId":"ticket-123"}\n',
+        })).toMatchInlineSnapshot(`
+      "Handle support requests
+
+      ## Pre-run command output
+
+      {"ticketId":"ticket-123"}"
+    `);
+    });
+    test('runs the pre-run command in the project directory', async () => {
+        const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-task-'));
+        tempDirectories.push(directory);
+        fs.writeFileSync(path.join(directory, 'should-run.ts'), "process.stdout.write(JSON.stringify({ cwd: process.cwd(), ticketId: 'ticket-123' }))\n");
+        const taskId = await createScheduledTask({
+            scheduleKind: 'cron',
+            cronExpr: '*/5 * * * *',
+            timezone: 'UTC',
+            nextRunAt: new Date('2026-08-12T18:00:00Z'),
+            payloadJson: JSON.stringify({
+                kind: 'thread',
+                threadId: 'thread-1',
+                prompt: 'Handle support requests',
+                preRunCommand: 'tsx should-run.ts',
+            }),
+            promptPreview: 'Handle support requests',
+            projectDirectory: directory,
+        });
+        const task = await getScheduledTask(taskId);
+        if (!task)
+            throw new Error('Expected scheduled task');
+        const payload = parseScheduledTaskPayload(task.payload_json);
+        if (payload instanceof Error)
+            throw payload;
+        const result = await runTaskCommand({ task, payload });
+        const realDirectory = fs.realpathSync(directory);
+        expect(result instanceof Error || result.kind === 'skip' ? result : {
+            ...result,
+            prompt: result.prompt.replace(realDirectory, '<project-directory>'),
+        }).toMatchInlineSnapshot(`
+      {
+        "kind": "run",
+        "prompt": "Handle support requests
+
+      ## Pre-run command output
+
+      {"cwd":"<project-directory>","ticketId":"ticket-123"}",
+      }
+    `);
+    });
+    test('skips the task when the pre-run command exits nonzero', async () => {
+        const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-task-'));
+        tempDirectories.push(directory);
+        const taskId = await createScheduledTask({
+            scheduleKind: 'cron',
+            cronExpr: '*/5 * * * *',
+            timezone: 'UTC',
+            nextRunAt: new Date('2026-08-12T18:00:00Z'),
+            payloadJson: JSON.stringify({
+                kind: 'thread',
+                threadId: 'thread-skip',
+                prompt: 'Handle support requests',
+                preRunCommand: "node -e \"process.stdout.write('nothing pending'); process.exit(1)\"",
+            }),
+            promptPreview: 'Handle support requests',
+            projectDirectory: directory,
+        });
+        const task = await getScheduledTask(taskId);
+        if (!task)
+            throw new Error('Expected scheduled task');
+        const payload = parseScheduledTaskPayload(task.payload_json);
+        if (payload instanceof Error)
+            throw payload;
+        expect(await runTaskCommand({ task, payload })).toMatchInlineSnapshot(`
+      {
+        "kind": "skip",
+      }
+    `);
+    });
+    test('tracks active runs until their OpenCode session completes', async () => {
+        const taskId = await createScheduledTask({
+            scheduleKind: 'cron',
+            cronExpr: '*/5 * * * *',
+            timezone: 'UTC',
+            nextRunAt: new Date('2026-08-12T18:00:00Z'),
+            payloadJson: JSON.stringify({
+                kind: 'thread',
+                threadId: 'thread-2',
+                prompt: 'Handle support requests',
+            }),
+            promptPreview: 'Handle support requests',
+        });
+        const runId = await createScheduledTaskRun({
+            taskId,
+            startedAt: new Date('2026-08-12T18:00:00Z'),
+        });
+        await startScheduledTaskRunSession({
+            runId,
+            sessionId: 'session-1',
+            projectDirectory: '/project',
+        });
+        expect(await getActiveScheduledTaskRuns(taskId)).toHaveLength(1);
+        await completeScheduledTaskRunsForSession('session-1');
+        expect(await getActiveScheduledTaskRuns(taskId)).toHaveLength(0);
+    });
+});
+afterAll(async () => {
+    await closeDb();
+});