kimaki 0.20.0 → 0.21.0

package/dist/discord-bot.js

@@ -261,9 +261,8 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         discordLogger.warn(`[GATEWAY] Shard ${shardId} reconnecting: ${parts.join(', ')}`);
         if (state.attempts >= MAX_RECONNECT_ATTEMPTS) {
             discordLogger.error(`[GATEWAY] Shard ${shardId} exceeded ${MAX_RECONNECT_ATTEMPTS} reconnect attempts, self-restarting`);
-            // Self-restart: cleanup then spawn a fresh process. This works whether
-            // the bin.ts wrapper is present or not (unlike process.exit(1) which
-            // only restarts when the wrapper is the parent).
+            // Self-restart: cleanup, then exit non-zero so the bin.ts wrapper
+            // restarts us. Without the wrapper this exits after logging a warning.
             void selfRestart('gateway-reconnect-limit');
         }
     });
@@ -318,6 +317,9 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             const cliInjectedInjectionGuardPatterns = isCliInjectedPrompt
                 ? promptMarker?.injectionGuardPatterns
                 : undefined;
+            const cliInjectedParentSessionId = isCliInjectedPrompt
+                ? promptMarker?.parentSessionId
+                : undefined;
             // Always ignore our own messages (unless CLI-injected prompt above).
             // Without this, assigning the Kimaki role to the bot itself would loop.
             if (isSelfBotMessage && !isCliInjectedPrompt) {
@@ -607,6 +609,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     model: cliInjectedModel,
                     permissions: cliInjectedPermissions,
                     injectionGuardPatterns: cliInjectedInjectionGuardPatterns,
+                    parentSessionId: cliInjectedParentSessionId,
                     noReply: isLeadingMentionToOtherUser || undefined,
                     sessionStartSource: sessionStartSource
                         ? {
@@ -628,7 +631,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 });
                 // Notify when a voice message was queued instead of sent immediately
                 if (enqueueResult.queued && enqueueResult.position) {
-                    await sendThreadMessage(thread, `Queued at position ${enqueueResult.position}. Edit your message to update it in queue`);
+                    await sendThreadMessage(thread, `Queued at position ${enqueueResult.position}. Edit or delete your message to update the queue`);
                 }
             }
             if (channel.type === ChannelType.GuildText) {
@@ -851,6 +854,27 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             discordLogger.error('Error handling message update:', error instanceof Error ? error.stack : String(error));
         }
     });
+    // Handle user message deletes to remove queued messages.
+    // Discord delete events do not include author/content, so attribution comes
+    // from the queued item captured at enqueue time.
+    discordClient.on(Events.MessageDelete, async (message) => {
+        try {
+            const channel = message.channel;
+            if (!channel.isThread())
+                return;
+            const runtime = getRuntime(channel.id);
+            if (!runtime)
+                return;
+            const removed = runtime.removeQueuedMessage(message.id);
+            if (!removed)
+                return;
+            discordLogger.log(`[MESSAGE_DELETE] Removed queued message ${message.id} in thread ${channel.id}`);
+            await sendThreadMessage(channel, `⬦ **${removed.username}** removed message from queue`);
+        }
+        catch (error) {
+            discordLogger.error('Error handling message delete:', error instanceof Error ? error.stack : String(error));
+        }
+    });
     // Handle bot-initiated threads created by `kimaki send` (without --notify-only)
     // Uses JSON embed marker to pass options (start, worktree name)
     discordClient.on(Events.ThreadCreate, async (thread, newlyCreated) => {
@@ -1018,6 +1042,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 model: marker.model,
                 permissions: marker.permissions,
                 injectionGuardPatterns: marker.injectionGuardPatterns,
+                parentSessionId: marker.parentSessionId,
                 mode: 'opencode',
                 sessionStartSource: botThreadStartSource
                     ? {
@@ -1166,7 +1191,13 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             discordLogger.error('Failed to write heap snapshot:', e instanceof Error ? e.message : String(e));
         });
     });
-    // Self-restart: prefer bin.ts wrapper (keeps Ctrl+C), fall back to detached spawn.
+    // Self-restart: exit with code 1 so the bin.ts wrapper restarts us with
+    // exponential backoff and crash-loop detection. When running without the
+    // wrapper (e.g. `tsx src/cli.ts`), the process just exits and the user
+    // sees the non-zero exit code — they should use `tsx src/bin.ts` instead
+    // for auto-restart support. The previous detached-spawn fallback was
+    // unreliable: process.exit(0) could kill the child before it started,
+    // there was no backoff between restarts, and spawn failures were silent.
     let selfRestarting = false;
     async function selfRestart(reason) {
         if (selfRestarting) {
@@ -1181,20 +1212,10 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         catch (error) {
             voiceLogger.error(`[${reason}] Error during shutdown:`, error);
         }
-        if (process.env.__KIMAKI_CHILD) {
-            discordLogger.log('Wrapper detected, exiting for wrapper restart');
-            process.exit(1);
+        if (!process.env.__KIMAKI_CHILD) {
+            discordLogger.warn('No restart wrapper detected. Run via `tsx src/bin.ts` (dev) or `kimaki` (npm) for auto-restart on crash.');
         }
-        const { spawn } = await import('node:child_process');
-        const env = { ...process.env };
-        delete env.__KIMAKI_CHILD;
-        spawn(process.argv[0], [...process.execArgv, ...process.argv.slice(1)], {
-            stdio: 'inherit',
-            detached: true,
-            cwd: process.cwd(),
-            env,
-        }).unref();
-        process.exit(0);
+        process.exit(1);
     }
     process.on('SIGUSR2', () => {
         discordLogger.log('Received SIGUSR2, restarting after cleanup...');

package/dist/discord-utils.js

@@ -590,14 +590,31 @@ export async function resolveWorkingDirectory({ channel, }) {
         workingDirectory,
     };
 }
+// Discord upload size limits per server boost tier (bytes).
+// Bots default to 25 MB; boosted servers raise the ceiling.
+export const DISCORD_DEFAULT_MAX_FILE_SIZE = 25 * 1024 * 1024;
 /**
  * Upload files to a Discord thread/channel in a single message.
  * Sending all files in one message causes Discord to display images in a grid layout.
+ *
+ * Files are validated against the Discord upload size limit before reading them
+ * into memory. Pass `maxFileSize` if you know the guild's boost tier limit;
+ * otherwise the conservative 25 MB bot default is used.
  */
-export async function uploadFilesToDiscord({ threadId, botToken, files, }) {
+export async function uploadFilesToDiscord({ threadId, botToken, files, maxFileSize = DISCORD_DEFAULT_MAX_FILE_SIZE, }) {
     if (files.length === 0) {
         return;
     }
+    // Fail fast: check file sizes before reading anything into memory
+    const sizeLimit = maxFileSize ?? DISCORD_DEFAULT_MAX_FILE_SIZE;
+    for (const file of files) {
+        const stat = fs.statSync(file);
+        if (stat.size > sizeLimit) {
+            const fileMB = (stat.size / 1024 / 1024).toFixed(1);
+            const limitMB = (sizeLimit / 1024 / 1024).toFixed(0);
+            throw new Error(`File "${path.basename(file)}" is ${fileMB} MB, which exceeds Discord's ${limitMB} MB upload limit`);
+        }
+    }
     // Build attachments array for all files
     const attachments = files.map((file, index) => ({
         id: index,

package/dist/interaction-handler.js

@@ -103,22 +103,13 @@ export function registerInteractionHandler({ discordClient, appId, }) {
             // Multi-machine routing: only handle interactions for channels owned
             // by this machine (have a project directory configured in local db).
             // If not owned, silently return so the other machine handles it.
+            // Setup commands (create-new-project, add-project) bypass this check
+            // because they are designed to run from any channel — they create new
+            // project channels rather than requiring one to already exist.
+            const isSetupCommand = interaction.isChatInputCommand() &&
+                SETUP_COMMANDS.has(interaction.commandName);
             const owned = await isInteractionOwnedByThisMachine(interaction);
-            if (!owned) {
-                // Setup commands get a helpful reply instead of silent ignore.
-                // Both machines may race to reply; one wins, the other silently
-                // fails (interaction tokens are single-use). The message is the
-                // same from either machine so the race is harmless.
-                if (interaction.isChatInputCommand() &&
-                    SETUP_COMMANDS.has(interaction.commandName)) {
-                    await interaction.reply({
-                        content: 'Run this command in an existing Kimaki project channel.\nTo add a new project channel from the terminal, run:\n```\nkimaki project add /path/to/folder\n```',
-                        flags: MessageFlags.Ephemeral,
-                    }).catch(() => {
-                        // Another machine already responded, safe to ignore
-                    });
-                    return;
-                }
+            if (!owned && !isSetupCommand) {
                 interactionLogger.log(`[IGNORED] Channel ${interaction.channelId} has no project directory configured, skipping interaction`);
                 // Do not respond at all — consuming the interaction token would
                 // prevent the owning machine from responding (tokens are single-use).

package/dist/message-formatting.js

@@ -272,9 +272,9 @@ const MAX_BASH_COMMAND_INLINE_LENGTH = 100;
  * 2. Long/multiline command with description → show description
  * 3. Long/multiline command without description → truncate first line of command
  *
- * The description field was removed from the bash tool schema in newer opencode
- * versions, so case 3 is the common path now. Without this fallback, long commands
- * would render as just "┣ bash" with no context.
+ * The description field was removed from the opencode v2 bash tool schema but
+ * kimaki's system prompt instructs models to always send it as an extra field.
+ * Case 3 is the fallback when a model omits it.
  */
 export function formatBashToolTitle({ command, description, stateTitle, }) {
     if (!command && !description && !stateTitle)
@@ -292,10 +292,12 @@ export function formatBashToolTitle({ command, description, stateTitle, }) {
         return ` _${escapeInlineMarkdown(description)}_`;
     }
     if (firstMeaningfulLine.length > 0) {
-        const truncated = firstMeaningfulLine.length > MAX_BASH_COMMAND_INLINE_LENGTH
-            ? firstMeaningfulLine.slice(0, MAX_BASH_COMMAND_INLINE_LENGTH) + '…'
+        const needsTruncation = firstMeaningfulLine.length > MAX_BASH_COMMAND_INLINE_LENGTH;
+        const base = needsTruncation
+            ? firstMeaningfulLine.slice(0, MAX_BASH_COMMAND_INLINE_LENGTH)
             : firstMeaningfulLine;
-        return ` _${escapeInlineMarkdown(truncated)}_`;
+        // Always add ellipsis when showing a partial command (multiline or length-truncated)
+        return ` _${escapeInlineMarkdown(base)}…_`;
     }
     if (stateTitle) {
         return ` _${escapeInlineMarkdown(stateTitle)}_`;

package/dist/message-formatting.test.js

@@ -47,7 +47,7 @@ describe('formatBashToolTitle', () => {
         expect(formatBashToolTitle({ command: 'echo hello' })).toMatchInlineSnapshot(`" _echo hello_"`);
     });
     test('multiline command without description truncates to first line', () => {
-        expect(formatBashToolTitle({ command: 'echo hello\necho world\necho done' })).toMatchInlineSnapshot(`" _echo hello_"`);
+        expect(formatBashToolTitle({ command: 'echo hello\necho world\necho done' })).toMatchInlineSnapshot(`" _echo hello…_"`);
     });
     test('long single-line command is truncated with ellipsis', () => {
         const longCommand = 'a'.repeat(150);
@@ -68,16 +68,16 @@ describe('formatBashToolTitle', () => {
         expect(formatBashToolTitle({ command: '' })).toBe('');
     });
     test('leading blank line skipped, uses first meaningful line', () => {
-        expect(formatBashToolTitle({ command: '\npnpm test\npnpm build' })).toMatchInlineSnapshot(`" _pnpm test_"`);
+        expect(formatBashToolTitle({ command: '\npnpm test\npnpm build' })).toMatchInlineSnapshot(`" _pnpm test…_"`);
     });
     test('whitespace-only first line skipped', () => {
-        expect(formatBashToolTitle({ command: '   \npnpm test' })).toMatchInlineSnapshot(`" _pnpm test_"`);
+        expect(formatBashToolTitle({ command: '   \npnpm test' })).toMatchInlineSnapshot(`" _pnpm test…_"`);
     });
     test('no description field (new opencode) with multiline command', () => {
         // This is the exact scenario that was broken: opencode removed `description`
         // from the bash tool schema, so multiline commands rendered as just "┣ bash"
         const command = 'git diff HEAD~1 --stat && git log --oneline -5';
-        expect(formatBashToolTitle({ command: command + '\n' + 'echo done' })).toMatchInlineSnapshot(`" _git diff HEAD\\~1 --stat && git log --oneline -5_"`);
+        expect(formatBashToolTitle({ command: command + '\n' + 'echo done' })).toMatchInlineSnapshot(`" _git diff HEAD\\~1 --stat && git log --oneline -5…_"`);
     });
 });
 describe('formatTodoList', () => {

package/dist/queue-advanced-e2e-setup.js

@@ -99,6 +99,27 @@ export function createDeterministicMatchers() {
             partDelaysMs: [0, 0, 0, 3_000, 0],
         },
     };
+    const slowBusyMatcher = {
+        id: 'slow-busy-reply',
+        priority: 100,
+        when: {
+            latestUserTextIncludes: 'SLOW_BUSY_MARKER',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'slow-busy' },
+                { type: 'text-delta', id: 'slow-busy', delta: 'slow-busy-reply' },
+                { type: 'text-end', id: 'slow-busy' },
+                {
+                    type: 'finish',
+                    finishReason: 'stop',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+            partDelaysMs: [0, 0, 0, 2_000, 0],
+        },
+    };
     const toolFollowupMatcher = {
         id: 'tool-followup',
         priority: 50,
@@ -704,6 +725,7 @@ export function createDeterministicMatchers() {
     };
     return [
         slowAbortMatcher,
+        slowBusyMatcher,
         typingRepulseMatcher,
         pluginTimeoutSleepMatcher,
         actionButtonClickFollowupMatcher,

package/dist/queue-delete-message.e2e.test.js

@@ -0,0 +1,75 @@
+// E2e tests for deleting queued Discord messages.
+// Covers the MessageDelete path that removes pending local queue items before drain.
+import { describe, test, expect } from 'vitest';
+import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
+import { waitForBotMessageContaining, waitForFooterMessage, waitForThreadState, } from './test-utils.js';
+const TEXT_CHANNEL_ID = '200000000000001071';
+const e2eTest = describe;
+e2eTest('queue delete message', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'queue-delete-message-e2e',
+        dirName: 'queue-delete-message-e2e',
+        username: 'queue-delete-tester',
+    });
+    test('deleting a queued Discord message removes it from queue', async () => {
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'SLOW_BUSY_MARKER Reply with exactly: delete-queue-setup',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'SLOW_BUSY_MARKER Reply with exactly: delete-queue-setup';
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        await th.waitForBotReply({ timeout: 4_000 });
+        const queuedMsg = await th.user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: deleted-queue. queue',
+        });
+        await waitForThreadState({
+            threadId: thread.id,
+            predicate: (state) => {
+                return state.queueItems.some((item) => {
+                    return item.sourceMessageId === queuedMsg.id;
+                });
+            },
+            timeout: 4_000,
+            description: 'queue has item to delete',
+        });
+        await th.user(TEST_USER_ID).deleteMessage({ messageId: queuedMsg.id });
+        await waitForThreadState({
+            threadId: thread.id,
+            predicate: (state) => {
+                return !state.queueItems.some((item) => {
+                    return item.sourceMessageId === queuedMsg.id;
+                });
+            },
+            timeout: 4_000,
+            description: 'queued item removed after Discord delete',
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: 'removed message from queue',
+            timeout: 4_000,
+        });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 8_000,
+        });
+        expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (queue-delete-tester)
+        SLOW_BUSY_MARKER Reply with exactly: delete-queue-setup
+        --- from: assistant (TestBot)
+        *using deterministic-provider/deterministic-v2*
+        Queued at position 1. Edit or delete your message to update the queue
+        ⬦ **queue-delete-tester** removed message from queue
+        ⬥ slow-busy-reply
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `);
+        const finalText = await th.text();
+        expect(finalText).not.toContain('» **queue-delete-tester:** Reply with exactly: deleted-queue');
+    }, 12_000);
+});

package/dist/schema.js

@@ -23,6 +23,9 @@ export const thread_sessions = sqliteCore.sqliteTable('thread_sessions', {
     session_id: sqliteCore.text('session_id').notNull(),
     source: sqliteCore.text('source', { enum: ['kimaki', 'external_poll'] }).notNull().default('kimaki'),
     last_synced_name: sqliteCore.text('last_synced_name'),
+    // Parent OpenCode session that spawned this thread via kimaki send --parent-session.
+    // Survives bot restarts so child multi-turn system prompts keep the parent ID.
+    parent_session_id: sqliteCore.text('parent_session_id'),
     created_at: datetime('created_at').default(orm.sql `CURRENT_TIMESTAMP`),
 });
 export const session_events = sqliteCore.sqliteTable('session_events', {

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

@@ -17,6 +17,7 @@ export function initialThreadState() {
         sessionId: undefined,
         sessionUsername: undefined,
         sessionUserId: undefined,
+        parentSessionId: undefined,
         queueItems: [],
         sentPartIds: new Set(),
     };
@@ -77,6 +78,14 @@ export function setSessionUserId(threadId, userId) {
         return { ...t, sessionUserId: userId };
     });
 }
+export function setParentSessionId(threadId, parentSessionId) {
+    updateThread(threadId, (t) => {
+        if (t.parentSessionId) {
+            return t;
+        }
+        return { ...t, parentSessionId };
+    });
+}
 export function enqueueItem(threadId, item) {
     updateThread(threadId, (t) => ({
         ...t,

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

@@ -17,7 +17,7 @@ import { registerEventListener, unregisterEventListener, } from './global-event-
 import { createLogger, LogPrefix } from '../logger.js';
 import { sendThreadMessage, SILENT_MESSAGE_FLAGS, NOTIFY_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { formatPart } from '../message-formatting.js';
-import { getChannelVerbosity, getPartMessageIds, getDb, setPartMessage, getThreadSession, setThreadSession, getThreadWorktreeOrWorkspace, setSessionAgent, clearSessionModel, getVariantCascade, setSessionStartSource, appendSessionEventsSinceLastTimestamp, getSessionEventSnapshot, } from '../database.js';
+import { getChannelVerbosity, getPartMessageIds, getDb, setPartMessage, getThreadSession, setThreadSession, getThreadParentSessionId, setThreadParentSessionId, getThreadWorktreeOrWorkspace, setSessionAgent, clearSessionModel, getVariantCascade, setSessionStartSource, appendSessionEventsSinceLastTimestamp, getSessionEventSnapshot, } from '../database.js';
 import * as orm from 'drizzle-orm';
 import * as schema from '../schema.js';
 import { showPermissionButtons, addPermissionRequestToContext, arePatternsCoveredBy, pendingPermissionContexts, } from '../commands/permissions.js';
@@ -2274,6 +2274,7 @@ export class ThreadSessionRuntime {
                     agents: availableAgents,
                     username: this.state?.sessionUsername || input.username,
                     userId: this.state?.sessionUserId || input.userId,
+                    parentSessionId: this.state?.parentSessionId || input.parentSessionId,
                 }),
                 ...(resolvedAgent ? { agent: resolvedAgent } : {}),
                 ...(modelField ? { model: modelField } : {}),
@@ -2321,6 +2322,7 @@ export class ThreadSessionRuntime {
             permissions: input.permissions,
             permissionRules: input.permissionRules,
             injectionGuardPatterns: input.injectionGuardPatterns,
+            parentSessionId: input.parentSessionId,
             sourceMessageId: input.sourceMessageId,
             sourceThreadId: input.sourceThreadId,
             repliedMessage: input.repliedMessage,
@@ -2363,6 +2365,9 @@ export class ThreadSessionRuntime {
     async enqueueIncoming(input) {
         threadState.setSessionUsername(this.threadId, input.username);
         threadState.setSessionUserId(this.threadId, input.userId);
+        await this.ensureParentSessionId({
+            parentSessionId: input.parentSessionId,
+        });
         // When a preprocessor is provided, we must resolve it inside
         // dispatchAction before we know the final mode for routing.
         if (input.preprocess) {
@@ -2383,6 +2388,33 @@ export class ThreadSessionRuntime {
         }
         return this.submitViaOpencodeQueue(input);
     }
+    /**
+     * Resolve parent session ID for child system prompts.
+     * Prefer in-memory state, then SQLite, then the ingress marker.
+     * Persist once so multi-turn child sessions keep the parent after restart.
+     */
+    async ensureParentSessionId({ parentSessionId, }) {
+        if (this.state?.parentSessionId) {
+            return;
+        }
+        const storedParentSessionId = await getThreadParentSessionId(this.threadId);
+        if (storedParentSessionId) {
+            threadState.setParentSessionId(this.threadId, storedParentSessionId);
+            return;
+        }
+        if (!parentSessionId) {
+            return;
+        }
+        threadState.setParentSessionId(this.threadId, parentSessionId);
+        // Row may not exist yet on first ingress before ensureSession creates it.
+        // Best-effort write; ensureSession path also persists after setThreadSession.
+        await setThreadParentSessionId({
+            threadId: this.threadId,
+            parentSessionId,
+        }).catch((error) => {
+            logger.warn(`[PARENT SESSION] Failed to persist parent session for thread ${this.threadId}: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    }
     /**
      * Serialize the preprocess callback via a lightweight promise chain, then
      * route the resolved input through the normal enqueue paths.
@@ -2586,6 +2618,10 @@ export class ThreadSessionRuntime {
             return { found: true, removed: true };
         return { found: true, removed: false };
     }
+    /** Remove a queued message identified by its Discord source message ID. */
+    removeQueuedMessage(sourceMessageId) {
+        return threadState.updateQueueItemBySourceMessageId(this.threadId, sourceMessageId, () => null);
+    }
     // ── Queue Drain ─────────────────────────────────────────────
     /**
      * Check if we can dispatch the next queued message. If so, dequeue and
@@ -2964,6 +3000,7 @@ export class ThreadSessionRuntime {
                 agents: earlyAvailableAgents,
                 username: this.state?.sessionUsername || input.username,
                 userId: this.state?.sessionUserId || input.userId,
+                parentSessionId: this.state?.parentSessionId || input.parentSessionId,
             }),
             model: earlyModelParam,
             agent: earlyAgentPreference,
@@ -3103,6 +3140,17 @@ export class ThreadSessionRuntime {
         // Store session in DB and thread state
         await setThreadSession(this.thread.id, session.id);
         threadState.setSessionId(this.threadId, session.id);
+        // Parent may have been set on ingress before the thread_sessions row
+        // existed; write it now that the row is guaranteed.
+        const parentSessionId = this.state?.parentSessionId;
+        if (parentSessionId) {
+            await setThreadParentSessionId({
+                threadId: this.thread.id,
+                parentSessionId,
+            }).catch((error) => {
+                logger.warn(`[PARENT SESSION] Failed to persist parent session for thread ${this.threadId}: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        }
         await this.hydrateSessionEventsFromDatabase({ sessionId: session.id });
         // Store session start source for scheduled tasks
         if (createdNewSession && sessionStartScheduleKind) {