kimaki 0.26.0 → 0.27.0

package/dist/commands/new-worktree.js

@@ -2,25 +2,26 @@
 // Uses OpenCode SDK v2 to create worktrees with kimaki- prefix
 // Creates thread immediately, then worktree in background so user can type
 import { ChannelType, REST, } from 'discord.js';
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import { OpenCodeSdkError } from '../errors.js';
-import { createPendingWorkspace, setWorkspaceReady, setWorkspaceError, getChannelDirectory, getThreadSession, getThreadWorktreeOrWorkspace, setThreadSession, } from '../database.js';
+import { createPendingWorkspace, setWorkspaceReady, setWorkspaceError, getChannelDirectory, getThreadSession, setThreadSession, } from '../database.js';
 import { SILENT_MESSAGE_FLAGS, reactToThread, resolveProjectDirectoryFromAutocomplete, resolveTextChannel, sendThreadMessage, } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { notifyError } from '../sentry.js';
-import { execAsync, listBranchesByLastCommit, resolveBestBaseRef, validateBranchRef, } from '../worktrees.js';
+import { execAsync, getManagedWorktreeDirectory, listBranchesByLastCommit, resolveBestBaseRef, validateBranchRef, } from '../worktrees.js';
+import { KIMAKI_WORKTREE_ADAPTER_TYPE, removeWorktreeFromOwnRepository, resolveGitCommit, validateWorktreeIdentity, } from '../git-worktree-core.js';
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { buildSessionPermissions, initializeOpencodeForDirectory, } from '../opencode.js';
 import { WORKTREE_PREFIX } from './merge-worktree.js';
 import * as errore from 'errore';
 import { copyCurrentSessionModel } from './model.js';
 const logger = createLogger(LogPrefix.WORKTREE);
-const DEFAULT_WORKTREE_BASE_REF = 'HEAD';
 async function resolveRequestedWorktreeBaseRef({ projectDirectory, rawBaseBranch, }) {
     if (!rawBaseBranch) {
         // Default to the current local HEAD so worktrees can branch from
         // unpublished commits in the main checkout.
-        return DEFAULT_WORKTREE_BASE_REF;
+        return resolveGitCommit({ directory: projectDirectory, ref: 'HEAD' });
     }
     const validated = await validateBranchRef({
         directory: projectDirectory,
@@ -37,7 +38,7 @@ async function resolveRequestedWorktreeBaseRef({ projectDirectory, rawBaseBranch
     if (bestRef !== validated) {
         logger.log(`Base branch resolved: ${validated} → ${bestRef} (remote is ahead)`);
     }
-    return bestRef;
+    return resolveGitCommit({ directory: projectDirectory, ref: bestRef });
 }
 /** Status message shown while a worktree is being created. */
 export function worktreeCreatingMessage(worktreeName) {
@@ -153,28 +154,83 @@ async function getProjectDirectoryFromChannel(channel) {
 /**
  * Try creating a worktree via the OpenCode workspace SDK.
  * Returns the workspace directory on success, or an Error if the workspace
- * feature is not available or the creation fails. Callers fall back to the
- * direct git path on Error.
+ * feature is not available or the creation fails.
  */
-async function tryWorkspaceCreate({ threadId, worktreeName, projectDirectory, baseBranch, }) {
+export async function tryWorkspaceCreate({ worktreeName, projectDirectory, baseCommit, }) {
     const getClient = await initializeOpencodeForDirectory(projectDirectory);
     if (getClient instanceof Error)
         return getClient;
     const client = getClient();
+    const workspaceId = `wrk_${crypto.randomUUID()}`;
+    const managedDirectory = getManagedWorktreeDirectory({
+        directory: projectDirectory,
+        name: worktreeName,
+    });
+    const cleanupFailedWorkspace = async (worktreeDirectory) => {
+        const removeResponse = await client.experimental.workspace.remove({
+            id: workspaceId,
+            directory: projectDirectory,
+        }).catch((e) => new OpenCodeSdkError({ operation: 'workspace.remove', cause: e }));
+        const sdkCleanupError = (() => {
+            if (removeResponse instanceof Error)
+                return removeResponse;
+            if (removeResponse.error) {
+                return new Error(`Workspace cleanup failed: ${JSON.stringify(removeResponse.error)}`);
+            }
+            return undefined;
+        })();
+        const gitCleanupError = fs.existsSync(worktreeDirectory)
+            ? await removeWorktreeFromOwnRepository({
+                worktreeDirectory,
+                branchName: worktreeName,
+            })
+            : undefined;
+        return sdkCleanupError ?? gitCleanupError;
+    };
     const response = await client.experimental.workspace.create({
+        id: workspaceId,
         directory: projectDirectory,
-        type: 'kimaki-worktree',
+        type: KIMAKI_WORKTREE_ADAPTER_TYPE,
         branch: worktreeName,
-        extra: baseBranch ? { baseBranch } : null,
+        extra: {
+            projectDirectory,
+            baseCommit,
+        },
     }).catch((e) => new OpenCodeSdkError({ operation: 'workspace.create', cause: e }));
-    if (response instanceof Error)
-        return response;
-    if (response.error) {
-        return new Error(`Workspace creation failed: ${JSON.stringify(response.error)}`);
+    if (response instanceof Error || response.error) {
+        const creationError = response instanceof Error
+            ? response
+            : new Error(`Workspace creation failed: ${JSON.stringify(response.error)}`);
+        const cleanupError = await cleanupFailedWorkspace(managedDirectory);
+        if (cleanupError instanceof Error) {
+            return new Error(`${creationError.message}; cleanup failed: ${cleanupError.message}`, {
+                cause: creationError,
+            });
+        }
+        return creationError;
     }
     const workspace = response.data;
     if (!workspace?.directory || !workspace.id) {
-        return new Error('Workspace SDK returned no directory or ID');
+        const creationError = new Error('Workspace SDK returned no directory or ID');
+        const cleanupError = await cleanupFailedWorkspace(managedDirectory);
+        if (cleanupError instanceof Error) {
+            return new Error(`${creationError.message}; cleanup failed: ${cleanupError.message}`, {
+                cause: creationError,
+            });
+        }
+        return creationError;
+    }
+    const identityResult = await validateWorktreeIdentity({
+        projectDirectory,
+        worktreeDirectory: workspace.directory,
+        baseCommit,
+    });
+    if (identityResult instanceof Error) {
+        const cleanupError = await cleanupFailedWorkspace(workspace.directory);
+        if (cleanupError instanceof Error) {
+            return new Error(`${identityResult.message}; cleanup failed: ${cleanupError.message}`, { cause: identityResult });
+        }
+        return identityResult;
     }
     return { directory: workspace.directory, workspaceId: workspace.id };
 }
@@ -188,13 +244,13 @@ async function tryWorkspaceCreate({ threadId, worktreeName, projectDirectory, ba
  * starterMessage is optional — if omitted, status edits are skipped (creation
  * still proceeds). This keeps worktree creation independent of Discord message
  * delivery, so a transient send failure never silently skips the worktree.
+ * beforeReady can bind a session before incoming messages may use the checkout.
  *
  * Returns the worktree directory on success, or an Error on failure.
  * Never throws — all internal errors are caught and returned as Error values.
  */
-export async function createWorktreeInBackground({ thread, starterMessage, worktreeName, projectDirectory, baseBranch, rest, }) {
+export async function createWorktreeInBackground({ thread, starterMessage, worktreeName, projectDirectory, baseCommit, rest, beforeReady, }) {
     return (async () => {
-        logger.log(`Creating worktree "${worktreeName}" for project ${projectDirectory}${baseBranch ? ` from ${baseBranch}` : ''}`);
         // Serialize status message edits so onProgress can't overwrite the
         // final success/error edit even if Discord's API is slow.
         let editChain = Promise.resolve();
@@ -213,11 +269,23 @@ export async function createWorktreeInBackground({ thread, starterMessage, workt
             workspaceName: worktreeName,
             projectDirectory,
         });
+        const resolvedBaseCommit = baseCommit
+            ? baseCommit
+            : await resolveGitCommit({ directory: projectDirectory, ref: 'HEAD' });
+        if (resolvedBaseCommit instanceof Error) {
+            await setWorkspaceError({
+                threadId: thread.id,
+                errorMessage: resolvedBaseCommit.message,
+            });
+            editStatus(`🌳 **Worktree: ${worktreeName}**\n❌ ${resolvedBaseCommit.message}`);
+            await editChain;
+            return resolvedBaseCommit;
+        }
+        logger.log(`Creating worktree "${worktreeName}" for project ${projectDirectory} from ${resolvedBaseCommit}`);
         const workspaceResult = await tryWorkspaceCreate({
-            threadId: thread.id,
             worktreeName,
             projectDirectory,
-            baseBranch,
+            baseCommit: resolvedBaseCommit,
         });
         if (workspaceResult instanceof Error) {
             const errorMsg = workspaceResult.message;
@@ -227,6 +295,14 @@ export async function createWorktreeInBackground({ thread, starterMessage, workt
             await editChain;
             return workspaceResult;
         }
+        const preparationResult = beforeReady
+            ? await beforeReady(workspaceResult).catch((e) => new WorktreeError('Failed to prepare worktree session', { cause: e }))
+            : undefined;
+        if (preparationResult instanceof Error) {
+            logger.error('[WORKTREE] Session preparation failed:', preparationResult);
+            void notifyError(preparationResult, 'Worktree session preparation failed');
+            await sendThreadMessage(thread, `Worktree is ready, but failed to prepare its session: ${preparationResult.message}`);
+        }
         await setWorkspaceReady({
             threadId: thread.id,
             workspaceId: workspaceResult.workspaceId,
@@ -308,11 +384,11 @@ export async function handleNewWorktreeCommand({ command, appId, }) {
         return;
     }
     // Parallelize: base branch validation and existing worktree check are independent
-    const [baseBranch, existingWorktree] = await Promise.all([
+    const [baseCommit, existingWorktree] = await Promise.all([
         resolveRequestedWorktreeBaseRef({ projectDirectory, rawBaseBranch }),
         findExistingWorktreePath({ projectDirectory, worktreeName }),
     ]);
-    if (baseBranch instanceof Error) {
+    if (baseCommit instanceof Error) {
         await command.editReply(`Invalid base branch: \`${rawBaseBranch}\``);
         return;
     }
@@ -354,7 +430,7 @@ export async function handleNewWorktreeCommand({ command, appId, }) {
         starterMessage,
         worktreeName,
         projectDirectory,
-        baseBranch,
+        baseCommit,
         rest: command.client.rest,
     }).catch((e) => {
         logger.error('[NEW-WORKTREE] Background error:', e);
@@ -391,12 +467,12 @@ async function handleWorktreeInThread({ command, thread, appId, }) {
     // Parallelize: base branch validation, existing worktree check, and parent channel
     // resolve are all independent. resolveTextChannel fetches the parent from Discord
     // cache/API which can overlap with the git operations.
-    const [baseBranch, existingWorktreePath, textChannel] = await Promise.all([
+    const [baseCommit, existingWorktreePath, textChannel] = await Promise.all([
         resolveRequestedWorktreeBaseRef({ projectDirectory, rawBaseBranch }),
         findExistingWorktreePath({ projectDirectory, worktreeName }),
         resolveTextChannel(thread),
     ]);
-    if (baseBranch instanceof Error) {
+    if (baseCommit instanceof Error) {
         await command.editReply(`Invalid base branch: \`${rawBaseBranch}\``);
         return;
     }
@@ -440,86 +516,78 @@ async function handleWorktreeInThread({ command, thread, appId, }) {
         starterMessage: statusMessage,
         worktreeName,
         projectDirectory,
-        baseBranch,
+        baseCommit,
         rest: command.client.rest,
-    })
-        .then(async (result) => {
-        if (result instanceof Error)
-            return;
-        const sourceSessionId = await getThreadSession(thread.id);
-        if (!sourceSessionId) {
-            await sendThreadMessage(worktreeThread, 'Worktree is ready. Send a message here to start a fresh session in this checkout.');
-            return;
-        }
-        const workspace = await getThreadWorktreeOrWorkspace(worktreeThread.id);
-        if (!workspace?.workspace_id) {
-            await sendThreadMessage(worktreeThread, '✗ Worktree is ready, but OpenCode returned no workspace ID for context reuse.');
-            return;
-        }
-        const getClient = await initializeOpencodeForDirectory(result, {
-            originalRepoDirectory: projectDirectory,
-            channelId: parent.id,
-        });
-        if (getClient instanceof Error) {
-            await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to initialize OpenCode for context reuse: ${getClient.message}`);
-            return;
-        }
-        const forkResponse = await getClient().session.fork({
-            sessionID: sourceSessionId,
-            directory: result,
-            workspace: workspace.workspace_id,
-        }).catch((e) => new OpenCodeSdkError({ operation: 'session.fork', cause: e }));
-        if (forkResponse instanceof Error) {
-            logger.error('[NEW-WORKTREE] Failed to fork session into worktree:', forkResponse);
-            void notifyError(forkResponse, 'Failed to fork session into worktree');
-            await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to reuse session context there: ${forkResponse.message}`);
-            return;
-        }
-        const forkedSession = forkResponse.data;
-        if (!forkedSession) {
-            const error = new Error('OpenCode did not return a forked session');
-            logger.error('[NEW-WORKTREE] Failed to fork session into worktree:', error);
-            void notifyError(error, 'Failed to fork session into worktree');
-            await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to reuse session context there: ${error.message}`);
-            return;
-        }
-        await copyCurrentSessionModel({
-            sourceSessionId,
-            targetSessionId: forkedSession.id,
-            channelId: parent.id,
-            appId,
-            getClient,
-            directory: projectDirectory,
-        });
-        const permissionResponse = await getClient().session.update({
-            sessionID: forkedSession.id,
-            directory: result,
-            permission: buildSessionPermissions({
-                directory: result,
+        beforeReady: async ({ directory, workspaceId }) => {
+            const sourceSessionId = await getThreadSession(thread.id);
+            if (!sourceSessionId) {
+                await sendThreadMessage(worktreeThread, 'Worktree is ready. Send a message here to start a fresh session in this checkout.');
+                return;
+            }
+            const getClient = await initializeOpencodeForDirectory(directory, {
                 originalRepoDirectory: projectDirectory,
-            }),
-        }).catch((e) => new OpenCodeSdkError({ operation: 'session.update', cause: e }));
-        if (permissionResponse instanceof Error || permissionResponse.error) {
-            const error = permissionResponse instanceof Error
-                ? permissionResponse
-                : new Error('OpenCode rejected forked session permission update');
-            logger.error('[NEW-WORKTREE] Failed to update forked session permissions:', error);
-            void notifyError(error, 'Failed to update forked session permissions');
-            await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to update forked session permissions: ${error.message}`);
-            return;
-        }
-        await setThreadSession(worktreeThread.id, forkedSession.id);
-        getOrCreateRuntime({
-            threadId: worktreeThread.id,
-            thread: worktreeThread,
-            projectDirectory,
-            sdkDirectory: result,
-            channelId: parent.id,
-            appId,
-        });
-        await sendThreadMessage(worktreeThread, `Reusing context from <#${thread.id}> in worktree session \`${forkedSession.id}\`.`);
-    })
-        .catch((e) => {
+                channelId: parent.id,
+            });
+            if (getClient instanceof Error) {
+                await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to initialize OpenCode for context reuse: ${getClient.message}`);
+                return;
+            }
+            const forkResponse = await getClient().session.fork({
+                sessionID: sourceSessionId,
+                directory,
+                workspace: workspaceId,
+            }).catch((e) => new OpenCodeSdkError({ operation: 'session.fork', cause: e }));
+            if (forkResponse instanceof Error) {
+                logger.error('[NEW-WORKTREE] Failed to fork session into worktree:', forkResponse);
+                void notifyError(forkResponse, 'Failed to fork session into worktree');
+                await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to reuse session context there: ${forkResponse.message}`);
+                return;
+            }
+            const forkedSession = forkResponse.data;
+            if (!forkedSession) {
+                const error = new Error('OpenCode did not return a forked session');
+                logger.error('[NEW-WORKTREE] Failed to fork session into worktree:', error);
+                void notifyError(error, 'Failed to fork session into worktree');
+                await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to reuse session context there: ${error.message}`);
+                return;
+            }
+            await copyCurrentSessionModel({
+                sourceSessionId,
+                targetSessionId: forkedSession.id,
+                channelId: parent.id,
+                appId,
+                getClient,
+                directory: projectDirectory,
+            });
+            const permissionResponse = await getClient().session.update({
+                sessionID: forkedSession.id,
+                directory,
+                permission: buildSessionPermissions({
+                    directory,
+                    originalRepoDirectory: projectDirectory,
+                }),
+            }).catch((e) => new OpenCodeSdkError({ operation: 'session.update', cause: e }));
+            if (permissionResponse instanceof Error || permissionResponse.error) {
+                const error = permissionResponse instanceof Error
+                    ? permissionResponse
+                    : new Error('OpenCode rejected forked session permission update');
+                logger.error('[NEW-WORKTREE] Failed to update forked session permissions:', error);
+                void notifyError(error, 'Failed to update forked session permissions');
+                await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to update forked session permissions: ${error.message}`);
+                return;
+            }
+            await setThreadSession(worktreeThread.id, forkedSession.id);
+            getOrCreateRuntime({
+                threadId: worktreeThread.id,
+                thread: worktreeThread,
+                projectDirectory,
+                sdkDirectory: directory,
+                channelId: parent.id,
+                appId,
+            });
+            await sendThreadMessage(worktreeThread, `Reusing context from <#${thread.id}> in worktree session \`${forkedSession.id}\`.`);
+        },
+    }).catch((e) => {
         logger.error('[NEW-WORKTREE] Background error:', e);
         void notifyError(e, 'Background worktree creation failed (in-thread)');
     });

package/dist/commands/user-command.js

@@ -153,14 +153,12 @@ export const handleUserCommand = async ({ command, appId, }) => {
                     rest: command.client.rest,
                 });
             }
-            const sessionDirectory = await (async () => {
-                if (!worktreePromise)
-                    return projectDirectory;
-                const result = await worktreePromise;
-                if (result instanceof Error)
-                    return projectDirectory;
-                return result;
-            })();
+            const worktreeResult = worktreePromise ? await worktreePromise : projectDirectory;
+            if (worktreeResult instanceof Error) {
+                await command.editReply(`Worktree creation failed: ${worktreeResult.message}`);
+                return;
+            }
+            const sessionDirectory = worktreeResult;
             await command.editReply(`Started /${commandName} in ${newThread.toString()}`);
             const runtime = getOrCreateRuntime({
                 threadId: newThread.id,

package/dist/commands/worktrees.js

@@ -9,22 +9,15 @@ import { deleteThreadWorkspace, getChannelWorktreesEnabled, setChannelWorktreesE
 import { getDb } from '../db.js';
 import { splitTablesFromMarkdown, truncateComponents } from '../format-tables.js';
 import { buildHtmlActionCustomId, cancelHtmlActionsForOwner, registerHtmlAction, } from '../html-actions.js';
-import * as errore from 'errore';
 import crypto from 'node:crypto';
-import { GitCommandError, OpenCodeSdkError } from '../errors.js';
+import { OpenCodeSdkError } from '../errors.js';
 import { resolveTextChannel, resolveWorkingDirectory } from '../discord-utils.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
-import { deleteWorktree, git, getDefaultBranch, listGitWorktrees, } from '../worktrees.js';
+import { deleteWorktree, extractGitExecOutput, git, getDefaultBranch, listGitWorktrees, } from '../worktrees.js';
 import path from 'node:path';
-// Extracts the git stderr from a deleteWorktree error via errore.findCause.
-// Chain: Error { cause: GitCommandError { cause: CommandError { stderr } } }.
 export function extractGitStderr(error) {
-    const gitErr = errore.findCause(error, GitCommandError);
-    const stderr = gitErr?.cause?.stderr?.trim();
-    if (stderr && stderr.length > 0) {
-        return stderr;
-    }
-    return undefined;
+    const stderr = extractGitExecOutput(error).stderr;
+    return stderr.length > 0 ? stderr : undefined;
 }
 export function formatTimeAgo(date) {
     const diffMs = Date.now() - date.getTime();
@@ -73,8 +66,7 @@ function detectWorktreeSource({ branch, directory, }) {
 // Returns null when the directory is missing / git commands fail / timeout.
 async function getWorktreeGitStatus({ directory, defaultBranch, }) {
     try {
-        // Use raw git calls so errors/timeouts are visible — isDirty() swallows
-        // errors and returns false, which would render "merged" instead of "unknown".
+        // Use raw git calls so status and ahead-count share one timeout window.
         const [statusResult, aheadResult] = await Promise.all([
             git(directory, 'status --porcelain', { timeout: GIT_CMD_TIMEOUT }),
             git(directory, `rev-list --count "${defaultBranch}..HEAD"`, {

package/dist/config.js

@@ -10,7 +10,7 @@ import { store } from './store.js';
 const DEFAULT_DATA_DIR = path.join(os.homedir(), '.kimaki');
 /**
  * Get the data directory path.
- * Falls back to ~/.kimaki if not explicitly set.
+ * Order: store value, vitest temp dir, KIMAKI_DATA_DIR, then ~/.kimaki.
  * Under vitest (KIMAKI_VITEST env var), auto-creates an isolated temp dir so
  * tests never touch the real ~/.kimaki/ database. Tests that need a specific
  * dir can still call setDataDir() before any DB access to override this.
@@ -20,11 +20,20 @@ export function getDataDir() {
     if (current) {
         return current;
     }
+    // Tests stay isolated even if the parent process exported KIMAKI_DATA_DIR.
     if (process.env.KIMAKI_VITEST) {
         const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-test-'));
         store.setState({ dataDir: tmpDir });
         return tmpDir;
     }
+    // Child processes (OpenCode server, kimaki shim commands) inherit this from
+    // opencode.ts. Without it they would silently use ~/.kimaki.
+    const fromEnv = process.env.KIMAKI_DATA_DIR;
+    if (fromEnv) {
+        const resolved = path.resolve(fromEnv);
+        store.setState({ dataDir: resolved });
+        return resolved;
+    }
     store.setState({ dataDir: DEFAULT_DATA_DIR });
     return DEFAULT_DATA_DIR;
 }
@@ -79,6 +88,12 @@ export function getPermissionTimeoutMs() {
 export function getRestrictExternalDirectories() {
     return store.getState().restrictExternalDirectories;
 }
+export function getOpencodeHostname() {
+    return store.getState().opencodeHostname;
+}
+export function getOpencodePort() {
+    return store.getState().opencodePort;
+}
 const DEFAULT_LOCK_PORT = 29988;
 /**
  * Derive a lock port from the data directory path.

package/dist/database.js

@@ -213,6 +213,104 @@ export async function setSessionStartSource({ sessionId, scheduleKind, scheduled
         set: { schedule_kind: scheduleKind, scheduled_task_id: scheduledTaskId ?? null, updated_at: new Date() },
     });
 }
+export async function upsertSessionSleep({ sessionId, wakeAt, reason, }) {
+    const db = await getDb();
+    // A new occurrence gets a fresh delivery_id, which invalidates any in-flight
+    // wake for the previous occurrence: every delivery write is guarded on it.
+    const deliveryId = crypto.randomUUID();
+    await db.insert(schema.session_sleeps)
+        .values({
+        session_id: sessionId,
+        wake_at: wakeAt,
+        reason: reason ?? null,
+        status: 'planned',
+        delivery_id: deliveryId,
+    })
+        .onConflictDoUpdate({
+        target: schema.session_sleeps.session_id,
+        set: {
+            wake_at: wakeAt,
+            reason: reason ?? null,
+            status: 'planned',
+            delivery_id: deliveryId,
+            attempts: 0,
+            last_attempt_at: null,
+            created_at: new Date(),
+        },
+    });
+    return deliveryId;
+}
+export async function getSessionSleep({ sessionId }) {
+    const db = await getDb();
+    return await db.query.session_sleeps.findFirst({
+        where: { session_id: sessionId },
+    }) ?? null;
+}
+/** Rows that are due and not attempted too recently. Status stays `planned`. */
+export async function getDueSessionSleeps({ now, retryAfterMs, limit, }) {
+    const db = await getDb();
+    const retryBefore = new Date(now.getTime() - retryAfterMs);
+    return db.select()
+        .from(schema.session_sleeps)
+        .where(orm.and(orm.eq(schema.session_sleeps.status, 'planned'), orm.lte(schema.session_sleeps.wake_at, now), orm.or(orm.isNull(schema.session_sleeps.last_attempt_at), orm.lte(schema.session_sleeps.last_attempt_at, retryBefore))))
+        .orderBy(orm.asc(schema.session_sleeps.wake_at))
+        .limit(limit);
+}
+/**
+ * Reserve one delivery attempt. The row never leaves `planned` here.
+ *
+ * Only `last_attempt_at` moves, which keeps concurrent ticks off the same row
+ * for retryAfterMs. Because posting does not change the status either, one
+ * retry path covers every loss: dying before the post, dying after it, or
+ * never receiving the gateway event for the message we posted.
+ */
+export async function claimSessionSleepAttempt({ sessionId, deliveryId, now, retryAfterMs, }) {
+    const db = await getDb();
+    const retryBefore = new Date(now.getTime() - retryAfterMs);
+    const rows = await db.update(schema.session_sleeps)
+        .set({ last_attempt_at: now, attempts: orm.sql `${schema.session_sleeps.attempts} + 1` })
+        .where(orm.and(orm.eq(schema.session_sleeps.session_id, sessionId), orm.eq(schema.session_sleeps.delivery_id, deliveryId), orm.eq(schema.session_sleeps.status, 'planned'), orm.lte(schema.session_sleeps.wake_at, now), orm.or(orm.isNull(schema.session_sleeps.last_attempt_at), orm.lte(schema.session_sleeps.last_attempt_at, retryBefore))))
+        .returning();
+    return rows[0] ?? null;
+}
+export async function markSessionSleepFailed({ sessionId, deliveryId, }) {
+    const db = await getDb();
+    const rows = await db.update(schema.session_sleeps)
+        .set({ status: 'failed' })
+        .where(orm.and(orm.eq(schema.session_sleeps.session_id, sessionId), orm.eq(schema.session_sleeps.delivery_id, deliveryId), orm.eq(schema.session_sleeps.status, 'planned')))
+        .returning({ session_id: schema.session_sleeps.session_id });
+    return countRows(rows) > 0;
+}
+/**
+ * Ingress commit point. Marks the wake as delivered to the session.
+ *
+ * Returns false when the row is missing or no longer `planned`, which is how a
+ * wake that raced a user cancellation, or a duplicate of one already delivered,
+ * gets dropped instead of starting a turn.
+ */
+export async function consumeSessionSleepWake({ deliveryId }) {
+    const db = await getDb();
+    const rows = await db.update(schema.session_sleeps)
+        .set({ status: 'consumed' })
+        .where(orm.and(orm.eq(schema.session_sleeps.delivery_id, deliveryId), orm.eq(schema.session_sleeps.status, 'planned')))
+        .returning({ session_id: schema.session_sleeps.session_id });
+    return countRows(rows) > 0;
+}
+/**
+ * Cancel the pending sleep of the session currently bound to a thread.
+ *
+ * Runs on every ingress, so the binding is resolved with a correlated subquery
+ * rather than a second round trip. thread_id is the primary key of
+ * thread_sessions, so it yields at most one session.
+ */
+export async function cancelSessionSleepForThread({ threadId }) {
+    const db = await getDb();
+    const rows = await db.update(schema.session_sleeps)
+        .set({ status: 'cancelled' })
+        .where(orm.and(orm.eq(schema.session_sleeps.status, 'planned'), orm.eq(schema.session_sleeps.session_id, orm.sql `(SELECT ${schema.thread_sessions.session_id} FROM ${schema.thread_sessions} WHERE ${schema.thread_sessions.thread_id} = ${threadId})`)))
+        .returning({ session_id: schema.session_sleeps.session_id });
+    return countRows(rows) > 0;
+}
 export async function getSessionStartSourcesBySessionIds(sessionIds) {
     if (sessionIds.length === 0)
         return new Map();
@@ -440,9 +538,18 @@ export async function setThreadSession(threadId, sessionId) {
 }
 export async function upsertThreadSession({ threadId, sessionId, source }) {
     const db = await getDb();
+    // updated_at is written explicitly on BOTH paths, never left to the column's
+    // CURRENT_TIMESTAMP default. The default stores "YYYY-MM-DD HH:MM:SS" while
+    // Date values store ISO with a "T", and those two text formats do not sort
+    // against each other correctly. Writing ISO everywhere keeps the ordering in
+    // getThreadIdBySessionId honest and gives it millisecond resolution.
+    const boundAt = new Date();
     await db.insert(schema.thread_sessions)
-        .values({ thread_id: threadId, session_id: sessionId, source })
-        .onConflictDoUpdate({ target: schema.thread_sessions.thread_id, set: { session_id: sessionId, source } });
+        .values({ thread_id: threadId, session_id: sessionId, source, updated_at: boundAt })
+        .onConflictDoUpdate({
+        target: schema.thread_sessions.thread_id,
+        set: { session_id: sessionId, source, updated_at: boundAt },
+    });
 }
 export async function getThreadParentSessionId(threadId) {
     const db = await getDb();
@@ -462,9 +569,23 @@ export async function getThreadSessionSource(threadId) {
     const db = await getDb();
     return (await db.query.thread_sessions.findFirst({ where: { thread_id: threadId }, columns: { source: true } }))?.source;
 }
+/**
+ * Reverse lookup of the Discord thread that currently owns an OpenCode session.
+ *
+ * `thread_sessions.session_id` is NOT unique: /resume binds an existing session
+ * to a brand new thread without clearing the old row. An unordered findFirst
+ * therefore returns an arbitrary (often dead) thread, which made plugin tools
+ * post into the wrong conversation. Order by the most recent binding instead,
+ * falling back to created_at for rows written before updated_at existed.
+ */
 export async function getThreadIdBySessionId(sessionId) {
     const db = await getDb();
-    return (await db.query.thread_sessions.findFirst({ where: { session_id: sessionId } }))?.thread_id;
+    const rows = await db.select({ thread_id: schema.thread_sessions.thread_id })
+        .from(schema.thread_sessions)
+        .where(orm.eq(schema.thread_sessions.session_id, sessionId))
+        .orderBy(orm.desc(orm.sql `COALESCE(${schema.thread_sessions.updated_at}, ${schema.thread_sessions.created_at})`))
+        .limit(1);
+    return rows[0]?.thread_id;
 }
 export async function getAllThreadSessionIds() {
     const db = await getDb();