kimaki 0.26.0 → 0.28.0

package/dist/task-schedule.test.js

@@ -6,7 +6,7 @@ import { afterAll, afterEach, describe, expect, test } from 'vitest';
 import { completeScheduledTaskRunsForSession, createScheduledTask, createScheduledTaskRun, getActiveScheduledTaskRuns, getScheduledTask, startScheduledTaskRunSession, } from './database.js';
 import { closeDb } from './db.js';
 import { runTaskCommand } from './task-runner.js';
-import { appendTaskCommandOutput, parseScheduledTaskPayload, parseSendAtValue, } from './task-schedule.js';
+import { appendTaskCommandOutput, applyScheduledTaskUserEdit, parseScheduledTaskPayload, formatSessionSleepToolOutput, formatSessionSleepWakePrompt, parseSendAtValue, parseSleepWakeAt, } from './task-schedule.js';
 describe('parseSendAtValue', () => {
     test('accepts UTC ISO date ending with Z', () => {
         const now = new Date('2026-02-22T13:00:00Z');
@@ -75,6 +75,101 @@ describe('parseSendAtValue', () => {
         expect(result.nextRunAt.toISOString()).toBe('2026-02-23T09:00:00.000Z');
     });
 });
+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 = [];
     afterEach(() => {
@@ -105,6 +200,59 @@ 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/dist/test-utils.js

@@ -67,6 +67,8 @@ export function initTestGitRepo(directory) {
     execSync('git config user.name "Test"', { cwd: directory, stdio: 'pipe' });
     execSync('git commit --allow-empty -m "init"', { cwd: directory, stdio: 'pipe' });
 }
+import { getMessageVisibleText, } from 'discord-digital-twin/src';
+export { getMessageVisibleText };
 import { getOpencodeClient, initializeOpencodeForDirectory, } from './opencode.js';
 import { getThreadState, } from './session-handler/thread-runtime-state.js';
 const MAX_VITEST_WAIT_TIMEOUT_MS = 10_000;
@@ -155,7 +157,7 @@ export async function waitForBotReplyAfterUserMessage({ discord, threadId, userI
         const messages = await discord.thread(threadId).getMessages();
         const userMessageIndex = messages.findIndex((message) => {
             return (message.author.id === userId &&
-                message.content.includes(userMessageIncludes));
+                getMessageVisibleText(message).includes(userMessageIncludes));
         });
         const botReplyIndex = messages.findIndex((message, index) => {
             return index > userMessageIndex && message.author.id === discord.botUserId;
@@ -189,7 +191,7 @@ export async function waitForBotMessageContaining({ discord, threadId, userId, t
             if (afterUserMessageIncludes && userId) {
                 return messages.findLastIndex((message) => {
                     return (message.author.id === userId &&
-                        message.content.includes(afterUserMessageIncludes));
+                        getMessageVisibleText(message).includes(afterUserMessageIncludes));
                 });
             }
             return -1;
@@ -207,7 +209,7 @@ export async function waitForBotMessageContaining({ discord, threadId, userId, t
                 return false;
             }
             return (message.author.id === discord.botUserId &&
-                message.content.includes(text));
+                getMessageVisibleText(message).includes(text));
         });
         if (match) {
             return messages;
@@ -220,7 +222,7 @@ export async function waitForBotMessageContaining({ discord, threadId, userId, t
         .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(`Timed out waiting for bot message containing "${text}" in thread ${threadId}. Recent messages:\n${recent}`);
@@ -243,14 +245,20 @@ export async function waitForMessageById({ discord, threadId, messageId, timeout
     }
     throw new Error(`Timed out waiting for message ${messageId} in thread ${threadId}`);
 }
-function isFooterMessage({ message, botUserId, }) {
+export function isFooterMessage({ message, botUserId, }) {
     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;
     }
-    return message.content.includes('⋅');
+    if (content.startsWith('*using ')) {
+        return false;
+    }
+    return content.includes('⋅');
 }
 /**
  * Poll until a footer message appears, optionally after an anchor message.
@@ -265,7 +273,7 @@ export async function waitForFooterMessage({ discord, threadId, timeout, afterMe
         lastMessages = messages;
         const afterIndex = afterMessageIncludes
             ? messages.findLastIndex((message) => {
-                if (!message.content.includes(afterMessageIncludes)) {
+                if (!getMessageVisibleText(message).includes(afterMessageIncludes)) {
                     return false;
                 }
                 if (!afterAuthorId) {
@@ -297,7 +305,7 @@ export async function waitForFooterMessage({ discord, threadId, timeout, afterMe
         .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/dist/thinking-utils.js

@@ -33,3 +33,13 @@ export function matchThinkingValue({ requestedValue, availableValues, }) {
         return availableValue.toLowerCase() === normalizedRequestedValue;
     });
 }
+export function resolveRequestedThinkingVariant({ requestedValue, providers, providerId, modelId, }) {
+    return matchThinkingValue({
+        requestedValue,
+        availableValues: getThinkingValuesForModel({
+            providers,
+            providerId,
+            modelId,
+        }),
+    });
+}

package/dist/thinking-utils.test.js

@@ -0,0 +1,35 @@
+// 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();
+    });
+});