kimaki 0.30.0 → 0.31.0

package/dist/session-handler/thread-session-runtime.js

@@ -17,7 +17,7 @@ import { isAbortError } from '../utils.js';
 import { registerEventListener, unregisterEventListener, waitForGlobalEventListener, } from './global-event-listener.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { sendThreadMessage, sendSessionPartMessage, SILENT_MESSAGE_FLAGS, NOTIFY_MESSAGE_FLAGS, raceDiscordRename, DISCORD_THREAD_RENAME_TIMEOUT_MS, resolveThreadFooterMentionUserId, resolveWorkingDirectory, } from '../discord-utils.js';
-import { asDiscordQuote, asSystemLine, formatPart, formatTaskToolTitle, planAssistantTurnFlush, QUEUE_PREFIX, sessionPartContent, sessionPartKind, shouldLeadWithBlankLine, shouldQuoteIntermediateTextPart, STATUS_PREFIX, WORKTREE_PREFIX, } from '../message-formatting.js';
+import { asDiscordQuote, asSubtext, formatPart, formatTaskToolTitle, planAssistantTurnFlush, sessionPartContent, sessionPartKind, shouldLeadWithBlankLine, shouldQuoteIntermediateTextPart, STATUS_PREFIX, WORKTREE_PREFIX, } from '../message-formatting.js';
 import { getChannelVerbosity, getPartMessageIds, getDb, setPartMessage, getThreadSession, setThreadSession, getThreadParentSessionId, setThreadParentSessionId, getThreadWorktreeOrWorkspace, setSessionAgent, setSessionModel, clearSessionModel, getVariantCascade, setSessionStartSource, getSessionStartSource, getScheduledTask, completeScheduledTaskRunsForSession, failScheduledTaskRunsForSession, startScheduledTaskRunSession, appendSessionEventsSinceLastTimestamp, getSessionEventSnapshot, cancelSessionSleepForThread, insertThreadQueueItem, listAllThreadQueueItems, deleteThreadQueueItem, deleteThreadQueueItems, updateThreadQueueItemPayload, } from '../database.js';
 import * as orm from 'drizzle-orm';
 import * as schema from '../schema.js';
@@ -27,14 +27,14 @@ import { showActionButtons, waitForQueuedActionButtonsRequest, pendingActionButt
 import { pendingFileUploadContexts, cancelPendingFileUpload, } from '../commands/file-upload.js';
 import { getCurrentModelInfo, ensureSessionPreferencesSnapshot, } from '../commands/model.js';
 import { displayedModelLabel, resolveDisplayedModelName, validateModelId, } from './model-utils.js';
-import { getOpencodePromptContext, getOpencodeSystemMessage, writeSessionSystemPrompt, } from '../system-message.js';
+import { getOpencodePromptContext, getOpencodeSystemMessage, isSystemPromptForSession, resolveSessionSystemPrompt, systemPromptHasParentSession, } from '../system-message.js';
 import { getDataDir } from '../config.js';
 import { countSystemPromptDiffLines } from '../cache-rewrite.js';
 import { store } from '../store.js';
 import { trackEvent, } from '../analytics.js';
 import { resolveValidatedAgentPreference } from './agent-utils.js';
 import { appendOpencodeSessionEventLog, getOpencodeEventSessionId, isOpencodeSessionEventLogEnabled, } from './opencode-session-event-log.js';
-import { doesLatestUserTurnHaveNaturalCompletion, didLatestUserTurnUseSleepTool, didQuestionQueueHandoffSinceLatestQuestionAsked, deriveLatestUnansweredQuestion, getAssistantMessageIdsForLatestUserTurn, getCurrentTurnStartTime, isSessionBusy, getLatestRunInfo, getPromptCacheClear, formatPromptCacheClearMessage, getIdleTokenUsageDelta, getDerivedSubtaskIndex, getDerivedSubtaskAgentType, getTokenUsageSessionIdsForIdle, isDerivedChildSession, getLatestAssistantMessageIdForLatestUserTurn, getAssistantMessageKind, hasAssistantMessageCompletedBefore, isAssistantMessageInLatestUserTurn, isAssistantMessageNaturalCompletion, shouldBufferSessionEvent, shouldRetainSessionEvent, trimEventBuffer, } from './event-stream-state.js';
+import { doesLatestUserTurnHaveNaturalCompletion, didLatestUserTurnUseSleepTool, didQuestionQueueHandoffSinceLatestQuestionAsked, deriveLatestUnansweredQuestion, getAssistantMessageIdsForLatestUserTurn, getCurrentTurnStartTime, isSessionBusy, getLatestRunInfo, getPromptCacheClear, formatPromptCacheClearMessage, getIdleTokenUsageDelta, getDerivedSubtaskLabel, getTokenUsageSessionIdsForIdle, isDerivedChildSession, getLatestAssistantMessageIdForLatestUserTurn, getAssistantMessageKind, hasAssistantMessageCompletedBefore, isAssistantMessageInLatestUserTurn, isAssistantMessageNaturalCompletion, shouldBufferSessionEvent, shouldRetainSessionEvent, trimEventBuffer, } from './event-stream-state.js';
 // Track multiple pending permissions per thread (keyed by permission ID).
 // OpenCode handles blocking/sequencing — we just need to track all pending
 // permissions to avoid duplicates and properly clean up on reply/teardown.
@@ -789,17 +789,13 @@ export class ThreadSessionRuntime {
         })) {
             return undefined;
         }
-        const subtaskIndex = getDerivedSubtaskIndex({
+        const label = getDerivedSubtaskLabel({
             events: this.eventBuffer,
             mainSessionId,
             candidateSessionId,
         });
-        const agentType = getDerivedSubtaskAgentType({
-            events: this.eventBuffer,
-            mainSessionId,
-            candidateSessionId,
-        });
-        const label = `${agentType || 'task'}-${subtaskIndex || 1}`;
+        if (!label)
+            return undefined;
         const assistantMessageId = this.getLatestAssistantMessageIdForCurrentTurn({
             sessionId: candidateSessionId,
         });
@@ -1005,6 +1001,15 @@ export class ThreadSessionRuntime {
         });
         this.persistEventBufferDebounced.trigger();
     }
+    seedForkPromptCacheBaseline(message) {
+        if (message.sessionID !== this.state?.sessionId || this.eventBuffer.length > 0)
+            return;
+        this.appendEventToBuffer({
+            id: `fork-cache-baseline-${message.id}`,
+            type: 'message.updated',
+            properties: { sessionID: message.sessionID, info: message },
+        });
+    }
     // Queue-dispatch lifecycle markers are synthetic buffer-only events.
     // They are not fed into handleEvent(), so they do not emit Discord messages;
     // they only stabilize event-derived busy/idle gating for local queue drains.
@@ -1422,13 +1427,10 @@ export class ThreadSessionRuntime {
     }
     async unquoteFinalTextPart() {
         const parts = this.getCurrentTurnParts();
-        const finalPart = planAssistantTurnFlush({
-            parts,
-            mode: 'final',
-        }).sendParts.at(-1);
-        if (!finalPart || finalPart.quoteText || finalPart.part.type !== 'text')
+        const finalPart = parts.findLast((part) => part.type === 'text' || part.type === 'tool');
+        if (!finalPart || finalPart.type !== 'text')
             return;
-        const last = finalPart.part;
+        const last = finalPart;
         const db = await getDb();
         const row = await db.query.part_messages.findFirst({
             where: { part_id: last.id },
@@ -1653,14 +1655,15 @@ export class ThreadSessionRuntime {
             upToIndex: this.eventBuffer.length - 2,
         });
         const completedAt = msg.time.completed;
-        if (!wasAlreadyCompleted
-            && typeof completedAt === 'number'
-            && isAssistantMessageNaturalCompletion({ message: msg })) {
-            await this.handleNaturalAssistantCompletion({
-                completedMessageId: msg.id,
-                completedAt,
-            });
-            return;
+        if (!wasAlreadyCompleted && typeof completedAt === 'number') {
+            if (isAssistantMessageNaturalCompletion({ message: msg })) {
+                await this.handleNaturalAssistantCompletion({
+                    completedMessageId: msg.id,
+                    completedAt,
+                });
+                return;
+            }
+            await this.maybeNotifyPromptCacheClear({ sessionId, messageId: msg.id });
         }
         // Context usage notice.
         // Skip the final assistant update for a run: by the time the last
@@ -1693,7 +1696,7 @@ export class ThreadSessionRuntime {
             return;
         }
         this.lastDisplayedContextPercentage = thresholdCrossed;
-        const chunk = `${STATUS_PREFIX}context usage ${currentPercentage}%`;
+        const chunk = asSubtext(`context usage ${currentPercentage}%`);
         const sendResult = await this.thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
             .catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
         if (sendResult instanceof Error) {
@@ -1877,7 +1880,7 @@ export class ThreadSessionRuntime {
                         }
                         return ` (${pct.toFixed(1)}%)`;
                     })();
-                    const chunk = `${STATUS_PREFIX}${part.tool} returned ${formattedTokens} tokens${percentageSuffix}`;
+                    const chunk = asSubtext(`${STATUS_PREFIX}${part.tool} returned ${formattedTokens} tokens${percentageSuffix}`);
                     const largeOutputResult = await this.thread.send({
                         content: chunk,
                         flags: SILENT_MESSAGE_FLAGS,
@@ -2335,16 +2338,14 @@ export class ThreadSessionRuntime {
             logger.log(`[QUESTION QUEUE HANDOFF] Session changed before queue handoff for thread ${this.threadId}`);
             return;
         }
+        // Only a prompt can answer a pending question; a fork must wait for idle.
+        if (this.state?.queueItems[0]?.queuedAction === 'btw')
+            return;
         const next = threadState.dequeueItem(this.threadId);
         if (!next) {
             return;
         }
-        const displayText = next.command
-            ? `/${next.command.name}`
-            : `${next.prompt.slice(0, 150)}${next.prompt.length > 150 ? '...' : ''}`;
-        if (displayText.trim()) {
-            await sendThreadMessage(this.thread, `${QUEUE_PREFIX}**${next.username}:** ${displayText}`);
-        }
+        await this.sendQueueDrainIndicator(next);
         this.markQuestionQueueHandoffStarted(sessionId);
         await this.submitViaOpencodeQueue(next);
     }
@@ -2381,7 +2382,7 @@ export class ThreadSessionRuntime {
             const secs = remainingSec % 60;
             return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
         })();
-        const chunk = `${STATUS_PREFIX}${message} - retrying in ${duration} (attempt #${attempt})`;
+        const chunk = asSubtext(`${message} - retrying in ${duration} (attempt #${attempt})`);
         const retryResult = await this.thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
             .catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
         if (retryResult instanceof Error) {
@@ -2447,7 +2448,7 @@ export class ThreadSessionRuntime {
         const titlePrefix = properties.title
             ? `${properties.title.trim()}: `
             : '';
-        const chunk = `${STATUS_PREFIX}${properties.variant}: ${titlePrefix}${toastMessage}`;
+        const chunk = asSubtext(`${properties.variant}: ${titlePrefix}${toastMessage}`);
         const toastResult = await this.thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
             .catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
         if (toastResult instanceof Error) {
@@ -2674,6 +2675,16 @@ export class ThreadSessionRuntime {
                 }
                 return fetched.topic?.trim() || undefined;
             })();
+            const system = await this.resolveTurnSystemPrompt({
+                sessionId: session.id,
+                channelTopic,
+                agents: availableAgents,
+                input,
+            });
+            if (system instanceof Error) {
+                await cleanupOnError(`✗ Failed to prepare system prompt: ${system.message}`);
+                return;
+            }
             const worktreeChanged = this.consumeWorktreePromptChange(worktree);
             const syntheticContext = getOpencodePromptContext({
                 sessionId: session.id,
@@ -2687,6 +2698,8 @@ export class ThreadSessionRuntime {
                 worktree,
                 currentAgent: resolvedAgent,
                 worktreeChanged,
+                systemPromptFromSourceSession: !isSystemPromptForSession({ system, sessionId: session.id }),
+                parentSessionId: this.getParentSessionIdMissingFromSystem({ system, input }),
             });
             const parts = [
                 { type: 'text', text: promptWithImagePaths },
@@ -2697,18 +2710,7 @@ export class ThreadSessionRuntime {
                 sessionID: session.id,
                 directory: this.sdkDirectory,
                 parts,
-                system: getOpencodeSystemMessage({
-                    sessionId: session.id,
-                    channelId,
-                    guildId: this.thread.guildId,
-                    threadId: this.thread.id,
-                    channelTopic,
-                    agents: availableAgents,
-                    username: this.state?.sessionUsername || input.username,
-                    userId: this.state?.sessionUserId || input.userId,
-                    parentSessionId: this.state?.parentSessionId || input.parentSessionId,
-                    scheduledTask: await this.resolveScheduledTaskContext(session.id),
-                }),
+                system,
                 ...(resolvedAgent ? { agent: resolvedAgent } : {}),
                 ...(modelField ? { model: modelField } : {}),
                 ...variantField,
@@ -2782,6 +2784,7 @@ export class ThreadSessionRuntime {
         const queuedMessage = {
             queueId,
             prompt: input.prompt,
+            queuedAction: input.queuedAction,
             userId: input.userId,
             username: input.username,
             images: input.images,
@@ -2795,6 +2798,7 @@ export class ThreadSessionRuntime {
             parentSessionId: input.parentSessionId,
             sourceMessageId: input.sourceMessageId,
             sourceThreadId: input.sourceThreadId,
+            sourceChannelId: input.sourceChannelId,
             repliedMessage: input.repliedMessage,
             sessionStartScheduleKind: input.sessionStartSource?.scheduleKind,
             sessionStartScheduledTaskId: input.sessionStartSource?.scheduledTaskId,
@@ -2802,10 +2806,25 @@ export class ThreadSessionRuntime {
         };
         let result = { queued: false, queueId };
         await this.dispatchAction(async () => {
+            // Determine if the message will genuinely wait in queue
+            const position = (this.state?.queueItems.length ?? 0) + 1;
+            result = this.isBusy()
+                ? { queued: true, position, queueId }
+                : { queued: false, queueId };
+            // Post the ack before the item is visible to any drain path.
+            const queueAckMessageId = result.queued && input.onLocalQueued
+                ? await input.onLocalQueued({ queueId, position }).catch((error) => {
+                    logger.error(`[QUEUE] Failed to post queue ack for ${queueId}:`, error);
+                    return undefined;
+                })
+                : undefined;
+            const item = queueAckMessageId
+                ? { ...queuedMessage, queueAckMessageId }
+                : queuedMessage;
             const persistResult = await insertThreadQueueItem({
                 queueId,
                 threadId: this.threadId,
-                payloadJson: JSON.stringify(queuedMessage),
+                payloadJson: JSON.stringify(item),
             }).catch((error) => {
                 return new Error('Failed to persist queued message', { cause: error });
             });
@@ -2813,17 +2832,8 @@ export class ThreadSessionRuntime {
                 logger.error(`[QUEUE] Failed to persist queued message ${queueId} in thread ${this.threadId}: ${persistResult.message}`);
                 throw persistResult;
             }
-            threadState.enqueueItem(this.threadId, queuedMessage);
-            // Determine if the message is genuinely waiting in queue
+            threadState.enqueueItem(this.threadId, item);
             const stateAfterEnqueue = threadState.getThreadState(this.threadId);
-            const position = stateAfterEnqueue?.queueItems.length ?? 0;
-            const willDrainNow = stateAfterEnqueue
-                ? (stateAfterEnqueue.queueItems.length > 0
-                    && !this.isBusy())
-                : false;
-            result = !willDrainNow && position > 0
-                ? { queued: true, position, queueId }
-                : { queued: false, queueId };
             if (this.hasPendingQuestionUi()) {
                 this.maybeHandoffQueuedItemForPendingQuestion({
                     sessionId: stateAfterEnqueue?.sessionId || this.state?.sessionId,
@@ -2934,6 +2944,7 @@ export class ThreadSessionRuntime {
                 const resolvedInput = maybeConvertLeadingCommand({
                     ...input,
                     prompt: result.prompt,
+                    queuedAction: result.queuedAction,
                     images: result.images,
                     mode: result.mode,
                     // Voice transcription can extract an agent name — apply it only if
@@ -3022,17 +3033,20 @@ export class ThreadSessionRuntime {
             apiAbortPromise,
         };
     }
-    abortActiveRun(reason) {
+    /** Explicit user abort: stops the run and drops all queued messages. Returns the removed items. */
+    async abortActiveRun(reason) {
         const outcome = this.abortActiveRunInternal({
             reason,
         });
         if (outcome.apiAbortPromise) {
             void outcome.apiAbortPromise;
         }
-        // Drain local queued messages after explicit abort.
-        void this.dispatchAction(() => {
-            return this.tryDrainQueue({ showIndicator: true });
+        // Enqueued synchronously, so it runs before the abort's session.idle can drain the queue.
+        let cleared = [];
+        await this.dispatchAction(async () => {
+            cleared = await this.clearQueueNow();
         });
+        return cleared;
     }
     async abortActiveRunAndWait({ reason, timeoutMs = 2_000, }) {
         const state = this.state;
@@ -3073,17 +3087,21 @@ export class ThreadSessionRuntime {
     async clearQueue() {
         let cleared = [];
         await this.dispatchAction(async () => {
-            const persistResult = await deleteThreadQueueItems(this.threadId).catch((error) => {
-                return new Error('Failed to clear persisted queue', { cause: error });
-            });
-            if (persistResult instanceof Error) {
-                logger.error(`[QUEUE] Failed to clear persisted queue for thread ${this.threadId}: ${persistResult.message}`);
-                return;
-            }
-            cleared = threadState.clearQueueItems(this.threadId);
+            cleared = await this.clearQueueNow();
         });
         return cleared;
     }
+    // Must run inside dispatchAction.
+    async clearQueueNow() {
+        const persistResult = await deleteThreadQueueItems(this.threadId).catch((error) => {
+            return new Error('Failed to clear persisted queue', { cause: error });
+        });
+        if (persistResult instanceof Error) {
+            logger.error(`[QUEUE] Failed to clear persisted queue for thread ${this.threadId}: ${persistResult.message}`);
+            return [];
+        }
+        return threadState.clearQueueItems(this.threadId);
+    }
     /** Remove a queued message by its 1-based position. */
     async removeQueuePosition(position) {
         let removed;
@@ -3135,7 +3153,7 @@ export class ThreadSessionRuntime {
      * Returns { found: true, removed } if the item was in the queue,
      * or { found: false } if it was already dispatched or never queued.
      */
-    async updateQueuedMessage(sourceMessageId, newPrompt) {
+    async updateQueuedMessage({ sourceMessageId, newPrompt, queuedAction, }) {
         let result = { found: false, removed: false };
         await this.dispatchAction(async () => {
             const trimmed = newPrompt.trim();
@@ -3151,7 +3169,7 @@ export class ThreadSessionRuntime {
                 const persistResult = trimmed
                     ? await updateThreadQueueItemPayload({
                         queueId,
-                        payloadJson: JSON.stringify({ ...original, prompt: trimmed }),
+                        payloadJson: JSON.stringify({ ...original, prompt: trimmed, queuedAction }),
                     }).catch((error) => {
                         return new Error('Failed to update persisted queue item', { cause: error });
                     })
@@ -3167,7 +3185,7 @@ export class ThreadSessionRuntime {
             threadState.updateQueueItemBySourceMessageId(this.threadId, sourceMessageId, (item) => {
                 if (!trimmed)
                     return null;
-                return { ...item, prompt: trimmed };
+                return { ...item, prompt: trimmed, queuedAction };
             });
             result = trimmed
                 ? { found: true, removed: false }
@@ -3254,6 +3272,32 @@ export class ThreadSessionRuntime {
             threadState.removeQueueItemById(this.threadId, item.queueId);
         });
     }
+    // Silent reply to the message that queued the item. Discord replies must
+    // reference a message in the same channel.
+    async sendQueueDrainIndicator(item) {
+        const replyTarget = item.queueAckMessageId
+            ?? (item.sourceChannelId === this.threadId ? item.sourceMessageId : undefined);
+        const content = (() => {
+            if (replyTarget) {
+                return asSubtext('Executing queued prompt');
+            }
+            const preview = item.command
+                ? `/${item.command.name}`
+                : item.prompt.replace(/\s+/g, ' ').trim().slice(0, 150);
+            return asSubtext(`Executing queued prompt from ${item.username}: ${preview}`);
+        })();
+        const sendResult = await this.thread.send({
+            content,
+            flags: SILENT_MESSAGE_FLAGS,
+            allowedMentions: { parse: [], repliedUser: false },
+            reply: replyTarget
+                ? { messageReference: replyTarget, failIfNotExists: false }
+                : undefined,
+        }).catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
+        if (sendResult instanceof Error) {
+            discordLogger.error('Failed to send queue drain indicator:', sendResult);
+        }
+    }
     // ── Queue Drain ─────────────────────────────────────────────
     /**
      * Check if we can dispatch the next queued message. If so, dequeue and
@@ -3283,7 +3327,9 @@ export class ThreadSessionRuntime {
         if (sessionBusy) {
             return;
         }
-        const next = thread.queueItems.find((item) => item.queueId !== this.dispatchingQueueId);
+        if (this.dispatchingQueueId)
+            return;
+        const next = thread.queueItems[0];
         if (!next) {
             return;
         }
@@ -3292,12 +3338,7 @@ export class ThreadSessionRuntime {
         // Show queued message indicator only for messages that actually waited
         // behind a running request — not for the first immediate dispatch.
         if (showIndicator) {
-            const displayText = next.command
-                ? `/${next.command.name}`
-                : `${next.prompt.slice(0, 150)}${next.prompt.length > 150 ? '...' : ''}`;
-            if (displayText.trim()) {
-                await sendThreadMessage(this.thread, `${QUEUE_PREFIX}**${next.username}:** ${displayText}`);
-            }
+            await this.sendQueueDrainIndicator(next);
         }
         // Start dispatch (detached — does not block the action queue).
         // The prompt call is long-running. Events continue to flow through
@@ -3305,7 +3346,7 @@ export class ThreadSessionRuntime {
         // gating prevents concurrent local-queue dispatches. Mark busy now to
         // close the tiny window before the first session.status busy arrives.
         const dispatchSessionId = thread.sessionId;
-        if (dispatchSessionId) {
+        if (dispatchSessionId && next.queuedAction !== 'btw') {
             this.markQueueDispatchBusy(dispatchSessionId);
         }
         let accepted = false;
@@ -3335,6 +3376,27 @@ export class ThreadSessionRuntime {
     // The listener is already running, so this only handles
     // session ensure + model/agent + SDK call + state.
     async dispatchPrompt(input) {
+        if (input.queuedAction === 'btw') {
+            const { forkSessionToBtwThread } = await import('../commands/btw.js');
+            const result = await forkSessionToBtwThread({
+                sourceThread: this.thread,
+                projectDirectory: this.projectDirectory,
+                sdkDirectory: this.sdkDirectory,
+                prompt: input.prompt,
+                userId: input.userId,
+                username: input.username,
+                appId: input.appId,
+                images: input.images,
+                agent: input.agent,
+            });
+            if (result instanceof Error) {
+                logger.error('[QUEUE] Could not fork queued btw:', result);
+                await sendThreadMessage(this.thread, `Could not fork queued btw: ${result.message}`);
+                return true;
+            }
+            await sendThreadMessage(this.thread, `Session forked! Continue in ${result.thread.toString()}`);
+            return true;
+        }
         this.lastDisplayedContextPercentage = 0;
         this.lastRateLimitDisplayTime = 0;
         this.lastSentPartKind = undefined;
@@ -3530,6 +3592,23 @@ export class ThreadSessionRuntime {
             }
             return fetched.topic?.trim() || undefined;
         })();
+        // Pinned before building parts so the fork notice can compare identities.
+        // Also covers session.command: the context-awareness plugin reads the same
+        // pinned file because the command API has no system field.
+        const system = await this.resolveTurnSystemPrompt({
+            sessionId: session.id,
+            channelTopic,
+            agents: earlyAvailableAgents,
+            input,
+        });
+        if (system instanceof Error) {
+            logger.error(`[DISPATCH] Failed to pin system prompt for session ${session.id}: ${system.message}`);
+            void notifyError(system, 'Failed to pin session system prompt');
+            this.stopTyping();
+            await sendThreadMessage(this.thread, `✗ Failed to prepare system prompt: ${system.message}`, { flags: NOTIFY_MESSAGE_FLAGS });
+            return false;
+        }
+        const systemPromptFromSourceSession = !isSystemPromptForSession({ system, sessionId: session.id });
         const worktreeChanged = this.consumeWorktreePromptChange(worktree);
         const syntheticContext = getOpencodePromptContext({
             sessionId: session.id,
@@ -3543,6 +3622,8 @@ export class ThreadSessionRuntime {
             worktree,
             currentAgent: earlyAgentPreference,
             worktreeChanged,
+            systemPromptFromSourceSession,
+            parentSessionId: this.getParentSessionIdMissingFromSystem({ system, input }),
         });
         const parts = [
             { type: 'text', text: promptWithImagePaths },
@@ -3586,40 +3667,9 @@ export class ThreadSessionRuntime {
                 sourceThreadId: input.sourceThreadId || this.thread.id,
                 threadName: this.thread.name || undefined,
                 repliedMessage: input.repliedMessage,
+                systemPromptFromSourceSession,
+                parentSessionId: this.getParentSessionIdMissingFromSystem({ system, input }),
             });
-            // OpenCode's session.command API has no `system` field. Persist the
-            // kimaki system prompt so the context-awareness plugin can attach it
-            // on chat.message when the command user message is created.
-            // Fail the dispatch if persistence fails — otherwise the command runs
-            // without Discord context and silently restores the original bug.
-            const commandSystem = getOpencodeSystemMessage({
-                sessionId: session.id,
-                channelId,
-                guildId: this.thread.guildId,
-                threadId: this.thread.id,
-                channelTopic,
-                agents: earlyAvailableAgents,
-                username: this.state?.sessionUsername || input.username,
-                userId: this.state?.sessionUserId || input.userId,
-                parentSessionId: this.state?.parentSessionId || input.parentSessionId,
-                scheduledTask: await this.resolveScheduledTaskContext(session.id),
-            });
-            const systemWriteResult = await writeSessionSystemPrompt({
-                sessionId: session.id,
-                system: commandSystem,
-                dataDir: getDataDir(),
-            }).catch((e) => {
-                return e instanceof Error
-                    ? e
-                    : new Error(String(e), { cause: e });
-            });
-            if (systemWriteResult instanceof Error) {
-                logger.error(`[DISPATCH] Failed to persist system prompt for command session ${session.id}: ${systemWriteResult.message}`);
-                void notifyError(systemWriteResult, 'Failed to persist system prompt before session.command');
-                this.stopTyping();
-                await sendThreadMessage(this.thread, `✗ Failed to prepare command system prompt: ${systemWriteResult.message}`, { flags: NOTIFY_MESSAGE_FLAGS });
-                return false;
-            }
             const commandResponse = await getClient().session.command({
                 sessionID: session.id,
                 directory: this.sdkDirectory,
@@ -3682,18 +3732,7 @@ export class ThreadSessionRuntime {
             sessionID: session.id,
             directory: this.sdkDirectory,
             parts,
-            system: getOpencodeSystemMessage({
-                sessionId: session.id,
-                channelId,
-                guildId: this.thread.guildId,
-                threadId: this.thread.id,
-                channelTopic,
-                agents: earlyAvailableAgents,
-                username: this.state?.sessionUsername || input.username,
-                userId: this.state?.sessionUserId || input.userId,
-                parentSessionId: this.state?.parentSessionId || input.parentSessionId,
-                scheduledTask: await this.resolveScheduledTaskContext(session.id),
-            }),
+            system,
             model: earlyModelParam,
             agent: earlyAgentPreference,
             ...variantField,
@@ -3761,6 +3800,38 @@ export class ThreadSessionRuntime {
         cache.set(sessionId, context);
         return context;
     }
+    /**
+     * Pinned system prompt for this turn. Generated only on the first turn of a
+     * session; forks start with the source session's pinned prompt.
+     */
+    async resolveTurnSystemPrompt({ sessionId, channelTopic, agents, input, }) {
+        return resolveSessionSystemPrompt({
+            sessionId,
+            generate: async () => {
+                return getOpencodeSystemMessage({
+                    sessionId,
+                    channelId: this.channelId,
+                    guildId: this.thread.guildId,
+                    threadId: this.thread.id,
+                    channelTopic,
+                    agents,
+                    username: this.state?.sessionUsername || input.username,
+                    userId: this.state?.sessionUserId || input.userId,
+                    parentSessionId: this.state?.parentSessionId || input.parentSessionId,
+                    scheduledTask: await this.resolveScheduledTaskContext(sessionId),
+                });
+            },
+        });
+    }
+    /** Parent set after the first turn is not in the pinned prompt; send it per turn. */
+    getParentSessionIdMissingFromSystem({ system, input, }) {
+        const parentSessionId = this.state?.parentSessionId || input.parentSessionId;
+        if (!parentSessionId)
+            return undefined;
+        if (systemPromptHasParentSession({ system, parentSessionId }))
+            return undefined;
+        return parentSessionId;
+    }
     async updateExistingSessionPermissions({ client, sessionId, createdNewSession, permissions, }) {
         if (createdNewSession) {
             return null;
@@ -3912,7 +3983,7 @@ export class ThreadSessionRuntime {
         const agentLabel = agent && agent.toLowerCase() !== 'build'
             ? ` ⋅ ${agent}`
             : '';
-        const result = await sendThreadMessage(this.thread, asSystemLine(`*using ${modelLabel}${agentLabel}*`), { flags: SILENT_MESSAGE_FLAGS }).catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
+        const result = await sendThreadMessage(this.thread, asSubtext(`*using ${modelLabel}${agentLabel}*`), { flags: SILENT_MESSAGE_FLAGS }).catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
         if (result instanceof Error) {
             logger.warn(`[SESSION INFO] Failed to send model info: ${result.message}`);
         }
@@ -4041,7 +4112,7 @@ export class ThreadSessionRuntime {
             })
             : undefined;
         const mention = mentionUserId ? ` <@${mentionUserId}>` : '';
-        const footerText = asSystemLine(`*${projectInfo}${sessionDuration}${contextInfo}${modelInfo}${agentInfo}*${mention}`);
+        const footerText = asSubtext(`*${projectInfo}${sessionDuration}${contextInfo}${modelInfo}${agentInfo}*${mention}`);
         this.stopTyping();
         await sendThreadMessage(this.thread, footerText, {
             flags: shouldNotifyUser ? NOTIFY_MESSAGE_FLAGS : SILENT_MESSAGE_FLAGS,
@@ -4057,6 +4128,16 @@ export class ThreadSessionRuntime {
         this.lastSentPartKind = undefined;
     }
     async maybeNotifyPromptCacheClear({ sessionId, messageId, }) {
+        // Only the first reply after a user prompt can show a cold cache. Later steps re-read the turn's own writes.
+        // TODO: send this before step 1 tools finish. Tokens arrive only with step-finish, after tools in v1 and v2.
+        // OpenCode v2 publishes `session.step.streamed` at stream end (before tools settle) but without tokens, and
+        // packages/ai drops Anthropic `message_start` usage (onMessageStart returns NO_EVENTS). Needs upstream:
+        // add tokens to Step.Streamed, or emit a usage event on message_start for a notice right after the prompt.
+        // https://github.com/anomalyco/opencode/blob/v2/packages/schema/src/session-event.ts
+        const [firstAssistantId] = this.getAssistantMessageIdsForCurrentTurn({ sessionId });
+        if (firstAssistantId !== messageId) {
+            return;
+        }
         const cacheClear = getPromptCacheClear({
             events: this.eventBuffer,
             sessionId,
@@ -4070,7 +4151,7 @@ export class ThreadSessionRuntime {
             previousMessageId: cacheClear.previousMessageId,
             currentMessageId: cacheClear.currentMessageId,
         });
-        const chunk = `${STATUS_PREFIX}${formatPromptCacheClearMessage(cacheClear, systemDiff)}`;
+        const chunk = asSubtext(formatPromptCacheClearMessage(cacheClear, systemDiff));
         const sendResult = await this.thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
             .catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
         if (sendResult instanceof Error) {

package/dist/sleep.e2e.test.js

@@ -313,15 +313,15 @@ describe('kimaki_sleep', () => {
         -# *using deterministic-provider/deterministic-v2*
         > waiting for the deploy
 
-        ┣ kimaki_sleep until 2030-01-01T09:00:00Z _waiting for the deploy_
+        -# ┣ kimaki_sleep until 2030-01-01T09:00:00Z _waiting for the deploy_
 
-        > sleep-started
+        sleep-started
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         -# Woke after sleeping until 2030-01-01 09:00 UTC
         Reason: waiting for the deploy
         Continue the work you were waiting for.
         [embed]
-        > sleep-wake-done
+        sleep-wake-done
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         // The wake must continue the SAME OpenCode session, not start a new one:
@@ -412,14 +412,14 @@ describe('kimaki_sleep', () => {
         SLEEP_CANCEL_MARKER wait for something
         --- from: assistant (TestBot)
         -# *using deterministic-provider/deterministic-v2*
-        ┣ kimaki_sleep for 2h _cancel me_
+        -# ┣ kimaki_sleep for 2h _cancel me_
 
-        > cancel-sleep-started
+        cancel-sleep-started
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         --- from: user (sleep-tester)
         SLEEP_CANCEL_FOLLOWUP never mind, keep going
         --- from: assistant (TestBot)
-        > cancel-followup-done
+        cancel-followup-done
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
     }, 20_000);