kimaki 0.22.0 → 0.23.0

package/src/system-message.ts

@@ -309,7 +309,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>`,
         ]
       : []),
   ]
@@ -575,18 +575,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:
 
@@ -596,20 +608,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/src/task-runner.ts

@@ -10,7 +10,7 @@ import {
   markScheduledTaskCronRescheduled,
   markScheduledTaskCronRetry,
   markScheduledTaskFailed,
-  markScheduledTaskOneShotCompleted,
+  deleteScheduledTask,
   recoverStaleRunningScheduledTasks,
   type ScheduledTask,
 } from './database.js'
@@ -59,7 +59,10 @@ async function executeThreadScheduledTask({
   const marker: ThreadStartMarker = {
     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 } : {}),
@@ -105,7 +108,8 @@ async function executeChannelScheduledTask({
     : {
         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 } : {}),
@@ -222,7 +226,7 @@ async function finalizeSuccessfulTask({
   completedAt: Date
 }): Promise<void> {
   if (task.schedule_kind === 'at') {
-    await markScheduledTaskOneShotCompleted({ taskId: task.id, completedAt })
+    await deleteScheduledTask(task.id)
     return
   }
 

package/src/worktree-lifecycle.e2e.test.ts

@@ -61,6 +61,10 @@ function normalizeWorktreeLifecycleText(text: string): string {
     .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>')
@@ -444,11 +448,23 @@ 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)
@@ -841,9 +857,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"
       `)