kimaki 0.26.0 → 0.28.0

package/dist/system-message.test.js

@@ -11,6 +11,20 @@ afterEach(async () => {
     }));
 });
 describe('system-message', () => {
+    test('requires kimaki upload for Discord images, not markdown', () => {
+        const message = getOpencodeSystemMessage({
+            sessionId: 'ses_123',
+        });
+        expect(message).toContain('NEVER show images with markdown');
+        expect(message).toContain('Discord does not render local markdown images');
+        expect(message).toContain('ALWAYS upload them with `kimaki upload-to-discord`');
+    });
+    test('requires reading the report-bugs guide before filing kimaki issues', () => {
+        const message = getOpencodeSystemMessage({
+            sessionId: 'ses_123',
+        });
+        expect(message).toContain('Never open a pull request on remorses/kimaki unless remorses asked for one in a comment on the issue');
+    });
     test('includes callout guidance for important content', () => {
         const message = getOpencodeSystemMessage({
             sessionId: 'ses_123',
@@ -24,6 +38,24 @@ describe('system-message', () => {
         expect(message).toContain('- failed commands');
         expect(message).toContain('<callout accent="#f59e0b">');
     });
+    test('tells the model the sleep tool result is not a wake', () => {
+        const message = getOpencodeSystemMessage({
+            sessionId: 'ses_123',
+        });
+        expect(message).toContain('The tool result is not a wake');
+        expect(message).toContain('Woke after sleeping until');
+        expect(message).toContain('If you still need to wake later after answering, call `kimaki_sleep` again');
+        expect(message).not.toContain('After wake, continue the wait reason');
+    });
+    test('tells the model to stay quiet between tool calls', () => {
+        const message = getOpencodeSystemMessage({
+            sessionId: 'ses_123',
+        });
+        expect(message).toContain('## Discord output');
+        expect(message).toContain('Be concise');
+        expect(message).toContain('Do not narrate between tool calls');
+        expect(message).toContain('Do not output text until you are ready to give the user the final answer for this turn');
+    });
     test('requires interactive tools after all text, using exact tool names', () => {
         const message = getOpencodeSystemMessage({
             sessionId: 'ses_123',
@@ -33,6 +65,7 @@ describe('system-message', () => {
         expect(message).toContain('NEVER call `question` before your text');
         expect(message).toContain('`kimaki_action_buttons`');
         expect(message).toContain('`kimaki_file_upload`');
+        expect(message).toContain('`kimaki_sleep`');
     });
     test('persists and reads session system prompt for command path', async () => {
         const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-system-'));
@@ -67,6 +100,26 @@ describe('system-message', () => {
         await fs.promises.mkdir(filePath);
         await expect(readSessionSystemPrompt({ sessionId, dataDir })).rejects.toMatchObject({ code: 'EISDIR' });
     });
+    test('includes all-projects session search example', () => {
+        const message = getOpencodeSystemMessage({
+            sessionId: 'ses_123',
+            channelId: 'chan_123',
+        });
+        expect(message).toContain('kimaki session search "auth timeout" --all');
+        expect(message).toContain('kimaki session search "auth timeout" --days 0');
+        expect(message).toContain('Defaults to this project and the last 14 days. Use `--days 0` for all time. Use `--all` to search every locally registered project');
+    });
+    test('includes session title update guidance when scope or goal changed', () => {
+        const message = getOpencodeSystemMessage({
+            sessionId: 'ses_123',
+            threadId: 'thread_123',
+        });
+        expect(message).toContain('## updating the session title');
+        expect(message).toContain("kimaki session title 'Short title' --session ses_123");
+        expect(message).toContain('When the session scope or goal changed from the first message, update the title:');
+        expect(message).toContain('thread-name="..."');
+        expect(message).toContain('Do not retitle every turn');
+    });
     test('includes parent session context when parentSessionId is set', () => {
         const message = getOpencodeSystemMessage({
             sessionId: 'ses_child',
@@ -78,6 +131,64 @@ describe('system-message', () => {
         expect(message).toContain('Do NOT message the parent session unless the user explicitly asks you to.');
         expect(message).toContain('--parent-session ses_child');
     });
+    test('scheduled cron task section shows task id, cron and no-sleep rule', () => {
+        const message = getOpencodeSystemMessage({
+            sessionId: 'ses_task',
+            channelId: 'chan_123',
+            threadId: 'thread_123',
+            scheduledTask: {
+                taskId: 23,
+                scheduleKind: 'cron',
+                cronExpr: '0 6,14 * * *',
+                timezone: 'Europe/Rome',
+            },
+        });
+        expect(message).toContain('## scheduled task session');
+        expect(message).toContain('kimaki scheduled task #23');
+        expect(message).toContain('Schedule: cron `0 6,14 * * *` in Europe/Rome.');
+        expect(message).toContain('Do NOT use `kimaki_sleep` to wait for the next run');
+        expect(message).toContain('starts a fresh session automatically');
+        const section = message.slice(message.indexOf('## scheduled task session'), message.indexOf('## archiving the current thread'));
+        expect(section).not.toContain('archive');
+    });
+    test('cron task without timezone says UTC', () => {
+        const message = getOpencodeSystemMessage({
+            sessionId: 'ses_task_utc',
+            scheduledTask: { taskId: 7, scheduleKind: 'cron', cronExpr: '0 9 * * 1' },
+        });
+        expect(message).toContain('Schedule: cron `0 9 * * 1` in UTC.');
+    });
+    test('one-shot at task says it does not repeat and skips sleep', () => {
+        const message = getOpencodeSystemMessage({
+            sessionId: 'ses_oneshot',
+            scheduledTask: { scheduleKind: 'at' },
+        });
+        expect(message).toContain('## scheduled task session');
+        expect(message).toContain('a one-time kimaki scheduled task');
+        expect(message).toContain('This task runs once and does not repeat.');
+        expect(message).toContain('Do NOT use `kimaki_sleep` to wait for the next run');
+        expect(message).not.toContain('Schedule: cron');
+    });
+    test('no scheduled task section by default (normal sessions)', () => {
+        const message = getOpencodeSystemMessage({
+            sessionId: 'ses_normal',
+            channelId: 'chan_123',
+            threadId: 'thread_123',
+        });
+        expect(message).not.toContain('## scheduled task session');
+    });
+    test('lets agents omit --user for quiet scheduled work', () => {
+        const message = getOpencodeSystemMessage({
+            sessionId: 'ses_123',
+            channelId: 'chan_123',
+            threadId: 'thread_123',
+        });
+        expect(message).not.toContain('ALWAYS pass `--user` when scheduling a task.');
+        expect(message).not.toContain('(always pass this)');
+        expect(message).toContain("kimaki task edit <id> --user ''");
+        expect(message).toContain("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");
+        expect(message).not.toContain("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>'");
+    });
     test('omits parent session system block by default (btw/task/fork cache)', () => {
         // /btw, task subagents, and normal sessions must not get a parent block in
         // the system message. That block is opt-in via --parent-session only.
@@ -107,10 +218,17 @@ describe('system-message', () => {
             ],
         }).replace(/`[^`]*\/kimaki\.log`/, '`<data-dir>/kimaki.log`');
         expect(message).toContain('When pulling submodules and they jump to a new commit, commit that submodule pointer update right away before doing other work.');
+        expect(message).toContain('while kimaki session list --active --exclude ses_123; do sleep 5; done');
         expect(message).toMatchInlineSnapshot(`
       "
       The user is reading your messages from inside Discord, via kimaki.dev
 
+      ## Discord output
+
+      Be concise. Do not narrate between tool calls. Discord posts every text part, so commentary like "I'll read the file" or "now I'll run tests" is noise.
+      Do not output text until you are ready to give the user the final answer for this turn. Tool calls can run with no preceding text.
+      Exceptions: when a tool requires user-visible text first (\`question\`, \`kimaki_action_buttons\`, \`kimaki_file_upload\`, \`kimaki_sleep\`), write that required text, then call the tool.
+
       ## bash tool
 
       When calling the bash tool, always include these extra fields alongside \`command\`:
@@ -127,7 +245,7 @@ describe('system-message', () => {
       }
       \`\`\`
 
-      \`description\` is shown to the user in Discord as a summary of the bash call.
+      \`description\` is shown in Discord when the bash command is longer than 50 characters.
       \`hasSideEffect\` distinguishes essential bash calls from read-only ones in low-verbosity mode.
 
       Your current OpenCode session ID is: ses_123
@@ -135,7 +253,7 @@ describe('system-message', () => {
       Your current Discord thread ID is: thread_123
       Your current Discord guild ID is: guild_123
 
-      Per-turn Discord metadata like the current user and current agent is delivered in synthetic user message parts.
+      Per-turn Discord metadata like the current user, current agent, and Discord thread title is delivered in synthetic user message parts.
 
       ## permissions
 
@@ -158,6 +276,7 @@ describe('system-message', () => {
 
       ## debugging kimaki issues
 
+      ALWAYS read https://kimaki.dev/docs/guides/report-bugs first before submitting any issue to Kimaki. That page is the source of truth for exporting session jsonl, sharing evidence in a gist, and filing bugs. Never open a pull request on remorses/kimaki unless remorses asked for one in a comment on the issue.
       If there are internal kimaki issues (sessions not responding, bot errors, unexpected behavior), read the log file at \`<data-dir>/kimaki.log\`. This file contains detailed logs of all bot activity including session creation, event handling, errors, and API calls. The log file is reset every time the bot restarts, so it only contains logs from the current run.
 
       ## uploading files to discord
@@ -166,6 +285,8 @@ describe('system-message', () => {
 
       kimaki upload-to-discord --session ses_123 <file1> [file2] ...
 
+      NEVER show images with markdown like \`![alt](/tmp/file.png)\` or \`![alt](file://...)\`. Discord does not render local markdown images. ALWAYS upload them with \`kimaki upload-to-discord\` so they appear as real Discord attachments. Do this for every screenshot, generated image, and visual step the user should see.
+
       ## generating audio from text
 
       When the user asks you to generate audio of some text so they can listen instead of reading, use \`kimaki tts\` to create a speech file and \`kimaki upload-to-discord\` to send it to the thread. Only use this when the user explicitly asks for audio.
@@ -187,9 +308,18 @@ describe('system-message', () => {
       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.
 
+      ## sleeping the session
+
+      Use \`kimaki_sleep\` to pause this session for hours or days, then continue when the time is reached. The sleep is stored in SQLite and survives bot restarts.
+      Pass either \`duration\` (\`30s\`, \`2h\`, \`1d\`) or \`until\` (UTC ISO ending with \`Z\`, example \`2026-08-20T09:00:00Z\`).
+      You MUST call \`kimaki_sleep\` LAST, after ALL text. Do not call more tools after it.
+      A new user message cancels the sleep. If you still need to wake later after answering, call \`kimaki_sleep\` again with \`until\` set to the original UTC time.
+      The tool result is not a wake. After it succeeds, write one short line that you are waiting, then stop. Do not continue the wait reason and do not pretend time has passed.
+      Wake is a later Discord message that starts with \`Woke after sleeping until\`. Only then continue the wait reason.
+
       ## archiving the current thread
 
-      To archive the current Discord thread (hide it from sidebar) and stop the session, run:
+      To archive the current Discord thread (hide it from sidebar) without stopping the session, run:
 
       kimaki session archive thread_123 (or --session ses_123)
 
@@ -204,6 +334,17 @@ describe('system-message', () => {
       This stops the AI from processing but keeps the thread visible in Discord.
       Different from \`kimaki session archive\` which hides the thread.
 
+      ## updating the session title
+
+      When the session scope or goal changed from the first message, update the title:
+
+      kimaki session title 'Short title' --session ses_123
+
+      The current Discord thread title is in the per-turn \`<discord-user thread-name="..." />\` metadata.
+      This updates the OpenCode title. Discord follows automatically.
+      Do not retitle every turn. Discord rate-limits thread renames.
+      Keep titles short. Do not add emoji. Do not copy ⬦, btw:, or Fork: prefixes.
+
       ## discord user mentions
 
       Prefer Discord user IDs for mentions. Discord bots cannot ping by @name; use \`<@userId>\` in message text or pass the ID to \`--user\`.
@@ -304,13 +445,13 @@ describe('system-message', () => {
       Use \`--send-at\` to schedule a one-time or recurring task:
 
       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>'
+      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
 
       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.
+      Pass \`--user\` when the user should see or act on the thread. Omit \`--user\` for routine autonomous work (digests, monitors, housekeeping) so the thread does not appear in the user's Discord sidebar. Discord only shows a thread in the left sidebar to its members. Without \`--user\`, kimaki does not ensure anyone is a member. 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).
       When the user specifies a time without a timezone, ask them to confirm their timezone or the UTC equivalent. Never guess the user's timezone.
@@ -322,14 +463,14 @@ describe('system-message', () => {
       - \`--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)
+      - \`--user\` to add a specific user to the scheduled thread. Omit this for quiet autonomous work
 
       \`--wait\` is incompatible with \`--send-at\` because scheduled tasks run in the future.
 
       Keep scheduled task prompts **short**. The prompt text becomes the first message in the Discord thread, so long prompts clutter the channel. Instead of inlining the full task description in \`--prompt\`, write a markdown file in the project's \`tasks/\` folder and reference it:
 
       \`\`\`bash
-      kimaki send --channel chan_123 --prompt 'Read tasks/weekly-test-suite.md and follow instructions' --send-at '0 9 * * 1' --agent <current_agent> --parent-session ses_123 --user '<discord-user-id>'
+      kimaki send --channel chan_123 --prompt 'Read tasks/weekly-test-suite.md and follow instructions' --send-at '0 9 * * 1' --agent <current_agent> --parent-session ses_123
       \`\`\`
 
       The task file should contain all the detail: goal, constraints, expected output, completion criteria. Use this frontmatter format:
@@ -348,7 +489,7 @@ describe('system-message', () => {
       Notification strategy:
       - NEVER use \`@username\` (e.g. \`@Tommy\`) directly in task prompts. The prompt text becomes the first message in the thread, so a raw \`@\` mention triggers an actual Discord ping every time the task fires. Instead, wrap it in inline code like \`\\\`@Tommy\\\`\`, or use Discord user ID mentions like \`<@USER_ID>\` only in the body of the prompt where the agent will process it, not in the opening line.
       - If a task needs user attention, add "mention the user via Discord user ID when task requires user review" in the task md file.
-      - With \`--user\`, the user is added to the thread and receives thread-level notifications.
+      - With \`--user\`, the user is added to the thread and receives thread-level notifications. Omit \`--user\` when the work should stay out of the sidebar.
       - If a scheduled task completes with no actionable result, archive the session: \`kimaki session archive thread_123 (or --session ses_123)\`
 
       Manage scheduled tasks with:
@@ -357,7 +498,7 @@ describe('system-message', () => {
       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.
+      \`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. Add a user with \`kimaki task edit <id> --user '<discord-user-id>'\`. Clear a stored user with \`kimaki task edit <id> --user ''\`. 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.
 
       \`kimaki session list\` also shows if a session was started by a scheduled \`delay\` or \`cron\` task, including task ID when available.
 
@@ -435,15 +576,22 @@ describe('system-message', () => {
       kimaki session list
       kimaki session list --json  # machine-readable output
       kimaki session list --project /path/to/project  # specific project
+
+      # List only in-progress sessions. Exit status is 1 when none remain.
+      kimaki session list --active
       \`\`\`
 
-      To search past sessions for this project (supports plain text or /regex/flags):
+      Titles prefixed with \`btw:\` are side sessions that answer a related user question in parallel. They are not duplicate sessions of the main task.
+
+      To search past sessions (supports plain text or /regex/flags). Defaults to this project and the last 14 days. Use \`--days 0\` for all time. Use \`--all\` to search every locally registered project:
 
       \`\`\`bash
       kimaki session search "auth timeout"
+      kimaki session search "auth timeout" --days 0
       kimaki session search "/error\\s+42/i"
       kimaki session search "rate limit" --project /path/to/project
       kimaki session search "/panic|crash/i" --channel <channel_id>
+      kimaki session search "auth timeout" --all
       \`\`\`
 
       To read a session's full conversation as markdown, pipe to a file and grep it to avoid wasting context.
@@ -455,6 +603,29 @@ describe('system-message', () => {
 
       Then use grep/read tools on the file to find what you need.
 
+      ### who edited a file
+
+      To find the session that last edited a file, run:
+
+      \`\`\`bash
+      kimaki session editors src/foo.ts
+      kimaki session editors src/foo.ts --json
+      \`\`\`
+
+      Output is newest first. Each row has:
+
+      - **session ID** (\`ses_xxx\`)
+      - **title** (Discord thread name, so you can tell what that session was doing)
+      - **time ago** (when that session last edited the file)
+
+      Use this before a commit when this session did not edit the file. Put the original session ID as the last line of the commit message:
+
+      \`\`\`
+      Session: ses_xxx
+      \`\`\`
+
+      If this session edited the file, use this session ID instead. If several files come from different sessions, split the commit by session. Do not attribute another session's edits to this one.
+
       ## cross-project commands
 
       When the user references another project by name, run \`kimaki project list\` to find its directory path and channel ID. Then read files, search code, or run commands directly in that directory. If the project is not listed, use \`kimaki project add /path/to/repo\` to register it and create a Discord channel for it. Do not add subfolders of an existing project — only add root project directories.
@@ -521,7 +692,7 @@ describe('system-message', () => {
 
       When the user asks you to wait for an existing session, run \`kimaki session wait <session_id>\` yourself via Bash, then continue from the printed session markdown. Do not tell the user to run the command.
 
-      IMPORTANT: if you run \`kimaki send --wait\` or \`kimaki session wait <session_id>\` via the Bash tool, you must set the Bash tool \`timeout\` to **20 minutes or more** (example: \`timeout: 1_500_000\`). Otherwise the tool will terminate early (default is 2 minutes) and you won't see long sessions.
+      IMPORTANT: if you run \`kimaki send --wait\`, \`kimaki session wait <session_id>\`, or the active-session wait loop via the Bash tool, you must set the Bash tool \`timeout\` to **20 minutes or more** (example: \`timeout: 1_500_000\`). Otherwise the tool will terminate early (default is 2 minutes) and you won't see long sessions.
 
       If your Bash tool timeout triggers anyway, fall back to reading the session output from disk:
 
@@ -536,9 +707,14 @@ describe('system-message', () => {
 
       # Wait for a session that was already started elsewhere
       kimaki session wait <session_id>
+
+      # Wait until every other in-progress session in this project finishes
+      while kimaki session list --active --exclude ses_123; do sleep 5; done
       \`\`\`
 
-      The command exits with the session markdown on stdout once the model finishes responding.
+      \`session list --active\` exits with status 0 while it finds active sessions and status 1 when none remain. Exclude the current session in a wait loop so the loop does not wait for itself.
+
+      \`session wait\` exits with the session markdown on stdout once the model finishes responding.
 
       Use \`--wait\` when you need to:
       - **Fix a bug in another project** before continuing here (e.g. fix a dependency, then resume)
@@ -625,7 +801,7 @@ describe('system-message', () => {
 
       ## running dev servers with tunnel access
 
-      ALWAYS use \`kimaki tunnel\` when starting any dev server. NEVER run \`pnpm dev\`, \`npm run dev\`, or any dev server command without wrapping it in \`kimaki tunnel\`. Always invoke Kimaki directly as \`kimaki\`, never via \`npx\` or \`bunx\`. The user is on Discord, not at the terminal — localhost URLs are useless to them. They need a tunnel URL to access the site.
+      When starting a local dev server that the Discord user should open in a browser, prefer wrapping it in \`kimaki tunnel\` so they get a public URL. Localhost URLs are useless from Discord. Invoke Kimaki directly as \`kimaki\`, not via \`npx\` or \`bunx\`.
 
       Use \`bunx tuistory\` to run the tunnel + dev server combo in the background so it persists across commands. This is preferable to raw shell backgrounding because you can wait for real output, read logs, and interact with the running process.
 
@@ -803,7 +979,7 @@ describe('system-message', () => {
       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\`.
+      The same rule applies to \`kimaki_action_buttons\`, \`kimaki_file_upload\`, and \`kimaki_sleep\`.
       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.
@@ -831,6 +1007,7 @@ describe('system-message', () => {
             userId: 'user_123',
             sourceMessageId: 'msg_123',
             sourceThreadId: 'thread_123',
+            threadName: 'Fix auth bug',
             repliedMessage: {
                 authorUsername: 'alice',
                 text: 'Original replied message',
@@ -843,7 +1020,7 @@ describe('system-message', () => {
                 mainRepoDirectory: '/repo',
             },
         })).toMatchInlineSnapshot(`
-      "<discord-user name="Tommy" user-id="user_123" message-id="msg_123" thread-id="thread_123" />
+      "<discord-user name="Tommy" user-id="user_123" message-id="msg_123" thread-id="thread_123" thread-name="Fix auth bug" />
 
       This message was a reply to message
 

package/dist/task-runner.js

@@ -1,14 +1,15 @@
-// Scheduled task runner for executing due `send --send-at` jobs in the bot process.
-import { Routes } from 'discord.js';
+// Scheduled task runner for due `send --send-at` jobs and session sleep wakes.
+import { DiscordAPIError, Routes } from 'discord.js';
 import { createDiscordRest } from './discord-urls.js';
 import { ensureThreadMember } from './discord-utils.js';
 import YAML from 'yaml';
-import { claimScheduledTaskRunning, createScheduledTaskRun, failScheduledTaskRun, finishScheduledTaskRun, getDuePlannedScheduledTasks, getScheduledTask, getActiveScheduledTaskRuns, markScheduledTaskCronRescheduled, markScheduledTaskCronRetry, markScheduledTaskFailed, deleteScheduledTask, recoverStaleRunningScheduledTasks, releaseScheduledTaskClaim, setScheduledTaskRunThread, } from './database.js';
+import { claimScheduledTaskRunning, createScheduledTaskRun, failScheduledTaskRun, finishScheduledTaskRun, getDuePlannedScheduledTasks, getScheduledTask, getActiveScheduledTaskRuns, markScheduledTaskCronRescheduled, markScheduledTaskCronRetry, markScheduledTaskFailed, deleteScheduledTask, recoverStaleRunningScheduledTasks, releaseScheduledTaskClaim, setScheduledTaskRunThread, claimSessionSleepAttempt, getDueSessionSleeps, getThreadIdBySessionId, markSessionSleepFailed, } from './database.js';
 import { execAsync } from './exec-async.js';
+import { QUEUE_PREFIX } from './message-formatting.js';
 import { initializeOpencodeForDirectory } from './opencode.js';
 import { createLogger, formatErrorWithStack, LogPrefix } from './logger.js';
 import { notifyError } from './sentry.js';
-import { appendTaskCommandOutput, getNextCronRun, getPromptPreview, parseScheduledTaskPayload, } from './task-schedule.js';
+import { appendTaskCommandOutput, formatSessionSleepWakePrompt, 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;
@@ -46,7 +47,7 @@ async function executeThreadScheduledTask({ rest, task, payload, prompt, runId,
     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${prompt}`;
+    const prefixedPrompt = `${QUEUE_PREFIX}**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.
@@ -76,6 +77,95 @@ async function executeThreadScheduledTask({ rest, task, payload, prompt, runId,
         return postResult;
     return payload.threadId;
 }
+/** Wait before retrying a wake that ingress has not consumed yet. */
+const SLEEP_WAKE_RETRY_AFTER_MS = 30_000;
+const SLEEP_WAKE_MAX_ATTEMPTS = 5;
+export function buildSessionSleepWakeBody({ deliveryId, wakeAt, reason, }) {
+    const marker = {
+        start: true,
+        sleepWake: true,
+        sleepId: deliveryId,
+    };
+    return {
+        content: formatSessionSleepWakePrompt({ wakeAt, reason }),
+        embeds: [{ color: 0x2b2d31, footer: { text: YAML.stringify(marker) } }],
+        // Discord limits nonces to 25 characters. The full ID stays in the marker.
+        // A stable nonce deduplicates retries when a successful response is lost.
+        nonce: deliveryId.replaceAll('-', '').slice(0, 25),
+        enforce_nonce: true,
+    };
+}
+async function postSessionSleepWake({ rest, sleep, threadId, }) {
+    // `.then(() => null)` keeps the success type concrete. Returning the raw post
+    // value would widen the union to `unknown` and erase the failure shape.
+    return await rest
+        .post(Routes.channelMessages(threadId), {
+        body: buildSessionSleepWakeBody({
+            deliveryId: sleep.delivery_id,
+            wakeAt: sleep.wake_at,
+            reason: sleep.reason,
+        }),
+    })
+        .then(() => {
+        return null;
+    })
+        .catch((error) => {
+        // Only an unknown channel/message is genuinely unrecoverable. A 403 is
+        // often temporary (permissions revoked, thread locked) so it keeps
+        // retrying until the attempt budget runs out.
+        const permanent = error instanceof DiscordAPIError &&
+            error.status === 404;
+        return {
+            error: new Error(`Failed to post sleep wake for session ${sleep.session_id}`, { cause: error }),
+            permanent,
+        };
+    });
+}
+export async function wakeDueSessionSleeps({ rest, now = new Date(), limit = 20, }) {
+    const dueSleeps = await getDueSessionSleeps({
+        now,
+        retryAfterMs: SLEEP_WAKE_RETRY_AFTER_MS,
+        limit,
+    });
+    for (const sleep of dueSleeps) {
+        // Reserves an attempt but stays `planned`. The row only leaves `planned`
+        // when ingress consumes the wake, so dying anywhere below costs one retry
+        // delay instead of losing the wake.
+        const claimed = await claimSessionSleepAttempt({
+            sessionId: sleep.session_id,
+            deliveryId: sleep.delivery_id,
+            now,
+            retryAfterMs: SLEEP_WAKE_RETRY_AFTER_MS,
+        });
+        if (!claimed)
+            continue;
+        // Resolved now, not when the tool ran, so a session rebound by /resume
+        // wakes in the thread that currently owns it.
+        const threadId = await getThreadIdBySessionId(claimed.session_id);
+        if (!threadId) {
+            await markSessionSleepFailed({
+                sessionId: claimed.session_id,
+                deliveryId: claimed.delivery_id,
+            });
+            taskLogger.warn(`[task-runner] no thread owns session ${claimed.session_id}, dropping sleep wake`);
+            continue;
+        }
+        // A successful post changes nothing here on purpose: ingress owns the
+        // transition out of `planned` when the wake actually becomes a turn.
+        const postResult = await postSessionSleepWake({ rest, sleep: claimed, threadId });
+        if (!postResult)
+            continue;
+        const exhausted = claimed.attempts >= SLEEP_WAKE_MAX_ATTEMPTS;
+        if (postResult.permanent || exhausted) {
+            await markSessionSleepFailed({
+                sessionId: claimed.session_id,
+                deliveryId: claimed.delivery_id,
+            });
+        }
+        taskLogger.error(`[task-runner] ${formatErrorWithStack(postResult.error)}`);
+        void notifyError(postResult.error, 'Session sleep wake failed');
+    }
+}
 async function executeChannelScheduledTask({ rest, task, payload, prompt, runId, }) {
     const marker = payload.notifyOnly
         ? undefined
@@ -407,6 +497,7 @@ async function runTaskRunnerTick({ rest, staleRunningMs, dueBatchSize, }) {
         await previous;
         await processDueTask({ rest, task });
     }, Promise.resolve());
+    await wakeDueSessionSleeps({ rest });
 }
 export function startTaskRunner({ token, pollIntervalMs = 5_000, staleRunningMs = 120_000, dueBatchSize = 20, }) {
     const rest = createDiscordRest(token);

package/dist/task-schedule.js

@@ -1,6 +1,7 @@
-// Scheduled task parsing utilities for `send --send-at` and task runner execution.
+// Scheduled task parsing for `send --send-at`, plus kimaki_sleep wake/result text.
 import { CronExpressionParser } from 'cron-parser';
 import * as errore from 'errore';
+import { STATUS_PREFIX } from './message-formatting.js';
 const UTC_SEND_AT_DATE_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?Z$/;
 export function getLocalTimeZone() {
     const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
@@ -33,6 +34,75 @@ function parseUtcSendAtDate({ value, now, }) {
     }
     return runAt;
 }
+const SLEEP_DURATION_REGEX = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/i;
+const SLEEP_DURATION_MS = {
+    ms: 1,
+    s: 1000,
+    m: 60_000,
+    h: 3_600_000,
+    d: 86_400_000,
+};
+function parseUtcFutureDate({ value, now, field, }) {
+    if (!UTC_SEND_AT_DATE_REGEX.test(value)) {
+        return new Error(`${field} must be UTC ISO format ending with Z (example: 2026-08-20T09:00:00Z). Received: ${value}`);
+    }
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime())) {
+        return new Error(`Invalid UTC date for ${field}: ${value}`);
+    }
+    if (parsed.getTime() <= now.getTime()) {
+        return new Error(`${field} must be in the future (UTC): ${value}`);
+    }
+    return parsed;
+}
+export function parseSleepWakeAt({ duration, until, now, }) {
+    const trimmedDuration = duration?.trim() || '';
+    const trimmedUntil = until?.trim() || '';
+    if (trimmedDuration && trimmedUntil) {
+        return new Error('Pass either duration or until, not both');
+    }
+    if (!trimmedDuration && !trimmedUntil) {
+        return new Error('Pass duration or until');
+    }
+    if (trimmedUntil) {
+        return parseUtcFutureDate({
+            value: trimmedUntil,
+            now,
+            field: 'until',
+        });
+    }
+    const match = SLEEP_DURATION_REGEX.exec(trimmedDuration);
+    if (!match) {
+        return new Error(`Invalid duration: "${trimmedDuration}". Use a number plus ms, s, m, h, or d (example: 2h).`);
+    }
+    const amount = Number(match[1]);
+    const unit = match[2].toLowerCase();
+    if (!Number.isFinite(amount) || amount <= 0) {
+        return new Error('duration must be greater than 0');
+    }
+    return new Date(now.getTime() + amount * SLEEP_DURATION_MS[unit]);
+}
+export function formatSessionSleepWakeAt(wakeAt) {
+    return `${wakeAt.toISOString().slice(0, 16).replace('T', ' ')} UTC`;
+}
+export function formatSessionSleepWakePrompt({ wakeAt, reason, }) {
+    const until = formatSessionSleepWakeAt(wakeAt);
+    const reasonLine = reason?.trim() ? `\nReason: ${reason.trim()}` : '';
+    return `${STATUS_PREFIX}Woke after sleeping until ${until}${reasonLine}\nContinue the work you were waiting for.`;
+}
+// Tool result after persist. Keep "Sleeping until" first so e2e matchers still hit.
+// Do not say "woken" or "Woke after": models treat that as the wake turn.
+export function formatSessionSleepToolOutput({ wakeAt, reason, }) {
+    const until = formatSessionSleepWakeAt(wakeAt);
+    const reasonText = reason?.trim() ? ` Reason: ${reason.trim()}.` : '';
+    return [
+        `Sleeping until ${until}.${reasonText}`,
+        'This tool result is not a wake. Do not continue the waited work. Do not call more tools.',
+        'Reply with one short line that you are waiting until that time, then stop.',
+        'The real wake is a later Discord message that starts with "Woke after sleeping until". Only then continue the wait reason.',
+        'A new user message in this thread cancels the sleep. If you still need that later wake after answering, call kimaki_sleep again with until set to the same UTC time.',
+    ].join(' ');
+}
 export function parseSendAtValue({ value, now, timezone, }) {
     const trimmed = value.trim();
     if (!trimmed) {
@@ -106,6 +176,22 @@ export function getNextCronRun({ cronExpr, timezone, from, }) {
 export function serializeScheduledTaskPayload(payload) {
     return JSON.stringify(payload);
 }
+export function applyScheduledTaskUserEdit({ payload, userOption, resolvedUser, }) {
+    if (!userOption.trim()) {
+        return {
+            ...payload,
+            userId: null,
+            username: null,
+        };
+    }
+    if (!resolvedUser)
+        return payload;
+    return {
+        ...payload,
+        userId: resolvedUser.id,
+        username: resolvedUser.username || null,
+    };
+}
 export function appendTaskCommandOutput({ prompt, stdout, }) {
     const output = stdout.trim();
     if (!output)