kimaki 0.6.0 → 0.7.1

package/dist/anthropic-auth-plugin.js

@@ -65,6 +65,9 @@ const CLAUDE_CODE_VERSION = "2.1.75";
 const CLAUDE_CODE_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude.";
 const OPENCODE_IDENTITY = "You are OpenCode, the best coding agent on the planet.";
 const ANTHROPIC_PROMPT_MARKER = "Skills provide specialized instructions";
+// Subagent prompts don't contain OPENCODE_IDENTITY; opencode appends this
+// line + an <env> block instead. We strip from here to </env> inclusive.
+const SUBAGENT_MODEL_IDENTITY = "You are powered by the model named";
 const CLAUDE_CODE_BETA = "claude-code-20250219";
 const OAUTH_BETA = "oauth-2025-04-20";
 const FINE_GRAINED_TOOL_STREAMING_BETA = "fine-grained-tool-streaming-2025-05-14";
@@ -477,21 +480,59 @@ function toClaudeCodeToolName(name) {
  */
 function sanitizeAnthropicSystemText(text, onError) {
     const startIdx = text.indexOf(OPENCODE_IDENTITY);
-    if (startIdx === -1)
-        return text;
-    // Keep the marker aligned with the current OpenCode Anthropic prompt.
-    const endIdx = text.indexOf(ANTHROPIC_PROMPT_MARKER, startIdx);
-    if (endIdx === -1) {
-        onError?.("sanitizeAnthropicSystemText: could not find Anthropic prompt marker after OpenCode identity");
-        return text;
+    if (startIdx !== -1) {
+        // Main session path: strip from OpenCode identity to the Anthropic prompt marker.
+        // Keep the marker aligned with the current OpenCode Anthropic prompt.
+        const endIdx = text.indexOf(ANTHROPIC_PROMPT_MARKER, startIdx);
+        if (endIdx === -1) {
+            onError?.("sanitizeAnthropicSystemText: could not find Anthropic prompt marker after OpenCode identity");
+            return text;
+        }
+        return replaceBlockWithCompactEnv(text, startIdx, endIdx);
+    }
+    // Subagent path: opencode appends "You are powered by the model named ..."
+    // followed by an <env> block. Strip from that line through </env>.
+    const subagentIdx = text.indexOf(SUBAGENT_MODEL_IDENTITY);
+    if (subagentIdx !== -1) {
+        const envCloseTag = "</env>";
+        const envCloseIdx = text.indexOf(envCloseTag, subagentIdx);
+        if (envCloseIdx === -1) {
+            onError?.("sanitizeAnthropicSystemText: could not find </env> after subagent model identity");
+            return text;
+        }
+        const endIdx = envCloseIdx + envCloseTag.length;
+        // Skip trailing newline so the join is clean
+        const afterEnd = text[endIdx] === "\n" ? endIdx + 1 : endIdx;
+        return replaceBlockWithCompactEnv(text, subagentIdx, afterEnd);
     }
-    // Re-inject the process working directory that was inside the stripped block.
-    const envContext = `\n<environment>\n<cwd>${process.cwd()}</cwd>\n</environment>\n\n`;
-    const result = text.slice(0, startIdx) +
+    return text;
+}
+// Extract cwd from the block being stripped and replace it with a compact
+// <environment> tag. Shared by both main-session and subagent paths.
+// Source: anomalyco/opencode packages/opencode/src/session/system.ts
+// OpenCode's system prompt format (as of 2025):
+//   <env>
+//     Working directory: ${Instance.directory}
+//     Workspace root folder: ${Instance.worktree}
+//     Is directory a git repo: yes/no
+//     Platform: ${process.platform}
+//     Today's date: ${new Date().toDateString()}
+//   </env>
+// Older format used <environment><cwd>/path</cwd></environment>.
+// We try both patterns to stay compatible across opencode versions.
+// We preserve the per-session directory instead of falling back to
+// process.cwd() which is the opencode server's cwd and wrong for
+// multi-session/worktree setups where each session has a different directory.
+function replaceBlockWithCompactEnv(text, startIdx, endIdx) {
+    const strippedBlock = text.slice(startIdx, endIdx);
+    const cwdMatch = strippedBlock.match(/Working directory:\s*(.+)/)?.[1]?.trim() ||
+        strippedBlock.match(/<cwd>([^<]+)<\/cwd>/)?.[1];
+    const cwd = cwdMatch || process.cwd();
+    const envContext = `\n<environment>\n<cwd>${cwd}</cwd>\n</environment>\n` +
+        `Read, write, and edit files under ${cwd}.\n\n`;
+    return (text.slice(0, startIdx) +
         envContext +
-        text.slice(endIdx);
-    return result;
-    // return result.replace(/\bopencode\b/gi, "openc0de");
+        text.slice(endIdx));
 }
 function mapSystemTextPart(part, onError) {
     if (typeof part === "string") {

package/dist/bundled-skills.js

@@ -0,0 +1,37 @@
+// Bundled Kimaki skills path helpers.
+// The canonical tracked skills live at the repository root in /skills.
+// Build and publish scripts copy them into cli/skills so the npm package ships
+// the same files. Prefer the repo-root directory during local development and
+// fall back to the packaged cli/skills directory when running from npm.
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+function getCliDir() {
+    const currentFilePath = fileURLToPath(import.meta.url);
+    return path.resolve(path.dirname(currentFilePath), '..');
+}
+export function resolvePackagedBundledSkillsDir() {
+    return path.join(getCliDir(), 'skills');
+}
+export function resolveBundledSkillsDir() {
+    const repoSkillsDir = path.resolve(getCliDir(), '..', 'skills');
+    if (fs.existsSync(repoSkillsDir)) {
+        return repoSkillsDir;
+    }
+    return resolvePackagedBundledSkillsDir();
+}
+export function listBundledSkillNames() {
+    try {
+        return fs
+            .readdirSync(resolveBundledSkillsDir(), { withFileTypes: true })
+            .filter((entry) => {
+            return entry.isDirectory();
+        })
+            .map((entry) => {
+            return entry.name;
+        });
+    }
+    catch {
+        return [];
+    }
+}

package/dist/cli.js

@@ -1291,11 +1291,11 @@ cli
     .option('--enable-skill <name>', z
     .array(z.string())
     .optional()
-    .describe('Whitelist a built-in skill by name. Only the listed skills are injected into the model (all others are hidden via an opencode permission.skill deny-all rule). Repeatable: pass --enable-skill multiple times. Mutually exclusive with --disable-skill. See https://github.com/remorses/kimaki/tree/main/cli/skills for available skills.'))
+    .describe('Whitelist a built-in skill by name. Only the listed skills are injected into the model (all others are hidden via an opencode permission.skill deny-all rule). Repeatable: pass --enable-skill multiple times. Mutually exclusive with --disable-skill. See https://github.com/remorses/kimaki/tree/main/skills for available skills.'))
     .option('--disable-skill <name>', z
     .array(z.string())
     .optional()
-    .describe('Blacklist a built-in skill by name. Listed skills are hidden from the model. Repeatable: pass --disable-skill multiple times. Mutually exclusive with --enable-skill. See https://github.com/remorses/kimaki/tree/main/cli/skills for available skills.'))
+    .describe('Blacklist a built-in skill by name. Listed skills are hidden from the model. Repeatable: pass --disable-skill multiple times. Mutually exclusive with --enable-skill. See https://github.com/remorses/kimaki/tree/main/skills for available skills.'))
     .action(async (options) => {
     // Guard: only one kimaki bot process can run at a time (they share a lock
     // port). Running `kimaki` here would kill the already-running bot process
@@ -2788,7 +2788,7 @@ cli
     });
 });
 cli
-    .command('screenshare', 'Share your screen via VNC tunnel. Auto-stops after 30 minutes. Runs until Ctrl+C. Use tmux to run in background.')
+    .command('screenshare', 'Share your screen via VNC tunnel. Auto-stops after 30 minutes. Runs until Ctrl+C. For background usage, start with bunx tuistory --help, then run it in a tuistory session.')
     .action(async () => {
     const { startScreenshare } = await import('./commands/screenshare.js');
     try {

package/dist/commands/add-dir.js

@@ -71,7 +71,7 @@ export async function handleAddDirCommand({ command, }) {
         });
         return;
     }
-    const requestedDirectory = command.options.getString('directory', true);
+    const requestedDirectory = command.options.getString('directory') ?? ALL_DIRECTORIES_PATTERN;
     const resolvedPattern = resolveDirectoryPermissionPattern({
         input: requestedDirectory,
         workingDirectory: resolvedDirectories.workingDirectory,

package/dist/commands/add-dir.test.js

@@ -1,6 +1,7 @@
 // Tests for /add-dir permission helpers.
 import { describe, expect, test } from 'vitest';
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { buildAddDirPermissionRules, resolveDirectoryPermissionPattern, } from './add-dir.js';
 import { buildExternalDirectoryPermissionRules, buildSessionPermissions, } from '../opencode.js';
@@ -16,6 +17,10 @@ describe('resolveDirectoryPermissionPattern', () => {
         expect(result).toBe(nested.replaceAll('\\', '/'));
     });
     test('supports allowing every directory with *', () => {
+        expect(resolveDirectoryPermissionPattern({
+            input: ' * ',
+            workingDirectory: '/repo',
+        })).toBe('*');
         expect(buildAddDirPermissionRules({
             resolvedPattern: '*',
         })).toMatchInlineSnapshot(`
@@ -85,38 +90,37 @@ describe('resolveDirectoryPermissionPattern', () => {
     `);
     });
     test('pre-allows common toolchain caches under home with ~ patterns', () => {
+        const home = os.homedir().replaceAll('\\', '/');
         expect(buildSessionPermissions({
             directory: '/Users/me/project',
         }).filter((rule) => {
             return [
-                '~/.cache/zig',
-                '~/.cargo',
-                '~/.cache/go-build',
-                '~/go/pkg',
+                `${home}/.cache/zig`,
+                `${home}/.cargo`,
+                `${home}/.cache/go-build`,
+                `${home}/go/pkg`,
             ].includes(rule.pattern);
-        })).toMatchInlineSnapshot(`
-      [
-        {
-          "action": "allow",
-          "pattern": "~/.cache/zig",
-          "permission": "external_directory",
-        },
-        {
-          "action": "allow",
-          "pattern": "~/.cargo",
-          "permission": "external_directory",
-        },
-        {
-          "action": "allow",
-          "pattern": "~/.cache/go-build",
-          "permission": "external_directory",
-        },
-        {
-          "action": "allow",
-          "pattern": "~/go/pkg",
-          "permission": "external_directory",
-        },
-      ]
-    `);
+        })).toEqual([
+            {
+                permission: 'external_directory',
+                pattern: `${home}/.cache/zig`,
+                action: 'allow',
+            },
+            {
+                permission: 'external_directory',
+                pattern: `${home}/.cargo`,
+                action: 'allow',
+            },
+            {
+                permission: 'external_directory',
+                pattern: `${home}/.cache/go-build`,
+                action: 'allow',
+            },
+            {
+                permission: 'external_directory',
+                pattern: `${home}/go/pkg`,
+                action: 'allow',
+            },
+        ]);
     });
 });

package/dist/commands/btw.js

@@ -4,10 +4,10 @@
 // dispatches the user's prompt so the forked session starts working right away.
 import { ChannelType, ThreadAutoArchiveDuration, MessageFlags, } from 'discord.js';
 import { getThreadSession, setThreadSession } from '../database.js';
-import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveWorkingDirectory, resolveTextChannel, sendThreadMessage, } from '../discord-utils.js';
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { createLogger, LogPrefix } from '../logger.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
 const logger = createLogger(LogPrefix.FORK);
 export async function forkSessionToBtwThread({ sourceThread, projectDirectory, prompt, userId, username, appId, }) {
     const sessionId = await getThreadSession(sourceThread.id);
@@ -52,7 +52,7 @@ export async function forkSessionToBtwThread({ sourceThread, projectDirectory, p
         thread,
         projectDirectory,
         sdkDirectory: projectDirectory,
-        channelId: textChannel.id,
+        channelId: sourceThread.parentId || sourceThread.id,
         appId,
     });
     await runtime.enqueueIncoming({

package/dist/commands/fork-subagent.js

@@ -0,0 +1,177 @@
+// /fork-subagent command - Fork a subagent task session into a new thread.
+import { ActionRowBuilder, MessageFlags, StringSelectMenuBuilder, ThreadAutoArchiveDuration, } from 'discord.js';
+import { getSessionEventSnapshot, getThreadSession, setThreadSession, } from '../database.js';
+import { resolveTextChannel, resolveWorkingDirectory, sendThreadMessage, } from '../discord-utils.js';
+import { collectSessionChunks, batchChunksForDiscord, } from '../message-formatting.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { getDerivedSubagentSessions, } from '../session-handler/event-stream-state.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { getThreadChannel, parsePersistedEventRows, } from './fork.js';
+const forkLogger = createLogger(LogPrefix.FORK);
+function truncateLabelPart(text, maxLength) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    if (maxLength <= 1) {
+        return text.slice(0, maxLength);
+    }
+    return `${text.slice(0, maxLength - 1)}…`;
+}
+function getSubagentOptionLabel({ subagentType, description, }) {
+    const agent = truncateLabelPart(subagentType || 'task', 24);
+    const cleanedDescription = description?.trim() || 'No description';
+    const descriptionBudget = Math.max(1, 100 - agent.length - 3);
+    const truncatedDescription = truncateLabelPart(cleanedDescription, descriptionBudget);
+    return `${agent} · ${truncatedDescription}`;
+}
+export async function handleForkSubagentCommand(interaction) {
+    const threadChannel = getThreadChannel(interaction.channel);
+    if (threadChannel instanceof Error) {
+        await interaction.reply({
+            content: threadChannel.message,
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: threadChannel,
+    });
+    if (!resolved) {
+        await interaction.reply({
+            content: 'Could not determine project directory for this channel',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const sessionId = await getThreadSession(threadChannel.id);
+    if (!sessionId) {
+        await interaction.reply({
+            content: 'No active session in this thread',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+    const rows = await getSessionEventSnapshot({ sessionId });
+    const events = parsePersistedEventRows({ rows });
+    const subagentSessions = getDerivedSubagentSessions({
+        events,
+        mainSessionId: sessionId,
+    }).slice(0, 25);
+    if (subagentSessions.length === 0) {
+        await interaction.editReply({
+            content: 'No subagent task sessions found in this thread',
+        });
+        return;
+    }
+    const options = subagentSessions.map((subagentSession) => ({
+        label: getSubagentOptionLabel({
+            subagentType: subagentSession.subagentType,
+            description: subagentSession.description,
+        }),
+        value: subagentSession.childSessionId,
+        description: new Date(subagentSession.timestamp).toLocaleString().slice(0, 100),
+    }));
+    const selectMenu = new StringSelectMenuBuilder()
+        .setCustomId(`fork_subagent_select:${sessionId}`)
+        .setPlaceholder('Select a subagent session to fork')
+        .addOptions(options);
+    const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+    await interaction.editReply({
+        content: '**Fork Subagent Session**\nSelect a subagent task session to fork into a new thread:',
+        components: [actionRow],
+    });
+}
+export async function handleForkSubagentSelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('fork_subagent_select:')) {
+        return;
+    }
+    const [, parentSessionId] = customId.split(':');
+    if (!parentSessionId) {
+        await interaction.reply({
+            content: 'Invalid selection data',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const selectedSessionId = interaction.values[0];
+    if (!selectedSessionId) {
+        await interaction.reply({
+            content: 'No subagent session selected',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    await interaction.deferReply();
+    const threadChannel = getThreadChannel(interaction.channel);
+    if (threadChannel instanceof Error) {
+        await interaction.editReply(threadChannel.message);
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: threadChannel,
+    });
+    if (!resolved) {
+        await interaction.editReply('Could not determine project directory for this channel');
+        return;
+    }
+    const rows = await getSessionEventSnapshot({ sessionId: parentSessionId });
+    const events = parsePersistedEventRows({ rows });
+    const selectedSubagent = getDerivedSubagentSessions({
+        events,
+        mainSessionId: parentSessionId,
+    }).find((candidate) => {
+        return candidate.childSessionId === selectedSessionId;
+    });
+    const getClient = await initializeOpencodeForDirectory(resolved.projectDirectory);
+    if (getClient instanceof Error) {
+        await interaction.editReply(`Failed to fork session: ${getClient.message}`);
+        return;
+    }
+    const forkResponse = await getClient().session.fork({
+        sessionID: selectedSessionId,
+    });
+    if (!forkResponse.data) {
+        await interaction.editReply('Failed to fork session');
+        return;
+    }
+    const textChannel = await resolveTextChannel(threadChannel);
+    if (!textChannel) {
+        await interaction.editReply('Could not resolve parent text channel');
+        return;
+    }
+    const forkedSession = forkResponse.data;
+    const forkedThread = await textChannel.threads.create({
+        name: `Fork: ${selectedSubagent?.description || selectedSubagent?.subagentType || 'subagent session'}`.slice(0, 100),
+        autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+        reason: `Forked subagent session ${selectedSessionId}`,
+    });
+    await setThreadSession(forkedThread.id, forkedSession.id);
+    await forkedThread.members.add(interaction.user.id);
+    forkLogger.log(`Created forked subagent session ${forkedSession.id} in thread ${forkedThread.id} from ${selectedSessionId}`);
+    const agentLabel = selectedSubagent?.subagentType || 'task';
+    const descriptionLabel = selectedSubagent?.description || 'No description';
+    await sendThreadMessage(forkedThread, `**Forked subagent session created!**\nAgent: \`${agentLabel}\`\nTask: ${descriptionLabel}\nFrom: \`${selectedSessionId}\`\nNew session: \`${forkedSession.id}\``);
+    try {
+        const messagesResponse = await getClient().session.messages({
+            sessionID: forkedSession.id,
+        });
+        if (messagesResponse.data) {
+            const { chunks } = collectSessionChunks({
+                messages: messagesResponse.data,
+                limit: 30,
+            });
+            const batched = batchChunksForDiscord(chunks);
+            for (const batch of batched) {
+                await sendThreadMessage(forkedThread, batch.content);
+            }
+        }
+    }
+    catch (error) {
+        forkLogger.error('Error replaying forked subagent history:', error);
+        await sendThreadMessage(forkedThread, 'Failed to load session messages, but the session is connected and ready to continue.');
+    }
+    await sendThreadMessage(forkedThread, 'You can now continue the conversation from this point.');
+    await interaction.editReply(`Subagent session forked! Continue in ${forkedThread.toString()}`);
+}

package/dist/commands/fork.js

@@ -3,34 +3,78 @@ import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectM
 import { getThreadSession, setThreadSession, setPartMessagesBatch, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveWorkingDirectory, resolveTextChannel, sendThreadMessage, } from '../discord-utils.js';
-import { collectSessionChunks, batchChunksForDiscord } from '../message-formatting.js';
+import { collectSessionChunks, batchChunksForDiscord, } from '../message-formatting.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
 const sessionLogger = createLogger(LogPrefix.SESSION);
 const forkLogger = createLogger(LogPrefix.FORK);
-export async function handleForkCommand(interaction) {
-    const channel = interaction.channel;
+function isTruthy(value) {
+    return Boolean(value);
+}
+function getThreadChannelFromCommand(interaction) {
+    return getThreadChannel(interaction.channel);
+}
+function getThreadChannel(channel) {
     if (!channel) {
-        await interaction.reply({
-            content: 'This command can only be used in a channel',
-            flags: MessageFlags.Ephemeral,
+        return new Error('This command can only be used in a channel');
+    }
+    if (channel.type !== ChannelType.PublicThread
+        && channel.type !== ChannelType.PrivateThread
+        && channel.type !== ChannelType.AnnouncementThread) {
+        return new Error('This command can only be used in a thread with an active session');
+    }
+    return channel;
+}
+function parsePersistedEventRows({ rows, }) {
+    return rows.flatMap((row) => {
+        const parsed = errore.try({
+            try: () => {
+                return JSON.parse(row.event_json);
+            },
+            catch: (error) => {
+                return new Error('Failed to parse persisted event JSON', {
+                    cause: error,
+                });
+            },
         });
-        return;
+        if (parsed instanceof Error) {
+            forkLogger.warn(`[fork] Skipping invalid persisted event row ${row.id}: ${parsed.message}`);
+            return [];
+        }
+        return [{
+                event: parsed,
+                timestamp: Number(row.timestamp),
+                eventIndex: Number(row.event_index),
+            }];
+    });
+}
+function truncateLabelPart(text, maxLength) {
+    if (text.length <= maxLength) {
+        return text;
     }
-    const isThread = [
-        ChannelType.PublicThread,
-        ChannelType.PrivateThread,
-        ChannelType.AnnouncementThread,
-    ].includes(channel.type);
-    if (!isThread) {
+    if (maxLength <= 1) {
+        return text.slice(0, maxLength);
+    }
+    return `${text.slice(0, maxLength - 1)}…`;
+}
+function getSubagentOptionLabel({ subagentType, description, }) {
+    const agent = truncateLabelPart(subagentType || 'task', 24);
+    const cleanedDescription = description?.trim() || 'No description';
+    const descriptionBudget = Math.max(1, 100 - agent.length - 3);
+    const truncatedDescription = truncateLabelPart(cleanedDescription, descriptionBudget);
+    return `${agent} · ${truncatedDescription}`;
+}
+export async function handleForkCommand(interaction) {
+    const threadChannel = getThreadChannelFromCommand(interaction);
+    if (threadChannel instanceof Error) {
         await interaction.reply({
-            content: 'This command can only be used in a thread with an active session',
+            content: threadChannel.message,
             flags: MessageFlags.Ephemeral,
         });
         return;
     }
     const resolved = await resolveWorkingDirectory({
-        channel: channel,
+        channel: threadChannel,
     });
     if (!resolved) {
         await interaction.reply({
@@ -40,7 +84,7 @@ export async function handleForkCommand(interaction) {
         return;
     }
     const { projectDirectory } = resolved;
-    const sessionId = await getThreadSession(channel.id);
+    const sessionId = await getThreadSession(threadChannel.id);
     if (!sessionId) {
         await interaction.reply({
             content: 'No active session in this thread',
@@ -79,7 +123,9 @@ export async function handleForkCommand(interaction) {
         // injected by the opencode plugin — they clutter the dropdown preview.
         const options = recentMessages
             .map((m, index) => {
-            const textPart = m.parts.find((p) => p.type === 'text' && !p.synthetic);
+            const textPart = m.parts.find((p) => {
+                return p.type === 'text' && !p.synthetic && typeof p.text === 'string';
+            });
             if (!textPart?.text) {
                 return null;
             }
@@ -93,7 +139,7 @@ export async function handleForkCommand(interaction) {
                     .slice(0, 50),
             };
         })
-            .filter((o) => o !== null);
+            .filter(isTruthy);
         const selectMenu = new StringSelectMenuBuilder()
             // Discord component custom_id max length is 100 chars.
             // Avoid embedding long directory paths (or base64 of them) in the custom ID.
@@ -136,9 +182,9 @@ export async function handleForkSelectMenu(interaction) {
         return;
     }
     await interaction.deferReply();
-    const threadChannel = interaction.channel;
-    if (!threadChannel) {
-        await interaction.editReply('Could not access thread channel');
+    const threadChannel = getThreadChannel(interaction.channel);
+    if (threadChannel instanceof Error) {
+        await interaction.editReply(threadChannel.message);
         return;
     }
     const resolved = await resolveWorkingDirectory({
@@ -164,14 +210,9 @@ export async function handleForkSelectMenu(interaction) {
             return;
         }
         const forkedSession = forkResponse.data;
-        const parentChannel = interaction.channel;
-        if (!parentChannel ||
-            ![
-                ChannelType.PublicThread,
-                ChannelType.PrivateThread,
-                ChannelType.AnnouncementThread,
-            ].includes(parentChannel.type)) {
-            await interaction.editReply('Could not access parent channel');
+        const parentChannel = getThreadChannel(interaction.channel);
+        if (parentChannel instanceof Error) {
+            await interaction.editReply(parentChannel.message);
             return;
         }
         const textChannel = await resolveTextChannel(parentChannel);
@@ -218,3 +259,4 @@ export async function handleForkSelectMenu(interaction) {
         await interaction.editReply(`Failed to fork session: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 }
+export { getThreadChannel, parsePersistedEventRows };

package/dist/discord-command-registration.js

@@ -206,7 +206,7 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             option
                 .setName('directory')
                 .setDescription(truncateCommandDescription('Directory to allow, resolved from the current worktree. Use * for all folders'))
-                .setRequired(true);
+                .setRequired(false);
             return option;
         })
             .setDMPermission(false)
@@ -236,6 +236,11 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .setDescription(truncateCommandDescription('Fork the session from a past user message'))
             .setDMPermission(false)
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('fork-subagent')
+            .setDescription(truncateCommandDescription('Fork a subagent task session into a new thread'))
+            .setDMPermission(false)
+            .toJSON(),
         new SlashCommandBuilder()
             .setName('btw')
             .setDescription(truncateCommandDescription('Ask something without polluting or blocking the current session'))
@@ -255,7 +260,7 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .toJSON(),
         new SlashCommandBuilder()
             .setName('model-variant')
-            .setDescription(truncateCommandDescription('Quickly change the thinking level variant for the current model'))
+            .setDescription(truncateCommandDescription('Change thinking level for current model. Tied to the model; lost when you switch models'))
             .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()