kimaki 0.26.0 → 0.28.0

package/src/task-schedule.test.ts

@@ -16,8 +16,12 @@ import { closeDb } from './db.js'
 import { runTaskCommand } from './task-runner.js'
 import {
   appendTaskCommandOutput,
+  applyScheduledTaskUserEdit,
   parseScheduledTaskPayload,
+  formatSessionSleepToolOutput,
+  formatSessionSleepWakePrompt,
   parseSendAtValue,
+  parseSleepWakeAt,
 } from './task-schedule.js'
 
 describe('parseSendAtValue', () => {
@@ -100,6 +104,117 @@ describe('parseSendAtValue', () => {
   })
 })
 
+describe('parseSleepWakeAt', () => {
+  const now = new Date('2026-08-19T12:00:00Z')
+
+  test('adds 2h to now', () => {
+    const result = parseSleepWakeAt({ duration: '2h', now })
+    expect(result).not.toBeInstanceOf(Error)
+    if (result instanceof Error) throw result
+    expect(result.toISOString()).toBe('2026-08-19T14:00:00.000Z')
+  })
+
+  test('adds 30s and 1d', () => {
+    const thirtySeconds = parseSleepWakeAt({ duration: '30s', now })
+    expect(thirtySeconds).not.toBeInstanceOf(Error)
+    if (thirtySeconds instanceof Error) throw thirtySeconds
+    expect(thirtySeconds.toISOString()).toBe('2026-08-19T12:00:30.000Z')
+
+    const oneDay = parseSleepWakeAt({ duration: '1d', now })
+    expect(oneDay).not.toBeInstanceOf(Error)
+    if (oneDay instanceof Error) throw oneDay
+    expect(oneDay.toISOString()).toBe('2026-08-20T12:00:00.000Z')
+  })
+
+  test('accepts until UTC ISO date ending with Z', () => {
+    const result = parseSleepWakeAt({
+      until: '2026-08-20T09:00:00Z',
+      now,
+    })
+    expect(result).not.toBeInstanceOf(Error)
+    if (result instanceof Error) throw result
+    expect(result.toISOString()).toBe('2026-08-20T09:00:00.000Z')
+  })
+
+  test('rejects past until', () => {
+    const result = parseSleepWakeAt({
+      until: '2026-08-19T11:59:59Z',
+      now,
+    })
+    expect(result).toBeInstanceOf(Error)
+    if (result instanceof Error) {
+      expect(result.message).toContain('until must be in the future (UTC)')
+    }
+  })
+
+  test('rejects both duration and until', () => {
+    const result = parseSleepWakeAt({
+      duration: '1h',
+      until: '2026-08-20T09:00:00Z',
+      now,
+    })
+    expect(result).toBeInstanceOf(Error)
+    if (result instanceof Error) {
+      expect(result.message).toContain('either duration or until')
+    }
+  })
+
+  test('rejects neither duration nor until', () => {
+    const result = parseSleepWakeAt({ now })
+    expect(result).toBeInstanceOf(Error)
+    if (result instanceof Error) {
+      expect(result.message).toContain('duration or until')
+    }
+  })
+
+  test('rejects until with a non-UTC offset', () => {
+    const result = parseSleepWakeAt({
+      until: '2026-08-20T09:00:00+01:00',
+      now,
+    })
+    expect(result).toBeInstanceOf(Error)
+    if (result instanceof Error) {
+      expect(result.message).toContain('UTC ISO format ending with Z')
+    }
+  })
+})
+
+describe('formatSessionSleepToolOutput', () => {
+  const wakeAt = new Date('2026-09-07T13:21:00Z')
+
+  test('starts with Sleeping until and tells the model to wait', () => {
+    const output = formatSessionSleepToolOutput({
+      wakeAt,
+      reason: 'Wait 1 day, then check mail',
+    })
+
+    expect(output).toBe(
+      'Sleeping until 2026-09-07 13:21 UTC. Reason: Wait 1 day, then check mail. 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.',
+    )
+    expect(output.startsWith('Sleeping until ')).toBe(true)
+    expect(output).toContain('This tool result is not a wake')
+    expect(output).not.toContain('You will be woken')
+    expect(output).not.toContain('Stop now')
+  })
+
+  test('omits reason when none is passed', () => {
+    const output = formatSessionSleepToolOutput({ wakeAt })
+    expect(output.startsWith('Sleeping until 2026-09-07 13:21 UTC.')).toBe(true)
+    expect(output).not.toContain('Reason:')
+  })
+
+  test('wake prompt stays a separate later message', () => {
+    expect(
+      formatSessionSleepWakePrompt({
+        wakeAt,
+        reason: 'Wait 1 day, then check mail',
+      }),
+    ).toBe(
+      '⬦ Woke after sleeping until 2026-09-07 13:21 UTC\nReason: Wait 1 day, then check mail\nContinue the work you were waiting for.',
+    )
+  })
+})
+
 describe('scheduled task execution options', () => {
   const tempDirectories: string[] = []
 
@@ -134,6 +249,61 @@ describe('scheduled task execution options', () => {
     `)
   })
 
+  test('clears the stored user when task edit passes an empty --user', () => {
+    const payload = parseScheduledTaskPayload(JSON.stringify({
+      kind: 'thread',
+      threadId: 'thread-1',
+      prompt: 'Handle support requests',
+      userId: '535922349652836367',
+      username: 'Tommy',
+    }))
+    expect(payload).not.toBeInstanceOf(Error)
+    if (payload instanceof Error) throw payload
+
+    expect(applyScheduledTaskUserEdit({
+      payload,
+      userOption: '',
+    })).toMatchInlineSnapshot(`
+      {
+        "agent": null,
+        "allowConcurrency": false,
+        "injectionGuardPatterns": null,
+        "kind": "thread",
+        "model": null,
+        "parentSessionId": null,
+        "permissions": null,
+        "preRunCommand": null,
+        "prompt": "Handle support requests",
+        "threadId": "thread-1",
+        "userId": null,
+        "username": null,
+      }
+    `)
+    expect(applyScheduledTaskUserEdit({
+      payload,
+      userOption: '   ',
+    }).userId).toBeNull()
+  })
+
+  test('sets the stored user when task edit passes a resolved --user', () => {
+    const payload = parseScheduledTaskPayload(JSON.stringify({
+      kind: 'channel',
+      channelId: 'chan-1',
+      prompt: 'Daily digest',
+    }))
+    expect(payload).not.toBeInstanceOf(Error)
+    if (payload instanceof Error) throw payload
+
+    expect(applyScheduledTaskUserEdit({
+      payload,
+      userOption: '535922349652836367',
+      resolvedUser: { id: '535922349652836367', username: 'Tommy' },
+    })).toMatchObject({
+      userId: '535922349652836367',
+      username: 'Tommy',
+    })
+  })
+
   test('adds command stdout to the prompt', () => {
     expect(appendTaskCommandOutput({
       prompt: 'Handle support requests',

package/src/task-schedule.ts

@@ -1,7 +1,8 @@
-// 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'
 
 export type ScheduledTaskPayload = {
   preRunCommand: string | null
@@ -101,6 +102,121 @@ function parseUtcSendAtDate({
   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,
+} as const
+
+function parseUtcFutureDate({
+  value,
+  now,
+  field,
+}: {
+  value: string
+  now: Date
+  field: string
+}): Date | Error {
+  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,
+}: {
+  duration?: string
+  until?: string
+  now: Date
+}): Date | Error {
+  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() as keyof typeof SLEEP_DURATION_MS
+  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: Date): string {
+  return `${wakeAt.toISOString().slice(0, 16).replace('T', ' ')} UTC`
+}
+
+export function formatSessionSleepWakePrompt({
+  wakeAt,
+  reason,
+}: {
+  wakeAt: Date
+  reason: string | null
+}): string {
+  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,
+}: {
+  wakeAt: Date
+  reason?: string
+}): string {
+  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,
@@ -208,6 +324,30 @@ export function serializeScheduledTaskPayload(
   return JSON.stringify(payload)
 }
 
+export function applyScheduledTaskUserEdit({
+  payload,
+  userOption,
+  resolvedUser,
+}: {
+  payload: ScheduledTaskPayload
+  userOption: string
+  resolvedUser?: { id: string; username?: string } | null
+}): ScheduledTaskPayload {
+  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,

package/src/test-utils.ts

@@ -73,7 +73,12 @@ export function initTestGitRepo(directory: string): void {
   execSync('git commit --allow-empty -m "init"', { cwd: directory, stdio: 'pipe' })
 }
 
-import type { DigitalDiscord } from 'discord-digital-twin/src'
+import {
+  getMessageVisibleText,
+  type DigitalDiscord,
+} from 'discord-digital-twin/src'
+
+export { getMessageVisibleText }
 import {
   getOpencodeClient,
   initializeOpencodeForDirectory,
@@ -210,7 +215,7 @@ export async function waitForBotReplyAfterUserMessage({
     const userMessageIndex = messages.findIndex((message) => {
       return (
         message.author.id === userId &&
-        message.content.includes(userMessageIncludes)
+        getMessageVisibleText(message).includes(userMessageIncludes)
       )
     })
     const botReplyIndex = messages.findIndex((message, index) => {
@@ -265,7 +270,7 @@ export async function waitForBotMessageContaining({
         return messages.findLastIndex((message) => {
           return (
             message.author.id === userId &&
-            message.content.includes(afterUserMessageIncludes)
+            getMessageVisibleText(message).includes(afterUserMessageIncludes)
           )
         })
       }
@@ -285,7 +290,7 @@ export async function waitForBotMessageContaining({
       }
       return (
         message.author.id === discord.botUserId &&
-        message.content.includes(text)
+        getMessageVisibleText(message).includes(text)
       )
     })
     if (match) {
@@ -299,7 +304,7 @@ export async function waitForBotMessageContaining({
     .slice(-12)
     .map((message) => {
       const role = message.author.id === discord.botUserId ? 'bot' : 'user'
-      return `${role}: ${message.content.slice(0, 120)}`
+      return `${role}: ${getMessageVisibleText(message).slice(0, 120)}`
     })
     .join('\n')
   throw new Error(
@@ -339,7 +344,7 @@ export async function waitForMessageById({
   )
 }
 
-function isFooterMessage({
+export function isFooterMessage({
   message,
   botUserId,
 }: {
@@ -349,10 +354,16 @@ function isFooterMessage({
   if (message.author.id !== botUserId) {
     return false
   }
-  if (!message.content.startsWith('*')) {
+  const content = message.content.startsWith('> ')
+    ? message.content.slice(2)
+    : message.content
+  if (!content.startsWith('*')) {
+    return false
+  }
+  if (content.startsWith('*using ')) {
     return false
   }
-  return message.content.includes('⋅')
+  return content.includes('⋅')
 }
 
 /**
@@ -380,7 +391,7 @@ export async function waitForFooterMessage({
     lastMessages = messages
     const afterIndex = afterMessageIncludes
       ? messages.findLastIndex((message) => {
-          if (!message.content.includes(afterMessageIncludes)) {
+          if (!getMessageVisibleText(message).includes(afterMessageIncludes)) {
             return false
           }
           if (!afterAuthorId) {
@@ -413,7 +424,7 @@ export async function waitForFooterMessage({
     .slice(-12)
     .map((message) => {
       const role = message.author.id === discord.botUserId ? 'bot' : 'user'
-      return `${role}: ${message.content.slice(0, 120)}`
+      return `${role}: ${getMessageVisibleText(message).slice(0, 120)}`
     })
     .join('\n')
   const anchorText = afterMessageIncludes || 'start'

package/src/thinking-utils.test.ts

@@ -0,0 +1,46 @@
+// Tests thinking-level variant matching used by /xxx-agent variant.
+
+import { describe, expect, test } from 'vitest'
+import {
+  getThinkingValuesForModel,
+  matchThinkingValue,
+} from './thinking-utils.js'
+
+describe('matchThinkingValue', () => {
+  const providers = [
+    {
+      id: 'anthropic',
+      models: {
+        'claude-opus-4-6': {
+          variants: {
+            high: {},
+            max: {},
+          },
+        },
+      },
+    },
+  ]
+  const availableValues = getThinkingValuesForModel({
+    providers,
+    providerId: 'anthropic',
+    modelId: 'claude-opus-4-6',
+  })
+
+  test('matches a supported thinking level case-insensitively', () => {
+    expect(
+      matchThinkingValue({
+        requestedValue: 'HIGH',
+        availableValues,
+      }),
+    ).toBe('high')
+  })
+
+  test('returns undefined for an unsupported thinking level', () => {
+    expect(
+      matchThinkingValue({
+        requestedValue: 'not-a-real-level',
+        availableValues,
+      }),
+    ).toBeUndefined()
+  })
+})

package/src/thinking-utils.ts

@@ -59,3 +59,24 @@ export function matchThinkingValue({
     return availableValue.toLowerCase() === normalizedRequestedValue
   })
 }
+
+export function resolveRequestedThinkingVariant({
+  requestedValue,
+  providers,
+  providerId,
+  modelId,
+}: {
+  requestedValue: string
+  providers: ThinkingProvider[]
+  providerId: string
+  modelId: string
+}): string | undefined {
+  return matchThinkingValue({
+    requestedValue,
+    availableValues: getThinkingValuesForModel({
+      providers,
+      providerId,
+      modelId,
+    }),
+  })
+}