kimaki 0.25.0 → 0.27.0

package/dist/cli-commands/maintenance.js

@@ -60,13 +60,21 @@ cli
     }
 });
 cli
-    .command('worktree merge', 'Merge worktree branch into default branch using worktrunk-style pipeline')
+    .command('merge-worktree', 'Merge the current worktree into a target branch')
     .option('-d, --directory <path>', 'Worktree directory (defaults to cwd)')
     .option('-m, --main-repo <path>', 'Main repository directory (auto-detected from worktree)')
     .option('-n, --name <name>', 'Worktree/branch name (auto-detected from branch)')
+    .option('--strategy [strategy]', z.enum(['rebase', 'squash'])
+    .default('rebase')
+    .describe('Keep commits or squash them into one'))
+    .option('--target-branch [branch]', z.string()
+    .optional()
+    .describe('Branch to merge into (defaults to origin/HEAD or main)'))
+    .option('--thread [threadId]', z.string().optional().describe('Discord thread to mark as merged'))
+    .option('--thread-name [name]', z.string().optional().describe('Discord thread name after merging'))
     .action(async (options) => {
     try {
-        const { mergeWorktree } = await import('../worktrees.js');
+        const { formatMergeWorktreeError, mergeWorktree } = await import('../worktrees.js');
         const worktreeDir = path.resolve(options.directory || '.');
         // Auto-detect main repo: find the main worktree's toplevel.
         // For linked worktrees, --git-common-dir points to the shared .git,
@@ -77,14 +85,20 @@ cli
         if (!mainRepoDir) {
             try {
                 // `git worktree list --porcelain` first line is always the main worktree
-                const { stdout } = await execAsync(`git -C "${worktreeDir}" worktree list --porcelain`);
+                const { stdout } = await execAsync({
+                    command: 'git',
+                    args: ['-C', worktreeDir, 'worktree', 'list', '--porcelain'],
+                });
                 const firstLine = stdout.split('\n')[0] || '';
                 // Format: "worktree /path/to/main"
                 mainRepoDir = firstLine.replace(/^worktree\s+/, '').trim();
             }
             catch {
                 // Fallback: derive from git common dir
-                const { stdout: commonDir } = await execAsync(`git -C "${worktreeDir}" rev-parse --git-common-dir`);
+                const { stdout: commonDir } = await execAsync({
+                    command: 'git',
+                    args: ['-C', worktreeDir, 'rev-parse', '--git-common-dir'],
+                });
                 const resolved = path.isAbsolute(commonDir.trim())
                     ? commonDir.trim()
                     : path.resolve(worktreeDir, commonDir.trim());
@@ -95,7 +109,10 @@ cli
         let worktreeName = options.name;
         if (!worktreeName) {
             try {
-                const { stdout } = await execAsync(`git -C "${worktreeDir}" symbolic-ref --short HEAD`);
+                const { stdout } = await execAsync({
+                    command: 'git',
+                    args: ['-C', worktreeDir, 'symbolic-ref', '--short', 'HEAD'],
+                });
                 worktreeName = stdout.trim();
             }
             catch {
@@ -110,18 +127,40 @@ cli
             worktreeDir,
             mainRepoDir,
             worktreeName,
+            strategy: options.strategy,
+            targetBranch: options.targetBranch,
             onProgress: (msg) => {
                 cliLogger.log(msg);
             },
         });
         if (result instanceof Error) {
-            cliLogger.error(`Merge failed: ${result.message}`);
+            cliLogger.error(formatMergeWorktreeError(result, { maxLength: 8000 }));
             if (result instanceof RebaseConflictError) {
                 cliLogger.log('Resolve the rebase conflicts, then run this command again.');
             }
             process.exit(1);
         }
-        cliLogger.log(`Merged ${result.branchName} into ${result.defaultBranch} @ ${result.shortSha} (${result.commitCount} commit${result.commitCount === 1 ? '' : 's'})`);
+        const action = options.strategy === 'squash' ? 'Squashed' : 'Merged';
+        cliLogger.log(`${action} ${result.branchName} into ${result.defaultBranch} @ ${result.shortSha} (${result.commitCount} source commit${result.commitCount === 1 ? '' : 's'})`);
+        if (options.thread && options.threadName) {
+            const credentials = await resolveBotCredentials().catch((e) => {
+                return new Error('Failed to resolve Discord credentials', { cause: e });
+            });
+            if (credentials instanceof Error) {
+                cliLogger.warn(`Could not update the thread title: ${credentials.message}`);
+            }
+            else {
+                const rest = createDiscordRest(credentials.token);
+                const renameResult = await rest
+                    .patch(Routes.channel(options.thread), {
+                    body: { name: options.threadName },
+                })
+                    .catch((e) => new Error('Discord rejected the thread rename', { cause: e }));
+                if (renameResult instanceof Error) {
+                    cliLogger.warn(`Could not update the thread title: ${renameResult.message}`);
+                }
+            }
+        }
         process.exit(0);
     }
     catch (error) {

package/dist/cli-commands/send.js

@@ -29,6 +29,7 @@ import { execAsync, resolveSessionWorkingDirectory, isGitRepositoryRoot } from '
 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 { validateCliModelOption } from '../session-handler/model-utils.js';
 const cliLogger = createLogger(LogPrefix.CLI);
 const cli = goke();
 cli
@@ -52,6 +53,8 @@ cli
     .option('-f, --file <path>', z.array(z.string()).describe('Local file to attach (repeatable). Images, text files, PDFs, etc. ' +
     'Examples: --file screenshot.png --file report.pdf'))
     .option('--send-at <schedule>', 'Schedule send for future (UTC ISO date/time ending in Z, or cron expression)')
+    .option('--pre-run <command>', 'Run a shell command in the project before starting a scheduled task')
+    .option('--allow-concurrency', 'Allow concurrent sessions from the same scheduled task')
     .option('--thread <threadId>', 'Post prompt to an existing thread')
     .option('--session <sessionId>', 'Post prompt to thread mapped to an existing session')
     .option('--parent-session <sessionId>', 'Parent OpenCode session ID for newly created child sessions')
@@ -67,6 +70,10 @@ cli
         const { project: projectPath } = options;
         const sendAt = options.sendAt;
         const existingThreadMode = Boolean(threadId || sessionId);
+        if ((options.preRun || options.allowConcurrency) && !sendAt) {
+            cliLogger.error('--pre-run and --allow-concurrency require --send-at');
+            process.exit(EXIT_NO_RESTART);
+        }
         if (threadId && sessionId) {
             cliLogger.error('Use either --thread or --session, not both');
             process.exit(EXIT_NO_RESTART);
@@ -83,6 +90,13 @@ cli
             cliLogger.error('Prompt is required. Use --prompt <prompt>');
             process.exit(EXIT_NO_RESTART);
         }
+        const earlyModelCheck = await validateCliModelOption({
+            model: options.model,
+        });
+        if (earlyModelCheck instanceof Error) {
+            cliLogger.error(earlyModelCheck.message);
+            process.exit(EXIT_NO_RESTART);
+        }
         const filePaths = options.file?.length
             ? options.file.map((f) => path.resolve(f))
             : undefined;
@@ -329,6 +343,14 @@ cli
             // We only require it for features that genuinely need a local directory
             // (scheduled tasks and --wait).
             const channelConfig = await getChannelDirectory(threadData.parent_id);
+            const threadModelCheck = await validateCliModelOption({
+                model: options.model,
+                directory: channelConfig?.directory,
+            });
+            if (threadModelCheck instanceof Error) {
+                cliLogger.error(threadModelCheck.message);
+                process.exit(EXIT_NO_RESTART);
+            }
             // Guard early: fail before sending the message if a feature that
             // needs local project directory mapping is requested.
             if (!channelConfig && (parsedSchedule || options.wait)) {
@@ -348,6 +370,8 @@ cli
                     permissions: options.permission?.length ? options.permission : null,
                     injectionGuardPatterns: options.injectionGuard?.length ? options.injectionGuard : null,
                     parentSessionId: options.parentSession || null,
+                    preRunCommand: options.preRun || null,
+                    allowConcurrency: Boolean(options.allowConcurrency),
                 };
                 const taskId = await createScheduledTask({
                     scheduleKind: parsedSchedule.scheduleKind,
@@ -387,7 +411,7 @@ cli
             // detection can find the command on its own line.
             const prefixedPrompt = `» **kimaki-cli:**\n${prompt}`;
             if (threadTargetUser) {
-                cliLogger.log(`Adding user ${threadTargetUser.username} to thread...`);
+                cliLogger.log(`Adding user ${threadTargetUser.username || threadTargetUser.id} to thread...`);
                 const addMemberResult = await ensureThreadMember({
                     rest,
                     threadId: targetThreadId,
@@ -438,6 +462,14 @@ cli
         // (--send-at, --wait, --cwd).
         const channelConfig = await getChannelDirectory(channelData.id);
         const projectDirectory = channelConfig?.directory;
+        const channelModelCheck = await validateCliModelOption({
+            model: options.model,
+            directory: projectDirectory,
+        });
+        if (channelModelCheck instanceof Error) {
+            cliLogger.error(channelModelCheck.message);
+            process.exit(EXIT_NO_RESTART);
+        }
         // Features that require a local project directory mapping
         const needsProjectDirectory = Boolean(parsedSchedule || options.wait || options.cwd);
         if (!channelConfig && needsProjectDirectory) {
@@ -509,6 +541,8 @@ cli
                 permissions: options.permission?.length ? options.permission : null,
                 injectionGuardPatterns: options.injectionGuard?.length ? options.injectionGuard : null,
                 parentSessionId: options.parentSession || null,
+                preRunCommand: options.preRun || null,
+                allowConcurrency: Boolean(options.allowConcurrency),
             };
             const taskId = await createScheduledTask({
                 scheduleKind: parsedSchedule.scheduleKind,
@@ -535,8 +569,8 @@ cli
                 ...(worktreeName && { worktree: worktreeName }),
                 ...(resolvedCwd && { cwd: resolvedCwd }),
                 ...(resolvedUser && {
-                    username: resolvedUser.username,
                     userId: resolvedUser.id,
+                    ...(resolvedUser.username && { username: resolvedUser.username }),
                 }),
                 ...(options.agent && { agent: options.agent }),
                 ...(options.model && { model: options.model }),
@@ -574,7 +608,7 @@ cli
         cliLogger.log('Thread created!');
         // Add user to thread if specified
         if (resolvedUser) {
-            cliLogger.log(`Adding user ${resolvedUser.username} to thread...`);
+            cliLogger.log(`Adding user ${resolvedUser.username || resolvedUser.id} to thread...`);
             await rest.put(Routes.threadMembers(threadData.id, resolvedUser.id));
         }
         const threadUrl = `https://discord.com/channels/${channelData.guild_id}/${threadData.id}`;

package/dist/cli-commands/session.js

@@ -1,6 +1,7 @@
 // Session inspection and archival terminal commands.
 import { goke } from 'goke';
 import { z } from 'zod';
+import dedent from 'string-dedent';
 import { note } from '@clack/prompts';
 import YAML from 'yaml';
 import * as errore from 'errore';
@@ -15,10 +16,13 @@ import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessi
 import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
 import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';
+import { formatTimeAgo } from '../commands/worktrees.js';
+import { editorsForFile, loadFileEditEvents } from '../file-edit-log.js';
 import { WORKTREE_PREFIX } from '../commands/merge-worktree.js';
 import { buildOpencodeEventLogLine } from '../session-handler/opencode-session-event-log.js';
 import { createDiscordRest } from '../discord-urls.js';
 import { archiveThread, uploadFilesToDiscord, stripMentions } from '../discord-utils.js';
+import { OpenCodeSdkError } from '../errors.js';
 import { setDataDir, setProjectsDir, getDataDir, getProjectsDir } from '../config.js';
 import { execAsync, validateWorktreeDirectory } from '../worktrees.js';
 import { upgrade, getCurrentVersion } from '../upgrade.js';
@@ -53,6 +57,8 @@ async function resolveSessionDirectoryFromDatabase({ sessionId, }) {
 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('--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 {
@@ -66,9 +72,32 @@ cli
         }
         const sessionsResponse = await getClient().session.list();
         const sessions = sessionsResponse.data || [];
-        if (sessions.length === 0) {
-            cliLogger.log('No sessions found');
-            process.exit(0);
+        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');
+                process.exit(EXIT_NO_RESTART);
+            }
+            return response.data || {};
+        })();
+        const selectedSessions = sessions.filter((session) => {
+            if (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.json)
+                console.log('[]');
+            else
+                cliLogger.log(options.active ? 'No active sessions found' : 'No sessions found');
+            process.exit(options.active ? 1 : 0);
         }
         // Look up which sessions were started via kimaki (have a thread mapping)
         const db = await getDb();
@@ -78,7 +107,7 @@ cli
         const sessionToThread = new Map(threadSessions
             .filter((row) => row.session_id !== '')
             .map((row) => [row.session_id, row.thread_id]));
-        const sessionStartSources = await getSessionStartSourcesBySessionIds(sessions.map((session) => session.id));
+        const sessionStartSources = await getSessionStartSourcesBySessionIds(selectedSessions.map((session) => session.id));
         const scheduleModeLabel = ({ scheduleKind, }) => {
             if (scheduleKind === 'at') {
                 return 'delay';
@@ -86,7 +115,7 @@ cli
             return 'cron';
         };
         if (options.json) {
-            const output = sessions.map((session) => {
+            const output = selectedSessions.map((session) => {
                 const startSource = sessionStartSources.get(session.id);
                 const startedBy = startSource
                     ? `scheduled-${scheduleModeLabel({ scheduleKind: startSource.schedule_kind })}`
@@ -100,12 +129,13 @@ cli
                     threadId: sessionToThread.get(session.id) || null,
                     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 sessions) {
+        for (const session of selectedSessions) {
             const threadId = sessionToThread.get(session.id);
             const startSource = sessionStartSources.get(session.id);
             const source = threadId ? '(kimaki)' : '(opencode)';
@@ -114,7 +144,10 @@ cli
                 : '';
             const updatedAt = new Date(session.time.updated).toISOString();
             const threadInfo = threadId ? ` | thread: ${threadId}` : '';
-            console.log(`${session.id} | ${session.title || 'Untitled Session'} | ${session.directory} | ${updatedAt} | ${source}${threadInfo}${startedBy}`);
+            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}`);
         }
         process.exit(0);
     }
@@ -123,6 +156,79 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
 });
+cli
+    .command('session editors <file>', dedent `
+      List sessions that last edited a file, newest first.
+
+      Use this before a commit in another session so the \`Session:\` line
+      uses the session that actually edited the file.
+    `)
+    .option('--json', 'Output as JSON')
+    .option('--limit <n>', z.number().default(20).describe('Max sessions to show'))
+    .example('kimaki session editors src/cli.ts')
+    .example('kimaki session editors src/cli.ts --json')
+    .action(async (file, options, { console, process }) => {
+    try {
+        const cwd = process.cwd;
+        const loaded = loadFileEditEvents({ dataDir: getDataDir() });
+        if (loaded instanceof Error) {
+            console.error(loaded.message);
+            process.exit(EXIT_NO_RESTART);
+            return;
+        }
+        const editors = editorsForFile({
+            events: loaded,
+            filePath: file,
+            cwd,
+        }).slice(0, options.limit);
+        if (editors.length === 0) {
+            console.error(`No recorded editors for ${path.resolve(cwd, file)}`);
+            process.exit(1);
+            return;
+        }
+        const titles = new Map();
+        try {
+            await initDatabase();
+            const db = await getDb();
+            const sessionRows = await db.query.thread_sessions.findMany({
+                columns: { session_id: true, last_synced_name: true },
+                where: { session_id: { in: editors.map((editor) => editor.sessionId) } },
+                orderBy: { updated_at: 'desc' },
+            });
+            for (const row of sessionRows) {
+                if (!titles.has(row.session_id) && row.last_synced_name) {
+                    titles.set(row.session_id, row.last_synced_name);
+                }
+            }
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+        }
+        const rows = editors.map((editor) => {
+            const title = titles.get(editor.sessionId) || '-';
+            const editedAt = new Date(editor.at);
+            return {
+                sessionId: editor.sessionId,
+                title,
+                editedAt: editedAt.toISOString(),
+                ago: formatTimeAgo(editedAt),
+            };
+        });
+        if (options.json) {
+            console.log(JSON.stringify(rows, null, 2));
+            process.exit(0);
+            return;
+        }
+        for (const row of rows) {
+            console.log(`${row.sessionId} | ${row.title} | ${row.ago}`);
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
 cli
     .command('session read <sessionId>', 'Read a session conversation as markdown (pipe to file to grep)')
     .option('--project <path>', 'Project directory (defaults to cwd)')
@@ -430,7 +536,7 @@ cli
     process.exit(0);
 });
 cli
-    .command('session archive [threadId]', 'Archive a Discord thread and stop its mapped OpenCode session')
+    .command('session archive [threadId]', 'Archive a Discord thread without stopping its mapped OpenCode session')
     .option('--session <sessionId>', 'Resolve thread from an OpenCode session ID')
     .action(async (threadIdArg, options) => {
     try {
@@ -544,6 +650,75 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
 });
+cli
+    .command('session title <title>', 'Update the OpenCode session title. Discord thread name follows automatically.')
+    .option('--session <sessionId>', 'OpenCode session ID')
+    .option('--thread <threadId>', 'Discord thread ID')
+    .example("kimaki session title 'Fix queue draining' --session ses_xxx")
+    .action(async (title, options) => {
+    try {
+        await initDatabase();
+        const trimmedTitle = title.trim();
+        if (!trimmedTitle) {
+            cliLogger.error('Title must not be empty');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (options.session && options.thread) {
+            cliLogger.error('Use either --session or --thread, not both');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (!options.session && !options.thread) {
+            cliLogger.error('Provide --session <sessionId> or --thread <threadId>');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const sessionId = await (async () => {
+            if (options.session)
+                return options.session;
+            const threadId = options.thread;
+            if (!threadId)
+                return null;
+            return getThreadSession(threadId);
+        })();
+        if (!sessionId) {
+            cliLogger.error(options.thread
+                ? `No OpenCode session found for thread: ${options.thread}`
+                : 'Provide --session <sessionId> or --thread <threadId>');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const directory = await resolveSessionDirectoryFromDatabase({
+            sessionId,
+        });
+        if (directory instanceof Error) {
+            cliLogger.error(directory.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const serverResult = await initializeOpencodeForDirectory(directory);
+        if (serverResult instanceof Error) {
+            cliLogger.error(`Failed to initialize OpenCode: ${serverResult.message}`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const updateResult = await serverResult()
+            .session.update({
+            sessionID: sessionId,
+            title: trimmedTitle,
+        })
+            .catch((e) => new OpenCodeSdkError({ operation: 'session.update', cause: e }));
+        if (updateResult instanceof Error) {
+            cliLogger.error(updateResult.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (updateResult.error) {
+            cliLogger.error('OpenCode rejected the session title update');
+            process.exit(EXIT_NO_RESTART);
+        }
+        note(`Updated OpenCode title: ${trimmedTitle}`, 'Title updated');
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
 cli
     .command('session discord-url <sessionId>', 'Print the Discord thread URL for a session')
     .option('--json', 'Output as JSON')

package/dist/cli-commands/task.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, getDiscordUserIdFromUserOption, isDiscordMemberLookupUnavailable, isGuildMemberSearchResult, isThreadChannelType, printDiscordInstallUrlAndExit, resolveBotCredentials, resolveDiscordUserOption, sendDiscordMessageWithOptionalAttachment, } from '../cli-runner.js';
+import { validateCliModelOption } from '../session-handler/model-utils.js';
 const cliLogger = createLogger(LogPrefix.CLI);
 const cli = goke();
 cli
@@ -40,7 +41,7 @@ cli
             cliLogger.log('No scheduled tasks found');
             process.exit(0);
         }
-        console.log('id | status | message | channelId | userId | projectName | folderName | agent | model | timeRemaining | firesAt | cron');
+        console.log('id | status | message | channelId | userId | projectName | folderName | agent | model | preRun | allowConcurrency | timeRemaining | firesAt | cron');
         tasks.forEach((task) => {
             // Surfacing userId makes it obvious which tasks will never show up in
             // the user's Discord sidebar (no thread member is ever added for them).
@@ -49,6 +50,10 @@ cli
             const userId = payload instanceof Error ? '?' : payload.userId || '-';
             const agent = payload instanceof Error ? '?' : payload.agent || '-';
             const model = payload instanceof Error ? '?' : payload.model || '-';
+            const preRun = payload instanceof Error ? '?' : payload.preRunCommand || '-';
+            const allowConcurrency = payload instanceof Error
+                ? '?'
+                : String(payload.allowConcurrency);
             const projectDirectory = task.project_directory || '';
             const projectName = projectDirectory
                 ? path.basename(projectDirectory)
@@ -60,7 +65,7 @@ cli
                 ? task.run_at.toISOString()
                 : '-';
             const cronValue = task.schedule_kind === 'cron' ? task.cron_expr || '-' : '-';
-            console.log(`${task.id} | ${task.status} | ${task.prompt_preview} | ${task.channel_id || '-'} | ${userId} | ${projectName} | ${folderName} | ${agent} | ${model} | ${formatRelativeTime(task.next_run_at)} | ${firesAt} | ${cronValue}`);
+            console.log(`${task.id} | ${task.status} | ${task.prompt_preview} | ${task.channel_id || '-'} | ${userId} | ${projectName} | ${folderName} | ${agent} | ${model} | ${preRun} | ${allowConcurrency} | ${formatRelativeTime(task.next_run_at)} | ${firesAt} | ${cronValue}`);
         });
         process.exit(0);
     }
@@ -98,7 +103,7 @@ cli
 async function resolveTaskUser({ user, channelId, }) {
     const directUserId = getDiscordUserIdFromUserOption(user);
     if (directUserId) {
-        return { id: directUserId, username: directUserId };
+        return { id: directUserId };
     }
     if (!channelId) {
         return new Error(`Cannot look up username "${user}": task has no channel to resolve a guild from. Pass a Discord user ID instead.`);
@@ -128,18 +133,24 @@ cli
     .option('--send-at <sendAt>', 'New schedule (UTC ISO date or cron expression)')
     .option('--agent <agent>', 'Agent for the scheduled session (empty string clears)')
     .option('--model <model>', 'Model for the scheduled session, format provider/model (empty string clears)')
+    .option('--pre-run <command>', 'New pre-run command (empty string clears)')
+    .option('--allow-concurrency <enabled>', z.enum(['true', 'false']).describe('Allow concurrent sessions: true or false'))
     .option('-u, --user <user>', 'Discord user ID, mention, or username added to the task thread')
     .action(async (id, options) => {
     try {
         const trimmedPrompt = options.prompt === undefined ? undefined : options.prompt.trim();
         const hasAgent = options.agent !== undefined;
         const hasModel = options.model !== undefined;
+        const hasPreRun = options.preRun !== undefined;
+        const hasAllowConcurrency = options.allowConcurrency !== undefined;
         if (!trimmedPrompt &&
             !options.sendAt &&
             !options.user &&
             !hasAgent &&
-            !hasModel) {
-            cliLogger.error('Provide at least --prompt, --send-at, --user, --agent or --model');
+            !hasModel &&
+            !hasPreRun &&
+            !hasAllowConcurrency) {
+            cliLogger.error('Provide at least --prompt, --send-at, --user, --agent, --model, --pre-run or --allow-concurrency');
             process.exit(EXIT_NO_RESTART);
         }
         if (trimmedPrompt !== undefined && trimmedPrompt.length === 0) {
@@ -181,15 +192,30 @@ cli
             process.exit(EXIT_NO_RESTART);
         }
         const newPrompt = trimmedPrompt ?? existingPayload.prompt;
+        const nextModel = hasModel ? options.model.trim() || null : existingPayload.model;
+        if (nextModel) {
+            const modelCheck = await validateCliModelOption({
+                model: nextModel,
+                directory: task.project_directory ?? undefined,
+            });
+            if (modelCheck instanceof Error) {
+                cliLogger.error(modelCheck.message);
+                process.exit(EXIT_NO_RESTART);
+            }
+        }
         // Match send --model/--agent: empty string clears the override (null).
         const updatedPayload = {
             ...existingPayload,
             prompt: newPrompt,
             ...(resolvedUser
-                ? { userId: resolvedUser.id, username: resolvedUser.username }
+                ? { userId: resolvedUser.id, username: resolvedUser.username || null }
                 : {}),
             ...(hasAgent ? { agent: options.agent.trim() || null } : {}),
-            ...(hasModel ? { model: options.model.trim() || null } : {}),
+            ...(hasModel ? { model: nextModel } : {}),
+            ...(hasPreRun ? { preRunCommand: options.preRun.trim() || null } : {}),
+            ...(hasAllowConcurrency
+                ? { allowConcurrency: options.allowConcurrency === 'true' }
+                : {}),
         };
         const updateData = {
             taskId,
@@ -220,7 +246,7 @@ cli
         }
         const parts = [`Updated task ${taskId}`];
         if (resolvedUser) {
-            parts.push(`user ${resolvedUser.username} will be added to the thread`);
+            parts.push(`user ${resolvedUser.username || resolvedUser.id} will be added to the thread`);
         }
         if (hasAgent) {
             parts.push(`agent=${updatedPayload.agent || '-'}`);
@@ -228,6 +254,11 @@ cli
         if (hasModel) {
             parts.push(`model=${updatedPayload.model || '-'}`);
         }
+        if (hasPreRun)
+            parts.push(`preRun=${updatedPayload.preRunCommand || '-'}`);
+        if (hasAllowConcurrency) {
+            parts.push(`allowConcurrency=${updatedPayload.allowConcurrency}`);
+        }
         cliLogger.log(parts.join(' | '));
         process.exit(0);
     }