kimaki 0.22.0 → 0.23.0

package/dist/opencode.js

@@ -22,7 +22,7 @@ import readline from 'node:readline';
 import { fileURLToPath } from 'node:url';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 import { createOpencodeClient, } from '@opencode-ai/sdk/v2';
-import { restartGlobalEventListener } from './session-handler/global-event-listener.js';
+import { restartGlobalEventListener, waitForGlobalEventListener, } from './session-handler/global-event-listener.js';
 import { getDataDir, getLockPort, } from './config.js';
 import { store } from './store.js';
 import { getHranaUrl } from './hrana-server.js';
@@ -195,6 +195,10 @@ function killSingleServerProcessNow({ reason, }) {
     if (!singleServer) {
         return;
     }
+    // Never kill a server we didn't spawn (discovered from another process)
+    if (singleServer.discovered || !singleServer.process) {
+        return;
+    }
     const serverProcess = singleServer.process;
     const pid = serverProcess.pid;
     if (!pid || serverProcess.killed) {
@@ -375,16 +379,70 @@ function ensureOpencodeHomeDirectories({ directories, }) {
         fs.mkdirSync(directory, { recursive: true });
     });
 }
+/**
+ * Try to discover an OpenCode server already running in the bot process.
+ * Queries the hrana server on the lock port for the OpenCode server port,
+ * then verifies the server is healthy. Returns null if no server found.
+ */
+async function discoverExistingServer() {
+    const lockPort = getLockPort();
+    try {
+        const portResponse = await requestHealthcheck({
+            url: `http://127.0.0.1:${lockPort}/kimaki/opencode-port`,
+            timeoutMs: 2000,
+        });
+        if (portResponse.status !== 200) {
+            return null;
+        }
+        const parsed = JSON.parse(portResponse.body);
+        const port = parsed?.port;
+        if (typeof port !== 'number') {
+            return null;
+        }
+        // Verify the OpenCode server is actually healthy
+        const healthResponse = await requestHealthcheck({
+            url: `http://127.0.0.1:${port}/api/health`,
+            timeoutMs: 2000,
+        });
+        if (healthResponse.status >= 500) {
+            return null;
+        }
+        opencodeLogger.log(`Discovered existing OpenCode server on port ${port} via hrana lock port ${lockPort}`);
+        return {
+            process: null,
+            port,
+            baseUrl: `http://127.0.0.1:${port}`,
+            discovered: true,
+        };
+    }
+    catch {
+        // Connection refused or other network error — no bot running
+        return null;
+    }
+}
 async function ensureSingleServer({ directory, } = {}) {
     const startupDirectory = directory || preferredStartupDirectory || undefined;
-    if (singleServer && !singleServer.process.killed) {
+    if (singleServer && !singleServer.process?.killed) {
         return singleServer;
     }
-    // Deduplicate concurrent startup attempts
+    // Deduplicate concurrent startup attempts (covers both discovery and spawn)
     if (startingServer) {
         return startingServer;
     }
-    startingServer = startSingleServer({ directory: startupDirectory });
+    // Wrap discovery + spawn in a single shared promise so concurrent callers
+    // don't each run discoverExistingServer() and then each spawn a server.
+    startingServer = (async () => {
+        // Try to discover an already-running server from the bot process via
+        // the hrana server's /kimaki/opencode-port endpoint. This lets CLI
+        // subcommands (kimaki session list, archive, wait, etc.) reuse the
+        // bot's OpenCode server instead of spawning a redundant one.
+        const discovered = await discoverExistingServer();
+        if (discovered) {
+            singleServer = discovered;
+            return discovered;
+        }
+        return startSingleServer({ directory: startupDirectory });
+    })();
     try {
         return await startingServer;
     }
@@ -579,6 +637,7 @@ async function startSingleServer({ directory, } = {}) {
             OPENCODE_PORT: port.toString(),
             KIMAKI: '1',
             OPENCODE_EXPERIMENTAL_WORKSPACES: 'true',
+            OPENCODE_ENABLE_EXA: '1',
             KIMAKI_DATA_DIR: getDataDir(),
             KIMAKI_LOCK_PORT: getLockPort().toString(),
             KIMAKI_PARENT_LOCK_PORT: getLockPort().toString(),
@@ -991,6 +1050,14 @@ export async function stopOpencodeServer() {
         return false;
     }
     const server = singleServer;
+    // For discovered servers (from another process), just clear local state
+    // without killing the process we don't own.
+    if (server.discovered || !server.process) {
+        singleServer = null;
+        clientCache.clear();
+        serverRetryCount = 0;
+        return true;
+    }
     opencodeLogger.log(`Stopping opencode server (pid: ${server.process.pid}, port: ${server.port})`);
     if (!server.process.killed) {
         const killResult = errore.try(() => {
@@ -1032,5 +1099,7 @@ export async function restartOpencodeServer() {
     const result = await ensureSingleServer();
     if (result instanceof Error)
         return result;
+    restartGlobalEventListener();
+    await waitForGlobalEventListener();
     return true;
 }

package/dist/schema.js

@@ -59,6 +59,9 @@ export const channel_directories = sqliteCore.sqliteTable('channel_directories',
     channel_id: sqliteCore.text('channel_id').primaryKey().notNull(),
     directory: sqliteCore.text('directory').notNull(),
     channel_type: sqliteCore.text('channel_type', { enum: ['text', 'voice'] }).notNull(),
+    // Guild that owns this channel. Used to scope the default-channel tombstone
+    // check so multi-guild setups don't cross-block each other.
+    guild_id: sqliteCore.text('guild_id'),
     created_at: datetime('created_at').default(orm.sql `CURRENT_TIMESTAMP`),
 });
 export const bot_api_keys = sqliteCore.sqliteTable('bot_api_keys', {

package/dist/session-handler/global-event-listener.js

@@ -18,14 +18,26 @@ function isAbortError(err) {
         return true;
     return false;
 }
-function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+function delay(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal.aborted) {
+            resolve();
+            return;
+        }
+        const timeout = setTimeout(resolve, ms);
+        signal.addEventListener('abort', () => {
+            clearTimeout(timeout);
+            resolve();
+        }, { once: true });
+    });
 }
 // ── State ──────────────────────────────────────────────────────
 const callbacks = new Map();
 let loopRunning = false;
 let disposed = false;
 let controller = null;
+let connected = false;
+const connectionWaiters = new Set();
 // ── Public API ─────────────────────────────────────────────────
 /**
  * Register a thread runtime to receive global events. Every event from the
@@ -53,6 +65,7 @@ export function unregisterEventListener(threadId) {
 export function disposeGlobalEventListener() {
     disposed = true;
     loopRunning = false;
+    connected = false;
     controller?.abort();
     controller = null;
     callbacks.clear();
@@ -64,8 +77,18 @@ export function disposeGlobalEventListener() {
 export function restartGlobalEventListener() {
     if (disposed)
         return;
+    connected = false;
     controller?.abort();
 }
+/** Wait until the event stream is connected before starting event-producing work. */
+export function waitForGlobalEventListener() {
+    if (callbacks.size === 0 || connected)
+        return Promise.resolve();
+    ensureListenerRunning();
+    return new Promise((resolve) => {
+        connectionWaiters.add(resolve);
+    });
+}
 // ── Internals ──────────────────────────────────────────────────
 // Lazy subscription to opencode server lifecycle. Deferred to avoid
 // circular import: global-event-listener imports opencode.ts which
@@ -128,7 +151,7 @@ async function runEventLoop() {
                 return;
             }
             logger.warn(`[GLOBAL LISTENER] No OpenCode server available, retrying in ${backoffMs}ms`);
-            await delay(backoffMs);
+            await delay(backoffMs, signal);
             backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
             continue;
         }
@@ -143,11 +166,15 @@ async function runEventLoop() {
                 continue;
             }
             logger.warn(`[GLOBAL LISTENER] Subscribe failed, retrying in ${backoffMs}ms:`, subscribeResult.message);
-            await delay(backoffMs);
+            await delay(backoffMs, signal);
             backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
             continue;
         }
         const events = subscribeResult.stream;
+        connected = true;
+        for (const resolve of connectionWaiters)
+            resolve();
+        connectionWaiters.clear();
         logger.log('[GLOBAL LISTENER] Connected to global event stream');
         let receivedAnyEvent = false;
         const iterResult = await (async () => {
@@ -157,6 +184,7 @@ async function runEventLoop() {
             }
         })()
             .catch((e) => new OpenCodeSdkError({ operation: 'event.iterate', cause: e }));
+        connected = false;
         if (receivedAnyEvent) {
             backoffMs = 500;
         }
@@ -168,12 +196,16 @@ async function runEventLoop() {
                 continue;
             }
             logger.warn(`[GLOBAL LISTENER] Stream broke, reconnecting in ${backoffMs}ms:`, iterResult.message);
-            await delay(backoffMs);
+            await delay(backoffMs, signal);
             backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
         }
         else {
+            if (signal.aborted) {
+                backoffMs = 500;
+                continue;
+            }
             logger.log(`[GLOBAL LISTENER] Stream ended normally, reconnecting in ${backoffMs}ms`);
-            await delay(backoffMs);
+            await delay(backoffMs, signal);
             backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
         }
     }

package/dist/session-handler/thread-runtime-state.js

@@ -110,7 +110,9 @@ export function dequeueItem(threadId) {
     return next;
 }
 export function clearQueueItems(threadId) {
+    const items = store.getState().threads.get(threadId)?.queueItems.slice() ?? [];
     updateThread(threadId, (t) => ({ ...t, queueItems: [] }));
+    return items;
 }
 export function removeQueueItemAtPosition(threadId, position) {
     if (position < 1) {

package/dist/session-handler/thread-session-runtime.js

@@ -13,7 +13,7 @@ import * as errore from 'errore';
 import * as threadState from './thread-runtime-state.js';
 import { getOpencodeClient, initializeOpencodeForDirectory, buildSessionPermissions, parsePermissionRules, writeInjectionGuardConfig, extractSdkErrorMessage, } from '../opencode.js';
 import { isAbortError } from '../utils.js';
-import { registerEventListener, unregisterEventListener, } from './global-event-listener.js';
+import { registerEventListener, unregisterEventListener, waitForGlobalEventListener, } from './global-event-listener.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { sendThreadMessage, SILENT_MESSAGE_FLAGS, NOTIFY_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { formatPart } from '../message-formatting.js';
@@ -1663,6 +1663,20 @@ export class ThreadSessionRuntime {
             force: true,
             repulseTyping: false,
         });
+        // Skip footer if model produced no visible output (no text, no tool calls,
+        // just step-start/step-finish lifecycle parts). This happens when the model
+        // decides not to respond.
+        const hasVisibleOutput = assistantMessageIds.some((msgId) => {
+            const parts = this.getBufferedParts(msgId);
+            return parts.some((part) => part.type !== 'step-start' && part.type !== 'step-finish');
+        });
+        if (!hasVisibleOutput) {
+            this.stopTyping();
+            this.resetPerRunState();
+            this.clearBufferedPartsForMessages(assistantMessageIds);
+            logger.log(`[ASSISTANT COMPLETED] no visible output, skipping footer for message ${completedMessageId} sessionId=${sessionId}`);
+            return;
+        }
         this.stopTyping();
         const turnStartTime = getCurrentTurnStartTime({
             events: this.eventBuffer,
@@ -2281,6 +2295,7 @@ export class ThreadSessionRuntime {
                 ...variantField,
                 ...(input.noReply ? { noReply: true } : {}),
             };
+            await waitForGlobalEventListener();
             const promptResult = await getClient().session.promptAsync(request)
                 .catch((e) => new OpenCodeSdkError({ operation: 'session.promptAsync', cause: e }));
             if (promptResult instanceof Error || promptResult.error) {
@@ -2591,9 +2606,9 @@ export class ThreadSessionRuntime {
             ? SILENT_MESSAGE_FLAGS
             : NOTIFY_MESSAGE_FLAGS;
     }
-    /** Clear all queued messages. */
+    /** Clear all queued messages. Returns the removed items. */
     clearQueue() {
-        threadState.clearQueueItems(this.threadId);
+        return threadState.clearQueueItems(this.threadId);
     }
     /** Remove a queued message by its 1-based position. */
     removeQueuePosition(position) {
@@ -2987,6 +3002,7 @@ export class ThreadSessionRuntime {
             logger.log(`[DISPATCH] Successfully ran command for session ${session.id}`);
             return;
         }
+        await waitForGlobalEventListener();
         const promptResponse = await getClient().session.promptAsync({
             sessionID: session.id,
             directory: this.sdkDirectory,

package/dist/system-message.js

@@ -211,7 +211,7 @@ ${escapePromptText(repliedMessage.text)}
             : []),
         ...(worktree && worktreeChanged
             ? [
-                `<system-reminder>\nThis session is running inside a git worktree. The working directory (cwd / pwd) has changed. The user expects you to edit files in the new cwd. You MUST operate inside the new worktree from now on.\n- New worktree path (new cwd / pwd, edit files here): ${worktree.worktreeDirectory}\n- Branch: ${worktree.branch}\n- Main repo path (previous folder, DO NOT TOUCH): ${worktree.mainRepoDirectory}\n- To find the base branch (the branch this worktree was created from): \`git -C ${worktree.mainRepoDirectory} symbolic-ref --short HEAD\`\n- To find the base commit (the commit this worktree diverged from): \`git merge-base <base-branch> HEAD\`\nYou MUST read, write, and edit files only under the new worktree path ${worktree.worktreeDirectory}. You MUST NOT read, write, or edit any files under the main repo path ${worktree.mainRepoDirectory} — even though it is the same project, that folder is a separate checkout and the user or another agent may be actively working there, so writing to it would override their unrelated changes. Run all checks (tests, builds, lint) inside the new worktree. Do not create another worktree by default. Ask before merging changes back to the main branch.\n</system-reminder>`,
+                `<system-reminder>\nThis session is running inside a git worktree. The working directory (cwd / pwd) has changed. The user expects you to edit files in the new cwd. You MUST operate inside the new worktree from now on.\n- New worktree path (new cwd / pwd, edit files here): ${worktree.worktreeDirectory}\n- Branch: ${worktree.branch}\n- Main repo path (previous folder, DO NOT TOUCH): ${worktree.mainRepoDirectory}\n- To find the base branch (the branch this worktree was created from): \`git -C ${worktree.mainRepoDirectory} symbolic-ref --short HEAD\`\n- To find the base commit (the commit this worktree diverged from): \`git merge-base <base-branch> HEAD\`\nYou MUST read, write, and edit files only under the new worktree path ${worktree.worktreeDirectory}. You MUST NOT read, write, or edit any files under the main repo path ${worktree.mainRepoDirectory} — even though it is the same project, that folder is a separate checkout and the user or another agent may be actively working there, so writing to it would override their unrelated changes. Run all checks (tests, builds, lint) inside the new worktree. Do not create another worktree by default. To merge this worktree into the main branch, run \`kimaki merge-worktree\`. If it reports rebase conflicts, resolve them and rerun until it succeeds.\n</system-reminder>`,
             ]
             : []),
     ];
@@ -447,18 +447,30 @@ When the user specifies a time without a timezone, ask them to confirm their tim
 
 \`--wait\` is incompatible with \`--send-at\` because scheduled tasks run in the future.
 
-For scheduled tasks, use long and detailed prompts with goal, constraints, expected output format, and explicit completion criteria.
+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:
 
-Notification prompts must be very detailed. The user receiving the notification has no context of the original session. Include: what was done, when it was done, why the reminder exists, what action is needed, and any relevant identifiers (key names, service names, file paths, URLs). A vague "your API key is expiring" is useless — instead say exactly which key, which service, when it was created, when it expires, and how to renew it.
+\`\`\`bash
+kimaki send --channel ${channelId} --prompt 'Read tasks/weekly-test-suite.md and follow instructions' --send-at '0 9 * * 1' --agent <current_agent>${parentSessionArg}${userArg}
+\`\`\`
+
+The task file should contain all the detail: goal, constraints, expected output, completion criteria. Use this frontmatter format:
+
+\`\`\`yaml
+---
+title: Weekly test suite
+description: >
+  Managed by kimaki scheduled task. Do not move or delete this file
+  without also updating the kimaki task (kimaki task list / kimaki task edit).
+---
+\`\`\`
+
+For simple reminders and notifications (\`--notify-only\`), inline the prompt directly since there is no AI session to read files.
 
-Notification strategy for scheduled tasks:
+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.
-- Prefer selective mentions in the prompt instead of relying on broad thread notifications.
-- If a task needs user attention, include this instruction in the prompt: "mention the user via Discord user ID when task requires user review or notification".
-- Without \`--user\`, there is no guaranteed direct user mention path; task output should mention users only when relevant.
-- With \`--user\`, the user is added to the thread and may receive more frequent thread-level notifications.
-- If a scheduled task completes with no actionable result and no user-visible change, prefer archiving the session after the final message so Discord does not keep a no-op thread highlighted.
-- Example no-op cleanup command: \`kimaki session archive ${archiveTarget}\`
+- 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.
+- If a scheduled task completes with no actionable result, archive the session: \`kimaki session archive ${archiveTarget}\`
 
 Manage scheduled tasks with:
 
@@ -468,20 +480,22 @@ kimaki task delete <id>
 
 \`kimaki session list\` also shows if a session was started by a scheduled \`delay\` or \`cron\` task, including task ID when available.
 
+**Never duplicate tasks to run more frequently.** If a task should run twice a day (morning and evening), edit the existing task's cron expression instead of creating a second task. Cron supports comma-separated hours:
+
+\`\`\`bash
+# runs at 9:00 UTC and 18:00 UTC every day
+kimaki task edit <id> --send-at '0 9,18 * * *'
+\`\`\`
+
 Use case patterns:
-- Reminder flows: create deadline reminders in this channel with one-time \`--send-at\`; mention only if action is required.
-- Proactive reminders: when you encounter time-sensitive information during your work (e.g. creating an API key that expires in 90 days, a certificate with an expiration date, a trial period ending, a deadline mentioned in code comments), proactively schedule a \`--notify-only\` reminder before the expiration so the user gets notified in time. For example, if you generate an API key expiring on 2026-06-01, schedule a reminder a few days before: \`kimaki send --channel ${channelId} --prompt 'Reminder: <@USER_ID> the API key created on 2026-03-01 expires on 2026-06-01. Renew it before it breaks production.' --send-at '2026-05-28T09:00:00Z' --notify-only --agent <current_agent>\`. Always tell the user you scheduled the reminder so they know.
-- Weekly QA: schedule "run full test suite, inspect failures, post summary, and mention the user via Discord ID only when failures require review".
-- Weekly benchmark automation: schedule a benchmark prompt that runs model evals, writes JSON outputs in the repo, commits results, and mentions only for regressions.
-- Recurring maintenance: use cron \`--send-at\` for repetitive tasks like rotating secrets, checking dependency updates, running security audits, or cleaning up stale branches. Example: \`--send-at "0 9 1 * *"\` to run on the 1st of every month.
-- Quiet no-op checks: if a recurring task checks something and finds nothing to report, let it post a brief final summary and then archive the session with \`kimaki session archive ${archiveTarget}\`. Example: a scheduled email triage run that finds no new emails should archive itself so it does not add noise to Discord.
-- Thread reminders: when the user says "remind me about this in 2 hours" (or any duration), use \`--send-at\` with \`--thread\` to resurface the current thread. Compute the future UTC time and send a mention so Discord shows a notification:
+- Reminder flows: create deadline reminders with one-time \`--send-at\` and \`--notify-only\`; mention only if action is required.
+- Proactive reminders: when you encounter time-sensitive information (API key expiration, certificate renewal, trial ending), schedule a \`--notify-only\` reminder before the deadline. Always tell the user you scheduled the reminder so they know.
+- Weekly QA / recurring maintenance: write the full task spec in \`tasks/\` and schedule a short prompt pointing to it.
+- Thread reminders: when the user says "remind me about this in 2 hours", use \`--send-at\` with \`--thread\` to resurface the current thread:
 
 kimaki send ${sendToSelfTarget} --prompt 'Reminder: <@USER_ID> you asked to be reminded about this thread.' --send-at '<future_UTC_time>' --notify-only --agent <current_agent>
 
-Replace \`<future_UTC_time>\` with the computed UTC ISO timestamp. The \`--notify-only\` flag creates just a notification message without starting a new AI session. The \`<@userId>\` mention ensures the user gets a Discord notification.
-
-Scheduled tasks can maintain project memory by reading and updating an md file in the repository (for example \`docs/automation-notes.md\`) on each run.
+Replace \`<future_UTC_time>\` with the computed UTC ISO timestamp.
 
 Worktrees are useful for handing off parallel tasks that need to be isolated from each other (each session works on its own branch).
 

package/dist/system-message.test.js

@@ -264,18 +264,30 @@ describe('system-message', () => {
 
       \`--wait\` is incompatible with \`--send-at\` because scheduled tasks run in the future.
 
-      For scheduled tasks, use long and detailed prompts with goal, constraints, expected output format, and explicit completion criteria.
+      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:
 
-      Notification prompts must be very detailed. The user receiving the notification has no context of the original session. Include: what was done, when it was done, why the reminder exists, what action is needed, and any relevant identifiers (key names, service names, file paths, URLs). A vague "your API key is expiring" is useless — instead say exactly which key, which service, when it was created, when it expires, and how to renew 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>'
+      \`\`\`
+
+      The task file should contain all the detail: goal, constraints, expected output, completion criteria. Use this frontmatter format:
+
+      \`\`\`yaml
+      ---
+      title: Weekly test suite
+      description: >
+        Managed by kimaki scheduled task. Do not move or delete this file
+        without also updating the kimaki task (kimaki task list / kimaki task edit).
+      ---
+      \`\`\`
+
+      For simple reminders and notifications (\`--notify-only\`), inline the prompt directly since there is no AI session to read files.
 
-      Notification strategy for scheduled tasks:
+      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.
-      - Prefer selective mentions in the prompt instead of relying on broad thread notifications.
-      - If a task needs user attention, include this instruction in the prompt: "mention the user via Discord user ID when task requires user review or notification".
-      - Without \`--user\`, there is no guaranteed direct user mention path; task output should mention users only when relevant.
-      - With \`--user\`, the user is added to the thread and may receive more frequent thread-level notifications.
-      - If a scheduled task completes with no actionable result and no user-visible change, prefer archiving the session after the final message so Discord does not keep a no-op thread highlighted.
-      - Example no-op cleanup command: \`kimaki session archive thread_123 (or --session ses_123)\`
+      - 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.
+      - 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:
 
@@ -285,20 +297,22 @@ describe('system-message', () => {
 
       \`kimaki session list\` also shows if a session was started by a scheduled \`delay\` or \`cron\` task, including task ID when available.
 
+      **Never duplicate tasks to run more frequently.** If a task should run twice a day (morning and evening), edit the existing task's cron expression instead of creating a second task. Cron supports comma-separated hours:
+
+      \`\`\`bash
+      # runs at 9:00 UTC and 18:00 UTC every day
+      kimaki task edit <id> --send-at '0 9,18 * * *'
+      \`\`\`
+
       Use case patterns:
-      - Reminder flows: create deadline reminders in this channel with one-time \`--send-at\`; mention only if action is required.
-      - Proactive reminders: when you encounter time-sensitive information during your work (e.g. creating an API key that expires in 90 days, a certificate with an expiration date, a trial period ending, a deadline mentioned in code comments), proactively schedule a \`--notify-only\` reminder before the expiration so the user gets notified in time. For example, if you generate an API key expiring on 2026-06-01, schedule a reminder a few days before: \`kimaki send --channel chan_123 --prompt 'Reminder: <@USER_ID> the API key created on 2026-03-01 expires on 2026-06-01. Renew it before it breaks production.' --send-at '2026-05-28T09:00:00Z' --notify-only --agent <current_agent>\`. Always tell the user you scheduled the reminder so they know.
-      - Weekly QA: schedule "run full test suite, inspect failures, post summary, and mention the user via Discord ID only when failures require review".
-      - Weekly benchmark automation: schedule a benchmark prompt that runs model evals, writes JSON outputs in the repo, commits results, and mentions only for regressions.
-      - Recurring maintenance: use cron \`--send-at\` for repetitive tasks like rotating secrets, checking dependency updates, running security audits, or cleaning up stale branches. Example: \`--send-at "0 9 1 * *"\` to run on the 1st of every month.
-      - Quiet no-op checks: if a recurring task checks something and finds nothing to report, let it post a brief final summary and then archive the session with \`kimaki session archive thread_123 (or --session ses_123)\`. Example: a scheduled email triage run that finds no new emails should archive itself so it does not add noise to Discord.
-      - Thread reminders: when the user says "remind me about this in 2 hours" (or any duration), use \`--send-at\` with \`--thread\` to resurface the current thread. Compute the future UTC time and send a mention so Discord shows a notification:
+      - Reminder flows: create deadline reminders with one-time \`--send-at\` and \`--notify-only\`; mention only if action is required.
+      - Proactive reminders: when you encounter time-sensitive information (API key expiration, certificate renewal, trial ending), schedule a \`--notify-only\` reminder before the deadline. Always tell the user you scheduled the reminder so they know.
+      - Weekly QA / recurring maintenance: write the full task spec in \`tasks/\` and schedule a short prompt pointing to it.
+      - Thread reminders: when the user says "remind me about this in 2 hours", use \`--send-at\` with \`--thread\` to resurface the current thread:
 
       kimaki send --thread thread_123 (or --session ses_123) --prompt 'Reminder: <@USER_ID> you asked to be reminded about this thread.' --send-at '<future_UTC_time>' --notify-only --agent <current_agent>
 
-      Replace \`<future_UTC_time>\` with the computed UTC ISO timestamp. The \`--notify-only\` flag creates just a notification message without starting a new AI session. The \`<@userId>\` mention ensures the user gets a Discord notification.
-
-      Scheduled tasks can maintain project memory by reading and updating an md file in the repository (for example \`docs/automation-notes.md\`) on each run.
+      Replace \`<future_UTC_time>\` with the computed UTC ISO timestamp.
 
       Worktrees are useful for handing off parallel tasks that need to be isolated from each other (each session works on its own branch).
 
@@ -777,7 +791,7 @@ describe('system-message', () => {
       - Main repo path (previous folder, DO NOT TOUCH): /repo
       - To find the base branch (the branch this worktree was created from): \`git -C /repo symbolic-ref --short HEAD\`
       - To find the base commit (the commit this worktree diverged from): \`git merge-base <base-branch> HEAD\`
-      You MUST read, write, and edit files only under the new worktree path /repo/.worktrees/prompt-cache. You MUST NOT read, write, or edit any files under the main repo path /repo — even though it is the same project, that folder is a separate checkout and the user or another agent may be actively working there, so writing to it would override their unrelated changes. Run all checks (tests, builds, lint) inside the new worktree. Do not create another worktree by default. Ask before merging changes back to the main branch.
+      You MUST read, write, and edit files only under the new worktree path /repo/.worktrees/prompt-cache. You MUST NOT read, write, or edit any files under the main repo path /repo — even though it is the same project, that folder is a separate checkout and the user or another agent may be actively working there, so writing to it would override their unrelated changes. Run all checks (tests, builds, lint) inside the new worktree. Do not create another worktree by default. To merge this worktree into the main branch, run \`kimaki merge-worktree\`. If it reports rebase conflicts, resolve them and rerun until it succeeds.
       </system-reminder>
       "
     `);

package/dist/task-runner.js

@@ -2,7 +2,7 @@
 import { Routes } from 'discord.js';
 import { createDiscordRest } from './discord-urls.js';
 import YAML from 'yaml';
-import { claimScheduledTaskRunning, getDuePlannedScheduledTasks, getScheduledTask, markScheduledTaskCronRescheduled, markScheduledTaskCronRetry, markScheduledTaskFailed, markScheduledTaskOneShotCompleted, recoverStaleRunningScheduledTasks, } from './database.js';
+import { claimScheduledTaskRunning, getDuePlannedScheduledTasks, getScheduledTask, markScheduledTaskCronRescheduled, markScheduledTaskCronRetry, markScheduledTaskFailed, deleteScheduledTask, recoverStaleRunningScheduledTasks, } from './database.js';
 import { createLogger, formatErrorWithStack, LogPrefix } from './logger.js';
 import { notifyError } from './sentry.js';
 import { getNextCronRun, getPromptPreview, parseScheduledTaskPayload, } from './task-schedule.js';
@@ -23,7 +23,10 @@ async function executeThreadScheduledTask({ rest, task, payload, }) {
     const marker = {
         start: true,
         scheduledKind: task.schedule_kind,
-        scheduledTaskId: task.id,
+        // Only include scheduledTaskId for cron tasks. One-shot tasks are deleted
+        // 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 } : {}),
         ...(payload.agent ? { agent: payload.agent } : {}),
         ...(payload.model ? { model: payload.model } : {}),
         ...(payload.username ? { username: payload.username } : {}),
@@ -59,7 +62,8 @@ async function executeChannelScheduledTask({ rest, task, payload, }) {
         : {
             start: true,
             scheduledKind: task.schedule_kind,
-            scheduledTaskId: task.id,
+            // Only include scheduledTaskId for cron tasks (see thread variant comment)
+            ...(task.schedule_kind === 'cron' ? { scheduledTaskId: task.id } : {}),
             ...(payload.worktreeName ? { worktree: payload.worktreeName } : {}),
             ...(payload.cwd ? { cwd: payload.cwd } : {}),
             ...(payload.agent ? { agent: payload.agent } : {}),
@@ -149,7 +153,7 @@ async function executeScheduledTask({ rest, task, }) {
 }
 async function finalizeSuccessfulTask({ task, completedAt, }) {
     if (task.schedule_kind === 'at') {
-        await markScheduledTaskOneShotCompleted({ taskId: task.id, completedAt });
+        await deleteScheduledTask(task.id);
         return;
     }
     if (!task.cron_expr) {

package/dist/worktree-lifecycle.e2e.test.js

@@ -36,6 +36,7 @@ function normalizeWorktreeLifecycleText(text) {
         .replaceAll(CHANNEL_WORKTREE_NAME, 'CHANNEL_WORKTREE_NAME')
         .replaceAll(AUTO_WORKTREE_SUFFIX, 'AUTO_WORKTREE_NAME')
         .replaceAll(WORKTREE_NAME, 'WORKTREE_NAME')
+        .replace(/opencode\/kimaki-rply-wth-exctly-snd-at-wt-[a-z0-9]+/g, 'AUTO_WORKTREE_BRANCH')
         .replaceAll(WORKTREE_SUFFIX, 'SUFFIX')
         .replace(/ses_[a-zA-Z0-9]+/g, 'ses_TEST')
         .replace(/<#\d+>/g, '<#THREAD_ID>')
@@ -350,11 +351,24 @@ describe('worktree lifecycle', () => {
         expect(sourceSessionAfterFork).toBe(sessionBefore);
         const worktreeSession = await getThreadSession(worktreeThread.id);
         expect(worktreeSession).toBeTruthy();
+        if (!worktreeSession)
+            throw new Error('Worktree session was not persisted');
         expect(worktreeSession).not.toBe(sessionBefore);
         await expect(getThreadWorktreeOrWorkspace(thread.id)).resolves.toBeUndefined();
         const worktreeInfo = await getThreadWorktreeOrWorkspace(worktreeThread.id);
         expect(worktreeInfo?.status).toBe('ready');
         expect(worktreeInfo?.workspace_directory).toContain(WORKTREE_NAME);
+        const worktreeDirectory = worktreeInfo?.workspace_directory;
+        if (!worktreeDirectory)
+            throw new Error('Worktree directory was not persisted');
+        const getWorktreeClient = await initializeOpencodeForDirectory(worktreeDirectory);
+        if (getWorktreeClient instanceof Error)
+            throw getWorktreeClient;
+        const worktreeSessionResponse = await getWorktreeClient().session.get({
+            sessionID: worktreeSession,
+            directory: worktreeDirectory,
+        });
+        expect(worktreeSessionResponse.data?.directory).toBe(worktreeDirectory);
         const runtimeAfter = getRuntime(thread.id);
         expect(runtimeAfter).toBe(runtimeBefore);
         expect(runtimeAfter.sdkDirectory).toBe(directories.projectDirectory);
@@ -683,9 +697,9 @@ describe('worktree lifecycle', () => {
         » **kimaki-cli:**
         Reply with exactly: send-auto-wt-SUFFIX
         [embed]
-        🌳 **Worktree: opencode/kimaki-rply-wth-exctly-snd-at-wt-l8kct**
+        🌳 **Worktree: AUTO_WORKTREE_BRANCH**
         📁 \`/tmp/worktrees/WORKTREE_NAME\`
-        🌿 Branch: \`opencode/kimaki-rply-wth-exctly-snd-at-wt-l8kct\`
+        🌿 Branch: \`AUTO_WORKTREE_BRANCH\`
         *using deterministic-provider/deterministic-v2*
         ⬥ ok"
       `);

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "exports": {
@@ -31,10 +31,10 @@
     "lintcn": "^0.7.1",
     "tsx": "^4.20.5",
     "undici": "^8.0.2",
+    "db": "^0.0.0",
     "discord-digital-twin": "^0.1.1",
-    "opencode-deterministic-provider": "^0.0.1",
     "opencode-cached-provider": "^0.0.1",
-    "db": "^0.0.0"
+    "opencode-deterministic-provider": "^0.0.1"
   },
   "dependencies": {
     "@ai-sdk/google": "^3.0.53",
@@ -70,9 +70,9 @@
     "zod": "^4.3.6",
     "zustand": "^5.0.11",
     "errore": "^0.14.1",
-    "traforo": "^0.7.1",
-    "opencode-injection-guard": "^0.2.1",
-    "libsqlproxy": "^0.1.0"
+    "traforo": "^0.7.2",
+    "libsqlproxy": "^0.1.0",
+    "opencode-injection-guard": "^0.2.1"
   },
   "optionalDependencies": {
     "@snazzah/davey": "^0.1.10",