kimaki 0.26.0 → 0.28.0

package/dist/session-search.js

@@ -1,5 +1,8 @@
 // Session search helpers for kimaki CLI commands.
 // Parses string/regex queries and builds readable snippets from matched content.
+// Default window so search does not load years of old session messages.
+export const SESSION_SEARCH_DEFAULT_DAYS = 14;
+export const SESSION_SEARCH_MESSAGE_CONCURRENCY = 4;
 export function parseSessionSearchPattern(query) {
     const trimmedQuery = query.trim();
     if (!trimmedQuery) {
@@ -80,13 +83,13 @@ export function getPartSearchTexts(part) {
         case 'reasoning':
             return part.text ? [part.text] : [];
         case 'tool': {
-            const inputText = stringifyUnknown(part.state.input);
-            const outputText = part.state.status === 'completed'
+            const inputText = stringifyUnknown(part.state?.input);
+            const outputText = part.state?.status === 'completed'
                 ? stringifyUnknown(part.state.output)
-                : part.state.status === 'error'
+                : part.state?.status === 'error'
                     ? part.state.error || ''
                     : '';
-            return [`tool:${part.tool}`, inputText, outputText].filter((entry) => {
+            return [`tool:${part.tool || ''}`, inputText, outputText].filter((entry) => {
                 return entry.trim().length > 0;
             });
         }
@@ -98,3 +101,119 @@ export function getPartSearchTexts(part) {
             return [];
     }
 }
+export function validateSessionSearchScope({ all, project, channel, }) {
+    if (all && (project || channel)) {
+        return new Error('Use --all alone. Do not combine it with --project or --channel. Search one project with: kimaki session search "query" --project /path');
+    }
+    if (project && channel) {
+        return new Error('Use either --project or --channel, not both');
+    }
+    return null;
+}
+export function parseSessionSearchDays(raw) {
+    if (raw === undefined) {
+        return SESSION_SEARCH_DEFAULT_DAYS;
+    }
+    const parsed = Number.parseInt(raw, 10);
+    if (Number.isNaN(parsed) || parsed < 0 || String(parsed) !== raw.trim()) {
+        return new Error(`Invalid --days value: ${raw}. Use a whole number of days, or 0 for all time.`);
+    }
+    return parsed;
+}
+export function sessionSearchMinUpdated({ days, now = Date.now(), }) {
+    if (days === 0) {
+        return undefined;
+    }
+    return now - days * 24 * 60 * 60 * 1000;
+}
+export function resolveSessionSearchDirectories({ all, registeredDirectories, cwd, explicitDirectory, }) {
+    if (!all) {
+        return [explicitDirectory || cwd];
+    }
+    const uniqueDirectories = [...new Set(registeredDirectories)];
+    if (uniqueDirectories.length === 0) {
+        return new Error('No registered projects found. Add a project first with `kimaki project add`, or search one directory with --project.');
+    }
+    return uniqueDirectories;
+}
+export function getSessionSearchSnippets({ messages, searchPattern, }) {
+    return messages
+        .flatMap((message) => {
+        const rolePrefix = message.info.role === 'assistant'
+            ? 'assistant'
+            : message.info.role === 'user'
+                ? 'user'
+                : 'message';
+        return message.parts
+            .filter((part) => !(part.type === 'text' && part.synthetic))
+            .flatMap((part) => {
+            return getPartSearchTexts(part).flatMap((text) => {
+                const hit = findFirstSessionSearchHit({
+                    text,
+                    searchPattern,
+                });
+                if (!hit) {
+                    return [];
+                }
+                const snippet = buildSessionSearchSnippet({ text, hit });
+                if (!snippet) {
+                    return [];
+                }
+                return [`${rolePrefix}: ${snippet}`];
+            });
+        });
+    })
+        .slice(0, 3);
+}
+export async function collectSessionSearchMatches({ sessions, searchPattern, sessionToThread, limit, minUpdated, concurrency = SESSION_SEARCH_MESSAGE_CONCURRENCY, loadMessages, onMatch, }) {
+    const sortedSessions = [...sessions]
+        .sort((a, b) => {
+        return b.updated - a.updated;
+    })
+        .filter((session) => {
+        return minUpdated === undefined || session.updated >= minUpdated;
+    });
+    const matches = [];
+    let scannedSessions = 0;
+    const batchSize = Math.max(1, concurrency);
+    for (let offset = 0; offset < sortedSessions.length; offset += batchSize) {
+        if (matches.length >= limit) {
+            break;
+        }
+        const batch = sortedSessions.slice(offset, offset + batchSize);
+        scannedSessions += batch.length;
+        const loadedBatch = await Promise.all(batch.map(async (session) => {
+            const messages = session.messages
+                ? session.messages
+                : loadMessages
+                    ? await loadMessages(session)
+                    : [];
+            return { session, messages };
+        }));
+        for (const { session, messages } of loadedBatch) {
+            if (matches.length >= limit) {
+                break;
+            }
+            const snippets = getSessionSearchSnippets({
+                messages,
+                searchPattern,
+            });
+            if (snippets.length === 0) {
+                continue;
+            }
+            const threadId = sessionToThread.get(session.id);
+            const match = {
+                id: session.id,
+                title: session.title || 'Untitled Session',
+                directory: session.directory,
+                updated: new Date(session.updated).toISOString(),
+                source: threadId ? 'kimaki' : 'opencode',
+                threadId: threadId || null,
+                snippets,
+            };
+            matches.push(match);
+            onMatch?.(match);
+        }
+    }
+    return { matches, scannedSessions };
+}

package/dist/session-search.test.js

@@ -1,6 +1,6 @@
 // Tests for session search query parsing and snippet matching helpers.
 import { describe, expect, test } from 'vitest';
-import { buildSessionSearchSnippet, findFirstSessionSearchHit, parseSessionSearchPattern, } from './session-search.js';
+import { buildSessionSearchSnippet, collectSessionSearchMatches, findFirstSessionSearchHit, parseSessionSearchDays, parseSessionSearchPattern, resolveSessionSearchDirectories, sessionSearchMinUpdated, validateSessionSearchScope, } from './session-search.js';
 describe('session search helpers', () => {
     test('returns error for invalid regex query', () => {
         const parsed = parseSessionSearchPattern('/(unclosed/');
@@ -37,4 +37,251 @@ describe('session search helpers', () => {
             expect(snippet.toUpperCase()).toContain(expectedSubstring.toUpperCase());
         });
     });
+    test('rejects --all combined with --project or --channel', () => {
+        expect(validateSessionSearchScope({ all: true, project: '/tmp/a' })).toBeInstanceOf(Error);
+        expect(validateSessionSearchScope({ all: true, channel: '123' })).toBeInstanceOf(Error);
+        expect(validateSessionSearchScope({ all: true })).toBeNull();
+        expect(validateSessionSearchScope({ project: '/tmp/a', channel: '123' })).toBeInstanceOf(Error);
+    });
+    test('resolves --all to every registered project directory', () => {
+        const resolved = resolveSessionSearchDirectories({
+            all: true,
+            registeredDirectories: ['/tmp/kimaki', '/tmp/website', '/tmp/kimaki'],
+            cwd: '/tmp/current',
+        });
+        expect(resolved).toEqual(['/tmp/kimaki', '/tmp/website']);
+    });
+    test('returns error when --all has no registered projects', () => {
+        const resolved = resolveSessionSearchDirectories({
+            all: true,
+            registeredDirectories: [],
+            cwd: '/tmp/current',
+        });
+        expect(resolved).toBeInstanceOf(Error);
+    });
+    test('defaults to cwd or an explicit project when --all is off', () => {
+        expect(resolveSessionSearchDirectories({
+            all: false,
+            cwd: '/tmp/current',
+            registeredDirectories: ['/tmp/kimaki'],
+        })).toEqual(['/tmp/current']);
+        expect(resolveSessionSearchDirectories({
+            all: false,
+            explicitDirectory: '/tmp/website',
+            cwd: '/tmp/current',
+            registeredDirectories: ['/tmp/kimaki'],
+        })).toEqual(['/tmp/website']);
+    });
+    test('defaults --days to 14 and treats 0 as all time', () => {
+        expect(parseSessionSearchDays(undefined)).toBe(14);
+        expect(parseSessionSearchDays('0')).toBe(0);
+        expect(parseSessionSearchDays('7')).toBe(7);
+        expect(parseSessionSearchDays('-1')).toBeInstanceOf(Error);
+        expect(parseSessionSearchDays('nope')).toBeInstanceOf(Error);
+        expect(sessionSearchMinUpdated({ days: 0, now: 1_000 })).toBeUndefined();
+        expect(sessionSearchMinUpdated({ days: 14, now: 1_000 })).toBe(1_000 - 14 * 24 * 60 * 60 * 1000);
+    });
+    test('skips sessions older than minUpdated without loading messages', async () => {
+        const parsed = parseSessionSearchPattern('auth timeout');
+        if (parsed instanceof Error) {
+            throw parsed;
+        }
+        const now = 1_000_000_000_000;
+        const minUpdated = now - 14 * 24 * 60 * 60 * 1000;
+        const loaded = [];
+        const result = await collectSessionSearchMatches({
+            sessions: [
+                {
+                    id: 'ses_new',
+                    title: 'new hit',
+                    directory: '/tmp/kimaki',
+                    updated: now,
+                },
+                {
+                    id: 'ses_old',
+                    title: 'old hit',
+                    directory: '/tmp/website',
+                    updated: minUpdated - 1,
+                },
+            ],
+            searchPattern: parsed,
+            sessionToThread: new Map(),
+            limit: 20,
+            minUpdated,
+            loadMessages: async (session) => {
+                loaded.push(session.id);
+                return [
+                    {
+                        info: { role: 'user' },
+                        parts: [{ type: 'text', text: 'auth timeout', synthetic: false }],
+                    },
+                ];
+            },
+        });
+        expect(loaded).toEqual(['ses_new']);
+        expect(result.scannedSessions).toBe(1);
+        expect(result.matches.map((match) => match.id)).toEqual(['ses_new']);
+    });
+    test('loads old matching sessions when minUpdated is unset', async () => {
+        const parsed = parseSessionSearchPattern('auth timeout');
+        if (parsed instanceof Error) {
+            throw parsed;
+        }
+        const loaded = [];
+        const result = await collectSessionSearchMatches({
+            sessions: [
+                {
+                    id: 'ses_old',
+                    title: 'old hit',
+                    directory: '/tmp/website',
+                    updated: 1,
+                },
+            ],
+            searchPattern: parsed,
+            sessionToThread: new Map(),
+            limit: 20,
+            loadMessages: async (session) => {
+                loaded.push(session.id);
+                return [
+                    {
+                        info: { role: 'user' },
+                        parts: [{ type: 'text', text: 'auth timeout', synthetic: false }],
+                    },
+                ];
+            },
+        });
+        expect(loaded).toEqual(['ses_old']);
+        expect(result.matches.map((match) => match.id)).toEqual(['ses_old']);
+    });
+    test('loads messages in parallel but keeps newest matches first', async () => {
+        const parsed = parseSessionSearchPattern('auth timeout');
+        if (parsed instanceof Error) {
+            throw parsed;
+        }
+        let inFlight = 0;
+        let maxInFlight = 0;
+        const streamed = [];
+        const result = await collectSessionSearchMatches({
+            sessions: [
+                {
+                    id: 'ses_new',
+                    title: 'new hit',
+                    directory: '/tmp/kimaki',
+                    updated: 3,
+                },
+                {
+                    id: 'ses_mid',
+                    title: 'mid hit',
+                    directory: '/tmp/cli',
+                    updated: 2,
+                },
+                {
+                    id: 'ses_old',
+                    title: 'old hit',
+                    directory: '/tmp/website',
+                    updated: 1,
+                },
+            ],
+            searchPattern: parsed,
+            sessionToThread: new Map(),
+            limit: 2,
+            concurrency: 3,
+            onMatch: (match) => {
+                streamed.push(match.id);
+            },
+            loadMessages: async (session) => {
+                inFlight++;
+                maxInFlight = Math.max(maxInFlight, inFlight);
+                await new Promise((resolve) => {
+                    setTimeout(resolve, session.id === 'ses_new' ? 40 : 5);
+                });
+                inFlight--;
+                return [
+                    {
+                        info: { role: 'user' },
+                        parts: [{ type: 'text', text: 'auth timeout', synthetic: false }],
+                    },
+                ];
+            },
+        });
+        expect(maxInFlight).toBeGreaterThan(1);
+        expect(result.matches.map((match) => match.id)).toEqual([
+            'ses_new',
+            'ses_mid',
+        ]);
+        expect(streamed).toEqual(['ses_new', 'ses_mid']);
+    });
+    test('collects newest matches across projects up to the global limit', async () => {
+        const parsed = parseSessionSearchPattern('auth timeout');
+        if (parsed instanceof Error) {
+            throw parsed;
+        }
+        const result = await collectSessionSearchMatches({
+            sessions: [
+                {
+                    id: 'ses_old',
+                    title: 'old website hit',
+                    directory: '/tmp/website',
+                    updated: 1,
+                    messages: [
+                        {
+                            info: { role: 'user' },
+                            parts: [{ type: 'text', text: 'auth timeout on login', synthetic: false }],
+                        },
+                    ],
+                },
+                {
+                    id: 'ses_new',
+                    title: 'new kimaki hit',
+                    directory: '/tmp/kimaki',
+                    updated: 3,
+                    messages: [
+                        {
+                            info: { role: 'assistant' },
+                            parts: [{ type: 'text', text: 'fixed the auth timeout', synthetic: false }],
+                        },
+                    ],
+                },
+                {
+                    id: 'ses_miss',
+                    title: 'unrelated',
+                    directory: '/tmp/cli',
+                    updated: 4,
+                    messages: [
+                        {
+                            info: { role: 'user' },
+                            parts: [{ type: 'text', text: 'refactor logger', synthetic: false }],
+                        },
+                    ],
+                },
+                {
+                    id: 'ses_mid',
+                    title: 'mid cli hit',
+                    directory: '/tmp/cli',
+                    updated: 2,
+                    messages: [
+                        {
+                            info: { role: 'user' },
+                            parts: [{ type: 'text', text: 'auth timeout retry', synthetic: false }],
+                        },
+                    ],
+                },
+            ],
+            searchPattern: parsed,
+            sessionToThread: new Map([
+                ['ses_new', 'thread_new'],
+                ['ses_mid', 'thread_mid'],
+            ]),
+            limit: 2,
+            concurrency: 1,
+        });
+        expect(result.scannedSessions).toBe(3);
+        expect(result.matches.map((match) => match.id)).toEqual([
+            'ses_new',
+            'ses_mid',
+        ]);
+        expect(result.matches[0]?.directory).toBe('/tmp/kimaki');
+        expect(result.matches[0]?.source).toBe('kimaki');
+        expect(result.matches[1]?.directory).toBe('/tmp/cli');
+    });
 });

package/dist/session-sleep.test.js

@@ -0,0 +1,224 @@
+// Tests for the durable session-sleep delivery protocol.
+//
+// The invariant under test: a wake is delivered at least once and turned into a
+// session turn at most once. A row therefore stays `planned` until ingress
+// consumes it, and every delivery write is guarded on delivery_id so a stale
+// in-flight wake can never touch a newer sleep occurrence.
+import { afterAll, describe, expect, test } from 'vitest';
+import { cancelSessionSleepForThread, claimSessionSleepAttempt, consumeSessionSleepWake, getDueSessionSleeps, getSessionSleep, getThreadIdBySessionId, markSessionSleepFailed, setThreadSession, upsertSessionSleep, } from './database.js';
+import { closeDb } from './db.js';
+import { buildSessionSleepWakeBody } from './task-runner.js';
+const RETRY_AFTER_MS = 30_000;
+const NOW = new Date('2026-08-19T12:00:00Z');
+const DUE = new Date('2026-08-19T11:00:00Z');
+async function createSleep({ sessionId, threadId, wakeAt = DUE, reason = null, }) {
+    await setThreadSession(threadId, sessionId);
+    return upsertSessionSleep({ sessionId, wakeAt, reason });
+}
+describe('session sleep delivery', () => {
+    test('uses a Discord-compatible nonce without changing the delivery marker', () => {
+        const deliveryId = 'f0e3a009-dd6b-4c6a-a244-646693d9ae8d';
+        const body = buildSessionSleepWakeBody({
+            deliveryId,
+            wakeAt: DUE,
+            reason: 'Continue after deployment',
+        });
+        expect({
+            nonce: body.nonce,
+            nonceLength: body.nonce.length,
+            markerIncludesDeliveryId: body.embeds[0]?.footer.text.includes(deliveryId),
+        }).toMatchInlineSnapshot(`
+      {
+        "markerIncludesDeliveryId": true,
+        "nonce": "f0e3a009dd6b4c6aa24464669",
+        "nonceLength": 25,
+      }
+    `);
+        expect(body.nonce.length).toBeLessThanOrEqual(25);
+    });
+    test('claim reserves an attempt but stays planned so a crash retries', async () => {
+        const deliveryId = await createSleep({
+            sessionId: 'ses-crash',
+            threadId: 'thr-crash',
+        });
+        const claimed = await claimSessionSleepAttempt({
+            sessionId: 'ses-crash',
+            deliveryId,
+            now: NOW,
+            retryAfterMs: RETRY_AFTER_MS,
+        });
+        expect(claimed?.status).toBe('planned');
+        expect(claimed?.attempts).toBe(1);
+        // Simulates the process dying before the Discord post: once the retry
+        // window passes the row is due again rather than lost.
+        const laterDue = await getDueSessionSleeps({
+            now: new Date(NOW.getTime() + RETRY_AFTER_MS + 1),
+            retryAfterMs: RETRY_AFTER_MS,
+            limit: 10,
+        });
+        expect(laterDue.map((row) => row.session_id)).toContain('ses-crash');
+    });
+    test('a second claim inside the retry window is refused', async () => {
+        const deliveryId = await createSleep({
+            sessionId: 'ses-window',
+            threadId: 'thr-window',
+        });
+        const first = await claimSessionSleepAttempt({
+            sessionId: 'ses-window',
+            deliveryId,
+            now: NOW,
+            retryAfterMs: RETRY_AFTER_MS,
+        });
+        const second = await claimSessionSleepAttempt({
+            sessionId: 'ses-window',
+            deliveryId,
+            now: new Date(NOW.getTime() + 1_000),
+            retryAfterMs: RETRY_AFTER_MS,
+        });
+        expect(first).not.toBe(null);
+        expect(second).toBe(null);
+    });
+    test('a new sleep occurrence invalidates an in-flight delivery', async () => {
+        const staleDeliveryId = await createSleep({
+            sessionId: 'ses-generation',
+            threadId: 'thr-generation',
+        });
+        const freshDeliveryId = await createSleep({
+            sessionId: 'ses-generation',
+            threadId: 'thr-generation',
+            wakeAt: new Date('2026-08-19T11:30:00Z'),
+        });
+        expect(freshDeliveryId).not.toBe(staleDeliveryId);
+        const staleClaim = await claimSessionSleepAttempt({
+            sessionId: 'ses-generation',
+            deliveryId: staleDeliveryId,
+            now: NOW,
+            retryAfterMs: RETRY_AFTER_MS,
+        });
+        // The wake message already in flight for the old occurrence must not be
+        // able to deliver against the new one.
+        const staleConsume = await consumeSessionSleepWake({
+            deliveryId: staleDeliveryId,
+        });
+        expect(staleClaim).toBe(null);
+        expect(staleConsume).toBe(false);
+        expect((await getSessionSleep({ sessionId: 'ses-generation' }))?.status).toBe('planned');
+    });
+    test('a wake becomes a turn at most once', async () => {
+        const deliveryId = await createSleep({
+            sessionId: 'ses-once',
+            threadId: 'thr-once',
+        });
+        // A retry can post the same wake twice; only the first delivery may win.
+        const first = await consumeSessionSleepWake({ deliveryId });
+        const second = await consumeSessionSleepWake({ deliveryId });
+        expect(first).toBe(true);
+        expect(second).toBe(false);
+        expect((await getSessionSleep({ sessionId: 'ses-once' }))?.status).toBe('consumed');
+    });
+    test('a wake cancelled while posting is dropped instead of starting a turn', async () => {
+        const deliveryId = await createSleep({
+            sessionId: 'ses-raced',
+            threadId: 'thr-raced',
+        });
+        await claimSessionSleepAttempt({
+            sessionId: 'ses-raced',
+            deliveryId,
+            now: NOW,
+            retryAfterMs: RETRY_AFTER_MS,
+        });
+        // User takes the conversation back while the post is in flight.
+        await cancelSessionSleepForThread({ threadId: 'thr-raced' });
+        expect(await consumeSessionSleepWake({ deliveryId })).toBe(false);
+        expect((await getSessionSleep({ sessionId: 'ses-raced' }))?.status).toBe('cancelled');
+    });
+    test('cancel reaches the sleep from any thread bound to the session', async () => {
+        const deliveryId = await createSleep({
+            sessionId: 'ses-rebound',
+            threadId: 'thr-rebound-old',
+        });
+        // /resume binds the same session to a second thread. A sleep belongs to the
+        // session, not to the thread it was created in, so either thread cancels it.
+        await setThreadSession('thr-rebound-new', 'ses-rebound');
+        const cancelled = await cancelSessionSleepForThread({
+            threadId: 'thr-rebound-new',
+        });
+        expect(cancelled).toBe(true);
+        expect(await consumeSessionSleepWake({ deliveryId })).toBe(false);
+    });
+    test('a wake nobody consumed stays due and is retried', async () => {
+        const deliveryId = await createSleep({
+            sessionId: 'ses-stale',
+            threadId: 'thr-stale',
+        });
+        // Posting does not change the status, so a wake that was delivered to
+        // Discord but never reached ingress is simply due again after the retry
+        // window. This is the same path that covers a crash before posting.
+        await claimSessionSleepAttempt({
+            sessionId: 'ses-stale',
+            deliveryId,
+            now: NOW,
+            retryAfterMs: RETRY_AFTER_MS,
+        });
+        expect((await getSessionSleep({ sessionId: 'ses-stale' }))?.status).toBe('planned');
+        const retryDue = await getDueSessionSleeps({
+            now: new Date(NOW.getTime() + RETRY_AFTER_MS + 1),
+            retryAfterMs: RETRY_AFTER_MS,
+            limit: 50,
+        });
+        expect(retryDue.map((row) => row.session_id)).toContain('ses-stale');
+    });
+    test('failing a delivery is also guarded by delivery_id', async () => {
+        const deliveryId = await createSleep({
+            sessionId: 'ses-failed',
+            threadId: 'thr-failed',
+        });
+        expect(await markSessionSleepFailed({
+            sessionId: 'ses-failed',
+            deliveryId: 'some-other-delivery',
+        })).toBe(false);
+        expect(await markSessionSleepFailed({ sessionId: 'ses-failed', deliveryId })).toBe(true);
+    });
+    test('only planned rows that are due and not just attempted are returned', async () => {
+        await createSleep({ sessionId: 'ses-due', threadId: 'thr-due' });
+        await createSleep({
+            sessionId: 'ses-future',
+            threadId: 'thr-future',
+            wakeAt: new Date('2026-08-19T13:00:00Z'),
+        });
+        const due = await getDueSessionSleeps({
+            now: NOW,
+            retryAfterMs: RETRY_AFTER_MS,
+            limit: 50,
+        });
+        const ids = due.map((row) => row.session_id);
+        expect(ids).toContain('ses-due');
+        expect(ids).not.toContain('ses-future');
+    });
+});
+describe('session to thread resolution', () => {
+    test('resolves to the most recently bound thread, not an arbitrary one', async () => {
+        // Bindings are ordered by wall-clock time, so space them enough to get
+        // distinct millisecond stamps. Real /resume flows are seconds apart.
+        const tick = async () => {
+            await new Promise((resolve) => {
+                setTimeout(resolve, 5);
+            });
+        };
+        await setThreadSession('thr-first', 'ses-resume');
+        await tick();
+        // /resume maps the same session into a brand new thread without clearing
+        // the old row. The newest binding must win, otherwise plugin tools post
+        // into a dead conversation.
+        await setThreadSession('thr-second', 'ses-resume');
+        expect(await getThreadIdBySessionId('ses-resume')).toBe('thr-second');
+        await tick();
+        // Rebinding the older thread makes it current again. created_at ordering
+        // would still answer thr-second here, which is why updated_at exists.
+        await setThreadSession('thr-first', 'ses-resume');
+        expect(await getThreadIdBySessionId('ses-resume')).toBe('thr-first');
+    });
+});
+afterAll(async () => {
+    await closeDb();
+});