kimaki 0.4.46 → 0.4.47

package/dist/genai-worker-wrapper.js

@@ -2,9 +2,9 @@
 // Spawns and manages the worker thread, handling message passing for
 // audio input/output, tool call completions, and graceful shutdown.
 import { Worker } from 'node:worker_threads';
-import { createLogger } from './logger.js';
-const genaiWorkerLogger = createLogger('GENAI WORKER');
-const genaiWrapperLogger = createLogger('GENAI WORKER WRAPPER');
+import { createLogger, LogPrefix } from './logger.js';
+const genaiWorkerLogger = createLogger(LogPrefix.GENAI_WORKER);
+const genaiWrapperLogger = createLogger(LogPrefix.GENAI_WORKER);
 export function createGenAIWorker(options) {
     return new Promise((resolve, reject) => {
         const worker = new Worker(new URL('../dist/genai-worker.js', import.meta.url));

package/dist/genai-worker.js

@@ -10,11 +10,11 @@ import * as prism from 'prism-media';
 import { startGenAiSession } from './genai.js';
 import { getTools } from './tools.js';
 import { mkdir } from 'node:fs/promises';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 if (!parentPort) {
     throw new Error('This module must be run as a worker thread');
 }
-const workerLogger = createLogger(`WORKER ${threadId}`);
+const workerLogger = createLogger(`${LogPrefix.WORKER}_${threadId}`);
 workerLogger.log('GenAI worker started');
 // Define sendError early so it can be used by global handlers
 function sendError(error) {

package/dist/genai.js

@@ -3,9 +3,9 @@
 // and manages the assistant's audio output for Discord voice channels.
 import { GoogleGenAI, LiveServerMessage, MediaResolution, Modality, Session } from '@google/genai';
 import { writeFile } from 'fs';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import { aiToolToCallableTool } from './ai-tool-to-genai.js';
-const genaiLogger = createLogger('GENAI');
+const genaiLogger = createLogger(LogPrefix.GENAI);
 const audioParts = [];
 function saveBinaryFile(fileName, content) {
     writeFile(fileName, content, 'utf8', (err) => {

package/dist/interaction-handler.js

@@ -12,6 +12,7 @@ import { handleRemoveProjectCommand, handleRemoveProjectAutocomplete, } from './
 import { handleCreateNewProjectCommand } from './commands/create-new-project.js';
 import { handlePermissionSelectMenu } from './commands/permissions.js';
 import { handleAbortCommand } from './commands/abort.js';
+import { handleCompactCommand } from './commands/compact.js';
 import { handleShareCommand } from './commands/share.js';
 import { handleForkCommand, handleForkSelectMenu } from './commands/fork.js';
 import { handleModelCommand, handleProviderSelectMenu, handleModelSelectMenu, } from './commands/model.js';
@@ -21,8 +22,8 @@ import { handleQueueCommand, handleClearQueueCommand } from './commands/queue.js
 import { handleUndoCommand, handleRedoCommand } from './commands/undo-redo.js';
 import { handleUserCommand } from './commands/user-command.js';
 import { handleVerbosityCommand } from './commands/verbosity.js';
-import { createLogger } from './logger.js';
-const interactionLogger = createLogger('INTERACTION');
+import { createLogger, LogPrefix } from './logger.js';
+const interactionLogger = createLogger(LogPrefix.INTERACTION);
 export function registerInteractionHandler({ discordClient, appId, }) {
     interactionLogger.log('[REGISTER] Interaction handler registered');
     discordClient.on(Events.InteractionCreate, async (interaction) => {
@@ -85,6 +86,9 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     case 'stop':
                         await handleAbortCommand({ command: interaction, appId });
                         return;
+                    case 'compact':
+                        await handleCompactCommand({ command: interaction, appId });
+                        return;
                     case 'share':
                         await handleShareCommand({ command: interaction, appId });
                         return;

package/dist/logger.js

@@ -1,11 +1,49 @@
-// Prefixed logging utility using @clack/prompts.
-// Creates loggers with consistent prefixes for different subsystems
-// (DISCORD, VOICE, SESSION, etc.) for easier debugging.
-import { log } from '@clack/prompts';
+// Prefixed logging utility.
+// Uses picocolors for compact frequent logs (log, info, debug).
+// Uses @clack/prompts only for important events (warn, error) with visual distinction.
+import { log as clackLog } from '@clack/prompts';
 import fs from 'node:fs';
 import path, { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import util from 'node:util';
+import pc from 'picocolors';
+// All known log prefixes - add new ones here to keep alignment consistent
+export const LogPrefix = {
+    ABORT: 'ABORT',
+    ADD_PROJECT: 'ADD_PROJ',
+    AGENT: 'AGENT',
+    ASK_QUESTION: 'QUESTION',
+    CLI: 'CLI',
+    COMPACT: 'COMPACT',
+    CREATE_PROJECT: 'NEW_PROJ',
+    DB: 'DB',
+    DISCORD: 'DISCORD',
+    FORK: 'FORK',
+    FORMATTING: 'FORMAT',
+    GENAI: 'GENAI',
+    GENAI_WORKER: 'GENAI_W',
+    INTERACTION: 'INTERACT',
+    MARKDOWN: 'MARKDOWN',
+    MODEL: 'MODEL',
+    OPENAI: 'OPENAI',
+    OPENCODE: 'OPENCODE',
+    PERMISSIONS: 'PERMS',
+    QUEUE: 'QUEUE',
+    REMOVE_PROJECT: 'RM_PROJ',
+    RESUME: 'RESUME',
+    SESSION: 'SESSION',
+    SHARE: 'SHARE',
+    TOOLS: 'TOOLS',
+    UNDO_REDO: 'UNDO',
+    USER_CMD: 'USER_CMD',
+    VERBOSITY: 'VERBOSE',
+    VOICE: 'VOICE',
+    WORKER: 'WORKER',
+    WORKTREE: 'WORKTREE',
+    XML: 'XML',
+};
+// compute max length from all known prefixes for alignment
+const MAX_PREFIX_LENGTH = Math.max(...Object.values(LogPrefix).map((p) => p.length));
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const isDev = !__dirname.includes('node_modules');
@@ -32,27 +70,37 @@ function writeToFile(level, prefix, args) {
     const message = `[${timestamp}] [${level}] [${prefix}] ${args.map(formatArg).join(' ')}\n`;
     fs.appendFileSync(logFilePath, message);
 }
+function getTimestamp() {
+    const now = new Date();
+    return `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}`;
+}
+function padPrefix(prefix) {
+    return prefix.padEnd(MAX_PREFIX_LENGTH);
+}
 export function createLogger(prefix) {
+    const paddedPrefix = padPrefix(prefix);
     return {
         log: (...args) => {
             writeToFile('INFO', prefix, args);
-            log.info([`[${prefix}]`, ...args.map(formatArg)].join(' '));
+            console.log(pc.dim(getTimestamp()), pc.cyan(paddedPrefix), ...args.map(formatArg));
         },
         error: (...args) => {
             writeToFile('ERROR', prefix, args);
-            log.error([`[${prefix}]`, ...args.map(formatArg)].join(' '));
+            // use clack for errors - visually distinct
+            clackLog.error([paddedPrefix, ...args.map(formatArg)].join(' '));
         },
         warn: (...args) => {
             writeToFile('WARN', prefix, args);
-            log.warn([`[${prefix}]`, ...args.map(formatArg)].join(' '));
+            // use clack for warnings - visually distinct
+            clackLog.warn([paddedPrefix, ...args.map(formatArg)].join(' '));
         },
         info: (...args) => {
             writeToFile('INFO', prefix, args);
-            log.info([`[${prefix}]`, ...args.map(formatArg)].join(' '));
+            console.log(pc.dim(getTimestamp()), pc.blue(paddedPrefix), ...args.map(formatArg));
         },
         debug: (...args) => {
             writeToFile('DEBUG', prefix, args);
-            log.info([`[${prefix}]`, ...args.map(formatArg)].join(' '));
+            console.log(pc.dim(getTimestamp()), pc.dim(paddedPrefix), ...args.map(formatArg));
         },
     };
 }

package/dist/markdown.js

@@ -7,7 +7,7 @@ import { createTaggedError } from 'errore';
 import * as yaml from 'js-yaml';
 import { formatDateTime } from './utils.js';
 import { extractNonXmlContent } from './xml.js';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import { SessionNotFoundError, MessagesNotFoundError } from './errors.js';
 // Generic error for unexpected exceptions in async operations
 class UnexpectedError extends createTaggedError({
@@ -15,7 +15,7 @@ class UnexpectedError extends createTaggedError({
     message: '$message',
 }) {
 }
-const markdownLogger = createLogger('MARKDOWN');
+const markdownLogger = createLogger(LogPrefix.MARKDOWN);
 export class ShareMarkdown {
     client;
     constructor(client) {

package/dist/message-formatting.js

@@ -4,10 +4,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import * as errore from 'errore';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import { FetchError } from './errors.js';
 const ATTACHMENTS_DIR = path.join(process.cwd(), 'tmp', 'discord-attachments');
-const logger = createLogger('FORMATTING');
+const logger = createLogger(LogPrefix.FORMATTING);
 /**
  * Escapes Discord inline markdown characters so dynamic content
  * doesn't break formatting when wrapped in *, _, **, etc.
@@ -15,6 +15,12 @@ const logger = createLogger('FORMATTING');
 function escapeInlineMarkdown(text) {
     return text.replace(/([*_~|`\\])/g, '\\$1');
 }
+/**
+ * Normalize whitespace: convert newlines to spaces and collapse consecutive spaces.
+ */
+function normalizeWhitespace(text) {
+    return text.replace(/[\r\n]+/g, ' ').replace(/\s+/g, ' ');
+}
 /**
  * Collects and formats the last N assistant parts from session messages.
  * Used by both /resume and /fork to show recent assistant context.
@@ -125,6 +131,61 @@ export function getToolSummaryText(part) {
             ? `*${escapeInlineMarkdown(fileName)}* (+${added}-${removed})`
             : `(+${added}-${removed})`;
     }
+    if (part.tool === 'apply_patch') {
+        const state = part.state;
+        const rawFiles = state.metadata?.files;
+        const partMetaFiles = part.metadata?.files;
+        const filesList = Array.isArray(rawFiles)
+            ? rawFiles
+            : Array.isArray(partMetaFiles)
+                ? partMetaFiles
+                : [];
+        const summarizeFiles = (files) => {
+            const summarized = files
+                .map((f) => {
+                if (!f) {
+                    return null;
+                }
+                if (typeof f === 'string') {
+                    const fileName = f.split('/').pop() || '';
+                    return fileName ? `*${escapeInlineMarkdown(fileName)}* (+0-0)` : `(+0-0)`;
+                }
+                if (typeof f !== 'object') {
+                    return null;
+                }
+                const file = f;
+                const pathStr = String(file.relativePath || file.filePath || file.path || '');
+                const fileName = pathStr.split('/').pop() || '';
+                const added = typeof file.additions === 'number' ? file.additions : 0;
+                const removed = typeof file.deletions === 'number' ? file.deletions : 0;
+                return fileName
+                    ? `*${escapeInlineMarkdown(fileName)}* (+${added}-${removed})`
+                    : `(+${added}-${removed})`;
+            })
+                .filter(Boolean)
+                .join(', ');
+            return summarized;
+        };
+        if (filesList.length > 0) {
+            const summarized = summarizeFiles(filesList);
+            if (summarized) {
+                return summarized;
+            }
+        }
+        const outputText = typeof state.output === 'string' ? state.output : '';
+        const outputLines = outputText.split('\n');
+        const updatedIndex = outputLines.findIndex((line) => line.startsWith('Success. Updated the following files:'));
+        if (updatedIndex !== -1) {
+            const fileLines = outputLines.slice(updatedIndex + 1).filter(Boolean);
+            if (fileLines.length > 0) {
+                const summarized = summarizeFiles(fileLines.map((line) => line.replace(/^[AMD]\s+/, '').trim()));
+                if (summarized) {
+                    return summarized;
+                }
+            }
+        }
+        return '';
+    }
     if (part.tool === 'write') {
         const filePath = part.state.input?.filePath || '';
         const content = part.state.input?.content || '';
@@ -175,7 +236,8 @@ export function getToolSummaryText(part) {
         if (value === null || value === undefined)
             return null;
         const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
-        const truncatedValue = stringValue.length > 50 ? stringValue.slice(0, 50) + '…' : stringValue;
+        const normalized = normalizeWhitespace(stringValue);
+        const truncatedValue = normalized.length > 50 ? normalized.slice(0, 50) + '…' : normalized;
         return `${key}: ${truncatedValue}`;
     })
         .filter(Boolean);
@@ -201,7 +263,7 @@ export function formatTodoList(part) {
     return `${num} **${escapeInlineMarkdown(content)}**`;
 }
 export function formatPart(part, prefix) {
-    const pfx = prefix ? `${prefix}: ` : '';
+    const pfx = prefix ? `${prefix} ⋅ ` : '';
     if (part.type === 'text') {
         if (!part.text?.trim())
             return '';
@@ -278,12 +340,13 @@ export function formatPart(part, prefix) {
             if (part.state.status === 'error') {
                 return '⨯';
             }
-            if (part.tool === 'edit' || part.tool === 'write') {
+            if (part.tool === 'edit' || part.tool === 'write' || part.tool === 'apply_patch') {
                 return '◼︎';
             }
             return '┣';
         })();
-        return `${icon} ${pfx}${part.tool} ${toolTitle} ${summaryText}`.trim();
+        const toolParts = [part.tool, toolTitle, summaryText].filter(Boolean).join(' ');
+        return `${icon} ${pfx}${toolParts}`;
     }
     logger.warn('Unknown part type:', part);
     return '';

package/dist/openai-realtime.js

@@ -3,8 +3,8 @@
 // @ts-nocheck
 import { RealtimeClient } from '@openai/realtime-api-beta';
 import { writeFile } from 'fs';
-import { createLogger } from './logger.js';
-const openaiLogger = createLogger('OPENAI');
+import { createLogger, LogPrefix } from './logger.js';
+const openaiLogger = createLogger(LogPrefix.OPENAI);
 const audioParts = [];
 function saveBinaryFile(fileName, content) {
     writeFile(fileName, content, 'utf8', (err) => {

package/dist/opencode.js

@@ -8,9 +8,9 @@ import net from 'node:net';
 import { createOpencodeClient } from '@opencode-ai/sdk';
 import { createOpencodeClient as createOpencodeClientV2, } from '@opencode-ai/sdk/v2';
 import * as errore from 'errore';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import { DirectoryNotAccessibleError, ServerStartError, ServerNotReadyError, FetchError, } from './errors.js';
-const opencodeLogger = createLogger('OPENCODE');
+const opencodeLogger = createLogger(LogPrefix.OPENCODE);
 const opencodeServers = new Map();
 const serverRetryCount = new Map();
 async function getOpenPort() {

package/dist/session-handler.js

@@ -7,14 +7,14 @@ import { initializeOpencodeForDirectory, getOpencodeServers, getOpencodeClientV2
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS } from './discord-utils.js';
 import { formatPart } from './message-formatting.js';
 import { getOpencodeSystemMessage } from './system-message.js';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import { isAbortError } from './utils.js';
 import { showAskUserQuestionDropdowns, cancelPendingQuestion, pendingQuestionContexts, } from './commands/ask-question.js';
 import { showPermissionDropdown, cleanupPermissionContext, addPermissionRequestToContext, } from './commands/permissions.js';
 import * as errore from 'errore';
-const sessionLogger = createLogger('SESSION');
-const voiceLogger = createLogger('VOICE');
-const discordLogger = createLogger('DISCORD');
+const sessionLogger = createLogger(LogPrefix.SESSION);
+const voiceLogger = createLogger(LogPrefix.VOICE);
+const discordLogger = createLogger(LogPrefix.DISCORD);
 export const abortControllers = new Map();
 // Track multiple pending permissions per thread (keyed by permission ID)
 // OpenCode handles blocking/sequencing - we just need to track all pending permissions
@@ -56,7 +56,7 @@ export async function abortAndRetrySession({ sessionId, thread, projectDirectory
     }
     sessionLogger.log(`[ABORT+RETRY] Aborting session ${sessionId} for model change`);
     // Abort with special reason so we don't show "completed" message
-    controller.abort('model-change');
+    controller.abort(new Error('model-change'));
     // Also call the API abort endpoint
     const getClient = await initializeOpencodeForDirectory(projectDirectory);
     if (getClient instanceof Error) {
@@ -220,10 +220,10 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             await sendThreadMessage(thread, `⚠️ ${rejectedCount} pending permission request${plural} auto-rejected due to new message`);
         }
     }
-    // Cancel any pending question tool if user sends a new message (silently, no thread message)
-    const questionCancelled = await cancelPendingQuestion(thread.id);
-    if (questionCancelled) {
-        sessionLogger.log(`[QUESTION] Cancelled pending question due to new message`);
+    // Answer any pending question tool with the user's message (silently, no thread message)
+    const questionAnswered = await cancelPendingQuestion(thread.id, prompt);
+    if (questionAnswered) {
+        sessionLogger.log(`[QUESTION] Answered pending question with user message`);
     }
     const abortController = new AbortController();
     abortControllers.set(session.id, abortController);
@@ -272,6 +272,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
     let usedAgent;
     let tokensUsedInSession = 0;
     let lastDisplayedContextPercentage = 0;
+    let lastRateLimitDisplayTime = 0;
     let modelContextLimit;
     let assistantMessageId;
     let handlerPromise = null;
@@ -725,10 +726,44 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 });
             });
         };
+        const handleSessionStatus = async (properties) => {
+            if (properties.sessionID !== session.id) {
+                return;
+            }
+            if (properties.status.type !== 'retry') {
+                return;
+            }
+            // Throttle to once per 10 seconds
+            const now = Date.now();
+            if (now - lastRateLimitDisplayTime < 10_000) {
+                return;
+            }
+            lastRateLimitDisplayTime = now;
+            const { attempt, message, next } = properties.status;
+            const remainingMs = Math.max(0, next - now);
+            const remainingSec = Math.ceil(remainingMs / 1000);
+            const duration = (() => {
+                if (remainingSec < 60) {
+                    return `${remainingSec}s`;
+                }
+                const mins = Math.floor(remainingSec / 60);
+                const secs = remainingSec % 60;
+                return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
+            })();
+            const chunk = `⬦ ${message} - retrying in ${duration} (attempt #${attempt})`;
+            await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS });
+        };
         const handleSessionIdle = (idleSessionId) => {
             if (idleSessionId === session.id) {
+                // Ignore stale session.idle events - if we haven't received any content yet
+                // (no assistantMessageId set), this is likely a stale event from before
+                // the prompt was sent or from a previous request's subscription state.
+                if (!assistantMessageId) {
+                    sessionLogger.log(`[SESSION IDLE] Ignoring stale idle event for ${session.id} (no content received yet)`);
+                    return;
+                }
                 sessionLogger.log(`[SESSION IDLE] Session ${session.id} is idle, aborting`);
-                abortController.abort('finished');
+                abortController.abort(new Error('finished'));
                 return;
             }
             if (!subtaskSessions.has(idleSessionId)) {
@@ -763,6 +798,9 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                     case 'session.idle':
                         handleSessionIdle(event.properties.sessionID);
                         break;
+                    case 'session.status':
+                        await handleSessionStatus(event.properties);
+                        break;
                     default:
                         break;
                 }
@@ -791,7 +829,8 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 stopTyping();
                 stopTyping = null;
             }
-            if (!abortController.signal.aborted || abortController.signal.reason === 'finished') {
+            const abortReason = abortController.signal.reason?.message;
+            if (!abortController.signal.aborted || abortReason === 'finished') {
                 const sessionDuration = prettyMilliseconds(Date.now() - sessionStartTime);
                 const attachCommand = port ? ` ⋅ ${session.id}` : '';
                 const modelInfo = usedModel ? ` ⋅ ${usedModel}` : '';
@@ -860,7 +899,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 }
             }
             else {
-                sessionLogger.log(`Session was aborted (reason: ${abortController.signal.reason}), skipping duration message`);
+                sessionLogger.log(`Session was aborted (reason: ${abortReason}), skipping duration message`);
             }
         }
     };
@@ -958,7 +997,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             })();
             throw new Error(`OpenCode API error (${response.response.status}): ${errorMessage}`);
         }
-        abortController.abort('finished');
+        abortController.abort(new Error('finished'));
         sessionLogger.log(`Successfully sent prompt, got response`);
         if (originalMessage) {
             const reactionResult = await errore.tryAsync(async () => {
@@ -987,7 +1026,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
         return;
     }
     sessionLogger.error(`ERROR: Failed to send prompt:`, promptError);
-    abortController.abort('error');
+    abortController.abort(new Error('error'));
     if (originalMessage) {
         const reactionResult = await errore.tryAsync(async () => {
             await originalMessage.reactions.removeAll();

package/dist/tools.js

@@ -6,9 +6,9 @@ import { z } from 'zod';
 import { spawn } from 'node:child_process';
 import net from 'node:net';
 import { createOpencodeClient, } from '@opencode-ai/sdk';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import * as errore from 'errore';
-const toolsLogger = createLogger('TOOLS');
+const toolsLogger = createLogger(LogPrefix.TOOLS);
 import { ShareMarkdown } from './markdown.js';
 import { formatDistanceToNow } from './utils.js';
 import pc from 'picocolors';

package/dist/voice-handler.js

@@ -17,8 +17,8 @@ import { getDatabase } from './database.js';
 import { sendThreadMessage, escapeDiscordFormatting, SILENT_MESSAGE_FLAGS, } from './discord-utils.js';
 import { transcribeAudio } from './voice.js';
 import { FetchError } from './errors.js';
-import { createLogger } from './logger.js';
-const voiceLogger = createLogger('VOICE');
+import { createLogger, LogPrefix } from './logger.js';
+const voiceLogger = createLogger(LogPrefix.VOICE);
 export const voiceConnections = new Map();
 export function convertToMono16k(buffer) {
     const inputSampleRate = 48000;

package/dist/voice.js

@@ -4,11 +4,11 @@
 // Uses errore for type-safe error handling.
 import { GoogleGenAI, Type } from '@google/genai';
 import * as errore from 'errore';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 import { glob } from 'glob';
 import { ripGrep } from 'ripgrep-js';
 import { ApiKeyMissingError, InvalidAudioFormatError, TranscriptionError, EmptyTranscriptionError, NoResponseContentError, NoToolResponseError, GrepSearchError, GlobSearchError, } from './errors.js';
-const voiceLogger = createLogger('VOICE');
+const voiceLogger = createLogger(LogPrefix.VOICE);
 function runGrep({ pattern, directory }) {
     return errore.tryAsync({
         try: async () => {

package/dist/worktree-utils.js

@@ -1,15 +1,19 @@
 // Worktree utility functions.
 // Wrapper for OpenCode worktree creation that also initializes git submodules.
-import { exec } from 'node:child_process';
+// Also handles capturing and applying git diffs when creating worktrees from threads.
+import { exec, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
-import { createLogger } from './logger.js';
+import { createLogger, LogPrefix } from './logger.js';
 export const execAsync = promisify(exec);
-const logger = createLogger('WORKTREE-UTILS');
+const logger = createLogger(LogPrefix.WORKTREE);
 /**
  * Create a worktree using OpenCode SDK and initialize git submodules.
  * This wrapper ensures submodules are properly set up in new worktrees.
+ *
+ * If diff is provided, it's applied BEFORE submodule update to ensure
+ * any submodule pointer changes in the diff are respected.
  */
-export async function createWorktreeWithSubmodules({ clientV2, directory, name, }) {
+export async function createWorktreeWithSubmodules({ clientV2, directory, name, diff, }) {
     // 1. Create worktree via OpenCode SDK
     const response = await clientV2.worktree.create({
         directory,
@@ -22,7 +26,17 @@ export async function createWorktreeWithSubmodules({ clientV2, directory, name,
         return new Error('No worktree data returned from SDK');
     }
     const worktreeDir = response.data.directory;
-    // 2. Init submodules in new worktree (don't block on failure)
+    let diffApplied = false;
+    // 2. Apply diff BEFORE submodule update (if provided)
+    // This ensures any submodule pointer changes in the diff are applied first,
+    // so submodule update checks out the correct commits.
+    if (diff) {
+        logger.log(`Applying diff to ${worktreeDir} before submodule init`);
+        diffApplied = await applyGitDiff(worktreeDir, diff);
+    }
+    // 3. Init submodules in new worktree (don't block on failure)
+    // Uses --init to initialize, --recursive for nested submodules.
+    // Submodules will be checked out at the commit specified by the (possibly updated) index.
     try {
         logger.log(`Initializing submodules in ${worktreeDir}`);
         await execAsync('git submodule update --init --recursive', {
@@ -34,7 +48,7 @@ export async function createWorktreeWithSubmodules({ clientV2, directory, name,
         // Log but don't fail - submodules might not exist
         logger.warn(`Failed to init submodules in ${worktreeDir}: ${e instanceof Error ? e.message : String(e)}`);
     }
-    // 3. Install dependencies using ni (detects package manager from lockfile)
+    // 4. Install dependencies using ni (detects package manager from lockfile)
     try {
         logger.log(`Installing dependencies in ${worktreeDir}`);
         await execAsync('npx -y ni', {
@@ -46,5 +60,75 @@ export async function createWorktreeWithSubmodules({ clientV2, directory, name,
         // Log but don't fail - might not be a JS project or might fail for various reasons
         logger.warn(`Failed to install dependencies in ${worktreeDir}: ${e instanceof Error ? e.message : String(e)}`);
     }
-    return response.data;
+    return { ...response.data, diffApplied };
+}
+/**
+ * Capture git diff from a directory (both staged and unstaged changes).
+ * Returns null if no changes or on error.
+ */
+export async function captureGitDiff(directory) {
+    try {
+        // Capture unstaged changes
+        const unstagedResult = await execAsync('git diff', { cwd: directory });
+        const unstaged = unstagedResult.stdout.trim();
+        // Capture staged changes
+        const stagedResult = await execAsync('git diff --staged', { cwd: directory });
+        const staged = stagedResult.stdout.trim();
+        if (!unstaged && !staged) {
+            return null;
+        }
+        return { unstaged, staged };
+    }
+    catch (e) {
+        logger.warn(`Failed to capture git diff from ${directory}: ${e instanceof Error ? e.message : String(e)}`);
+        return null;
+    }
+}
+/**
+ * Run a git command with stdin input.
+ * Uses spawn to pipe the diff content to git apply.
+ */
+function runGitWithStdin(args, cwd, input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', args, { cwd, stdio: ['pipe', 'pipe', 'pipe'] });
+        let stderr = '';
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(stderr || `git ${args.join(' ')} failed with code ${code}`));
+            }
+        });
+        child.on('error', reject);
+        child.stdin?.write(input);
+        child.stdin?.end();
+    });
+}
+/**
+ * Apply a captured git diff to a directory.
+ * Applies staged changes first, then unstaged.
+ */
+export async function applyGitDiff(directory, diff) {
+    try {
+        // Apply staged changes first (and stage them)
+        if (diff.staged) {
+            logger.log(`Applying staged diff to ${directory}`);
+            await runGitWithStdin(['apply', '--index'], directory, diff.staged);
+        }
+        // Apply unstaged changes (don't stage them)
+        if (diff.unstaged) {
+            logger.log(`Applying unstaged diff to ${directory}`);
+            await runGitWithStdin(['apply'], directory, diff.unstaged);
+        }
+        logger.log(`Successfully applied diff to ${directory}`);
+        return true;
+    }
+    catch (e) {
+        logger.warn(`Failed to apply git diff to ${directory}: ${e instanceof Error ? e.message : String(e)}`);
+        return false;
+    }
 }

package/dist/xml.js

@@ -2,8 +2,8 @@
 // Parses XML-like tags from strings (e.g., channel topics) to extract
 // Kimaki configuration like directory paths and app IDs.
 import { DomHandler, Parser, ElementType } from 'htmlparser2';
-import { createLogger } from './logger.js';
-const xmlLogger = createLogger('XML');
+import { createLogger, LogPrefix } from './logger.js';
+const xmlLogger = createLogger(LogPrefix.XML);
 export function extractTagsArrays({ xml, tags, }) {
     const result = {
         others: [],