kimaki 0.28.0 → 0.29.0

package/dist/bash-tool-schema-plugin.js

@@ -3,7 +3,22 @@
 // Assign jsonSchema only. Leave parameters as the Effect Schema used to decode
 // args before execute. Extra fields stay in the model-facing schema and in
 // Discord input; they never reach the shell.
+//
+// Also injects KIMAKI_SESSION_ID into bash env. /btw and /fork clone parent
+// history, so the copied system prompt still says --session <parent>. Upload
+// then prefers this live env over that stale flag.
 import { z } from 'zod';
+export const KIMAKI_SESSION_ID_ENV = 'KIMAKI_SESSION_ID';
+export function injectKimakiSessionEnv({ sessionID, env, }) {
+    if (!sessionID)
+        return;
+    env[KIMAKI_SESSION_ID_ENV] = sessionID;
+}
+export function resolveUploadToDiscordSessionId({ flagSessionId, envSessionId = process.env[KIMAKI_SESSION_ID_ENV], } = {}) {
+    if (envSessionId)
+        return envSessionId;
+    return flagSessionId;
+}
 export const bashParameters = z.object({
     command: z.string().describe('The command to execute'),
     description: z
@@ -28,5 +43,8 @@ export const bashToolSchemaPlugin = async () => {
                 return;
             extendBashToolDefinition(output);
         },
+        'shell.env': async (input, output) => {
+            injectKimakiSessionEnv({ sessionID: input.sessionID, env: output.env });
+        },
     };
 };

package/dist/bash-tool-schema-plugin.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'vitest';
-import { extendBashToolDefinition, } from './bash-tool-schema-plugin.js';
+import { extendBashToolDefinition, injectKimakiSessionEnv, KIMAKI_SESSION_ID_ENV, resolveUploadToDiscordSessionId, } from './bash-tool-schema-plugin.js';
 describe('extendBashToolDefinition', () => {
     test('keeps parameters and assigns jsonSchema from bashParameters', () => {
         const parameters = { keep: true };
@@ -47,3 +47,22 @@ describe('extendBashToolDefinition', () => {
     `);
     });
 });
+describe('upload-to-discord session targeting', () => {
+    test('bash env uses the live OpenCode session, not a copied --session flag', () => {
+        const env = {};
+        injectKimakiSessionEnv({ sessionID: 'ses_child', env });
+        expect(env).toEqual({ [KIMAKI_SESSION_ID_ENV]: 'ses_child' });
+        expect(resolveUploadToDiscordSessionId({
+            flagSessionId: 'ses_parent',
+            envSessionId: env[KIMAKI_SESSION_ID_ENV],
+        })).toBe('ses_child');
+    });
+    test('falls back to --session when bash is not inside an OpenCode session', () => {
+        expect(resolveUploadToDiscordSessionId({
+            flagSessionId: 'ses_parent',
+        })).toBe('ses_parent');
+    });
+    test('returns undefined when neither live session nor flag is set', () => {
+        expect(resolveUploadToDiscordSessionId({})).toBeUndefined();
+    });
+});

package/dist/channel-management.js

@@ -4,7 +4,7 @@
 import { ChannelType, } from 'discord.js';
 import fs from 'node:fs';
 import path from 'node:path';
-import { getChannelDirectory, setChannelDirectory, findChannelsByDirectory, listTrackedTextChannels, } from './database.js';
+import { getChannelDirectory, setChannelDirectory, findChannelsByDirectory, listTrackedTextChannels, getGuildCategories, setGuildCategoryId, } from './database.js';
 import { getProjectsDir } from './config.js';
 import { execAsync } from './worktrees.js';
 import { createLogger, LogPrefix } from './logger.js';
@@ -39,41 +39,117 @@ async function trackProjectRegistered({ projectKind, source, }) {
     trackEvent('project_registered', props);
 }
 const logger = createLogger(LogPrefix.CHANNEL);
-export async function ensureKimakiCategory(guild, botName) {
-    // Skip appending bot name if it's already "kimaki" to avoid "Kimaki kimaki"
+function defaultCategoryName(kind, botName) {
     const isKimakiBot = botName?.toLowerCase() === 'kimaki';
-    const categoryName = botName && !isKimakiBot ? `Kimaki ${botName}` : 'Kimaki';
-    const existingCategory = guild.channels.cache.find((channel) => {
-        if (channel.type !== ChannelType.GuildCategory) {
-            return false;
+    if (kind === 'audio') {
+        return botName && !isKimakiBot ? `Kimaki Audio ${botName}` : 'Kimaki Audio';
+    }
+    return botName && !isKimakiBot ? `Kimaki ${botName}` : 'Kimaki';
+}
+function defaultKimakiChannelName({ botName, isGatewayMode, }) {
+    if (isGatewayMode || !botName)
+        return 'kimaki';
+    const sanitized = botName
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+    if (!sanitized || sanitized === 'kimaki')
+        return 'kimaki';
+    return `kimaki-${sanitized}`.slice(0, 100);
+}
+const categoryEnsures = new Map();
+function ensureCategorySerialized({ key, run, }) {
+    const existing = categoryEnsures.get(key);
+    if (existing)
+        return existing;
+    const promise = run().finally(() => {
+        if (categoryEnsures.get(key) === promise) {
+            categoryEnsures.delete(key);
         }
-        return channel.name.toLowerCase() === categoryName.toLowerCase();
     });
-    if (existingCategory) {
-        return existingCategory;
+    categoryEnsures.set(key, promise);
+    return promise;
+}
+function isUnknownDiscordChannel(error) {
+    const code = error instanceof Error ? Reflect.get(error, 'code') : undefined;
+    const status = error instanceof Error ? Reflect.get(error, 'status') : undefined;
+    return code === 10003 || status === 404;
+}
+function isCategoryChannel(channel) {
+    return channel?.type === ChannelType.GuildCategory;
+}
+async function fetchCategoryById(guild, categoryId) {
+    const cached = guild.channels.cache.get(categoryId);
+    if (isCategoryChannel(cached))
+        return cached;
+    try {
+        const fetched = await guild.channels.fetch(categoryId);
+        return isCategoryChannel(fetched) ? fetched : null;
+    }
+    catch (error) {
+        if (isUnknownDiscordChannel(error))
+            return null;
+        throw error;
     }
-    return guild.channels.create({
-        name: categoryName,
-        type: ChannelType.GuildCategory,
-    });
 }
-export async function ensureKimakiAudioCategory(guild, botName) {
-    // Skip appending bot name if it's already "kimaki" to avoid "Kimaki Audio kimaki"
-    const isKimakiBot = botName?.toLowerCase() === 'kimaki';
-    const categoryName = botName && !isKimakiBot ? `Kimaki Audio ${botName}` : 'Kimaki Audio';
-    const existingCategory = guild.channels.cache.find((channel) => {
-        if (channel.type !== ChannelType.GuildCategory) {
-            return false;
-        }
-        return channel.name.toLowerCase() === categoryName.toLowerCase();
+async function adoptParentFromTrackedChannels({ guild, channelType, }) {
+    const mappings = await findChannelsByDirectory({ channelType });
+    const channels = await guild.channels.fetch();
+    for (const row of mappings) {
+        if (row.guild_id && row.guild_id !== guild.id)
+            continue;
+        const channel = channels.get(row.channel_id);
+        if (!channel?.parentId)
+            continue;
+        const parent = await fetchCategoryById(guild, channel.parentId);
+        if (parent)
+            return parent;
+    }
+    return null;
+}
+async function resolveKimakiCategory({ guild, kind, botName, }) {
+    const stored = await getGuildCategories(guild.id);
+    const storedId = kind === 'audio' ? stored?.audio_category_id : stored?.category_id;
+    if (storedId) {
+        const existing = await fetchCategoryById(guild, storedId);
+        if (existing)
+            return existing;
+    }
+    const adopted = await adoptParentFromTrackedChannels({
+        guild,
+        channelType: kind === 'audio' ? 'voice' : 'text',
     });
-    if (existingCategory) {
-        return existingCategory;
+    if (adopted) {
+        await setGuildCategoryId({
+            guildId: guild.id,
+            kind,
+            categoryId: adopted.id,
+        });
+        return adopted;
     }
-    return guild.channels.create({
-        name: categoryName,
+    const created = await guild.channels.create({
+        name: defaultCategoryName(kind, botName),
         type: ChannelType.GuildCategory,
     });
+    await setGuildCategoryId({
+        guildId: guild.id,
+        kind,
+        categoryId: created.id,
+    });
+    return created;
+}
+export function ensureKimakiCategory(guild, botName) {
+    return ensureCategorySerialized({
+        key: `${guild.id}:text`,
+        run: () => resolveKimakiCategory({ guild, kind: 'text', botName }),
+    });
+}
+export function ensureKimakiAudioCategory(guild, botName) {
+    return ensureCategorySerialized({
+        key: `${guild.id}:audio`,
+        run: () => resolveKimakiCategory({ guild, kind: 'audio', botName }),
+    });
 }
 export async function createProjectChannels({ guild, projectDirectory, botName, enableVoiceChannels = false, analyticsSource = 'cli', }) {
     const baseName = path.basename(projectDirectory);
@@ -92,6 +168,7 @@ export async function createProjectChannels({ guild, projectDirectory, botName,
         channelId: textChannel.id,
         directory: projectDirectory,
         channelType: 'text',
+        guildId: guild.id,
     });
     await trackProjectRegistered({
         projectKind: 'user',
@@ -109,6 +186,7 @@ export async function createProjectChannels({ guild, projectDirectory, botName,
             channelId: voiceChannel.id,
             directory: projectDirectory,
             channelType: 'voice',
+            guildId: guild.id,
         });
         voiceChannelId = voiceChannel.id;
     }
@@ -158,8 +236,9 @@ const DEFAULT_CHANNEL_TOPIC = 'General channel for misc tasks with Kimaki. Not c
  * Directory is ~/.kimaki/projects/kimaki, git-initialized with a .gitignore.
  *
  * Idempotency: checks the database for an existing channel mapped to the
- * kimaki projects directory. Also scans guild channels by name+category
- * as a fallback for channels created before DB mapping existed.
+ * kimaki projects directory. Also scans this machine's category for the
+ * exact default channel name as a fallback for channels created before
+ * DB mapping existed.
  */
 export async function createDefaultKimakiChannel({ guild, botName, appId, isGatewayMode, }) {
     const projectDirectory = getDefaultKimakiDirectory();
@@ -209,11 +288,9 @@ export async function createDefaultKimakiChannel({ guild, botName, appId, isGate
         logger.log(`Default kimaki channel was previously provisioned for guild ${guild.name} (${guild.id}) as ${staleForThisGuild.channel_id}, but no longer exists. Skipping recreation.`);
         return null;
     }
-    // 2. Fallback: detect existing channel by name+category.
-    // If a "kimaki" channel already exists in the guild but is NOT in our local
-    // DB, it was likely created by another kimaki instance (different machine).
-    // Do NOT adopt it — just skip channel creation entirely to avoid both
-    // instances fighting over the same channel.
+    // 2. Fallback: detect an existing default channel in THIS machine's group.
+    // A #kimaki channel in another machine's group is ignored.
+    const channelName = defaultKimakiChannelName({ botName, isGatewayMode });
     const kimakiCategory = await ensureKimakiCategory(guild, botName);
     const existingByName = guild.channels.cache.find((ch) => {
         if (ch.type !== ChannelType.GuildText) {
@@ -222,10 +299,10 @@ export async function createDefaultKimakiChannel({ guild, botName, appId, isGate
         if (ch.parentId !== kimakiCategory.id) {
             return false;
         }
-        return ch.name === 'kimaki' || ch.name.startsWith('kimaki-');
+        return ch.name === channelName;
     });
     if (existingByName) {
-        logger.log(`Found existing default kimaki channel by name: ${existingByName.id}, but it is not in our DB — skipping (likely owned by another kimaki instance)`);
+        logger.log(`Found existing default kimaki channel by name: ${existingByName.id}. Skipping recreation.`);
         return null;
     }
     // Git init — gracefully skip if git is not installed
@@ -244,21 +321,6 @@ export async function createDefaultKimakiChannel({ guild, botName, appId, isGate
     if (!fs.existsSync(gitignorePath)) {
         fs.writeFileSync(gitignorePath, DEFAULT_GITIGNORE);
     }
-    // Channel name: "kimaki-{botName}" for self-hosted, "kimaki" for gateway
-    const channelName = (() => {
-        if (isGatewayMode || !botName) {
-            return 'kimaki';
-        }
-        const sanitized = botName
-            .toLowerCase()
-            .replace(/[^a-z0-9-]/g, '-')
-            .replace(/-+/g, '-')
-            .replace(/^-|-$/g, '');
-        if (!sanitized || sanitized === 'kimaki') {
-            return 'kimaki';
-        }
-        return `kimaki-${sanitized}`.slice(0, 100);
-    })();
     const textChannel = await guild.channels.create({
         name: channelName,
         type: ChannelType.GuildText,

package/dist/cli-commands/misc.js

@@ -24,6 +24,7 @@ import { execAsync, validateWorktreeDirectory } from '../worktrees.js';
 import { upgrade, getCurrentVersion } from '../upgrade.js';
 import { getPromptPreview, parseSendAtValue, parseScheduledTaskPayload, serializeScheduledTaskPayload } from '../task-schedule.js';
 import { EXIT_NO_RESTART, formatMemberLookupUnavailableMessage, formatRelativeTime, formatTaskScheduleLine, isDiscordMemberLookupUnavailable, isGuildMemberSearchResult, isThreadChannelType, printDiscordInstallUrlAndExit, resolveBotCredentials, resolveDiscordUserOption, sendDiscordMessageWithOptionalAttachment, } from '../cli-runner.js';
+import { resolveUploadToDiscordSessionId } from '../bash-tool-schema-plugin.js';
 const cliLogger = createLogger(LogPrefix.CLI);
 const cli = goke();
 cli
@@ -31,7 +32,9 @@ cli
     .option('-s, --session <sessionId>', 'OpenCode session ID')
     .action(async (files, options) => {
     try {
-        const { session: sessionId } = options;
+        const sessionId = resolveUploadToDiscordSessionId({
+            flagSessionId: options.session,
+        });
         if (!sessionId) {
             cliLogger.error('Session ID is required. Use --session <sessionId>');
             process.exit(EXIT_NO_RESTART);

package/dist/cli-commands/project.js

@@ -12,7 +12,7 @@ import { spawn, execSync } from 'node:child_process';
 import { createLogger, LogPrefix, initLogFile } from '../logger.js';
 import { createDiscordClient, initDatabase, getChannelDirectory, initializeOpencodeForDirectory, createProjectChannels } from '../discord-bot.js';
 import { getDefaultKimakiDirectory } from '../channel-management.js';
-import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory, findRegisteredTextChannelForDirectory, formatProjectAlreadyRegisteredError } from '../database.js';
+import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory, findRegisteredTextChannelForDirectory, formatProjectAlreadyRegisteredError, listGuildCategoryIds } from '../database.js';
 import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
 import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';
@@ -88,7 +88,7 @@ cli
 cli
     .command('project list', 'List all registered projects with their Discord channels')
     .option('--json', 'Output as JSON')
-    .option('--all', 'Include remote projects from other machines (scans Kimaki category in Discord)')
+    .option('--all', 'Include remote projects from other machines (scans Kimaki groups in Discord)')
     .option('-g, --guild <guildId>', 'Discord guild/server ID to scan (used with --all when no local projects exist)')
     .option('--prune', 'Remove stale entries whose Discord channel no longer exists')
     .action(async (options) => {
@@ -158,12 +158,15 @@ cli
             process.exit(EXIT_NO_RESTART);
         }
         let guildScanFailures = 0;
+        const storedCategoryIds = new Set(await listGuildCategoryIds());
         for (const guildId of uniqueGuildIds) {
             try {
                 const guildChannels = (await rest.get(Routes.guildChannels(guildId)));
-                // Find Kimaki category channels (type 4 = GuildCategory)
+                // Kimaki groups: name still starts with Kimaki, or this machine stored the id
+                // after a rename. Other machines' renamed groups cannot be found by name.
                 const kimakiCategoryIds = new Set(guildChannels
-                    .filter((ch) => ch.type === 4 && /^kimaki(\s|$)/i.test(ch.name))
+                    .filter((ch) => ch.type === 4 &&
+                    (/^kimaki(\s|$)/i.test(ch.name) || storedCategoryIds.has(ch.id)))
                     .map((ch) => ch.id));
                 // Find text channels (type 0) in Kimaki categories that are not in our local DB
                 for (const ch of guildChannels) {

package/dist/cli-commands/session.js

@@ -54,45 +54,82 @@ async function resolveSessionDirectoryFromDatabase({ sessionId, }) {
     }
     return new Error(`Session is not linked to a Kimaki thread in the local database: ${sessionId}`);
 }
+// Total token footprint of a session (input + output + reasoning + cache).
+function getSessionTokenTotal(tokens) {
+    return (tokens.input +
+        tokens.output +
+        tokens.reasoning +
+        tokens.cache.read +
+        tokens.cache.write);
+}
+// Compact token count: 1234 -> "1k", 200000 -> "200k", 1_500_000 -> "1.5M".
+function formatTokenCount(count) {
+    if (count >= 1_000_000) {
+        return `${(count / 1_000_000).toFixed(1)}M`;
+    }
+    if (count >= 1_000) {
+        return `${Math.round(count / 1_000)}k`;
+    }
+    return String(count);
+}
 cli
     .command('session list', 'List all OpenCode sessions, marking which were started via Kimaki')
     .option('--project <path>', 'Project directory to list sessions for (defaults to cwd)')
+    .option('--all', 'List sessions across every locally registered project')
     .option('--active', 'Only list active sessions; exits 1 when none remain')
     .option('--exclude <sessionId>', 'Exclude one session ID from the results')
     .option('--json', 'Output as JSON')
     .action(async (options) => {
     try {
-        const projectDirectory = path.resolve(options.project || '.');
         await initDatabase();
-        cliLogger.log('Connecting to OpenCode server...');
-        const getClient = await initializeOpencodeForDirectory(projectDirectory);
-        if (getClient instanceof Error) {
-            cliLogger.error('Failed to connect to OpenCode:', getClient.message);
+        if (options.all && options.project) {
+            cliLogger.error('Use either --all or --project, not both');
             process.exit(EXIT_NO_RESTART);
         }
-        const sessionsResponse = await getClient().session.list();
-        const sessions = sessionsResponse.data || [];
-        const statuses = await (async () => {
-            if (!options.active)
-                return null;
-            const response = await getClient().session.status({
-                directory: projectDirectory,
-            });
-            if (response.error) {
-                cliLogger.error('Failed to list active sessions');
+        const projectDirectories = options.all
+            ? Array.from(new Set((await getAllTextChannelDirectories()).map((directory) => path.resolve(directory))))
+            : [path.resolve(options.project || '.')];
+        if (projectDirectories.length === 0) {
+            cliLogger.error('No registered project directories found. Add a project with `kimaki project add`.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const gathered = [];
+        for (const projectDirectory of projectDirectories) {
+            cliLogger.log(`Connecting to OpenCode server for ${projectDirectory}...`);
+            const getClient = await initializeOpencodeForDirectory(projectDirectory);
+            if (getClient instanceof Error) {
+                if (options.all) {
+                    cliLogger.warn(`Skipping ${projectDirectory}: failed to connect to OpenCode: ${getClient.message}`);
+                    continue;
+                }
+                cliLogger.error('Failed to connect to OpenCode:', getClient.message);
                 process.exit(EXIT_NO_RESTART);
             }
-            return response.data || {};
-        })();
-        const selectedSessions = sessions.filter((session) => {
-            if (session.id === options.exclude)
+            const client = getClient();
+            const [sessionsResponse, statusResponse] = await Promise.all([
+                client.session.list(),
+                client.session.status({ directory: projectDirectory }).catch(() => null),
+            ]);
+            const statuses = statusResponse?.data || {};
+            for (const session of sessionsResponse.data || []) {
+                const status = statuses[session.id];
+                gathered.push({
+                    session,
+                    projectDirectory,
+                    status: status && status.type !== 'idle' ? 'busy' : 'idle',
+                });
+            }
+        }
+        const selected = gathered
+            .filter((entry) => {
+            if (entry.session.id === options.exclude)
                 return false;
-            if (!options.active)
-                return true;
-            const status = statuses?.[session.id];
-            return Boolean(status && status.type !== 'idle');
-        });
-        if (selectedSessions.length === 0) {
+            if (options.active && entry.status !== 'busy')
+                return false;
+            return true;
+        })
+            .sort((a, b) => b.session.time.updated - a.session.time.updated);
+        if (selected.length === 0) {
             if (options.json)
                 console.log('[]');
             else
@@ -107,15 +144,26 @@ cli
         const sessionToThread = new Map(threadSessions
             .filter((row) => row.session_id !== '')
             .map((row) => [row.session_id, row.thread_id]));
-        const sessionStartSources = await getSessionStartSourcesBySessionIds(selectedSessions.map((session) => session.id));
+        const sessionStartSources = await getSessionStartSourcesBySessionIds(selected.map((entry) => entry.session.id));
         const scheduleModeLabel = ({ scheduleKind, }) => {
             if (scheduleKind === 'at') {
                 return 'delay';
             }
             return 'cron';
         };
+        // Token footprint straight from the session object (no message fetch).
+        // Session.tokens is a per-session aggregate, so it is reported as a token
+        // count rather than a context-window percentage.
+        const contextInfo = (entry) => {
+            const tokens = entry.session.tokens;
+            if (!tokens)
+                return null;
+            const total = getSessionTokenTotal(tokens);
+            return total > 0 ? total : null;
+        };
         if (options.json) {
-            const output = selectedSessions.map((session) => {
+            const output = selected.map((entry) => {
+                const session = entry.session;
                 const startSource = sessionStartSources.get(session.id);
                 const startedBy = startSource
                     ? `scheduled-${scheduleModeLabel({ scheduleKind: startSource.schedule_kind })}`
@@ -127,15 +175,18 @@ cli
                     updated: new Date(session.time.updated).toISOString(),
                     source: sessionToThread.has(session.id) ? 'kimaki' : 'opencode',
                     threadId: sessionToThread.get(session.id) || null,
+                    status: entry.status,
+                    model: session.model?.id || null,
+                    tokens: contextInfo(entry),
                     startedBy,
                     scheduledTaskId: startSource?.scheduled_task_id || null,
-                    status: options.active ? statuses?.[session.id]?.type || 'busy' : undefined,
                 };
             });
             console.log(JSON.stringify(output, null, 2));
             process.exit(0);
         }
-        for (const session of selectedSessions) {
+        for (const entry of selected) {
+            const session = entry.session;
             const threadId = sessionToThread.get(session.id);
             const startSource = sessionStartSources.get(session.id);
             const source = threadId ? '(kimaki)' : '(opencode)';
@@ -144,10 +195,10 @@ cli
                 : '';
             const updatedAt = new Date(session.time.updated).toISOString();
             const threadInfo = threadId ? ` | thread: ${threadId}` : '';
-            const statusInfo = options.active
-                ? ` | status: ${statuses?.[session.id]?.type || 'busy'}`
-                : '';
-            console.log(`${session.id} | ${session.title || 'Untitled Session'} | ${session.directory} | ${updatedAt} | ${source}${threadInfo}${startedBy}${statusInfo}`);
+            const statusInfo = ` | status: ${entry.status === 'busy' ? 'working' : 'idle'}`;
+            const tokens = contextInfo(entry);
+            const tokensText = tokens ? ` | tokens: ${formatTokenCount(tokens)}` : '';
+            console.log(`${session.id} | ${session.title || 'Untitled Session'} | ${session.directory} | ${updatedAt} | ${source}${statusInfo}${tokensText}${threadInfo}${startedBy}`);
         }
         process.exit(0);
     }

package/dist/cli-commands/thread.js

@@ -0,0 +1,63 @@
+import { goke } from 'goke';
+import { z } from 'zod';
+import { createLogger, LogPrefix } from '../logger.js';
+import { initDatabase } from '../discord-bot.js';
+import { createDiscordRest } from '../discord-urls.js';
+import { EXIT_NO_RESTART, resolveBotCredentials } from '../cli-runner.js';
+import { listDiscordChannelThreads } from '../list-channel-threads.js';
+const cliLogger = createLogger(LogPrefix.CLI);
+const cli = goke();
+cli
+    .command('thread list', 'List Discord threads in a channel. Use this to find a thread on another computer, then send with --thread.')
+    .option('-c, --channel <channelId>', 'Discord channel ID')
+    .option('--json', 'Output as JSON')
+    .option('--limit <n>', z.number().default(50).describe('Maximum threads to show'))
+    .example('kimaki thread list --channel 123456789012345678')
+    .example('kimaki thread list --channel 123456789012345678 --json')
+    .action(async (options, { console, process }) => {
+    try {
+        if (!options.channel) {
+            cliLogger.error('Channel ID is required. Use --channel <channelId>. Find remote channels with `kimaki project list --all --json`.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        await initDatabase();
+        const { token: botToken } = await resolveBotCredentials({});
+        const rest = createDiscordRest(botToken);
+        const listed = await listDiscordChannelThreads({
+            rest,
+            channelId: options.channel,
+        });
+        if (!listed.ok) {
+            cliLogger.error(listed.error.message);
+            process.exit(EXIT_NO_RESTART);
+            return;
+        }
+        const limited = listed.threads.slice(0, options.limit);
+        if (options.json) {
+            console.log(JSON.stringify(limited.map((thread) => ({
+                thread_id: thread.id,
+                name: thread.name,
+                channel_id: thread.parentId,
+                guild_id: thread.guildId,
+                archived: thread.archived,
+                archive_state: thread.archiveState,
+                last_message_id: thread.lastMessageId,
+            })), null, 2));
+            process.exit(0);
+        }
+        if (limited.length === 0) {
+            console.log(`No threads found in channel ${options.channel}`);
+            process.exit(0);
+        }
+        for (const thread of limited) {
+            const archivedTag = thread.archived ? ' [archived]' : '';
+            console.log(`${thread.id} | ${thread.name}${archivedTag}`);
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+export default cli;

package/dist/cli.js

@@ -20,6 +20,7 @@ import projectCommands from './cli-commands/project.js';
 import sendCommands from './cli-commands/send.js';
 import sessionCommands from './cli-commands/session.js';
 import taskCommands from './cli-commands/task.js';
+import threadCommands from './cli-commands/thread.js';
 import userCommands from './cli-commands/user.js';
 import { EXIT_NO_RESTART, printDiscordInstallUrlAndExit, run, } from './cli-runner.js';
 const cliLogger = createLogger(LogPrefix.CLI);
@@ -258,6 +259,7 @@ cli.use(miscCommands);
 cli.use(sendCommands);
 cli.use(taskCommands);
 cli.use(projectCommands);
+cli.use(threadCommands);
 cli.use(userCommands);
 cli.use(sessionCommands);
 cli.use(maintenanceCommands);